Merge branch 'topic/error' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator into regulator-fixed

632 files changed, 38827 insertions, 4504 deletions

diff --git a/tools/Makefile b/tools/Makefile
index f10b64d8c674..daa8fb3e4363 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -85,7 +85,7 @@ tmon: FORCE
 freefall: FORCE
         $(call descend,laptop/$@)
 
-all: acpi cgroup cpupower hv firewire lguest \
+all: acpi cgroup cpupower gpio hv firewire lguest \
                 perf selftests turbostat usb \
                 virtio vm net x86_energy_perf_policy \
                 tmon freefall objtool
@@ -96,7 +96,7 @@ acpi_install:
 cpupower_install:
         $(call descend,power/$(@:_install=),install)
 
-cgroup_install firewire_install hv_install lguest_install perf_install usb_install virtio_install vm_install net_install objtool_install:
+cgroup_install firewire_install gpio_install hv_install lguest_install perf_install usb_install virtio_install vm_install net_install objtool_install:
         $(call descend,$(@:_install=),install)
 
 selftests_install:
@@ -114,7 +114,8 @@ freefall_install:
 kvm_stat_install:
         $(call descend,kvm/$(@:_install=),install)
 
-install: acpi_install cgroup_install cpupower_install hv_install firewire_install lguest_install \
+install: acpi_install cgroup_install cpupower_install gpio_install \
+                hv_install firewire_install lguest_install \
                 perf_install selftests_install turbostat_install usb_install \
                 virtio_install vm_install net_install x86_energy_perf_policy_install \
                 tmon_install freefall_install objtool_install kvm_stat_install
diff --git a/tools/accounting/.gitignore b/tools/accounting/.gitignore
new file mode 100644
index 000000000000..86485203c4ae
--- /dev/null
+++ b/tools/accounting/.gitignore
@@ -0,0 +1 @@
+getdelays
diff --git a/tools/accounting/Makefile b/tools/accounting/Makefile
new file mode 100644
index 000000000000..647c94a219bf
--- /dev/null
+++ b/tools/accounting/Makefile
@@ -0,0 +1,9 @@
+CC := $(CROSS_COMPILE)gcc
+CFLAGS := -I../../usr/include
+
+PROGS := getdelays
+
+all: $(PROGS)
+
+clean:
+        rm -fr $(PROGS)
diff --git a/tools/accounting/getdelays.c b/tools/accounting/getdelays.c
new file mode 100644
index 000000000000..b5ca536e56a8
--- /dev/null
+++ b/tools/accounting/getdelays.c
@@ -0,0 +1,550 @@
+/* getdelays.c
+ *
+ * Utility to get per-pid and per-tgid delay accounting statistics
+ * Also illustrates usage of the taskstats interface
+ *
+ * Copyright (C) Shailabh Nagar, IBM Corp. 2005
+ * Copyright (C) Balbir Singh, IBM Corp. 2006
+ * Copyright (c) Jay Lan, SGI. 2006
+ *
+ * Compile with
+ *      gcc -I/usr/src/linux/include getdelays.c -o getdelays
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <poll.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#include <linux/genetlink.h>
+#include <linux/taskstats.h>
+#include <linux/cgroupstats.h>
+
+/*
+ * Generic macros for dealing with netlink sockets. Might be duplicated
+ * elsewhere. It is recommended that commercial grade applications use
+ * libnl or libnetlink and use the interfaces provided by the library
+ */
+#define GENLMSG_DATA(glh)       ((void *)(NLMSG_DATA(glh) + GENL_HDRLEN))
+#define GENLMSG_PAYLOAD(glh)    (NLMSG_PAYLOAD(glh, 0) - GENL_HDRLEN)
+#define NLA_DATA(na)            ((void *)((char*)(na) + NLA_HDRLEN))
+#define NLA_PAYLOAD(len)        (len - NLA_HDRLEN)
+
+#define err(code, fmt, arg...)                  \
+        do {                                    \
+                fprintf(stderr, fmt, ##arg);    \
+                exit(code);                     \
+        } while (0)
+
+int done;
+int rcvbufsz;
+char name[100];
+int dbg;
+int print_delays;
+int print_io_accounting;
+int print_task_context_switch_counts;
+
+#define PRINTF(fmt, arg...) {                   \
+            if (dbg) {                          \
+                printf(fmt, ##arg);             \
+            }                                   \
+        }
+
+/* Maximum size of response requested or message sent */
+#define MAX_MSG_SIZE    1024
+/* Maximum number of cpus expected to be specified in a cpumask */
+#define MAX_CPUS        32
+
+struct msgtemplate {
+        struct nlmsghdr n;
+        struct genlmsghdr g;
+        char buf[MAX_MSG_SIZE];
+};
+
+char cpumask[100+6*MAX_CPUS];
+
+static void usage(void)
+{
+        fprintf(stderr, "getdelays [-dilv] [-w logfile] [-r bufsize] "
+                        "[-m cpumask] [-t tgid] [-p pid]\n");
+        fprintf(stderr, "  -d: print delayacct stats\n");
+        fprintf(stderr, "  -i: print IO accounting (works only with -p)\n");
+        fprintf(stderr, "  -l: listen forever\n");
+        fprintf(stderr, "  -v: debug on\n");
+        fprintf(stderr, "  -C: container path\n");
+}
+
+/*
+ * Create a raw netlink socket and bind
+ */
+static int create_nl_socket(int protocol)
+{
+        int fd;
+        struct sockaddr_nl local;
+
+        fd = socket(AF_NETLINK, SOCK_RAW, protocol);
+        if (fd < 0)
+                return -1;
+
+        if (rcvbufsz)
+                if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF,
+                                &rcvbufsz, sizeof(rcvbufsz)) < 0) {
+                        fprintf(stderr, "Unable to set socket rcv buf size to %d\n",
+                                rcvbufsz);
+                        goto error;
+                }
+
+        memset(&local, 0, sizeof(local));
+        local.nl_family = AF_NETLINK;
+
+        if (bind(fd, (struct sockaddr *) &local, sizeof(local)) < 0)
+                goto error;
+
+        return fd;
+error:
+        close(fd);
+        return -1;
+}
+
+
+static int send_cmd(int sd, __u16 nlmsg_type, __u32 nlmsg_pid,
+             __u8 genl_cmd, __u16 nla_type,
+             void *nla_data, int nla_len)
+{
+        struct nlattr *na;
+        struct sockaddr_nl nladdr;
+        int r, buflen;
+        char *buf;
+
+        struct msgtemplate msg;
+
+        msg.n.nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
+        msg.n.nlmsg_type = nlmsg_type;
+        msg.n.nlmsg_flags = NLM_F_REQUEST;
+        msg.n.nlmsg_seq = 0;
+        msg.n.nlmsg_pid = nlmsg_pid;
+        msg.g.cmd = genl_cmd;
+        msg.g.version = 0x1;
+        na = (struct nlattr *) GENLMSG_DATA(&msg);
+        na->nla_type = nla_type;
+        na->nla_len = nla_len + 1 + NLA_HDRLEN;
+        memcpy(NLA_DATA(na), nla_data, nla_len);
+        msg.n.nlmsg_len += NLMSG_ALIGN(na->nla_len);
+
+        buf = (char *) &msg;
+        buflen = msg.n.nlmsg_len ;
+        memset(&nladdr, 0, sizeof(nladdr));
+        nladdr.nl_family = AF_NETLINK;
+        while ((r = sendto(sd, buf, buflen, 0, (struct sockaddr *) &nladdr,
+                           sizeof(nladdr))) < buflen) {
+                if (r > 0) {
+                        buf += r;
+                        buflen -= r;
+                } else if (errno != EAGAIN)
+                        return -1;
+        }
+        return 0;
+}
+
+
+/*
+ * Probe the controller in genetlink to find the family id
+ * for the TASKSTATS family
+ */
+static int get_family_id(int sd)
+{
+        struct {
+                struct nlmsghdr n;
+                struct genlmsghdr g;
+                char buf[256];
+        } ans;
+
+        int id = 0, rc;
+        struct nlattr *na;
+        int rep_len;
+
+        strcpy(name, TASKSTATS_GENL_NAME);
+        rc = send_cmd(sd, GENL_ID_CTRL, getpid(), CTRL_CMD_GETFAMILY,
+                        CTRL_ATTR_FAMILY_NAME, (void *)name,
+                        strlen(TASKSTATS_GENL_NAME)+1);
+        if (rc < 0)
+                return 0;       /* sendto() failure? */
+
+        rep_len = recv(sd, &ans, sizeof(ans), 0);
+        if (ans.n.nlmsg_type == NLMSG_ERROR ||
+            (rep_len < 0) || !NLMSG_OK((&ans.n), rep_len))
+                return 0;
+
+        na = (struct nlattr *) GENLMSG_DATA(&ans);
+        na = (struct nlattr *) ((char *) na + NLA_ALIGN(na->nla_len));
+        if (na->nla_type == CTRL_ATTR_FAMILY_ID) {
+                id = *(__u16 *) NLA_DATA(na);
+        }
+        return id;
+}
+
+#define average_ms(t, c) (t / 1000000ULL / (c ? c : 1))
+
+static void print_delayacct(struct taskstats *t)
+{
+        printf("\n\nCPU   %15s%15s%15s%15s%15s\n"
+               "      %15llu%15llu%15llu%15llu%15.3fms\n"
+               "IO    %15s%15s%15s\n"
+               "      %15llu%15llu%15llums\n"
+               "SWAP  %15s%15s%15s\n"
+               "      %15llu%15llu%15llums\n"
+               "RECLAIM  %12s%15s%15s\n"
+               "      %15llu%15llu%15llums\n",
+               "count", "real total", "virtual total",
+               "delay total", "delay average",
+               (unsigned long long)t->cpu_count,
+               (unsigned long long)t->cpu_run_real_total,
+               (unsigned long long)t->cpu_run_virtual_total,
+               (unsigned long long)t->cpu_delay_total,
+               average_ms((double)t->cpu_delay_total, t->cpu_count),
+               "count", "delay total", "delay average",
+               (unsigned long long)t->blkio_count,
+               (unsigned long long)t->blkio_delay_total,
+               average_ms(t->blkio_delay_total, t->blkio_count),
+               "count", "delay total", "delay average",
+               (unsigned long long)t->swapin_count,
+               (unsigned long long)t->swapin_delay_total,
+               average_ms(t->swapin_delay_total, t->swapin_count),
+               "count", "delay total", "delay average",
+               (unsigned long long)t->freepages_count,
+               (unsigned long long)t->freepages_delay_total,
+               average_ms(t->freepages_delay_total, t->freepages_count));
+}
+
+static void task_context_switch_counts(struct taskstats *t)
+{
+        printf("\n\nTask   %15s%15s\n"
+               "       %15llu%15llu\n",
+               "voluntary", "nonvoluntary",
+               (unsigned long long)t->nvcsw, (unsigned long long)t->nivcsw);
+}
+
+static void print_cgroupstats(struct cgroupstats *c)
+{
+        printf("sleeping %llu, blocked %llu, running %llu, stopped %llu, "
+                "uninterruptible %llu\n", (unsigned long long)c->nr_sleeping,
+                (unsigned long long)c->nr_io_wait,
+                (unsigned long long)c->nr_running,
+                (unsigned long long)c->nr_stopped,
+                (unsigned long long)c->nr_uninterruptible);
+}
+
+
+static void print_ioacct(struct taskstats *t)
+{
+        printf("%s: read=%llu, write=%llu, cancelled_write=%llu\n",
+                t->ac_comm,
+                (unsigned long long)t->read_bytes,
+                (unsigned long long)t->write_bytes,
+                (unsigned long long)t->cancelled_write_bytes);
+}
+
+int main(int argc, char *argv[])
+{
+        int c, rc, rep_len, aggr_len, len2;
+        int cmd_type = TASKSTATS_CMD_ATTR_UNSPEC;
+        __u16 id;
+        __u32 mypid;
+
+        struct nlattr *na;
+        int nl_sd = -1;
+        int len = 0;
+        pid_t tid = 0;
+        pid_t rtid = 0;
+
+        int fd = 0;
+        int count = 0;
+        int write_file = 0;
+        int maskset = 0;
+        char *logfile = NULL;
+        int loop = 0;
+        int containerset = 0;
+        char *containerpath = NULL;
+        int cfd = 0;
+        int forking = 0;
+        sigset_t sigset;
+
+        struct msgtemplate msg;
+
+        while (!forking) {
+                c = getopt(argc, argv, "qdiw:r:m:t:p:vlC:c:");
+                if (c < 0)
+                        break;
+
+                switch (c) {
+                case 'd':
+                        printf("print delayacct stats ON\n");
+                        print_delays = 1;
+                        break;
+                case 'i':
+                        printf("printing IO accounting\n");
+                        print_io_accounting = 1;
+                        break;
+                case 'q':
+                        printf("printing task/process context switch rates\n");
+                        print_task_context_switch_counts = 1;
+                        break;
+                case 'C':
+                        containerset = 1;
+                        containerpath = optarg;
+                        break;
+                case 'w':
+                        logfile = strdup(optarg);
+                        printf("write to file %s\n", logfile);
+                        write_file = 1;
+                        break;
+                case 'r':
+                        rcvbufsz = atoi(optarg);
+                        printf("receive buf size %d\n", rcvbufsz);
+                        if (rcvbufsz < 0)
+                                err(1, "Invalid rcv buf size\n");
+                        break;
+                case 'm':
+                        strncpy(cpumask, optarg, sizeof(cpumask));
+                        cpumask[sizeof(cpumask) - 1] = '\0';
+                        maskset = 1;
+                        printf("cpumask %s maskset %d\n", cpumask, maskset);
+                        break;
+                case 't':
+                        tid = atoi(optarg);
+                        if (!tid)
+                                err(1, "Invalid tgid\n");
+                        cmd_type = TASKSTATS_CMD_ATTR_TGID;
+                        break;
+                case 'p':
+                        tid = atoi(optarg);
+                        if (!tid)
+                                err(1, "Invalid pid\n");
+                        cmd_type = TASKSTATS_CMD_ATTR_PID;
+                        break;
+                case 'c':
+
+                        /* Block SIGCHLD for sigwait() later */
+                        if (sigemptyset(&sigset) == -1)
+                                err(1, "Failed to empty sigset");
+                        if (sigaddset(&sigset, SIGCHLD))
+                                err(1, "Failed to set sigchld in sigset");
+                        sigprocmask(SIG_BLOCK, &sigset, NULL);
+
+                        /* fork/exec a child */
+                        tid = fork();
+                        if (tid < 0)
+                                err(1, "Fork failed\n");
+                        if (tid == 0)
+                                if (execvp(argv[optind - 1],
+                                    &argv[optind - 1]) < 0)
+                                        exit(-1);
+
+                        /* Set the command type and avoid further processing */
+                        cmd_type = TASKSTATS_CMD_ATTR_PID;
+                        forking = 1;
+                        break;
+                case 'v':
+                        printf("debug on\n");
+                        dbg = 1;
+                        break;
+                case 'l':
+                        printf("listen forever\n");
+                        loop = 1;
+                        break;
+                default:
+                        usage();
+                        exit(-1);
+                }
+        }
+
+        if (write_file) {
+                fd = open(logfile, O_WRONLY | O_CREAT | O_TRUNC,
+                          S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+                if (fd == -1) {
+                        perror("Cannot open output file\n");
+                        exit(1);
+                }
+        }
+
+        nl_sd = create_nl_socket(NETLINK_GENERIC);
+        if (nl_sd < 0)
+                err(1, "error creating Netlink socket\n");
+
+
+        mypid = getpid();
+        id = get_family_id(nl_sd);
+        if (!id) {
+                fprintf(stderr, "Error getting family id, errno %d\n", errno);
+                goto err;
+        }
+        PRINTF("family id %d\n", id);
+
+        if (maskset) {
+                rc = send_cmd(nl_sd, id, mypid, TASKSTATS_CMD_GET,
+                              TASKSTATS_CMD_ATTR_REGISTER_CPUMASK,
+                              &cpumask, strlen(cpumask) + 1);
+                PRINTF("Sent register cpumask, retval %d\n", rc);
+                if (rc < 0) {
+                        fprintf(stderr, "error sending register cpumask\n");
+                        goto err;
+                }
+        }
+
+        if (tid && containerset) {
+                fprintf(stderr, "Select either -t or -C, not both\n");
+                goto err;
+        }
+
+        /*
+         * If we forked a child, wait for it to exit. Cannot use waitpid()
+         * as all the delicious data would be reaped as part of the wait
+         */
+        if (tid && forking) {
+                int sig_received;
+                sigwait(&sigset, &sig_received);
+        }
+
+        if (tid) {
+                rc = send_cmd(nl_sd, id, mypid, TASKSTATS_CMD_GET,
+                              cmd_type, &tid, sizeof(__u32));
+                PRINTF("Sent pid/tgid, retval %d\n", rc);
+                if (rc < 0) {
+                        fprintf(stderr, "error sending tid/tgid cmd\n");
+                        goto done;
+                }
+        }
+
+        if (containerset) {
+                cfd = open(containerpath, O_RDONLY);
+                if (cfd < 0) {
+                        perror("error opening container file");
+                        goto err;
+                }
+                rc = send_cmd(nl_sd, id, mypid, CGROUPSTATS_CMD_GET,
+                              CGROUPSTATS_CMD_ATTR_FD, &cfd, sizeof(__u32));
+                if (rc < 0) {
+                        perror("error sending cgroupstats command");
+                        goto err;
+                }
+        }
+        if (!maskset && !tid && !containerset) {
+                usage();
+                goto err;
+        }
+
+        do {
+                rep_len = recv(nl_sd, &msg, sizeof(msg), 0);
+                PRINTF("received %d bytes\n", rep_len);
+
+                if (rep_len < 0) {
+                        fprintf(stderr, "nonfatal reply error: errno %d\n",
+                                errno);
+                        continue;
+                }
+                if (msg.n.nlmsg_type == NLMSG_ERROR ||
+                    !NLMSG_OK((&msg.n), rep_len)) {
+                        struct nlmsgerr *err = NLMSG_DATA(&msg);
+                        fprintf(stderr, "fatal reply error,  errno %d\n",
+                                err->error);
+                        goto done;
+                }
+
+                PRINTF("nlmsghdr size=%zu, nlmsg_len=%d, rep_len=%d\n",
+                       sizeof(struct nlmsghdr), msg.n.nlmsg_len, rep_len);
+
+
+                rep_len = GENLMSG_PAYLOAD(&msg.n);
+
+                na = (struct nlattr *) GENLMSG_DATA(&msg);
+                len = 0;
+                while (len < rep_len) {
+                        len += NLA_ALIGN(na->nla_len);
+                        switch (na->nla_type) {
+                        case TASKSTATS_TYPE_AGGR_TGID:
+                                /* Fall through */
+                        case TASKSTATS_TYPE_AGGR_PID:
+                                aggr_len = NLA_PAYLOAD(na->nla_len);
+                                len2 = 0;
+                                /* For nested attributes, na follows */
+                                na = (struct nlattr *) NLA_DATA(na);
+                                done = 0;
+                                while (len2 < aggr_len) {
+                                        switch (na->nla_type) {
+                                        case TASKSTATS_TYPE_PID:
+                                                rtid = *(int *) NLA_DATA(na);
+                                                if (print_delays)
+                                                        printf("PID\t%d\n", rtid);
+                                                break;
+                                        case TASKSTATS_TYPE_TGID:
+                                                rtid = *(int *) NLA_DATA(na);
+                                                if (print_delays)
+                                                        printf("TGID\t%d\n", rtid);
+                                                break;
+                                        case TASKSTATS_TYPE_STATS:
+                                                count++;
+                                                if (print_delays)
+                                                        print_delayacct((struct taskstats *) NLA_DATA(na));
+                                                if (print_io_accounting)
+                                                        print_ioacct((struct taskstats *) NLA_DATA(na));
+                                                if (print_task_context_switch_counts)
+                                                        task_context_switch_counts((struct taskstats *) NLA_DATA(na));
+                                                if (fd) {
+                                                        if (write(fd, NLA_DATA(na), na->nla_len) < 0) {
+                                                                err(1,"write error\n");
+                                                        }
+                                                }
+                                                if (!loop)
+                                                        goto done;
+                                                break;
+                                        case TASKSTATS_TYPE_NULL:
+                                                break;
+                                        default:
+                                                fprintf(stderr, "Unknown nested"
+                                                        " nla_type %d\n",
+                                                        na->nla_type);
+                                                break;
+                                        }
+                                        len2 += NLA_ALIGN(na->nla_len);
+                                        na = (struct nlattr *)((char *)na +
+                                                               NLA_ALIGN(na->nla_len));
+                                }
+                                break;
+
+                        case CGROUPSTATS_TYPE_CGROUP_STATS:
+                                print_cgroupstats(NLA_DATA(na));
+                                break;
+                        default:
+                                fprintf(stderr, "Unknown nla_type %d\n",
+                                        na->nla_type);
+                        case TASKSTATS_TYPE_NULL:
+                                break;
+                        }
+                        na = (struct nlattr *) (GENLMSG_DATA(&msg) + len);
+                }
+        } while (loop);
+done:
+        if (maskset) {
+                rc = send_cmd(nl_sd, id, mypid, TASKSTATS_CMD_GET,
+                              TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK,
+                              &cpumask, strlen(cpumask) + 1);
+                printf("Sent deregister mask, retval %d\n", rc);
+                if (rc < 0)
+                        err(rc, "error sending deregister cpumask\n");
+        }
+err:
+        close(nl_sd);
+        if (fd)
+                close(fd);
+        if (cfd)
+                close(cfd);
+        return 0;
+}
diff --git a/tools/arch/alpha/include/uapi/asm/bitsperlong.h b/tools/arch/alpha/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..ad57f7868203
--- /dev/null
+++ b/tools/arch/alpha/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_ALPHA_BITSPERLONG_H
+#define __ASM_ALPHA_BITSPERLONG_H
+
+#define __BITS_PER_LONG 64
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_ALPHA_BITSPERLONG_H */
diff --git a/tools/arch/alpha/include/uapi/asm/mman.h b/tools/arch/alpha/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..e38b64c82b97
--- /dev/null
+++ b/tools/arch/alpha/include/uapi/asm/mman.h
@@ -0,0 +1,47 @@
+#ifndef TOOLS_ARCH_ALPHA_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_ALPHA_UAPI_ASM_MMAN_FIX_H
+#define MADV_DODUMP     17
+#define MADV_DOFORK     11
+#define MADV_DONTDUMP   16
+#define MADV_DONTFORK   10
+#define MADV_DONTNEED   6
+#define MADV_FREE       8
+#define MADV_HUGEPAGE   14
+#define MADV_MERGEABLE   12
+#define MADV_NOHUGEPAGE 15
+#define MADV_NORMAL     0
+#define MADV_RANDOM     1
+#define MADV_REMOVE     9
+#define MADV_SEQUENTIAL 2
+#define MADV_UNMERGEABLE 13
+#define MADV_WILLNEED   3
+#define MAP_ANONYMOUS   0x10
+#define MAP_DENYWRITE   0x02000
+#define MAP_EXECUTABLE  0x04000
+#define MAP_FILE        0
+#define MAP_FIXED       0x100
+#define MAP_GROWSDOWN   0x01000
+#define MAP_HUGETLB     0x100000
+#define MAP_LOCKED      0x08000
+#define MAP_NONBLOCK    0x40000
+#define MAP_NORESERVE   0x10000
+#define MAP_POPULATE    0x20000
+#define MAP_PRIVATE     0x02
+#define MAP_SHARED      0x01
+#define MAP_STACK       0x80000
+#define PROT_EXEC       0x4
+#define PROT_GROWSDOWN  0x01000000
+#define PROT_GROWSUP    0x02000000
+#define PROT_NONE       0x0
+#define PROT_READ       0x1
+#define PROT_SEM        0x8
+#define PROT_WRITE      0x2
+/* MADV_HWPOISON is undefined on alpha, fix it for perf */
+#define MADV_HWPOISON   100
+/* MADV_SOFT_OFFLINE is undefined on alpha, fix it for perf */
+#define MADV_SOFT_OFFLINE 101
+/* MAP_32BIT is undefined on alpha, fix it for perf */
+#define MAP_32BIT       0
+/* MAP_UNINITIALIZED is undefined on alpha, fix it for perf */
+#define MAP_UNINITIALIZED       0
+#endif
diff --git a/tools/arch/arc/include/uapi/asm/mman.h b/tools/arch/arc/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..aa3acd2aa9af
--- /dev/null
+++ b/tools/arch/arc/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_ARC_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_ARC_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on arc, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/arm/include/uapi/asm/kvm.h b/tools/arch/arm/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..a2b3eb313a25
--- /dev/null
+++ b/tools/arch/arm/include/uapi/asm/kvm.h
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2012 - Virtual Open Systems and Columbia University
+ * Author: Christoffer Dall <c.dall@virtualopensystems.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef __ARM_KVM_H__
+#define __ARM_KVM_H__
+
+#include <linux/types.h>
+#include <linux/psci.h>
+#include <asm/ptrace.h>
+
+#define __KVM_HAVE_GUEST_DEBUG
+#define __KVM_HAVE_IRQ_LINE
+#define __KVM_HAVE_READONLY_MEM
+
+#define KVM_REG_SIZE(id)                                                \
+        (1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
+
+/* Valid for svc_regs, abt_regs, und_regs, irq_regs in struct kvm_regs */
+#define KVM_ARM_SVC_sp          svc_regs[0]
+#define KVM_ARM_SVC_lr          svc_regs[1]
+#define KVM_ARM_SVC_spsr        svc_regs[2]
+#define KVM_ARM_ABT_sp          abt_regs[0]
+#define KVM_ARM_ABT_lr          abt_regs[1]
+#define KVM_ARM_ABT_spsr        abt_regs[2]
+#define KVM_ARM_UND_sp          und_regs[0]
+#define KVM_ARM_UND_lr          und_regs[1]
+#define KVM_ARM_UND_spsr        und_regs[2]
+#define KVM_ARM_IRQ_sp          irq_regs[0]
+#define KVM_ARM_IRQ_lr          irq_regs[1]
+#define KVM_ARM_IRQ_spsr        irq_regs[2]
+
+/* Valid only for fiq_regs in struct kvm_regs */
+#define KVM_ARM_FIQ_r8          fiq_regs[0]
+#define KVM_ARM_FIQ_r9          fiq_regs[1]
+#define KVM_ARM_FIQ_r10         fiq_regs[2]
+#define KVM_ARM_FIQ_fp          fiq_regs[3]
+#define KVM_ARM_FIQ_ip          fiq_regs[4]
+#define KVM_ARM_FIQ_sp          fiq_regs[5]
+#define KVM_ARM_FIQ_lr          fiq_regs[6]
+#define KVM_ARM_FIQ_spsr        fiq_regs[7]
+
+struct kvm_regs {
+        struct pt_regs usr_regs;        /* R0_usr - R14_usr, PC, CPSR */
+        unsigned long svc_regs[3];      /* SP_svc, LR_svc, SPSR_svc */
+        unsigned long abt_regs[3];      /* SP_abt, LR_abt, SPSR_abt */
+        unsigned long und_regs[3];      /* SP_und, LR_und, SPSR_und */
+        unsigned long irq_regs[3];      /* SP_irq, LR_irq, SPSR_irq */
+        unsigned long fiq_regs[8];      /* R8_fiq - R14_fiq, SPSR_fiq */
+};
+
+/* Supported Processor Types */
+#define KVM_ARM_TARGET_CORTEX_A15       0
+#define KVM_ARM_TARGET_CORTEX_A7        1
+#define KVM_ARM_NUM_TARGETS             2
+
+/* KVM_ARM_SET_DEVICE_ADDR ioctl id encoding */
+#define KVM_ARM_DEVICE_TYPE_SHIFT       0
+#define KVM_ARM_DEVICE_TYPE_MASK        (0xffff << KVM_ARM_DEVICE_TYPE_SHIFT)
+#define KVM_ARM_DEVICE_ID_SHIFT         16
+#define KVM_ARM_DEVICE_ID_MASK          (0xffff << KVM_ARM_DEVICE_ID_SHIFT)
+
+/* Supported device IDs */
+#define KVM_ARM_DEVICE_VGIC_V2          0
+
+/* Supported VGIC address types  */
+#define KVM_VGIC_V2_ADDR_TYPE_DIST      0
+#define KVM_VGIC_V2_ADDR_TYPE_CPU       1
+
+#define KVM_VGIC_V2_DIST_SIZE           0x1000
+#define KVM_VGIC_V2_CPU_SIZE            0x2000
+
+#define KVM_ARM_VCPU_POWER_OFF          0 /* CPU is started in OFF state */
+#define KVM_ARM_VCPU_PSCI_0_2           1 /* CPU uses PSCI v0.2 */
+
+struct kvm_vcpu_init {
+        __u32 target;
+        __u32 features[7];
+};
+
+struct kvm_sregs {
+};
+
+struct kvm_fpu {
+};
+
+struct kvm_guest_debug_arch {
+};
+
+struct kvm_debug_exit_arch {
+};
+
+struct kvm_sync_regs {
+};
+
+struct kvm_arch_memory_slot {
+};
+
+/* If you need to interpret the index values, here is the key: */
+#define KVM_REG_ARM_COPROC_MASK         0x000000000FFF0000
+#define KVM_REG_ARM_COPROC_SHIFT        16
+#define KVM_REG_ARM_32_OPC2_MASK        0x0000000000000007
+#define KVM_REG_ARM_32_OPC2_SHIFT       0
+#define KVM_REG_ARM_OPC1_MASK           0x0000000000000078
+#define KVM_REG_ARM_OPC1_SHIFT          3
+#define KVM_REG_ARM_CRM_MASK            0x0000000000000780
+#define KVM_REG_ARM_CRM_SHIFT           7
+#define KVM_REG_ARM_32_CRN_MASK         0x0000000000007800
+#define KVM_REG_ARM_32_CRN_SHIFT        11
+
+#define ARM_CP15_REG_SHIFT_MASK(x,n) \
+        (((x) << KVM_REG_ARM_ ## n ## _SHIFT) & KVM_REG_ARM_ ## n ## _MASK)
+
+#define __ARM_CP15_REG(op1,crn,crm,op2) \
+        (KVM_REG_ARM | (15 << KVM_REG_ARM_COPROC_SHIFT) | \
+        ARM_CP15_REG_SHIFT_MASK(op1, OPC1) | \
+        ARM_CP15_REG_SHIFT_MASK(crn, 32_CRN) | \
+        ARM_CP15_REG_SHIFT_MASK(crm, CRM) | \
+        ARM_CP15_REG_SHIFT_MASK(op2, 32_OPC2))
+
+#define ARM_CP15_REG32(...) (__ARM_CP15_REG(__VA_ARGS__) | KVM_REG_SIZE_U32)
+
+#define __ARM_CP15_REG64(op1,crm) \
+        (__ARM_CP15_REG(op1, 0, crm, 0) | KVM_REG_SIZE_U64)
+#define ARM_CP15_REG64(...) __ARM_CP15_REG64(__VA_ARGS__)
+
+#define KVM_REG_ARM_TIMER_CTL           ARM_CP15_REG32(0, 14, 3, 1)
+#define KVM_REG_ARM_TIMER_CNT           ARM_CP15_REG64(1, 14)
+#define KVM_REG_ARM_TIMER_CVAL          ARM_CP15_REG64(3, 14)
+
+/* Normal registers are mapped as coprocessor 16. */
+#define KVM_REG_ARM_CORE                (0x0010 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_CORE_REG(name)      (offsetof(struct kvm_regs, name) / 4)
+
+/* Some registers need more space to represent values. */
+#define KVM_REG_ARM_DEMUX               (0x0011 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_DEMUX_ID_MASK       0x000000000000FF00
+#define KVM_REG_ARM_DEMUX_ID_SHIFT      8
+#define KVM_REG_ARM_DEMUX_ID_CCSIDR     (0x00 << KVM_REG_ARM_DEMUX_ID_SHIFT)
+#define KVM_REG_ARM_DEMUX_VAL_MASK      0x00000000000000FF
+#define KVM_REG_ARM_DEMUX_VAL_SHIFT     0
+
+/* VFP registers: we could overload CP10 like ARM does, but that's ugly. */
+#define KVM_REG_ARM_VFP                 (0x0012 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_VFP_MASK            0x000000000000FFFF
+#define KVM_REG_ARM_VFP_BASE_REG        0x0
+#define KVM_REG_ARM_VFP_FPSID           0x1000
+#define KVM_REG_ARM_VFP_FPSCR           0x1001
+#define KVM_REG_ARM_VFP_MVFR1           0x1006
+#define KVM_REG_ARM_VFP_MVFR0           0x1007
+#define KVM_REG_ARM_VFP_FPEXC           0x1008
+#define KVM_REG_ARM_VFP_FPINST          0x1009
+#define KVM_REG_ARM_VFP_FPINST2         0x100A
+
+/* Device Control API: ARM VGIC */
+#define KVM_DEV_ARM_VGIC_GRP_ADDR       0
+#define KVM_DEV_ARM_VGIC_GRP_DIST_REGS  1
+#define KVM_DEV_ARM_VGIC_GRP_CPU_REGS   2
+#define   KVM_DEV_ARM_VGIC_CPUID_SHIFT  32
+#define   KVM_DEV_ARM_VGIC_CPUID_MASK   (0xffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
+#define   KVM_DEV_ARM_VGIC_OFFSET_SHIFT 0
+#define   KVM_DEV_ARM_VGIC_OFFSET_MASK  (0xffffffffULL << KVM_DEV_ARM_VGIC_OFFSET_SHIFT)
+#define KVM_DEV_ARM_VGIC_GRP_NR_IRQS    3
+#define KVM_DEV_ARM_VGIC_GRP_CTRL       4
+#define   KVM_DEV_ARM_VGIC_CTRL_INIT    0
+
+/* KVM_IRQ_LINE irq field index values */
+#define KVM_ARM_IRQ_TYPE_SHIFT          24
+#define KVM_ARM_IRQ_TYPE_MASK           0xff
+#define KVM_ARM_IRQ_VCPU_SHIFT          16
+#define KVM_ARM_IRQ_VCPU_MASK           0xff
+#define KVM_ARM_IRQ_NUM_SHIFT           0
+#define KVM_ARM_IRQ_NUM_MASK            0xffff
+
+/* irq_type field */
+#define KVM_ARM_IRQ_TYPE_CPU            0
+#define KVM_ARM_IRQ_TYPE_SPI            1
+#define KVM_ARM_IRQ_TYPE_PPI            2
+
+/* out-of-kernel GIC cpu interrupt injection irq_number field */
+#define KVM_ARM_IRQ_CPU_IRQ             0
+#define KVM_ARM_IRQ_CPU_FIQ             1
+
+/*
+ * This used to hold the highest supported SPI, but it is now obsolete
+ * and only here to provide source code level compatibility with older
+ * userland. The highest SPI number can be set via KVM_DEV_ARM_VGIC_GRP_NR_IRQS.
+ */
+#ifndef __KERNEL__
+#define KVM_ARM_IRQ_GIC_MAX             127
+#endif
+
+/* One single KVM irqchip, ie. the VGIC */
+#define KVM_NR_IRQCHIPS          1
+
+/* PSCI interface */
+#define KVM_PSCI_FN_BASE                0x95c1ba5e
+#define KVM_PSCI_FN(n)                  (KVM_PSCI_FN_BASE + (n))
+
+#define KVM_PSCI_FN_CPU_SUSPEND         KVM_PSCI_FN(0)
+#define KVM_PSCI_FN_CPU_OFF             KVM_PSCI_FN(1)
+#define KVM_PSCI_FN_CPU_ON              KVM_PSCI_FN(2)
+#define KVM_PSCI_FN_MIGRATE             KVM_PSCI_FN(3)
+
+#define KVM_PSCI_RET_SUCCESS            PSCI_RET_SUCCESS
+#define KVM_PSCI_RET_NI                 PSCI_RET_NOT_SUPPORTED
+#define KVM_PSCI_RET_INVAL              PSCI_RET_INVALID_PARAMS
+#define KVM_PSCI_RET_DENIED             PSCI_RET_DENIED
+
+#endif /* __ARM_KVM_H__ */
diff --git a/tools/arch/arm/include/uapi/asm/mman.h b/tools/arch/arm/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..478f699f56fd
--- /dev/null
+++ b/tools/arch/arm/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_ARM_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_ARM_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on arm, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/arm/include/uapi/asm/perf_regs.h b/tools/arch/arm/include/uapi/asm/perf_regs.h
new file mode 100644
index 000000000000..ce59448458b2
--- /dev/null
+++ b/tools/arch/arm/include/uapi/asm/perf_regs.h
@@ -0,0 +1,23 @@
+#ifndef _ASM_ARM_PERF_REGS_H
+#define _ASM_ARM_PERF_REGS_H
+
+enum perf_event_arm_regs {
+        PERF_REG_ARM_R0,
+        PERF_REG_ARM_R1,
+        PERF_REG_ARM_R2,
+        PERF_REG_ARM_R3,
+        PERF_REG_ARM_R4,
+        PERF_REG_ARM_R5,
+        PERF_REG_ARM_R6,
+        PERF_REG_ARM_R7,
+        PERF_REG_ARM_R8,
+        PERF_REG_ARM_R9,
+        PERF_REG_ARM_R10,
+        PERF_REG_ARM_FP,
+        PERF_REG_ARM_IP,
+        PERF_REG_ARM_SP,
+        PERF_REG_ARM_LR,
+        PERF_REG_ARM_PC,
+        PERF_REG_ARM_MAX,
+};
+#endif /* _ASM_ARM_PERF_REGS_H */
diff --git a/tools/arch/arm64/include/uapi/asm/bitsperlong.h b/tools/arch/arm64/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..fce9c2924fa3
--- /dev/null
+++ b/tools/arch/arm64/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2012 ARM Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __ASM_BITSPERLONG_H
+#define __ASM_BITSPERLONG_H
+
+#define __BITS_PER_LONG 64
+
+#include <asm-generic/bitsperlong.h>
+
+#endif  /* __ASM_BITSPERLONG_H */
diff --git a/tools/arch/arm64/include/uapi/asm/kvm.h b/tools/arch/arm64/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..3051f86a9b5f
--- /dev/null
+++ b/tools/arch/arm64/include/uapi/asm/kvm.h
@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2012,2013 - ARM Ltd
+ * Author: Marc Zyngier <marc.zyngier@arm.com>
+ *
+ * Derived from arch/arm/include/uapi/asm/kvm.h:
+ * Copyright (C) 2012 - Virtual Open Systems and Columbia University
+ * Author: Christoffer Dall <c.dall@virtualopensystems.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __ARM_KVM_H__
+#define __ARM_KVM_H__
+
+#define KVM_SPSR_EL1    0
+#define KVM_SPSR_SVC    KVM_SPSR_EL1
+#define KVM_SPSR_ABT    1
+#define KVM_SPSR_UND    2
+#define KVM_SPSR_IRQ    3
+#define KVM_SPSR_FIQ    4
+#define KVM_NR_SPSR     5
+
+#ifndef __ASSEMBLY__
+#include <linux/psci.h>
+#include <linux/types.h>
+#include <asm/ptrace.h>
+
+#define __KVM_HAVE_GUEST_DEBUG
+#define __KVM_HAVE_IRQ_LINE
+#define __KVM_HAVE_READONLY_MEM
+
+#define KVM_REG_SIZE(id)                                                \
+        (1U << (((id) & KVM_REG_SIZE_MASK) >> KVM_REG_SIZE_SHIFT))
+
+struct kvm_regs {
+        struct user_pt_regs regs;       /* sp = sp_el0 */
+
+        __u64   sp_el1;
+        __u64   elr_el1;
+
+        __u64   spsr[KVM_NR_SPSR];
+
+        struct user_fpsimd_state fp_regs;
+};
+
+/*
+ * Supported CPU Targets - Adding a new target type is not recommended,
+ * unless there are some special registers not supported by the
+ * genericv8 syreg table.
+ */
+#define KVM_ARM_TARGET_AEM_V8           0
+#define KVM_ARM_TARGET_FOUNDATION_V8    1
+#define KVM_ARM_TARGET_CORTEX_A57       2
+#define KVM_ARM_TARGET_XGENE_POTENZA    3
+#define KVM_ARM_TARGET_CORTEX_A53       4
+/* Generic ARM v8 target */
+#define KVM_ARM_TARGET_GENERIC_V8       5
+
+#define KVM_ARM_NUM_TARGETS             6
+
+/* KVM_ARM_SET_DEVICE_ADDR ioctl id encoding */
+#define KVM_ARM_DEVICE_TYPE_SHIFT       0
+#define KVM_ARM_DEVICE_TYPE_MASK        (0xffff << KVM_ARM_DEVICE_TYPE_SHIFT)
+#define KVM_ARM_DEVICE_ID_SHIFT         16
+#define KVM_ARM_DEVICE_ID_MASK          (0xffff << KVM_ARM_DEVICE_ID_SHIFT)
+
+/* Supported device IDs */
+#define KVM_ARM_DEVICE_VGIC_V2          0
+
+/* Supported VGIC address types  */
+#define KVM_VGIC_V2_ADDR_TYPE_DIST      0
+#define KVM_VGIC_V2_ADDR_TYPE_CPU       1
+
+#define KVM_VGIC_V2_DIST_SIZE           0x1000
+#define KVM_VGIC_V2_CPU_SIZE            0x2000
+
+/* Supported VGICv3 address types  */
+#define KVM_VGIC_V3_ADDR_TYPE_DIST      2
+#define KVM_VGIC_V3_ADDR_TYPE_REDIST    3
+#define KVM_VGIC_ITS_ADDR_TYPE          4
+
+#define KVM_VGIC_V3_DIST_SIZE           SZ_64K
+#define KVM_VGIC_V3_REDIST_SIZE         (2 * SZ_64K)
+#define KVM_VGIC_V3_ITS_SIZE            (2 * SZ_64K)
+
+#define KVM_ARM_VCPU_POWER_OFF          0 /* CPU is started in OFF state */
+#define KVM_ARM_VCPU_EL1_32BIT          1 /* CPU running a 32bit VM */
+#define KVM_ARM_VCPU_PSCI_0_2           2 /* CPU uses PSCI v0.2 */
+#define KVM_ARM_VCPU_PMU_V3             3 /* Support guest PMUv3 */
+
+struct kvm_vcpu_init {
+        __u32 target;
+        __u32 features[7];
+};
+
+struct kvm_sregs {
+};
+
+struct kvm_fpu {
+};
+
+/*
+ * See v8 ARM ARM D7.3: Debug Registers
+ *
+ * The architectural limit is 16 debug registers of each type although
+ * in practice there are usually less (see ID_AA64DFR0_EL1).
+ *
+ * Although the control registers are architecturally defined as 32
+ * bits wide we use a 64 bit structure here to keep parity with
+ * KVM_GET/SET_ONE_REG behaviour which treats all system registers as
+ * 64 bit values. It also allows for the possibility of the
+ * architecture expanding the control registers without having to
+ * change the userspace ABI.
+ */
+#define KVM_ARM_MAX_DBG_REGS 16
+struct kvm_guest_debug_arch {
+        __u64 dbg_bcr[KVM_ARM_MAX_DBG_REGS];
+        __u64 dbg_bvr[KVM_ARM_MAX_DBG_REGS];
+        __u64 dbg_wcr[KVM_ARM_MAX_DBG_REGS];
+        __u64 dbg_wvr[KVM_ARM_MAX_DBG_REGS];
+};
+
+struct kvm_debug_exit_arch {
+        __u32 hsr;
+        __u64 far;      /* used for watchpoints */
+};
+
+/*
+ * Architecture specific defines for kvm_guest_debug->control
+ */
+
+#define KVM_GUESTDBG_USE_SW_BP          (1 << 16)
+#define KVM_GUESTDBG_USE_HW             (1 << 17)
+
+struct kvm_sync_regs {
+};
+
+struct kvm_arch_memory_slot {
+};
+
+/* If you need to interpret the index values, here is the key: */
+#define KVM_REG_ARM_COPROC_MASK         0x000000000FFF0000
+#define KVM_REG_ARM_COPROC_SHIFT        16
+
+/* Normal registers are mapped as coprocessor 16. */
+#define KVM_REG_ARM_CORE                (0x0010 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_CORE_REG(name)      (offsetof(struct kvm_regs, name) / sizeof(__u32))
+
+/* Some registers need more space to represent values. */
+#define KVM_REG_ARM_DEMUX               (0x0011 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM_DEMUX_ID_MASK       0x000000000000FF00
+#define KVM_REG_ARM_DEMUX_ID_SHIFT      8
+#define KVM_REG_ARM_DEMUX_ID_CCSIDR     (0x00 << KVM_REG_ARM_DEMUX_ID_SHIFT)
+#define KVM_REG_ARM_DEMUX_VAL_MASK      0x00000000000000FF
+#define KVM_REG_ARM_DEMUX_VAL_SHIFT     0
+
+/* AArch64 system registers */
+#define KVM_REG_ARM64_SYSREG            (0x0013 << KVM_REG_ARM_COPROC_SHIFT)
+#define KVM_REG_ARM64_SYSREG_OP0_MASK   0x000000000000c000
+#define KVM_REG_ARM64_SYSREG_OP0_SHIFT  14
+#define KVM_REG_ARM64_SYSREG_OP1_MASK   0x0000000000003800
+#define KVM_REG_ARM64_SYSREG_OP1_SHIFT  11
+#define KVM_REG_ARM64_SYSREG_CRN_MASK   0x0000000000000780
+#define KVM_REG_ARM64_SYSREG_CRN_SHIFT  7
+#define KVM_REG_ARM64_SYSREG_CRM_MASK   0x0000000000000078
+#define KVM_REG_ARM64_SYSREG_CRM_SHIFT  3
+#define KVM_REG_ARM64_SYSREG_OP2_MASK   0x0000000000000007
+#define KVM_REG_ARM64_SYSREG_OP2_SHIFT  0
+
+#define ARM64_SYS_REG_SHIFT_MASK(x,n) \
+        (((x) << KVM_REG_ARM64_SYSREG_ ## n ## _SHIFT) & \
+        KVM_REG_ARM64_SYSREG_ ## n ## _MASK)
+
+#define __ARM64_SYS_REG(op0,op1,crn,crm,op2) \
+        (KVM_REG_ARM64 | KVM_REG_ARM64_SYSREG | \
+        ARM64_SYS_REG_SHIFT_MASK(op0, OP0) | \
+        ARM64_SYS_REG_SHIFT_MASK(op1, OP1) | \
+        ARM64_SYS_REG_SHIFT_MASK(crn, CRN) | \
+        ARM64_SYS_REG_SHIFT_MASK(crm, CRM) | \
+        ARM64_SYS_REG_SHIFT_MASK(op2, OP2))
+
+#define ARM64_SYS_REG(...) (__ARM64_SYS_REG(__VA_ARGS__) | KVM_REG_SIZE_U64)
+
+#define KVM_REG_ARM_TIMER_CTL           ARM64_SYS_REG(3, 3, 14, 3, 1)
+#define KVM_REG_ARM_TIMER_CNT           ARM64_SYS_REG(3, 3, 14, 3, 2)
+#define KVM_REG_ARM_TIMER_CVAL          ARM64_SYS_REG(3, 3, 14, 0, 2)
+
+/* Device Control API: ARM VGIC */
+#define KVM_DEV_ARM_VGIC_GRP_ADDR       0
+#define KVM_DEV_ARM_VGIC_GRP_DIST_REGS  1
+#define KVM_DEV_ARM_VGIC_GRP_CPU_REGS   2
+#define   KVM_DEV_ARM_VGIC_CPUID_SHIFT  32
+#define   KVM_DEV_ARM_VGIC_CPUID_MASK   (0xffULL << KVM_DEV_ARM_VGIC_CPUID_SHIFT)
+#define   KVM_DEV_ARM_VGIC_OFFSET_SHIFT 0
+#define   KVM_DEV_ARM_VGIC_OFFSET_MASK  (0xffffffffULL << KVM_DEV_ARM_VGIC_OFFSET_SHIFT)
+#define KVM_DEV_ARM_VGIC_GRP_NR_IRQS    3
+#define KVM_DEV_ARM_VGIC_GRP_CTRL       4
+#define   KVM_DEV_ARM_VGIC_CTRL_INIT    0
+
+/* Device Control API on vcpu fd */
+#define KVM_ARM_VCPU_PMU_V3_CTRL        0
+#define   KVM_ARM_VCPU_PMU_V3_IRQ       0
+#define   KVM_ARM_VCPU_PMU_V3_INIT      1
+
+/* KVM_IRQ_LINE irq field index values */
+#define KVM_ARM_IRQ_TYPE_SHIFT          24
+#define KVM_ARM_IRQ_TYPE_MASK           0xff
+#define KVM_ARM_IRQ_VCPU_SHIFT          16
+#define KVM_ARM_IRQ_VCPU_MASK           0xff
+#define KVM_ARM_IRQ_NUM_SHIFT           0
+#define KVM_ARM_IRQ_NUM_MASK            0xffff
+
+/* irq_type field */
+#define KVM_ARM_IRQ_TYPE_CPU            0
+#define KVM_ARM_IRQ_TYPE_SPI            1
+#define KVM_ARM_IRQ_TYPE_PPI            2
+
+/* out-of-kernel GIC cpu interrupt injection irq_number field */
+#define KVM_ARM_IRQ_CPU_IRQ             0
+#define KVM_ARM_IRQ_CPU_FIQ             1
+
+/*
+ * This used to hold the highest supported SPI, but it is now obsolete
+ * and only here to provide source code level compatibility with older
+ * userland. The highest SPI number can be set via KVM_DEV_ARM_VGIC_GRP_NR_IRQS.
+ */
+#ifndef __KERNEL__
+#define KVM_ARM_IRQ_GIC_MAX             127
+#endif
+
+/* One single KVM irqchip, ie. the VGIC */
+#define KVM_NR_IRQCHIPS          1
+
+/* PSCI interface */
+#define KVM_PSCI_FN_BASE                0x95c1ba5e
+#define KVM_PSCI_FN(n)                  (KVM_PSCI_FN_BASE + (n))
+
+#define KVM_PSCI_FN_CPU_SUSPEND         KVM_PSCI_FN(0)
+#define KVM_PSCI_FN_CPU_OFF             KVM_PSCI_FN(1)
+#define KVM_PSCI_FN_CPU_ON              KVM_PSCI_FN(2)
+#define KVM_PSCI_FN_MIGRATE             KVM_PSCI_FN(3)
+
+#define KVM_PSCI_RET_SUCCESS            PSCI_RET_SUCCESS
+#define KVM_PSCI_RET_NI                 PSCI_RET_NOT_SUPPORTED
+#define KVM_PSCI_RET_INVAL              PSCI_RET_INVALID_PARAMS
+#define KVM_PSCI_RET_DENIED             PSCI_RET_DENIED
+
+#endif
+
+#endif /* __ARM_KVM_H__ */
diff --git a/tools/arch/arm64/include/uapi/asm/mman.h b/tools/arch/arm64/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..70fd3113710a
--- /dev/null
+++ b/tools/arch/arm64/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_ARM64_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_ARM64_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on arm64, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/arm64/include/uapi/asm/perf_regs.h b/tools/arch/arm64/include/uapi/asm/perf_regs.h
new file mode 100644
index 000000000000..172b8317ee49
--- /dev/null
+++ b/tools/arch/arm64/include/uapi/asm/perf_regs.h
@@ -0,0 +1,40 @@
+#ifndef _ASM_ARM64_PERF_REGS_H
+#define _ASM_ARM64_PERF_REGS_H
+
+enum perf_event_arm_regs {
+        PERF_REG_ARM64_X0,
+        PERF_REG_ARM64_X1,
+        PERF_REG_ARM64_X2,
+        PERF_REG_ARM64_X3,
+        PERF_REG_ARM64_X4,
+        PERF_REG_ARM64_X5,
+        PERF_REG_ARM64_X6,
+        PERF_REG_ARM64_X7,
+        PERF_REG_ARM64_X8,
+        PERF_REG_ARM64_X9,
+        PERF_REG_ARM64_X10,
+        PERF_REG_ARM64_X11,
+        PERF_REG_ARM64_X12,
+        PERF_REG_ARM64_X13,
+        PERF_REG_ARM64_X14,
+        PERF_REG_ARM64_X15,
+        PERF_REG_ARM64_X16,
+        PERF_REG_ARM64_X17,
+        PERF_REG_ARM64_X18,
+        PERF_REG_ARM64_X19,
+        PERF_REG_ARM64_X20,
+        PERF_REG_ARM64_X21,
+        PERF_REG_ARM64_X22,
+        PERF_REG_ARM64_X23,
+        PERF_REG_ARM64_X24,
+        PERF_REG_ARM64_X25,
+        PERF_REG_ARM64_X26,
+        PERF_REG_ARM64_X27,
+        PERF_REG_ARM64_X28,
+        PERF_REG_ARM64_X29,
+        PERF_REG_ARM64_LR,
+        PERF_REG_ARM64_SP,
+        PERF_REG_ARM64_PC,
+        PERF_REG_ARM64_MAX,
+};
+#endif /* _ASM_ARM64_PERF_REGS_H */
diff --git a/tools/arch/frv/include/uapi/asm/bitsperlong.h b/tools/arch/frv/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..6dc0bb0c13b2
--- /dev/null
+++ b/tools/arch/frv/include/uapi/asm/bitsperlong.h
@@ -0,0 +1 @@
+#include <asm-generic/bitsperlong.h>
diff --git a/tools/arch/frv/include/uapi/asm/mman.h b/tools/arch/frv/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..5be78ac12464
--- /dev/null
+++ b/tools/arch/frv/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_FRV_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_FRV_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on frv, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/h8300/include/asm/bitsperlong.h b/tools/arch/h8300/include/asm/bitsperlong.h
new file mode 100644
index 000000000000..e140e46729ac
--- /dev/null
+++ b/tools/arch/h8300/include/asm/bitsperlong.h
@@ -0,0 +1,14 @@
+#ifndef __ASM_H8300_BITS_PER_LONG
+#define __ASM_H8300_BITS_PER_LONG
+
+#include <asm-generic/bitsperlong.h>
+
+#if !defined(__ASSEMBLY__)
+/* h8300-unknown-linux required long */
+#define __kernel_size_t __kernel_size_t
+typedef unsigned long   __kernel_size_t;
+typedef long            __kernel_ssize_t;
+typedef long            __kernel_ptrdiff_t;
+#endif
+
+#endif /* __ASM_H8300_BITS_PER_LONG */
diff --git a/tools/arch/h8300/include/uapi/asm/mman.h b/tools/arch/h8300/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..9d9ac54d3c5a
--- /dev/null
+++ b/tools/arch/h8300/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_H8300_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_H8300_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on h8300, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/hexagon/include/uapi/asm/bitsperlong.h b/tools/arch/hexagon/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..4a658151383d
--- /dev/null
+++ b/tools/arch/hexagon/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU 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 __ASM_HEXAGON_BITSPERLONG_H
+#define __ASM_HEXAGON_BITSPERLONG_H
+
+#define __BITS_PER_LONG 32
+
+#include <asm-generic/bitsperlong.h>
+
+#endif
diff --git a/tools/arch/hexagon/include/uapi/asm/mman.h b/tools/arch/hexagon/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..102f3fae6085
--- /dev/null
+++ b/tools/arch/hexagon/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_HEXAGON_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_HEXAGON_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on hexagon, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/ia64/include/uapi/asm/bitsperlong.h b/tools/arch/ia64/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..ec4db3c970b7
--- /dev/null
+++ b/tools/arch/ia64/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_IA64_BITSPERLONG_H
+#define __ASM_IA64_BITSPERLONG_H
+
+#define __BITS_PER_LONG 64
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_IA64_BITSPERLONG_H */
diff --git a/tools/arch/ia64/include/uapi/asm/mman.h b/tools/arch/ia64/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..1d6e5ac6442d
--- /dev/null
+++ b/tools/arch/ia64/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_IA64_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_IA64_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on ia64, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/m32r/include/uapi/asm/bitsperlong.h b/tools/arch/m32r/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..6dc0bb0c13b2
--- /dev/null
+++ b/tools/arch/m32r/include/uapi/asm/bitsperlong.h
@@ -0,0 +1 @@
+#include <asm-generic/bitsperlong.h>
diff --git a/tools/arch/m32r/include/uapi/asm/mman.h b/tools/arch/m32r/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..1c29635bb73b
--- /dev/null
+++ b/tools/arch/m32r/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_M32R_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_M32R_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on m32r, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/microblaze/include/uapi/asm/bitsperlong.h b/tools/arch/microblaze/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..6dc0bb0c13b2
--- /dev/null
+++ b/tools/arch/microblaze/include/uapi/asm/bitsperlong.h
@@ -0,0 +1 @@
+#include <asm-generic/bitsperlong.h>
diff --git a/tools/arch/microblaze/include/uapi/asm/mman.h b/tools/arch/microblaze/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..005cd50b50e1
--- /dev/null
+++ b/tools/arch/microblaze/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_MICROBLAZE_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_MICROBLAZE_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on microblaze, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/mips/include/uapi/asm/bitsperlong.h b/tools/arch/mips/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..3e4c10a8e787
--- /dev/null
+++ b/tools/arch/mips/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,8 @@
+#ifndef __ASM_MIPS_BITSPERLONG_H
+#define __ASM_MIPS_BITSPERLONG_H
+
+#define __BITS_PER_LONG _MIPS_SZLONG
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_MIPS_BITSPERLONG_H */
diff --git a/tools/arch/mips/include/uapi/asm/kvm.h b/tools/arch/mips/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..6985eb59b085
--- /dev/null
+++ b/tools/arch/mips/include/uapi/asm/kvm.h
@@ -0,0 +1,208 @@
+/*
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2012  MIPS Technologies, Inc.  All rights reserved.
+ * Copyright (C) 2013 Cavium, Inc.
+ * Authors: Sanjay Lal <sanjayl@kymasys.com>
+ */
+
+#ifndef __LINUX_KVM_MIPS_H
+#define __LINUX_KVM_MIPS_H
+
+#include <linux/types.h>
+
+/*
+ * KVM MIPS specific structures and definitions.
+ *
+ * Some parts derived from the x86 version of this file.
+ */
+
+/*
+ * for KVM_GET_REGS and KVM_SET_REGS
+ *
+ * If Config[AT] is zero (32-bit CPU), the register contents are
+ * stored in the lower 32-bits of the struct kvm_regs fields and sign
+ * extended to 64-bits.
+ */
+struct kvm_regs {
+        /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
+        __u64 gpr[32];
+        __u64 hi;
+        __u64 lo;
+        __u64 pc;
+};
+
+/*
+ * for KVM_GET_FPU and KVM_SET_FPU
+ */
+struct kvm_fpu {
+};
+
+
+/*
+ * For MIPS, we use KVM_SET_ONE_REG and KVM_GET_ONE_REG to access various
+ * registers.  The id field is broken down as follows:
+ *
+ *  bits[63..52] - As per linux/kvm.h
+ *  bits[51..32] - Must be zero.
+ *  bits[31..16] - Register set.
+ *
+ * Register set = 0: GP registers from kvm_regs (see definitions below).
+ *
+ * Register set = 1: CP0 registers.
+ *  bits[15..8]  - Must be zero.
+ *  bits[7..3]   - Register 'rd'  index.
+ *  bits[2..0]   - Register 'sel' index.
+ *
+ * Register set = 2: KVM specific registers (see definitions below).
+ *
+ * Register set = 3: FPU / MSA registers (see definitions below).
+ *
+ * Other sets registers may be added in the future.  Each set would
+ * have its own identifier in bits[31..16].
+ */
+
+#define KVM_REG_MIPS_GP         (KVM_REG_MIPS | 0x0000000000000000ULL)
+#define KVM_REG_MIPS_CP0        (KVM_REG_MIPS | 0x0000000000010000ULL)
+#define KVM_REG_MIPS_KVM        (KVM_REG_MIPS | 0x0000000000020000ULL)
+#define KVM_REG_MIPS_FPU        (KVM_REG_MIPS | 0x0000000000030000ULL)
+
+
+/*
+ * KVM_REG_MIPS_GP - General purpose registers from kvm_regs.
+ */
+
+#define KVM_REG_MIPS_R0         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  0)
+#define KVM_REG_MIPS_R1         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  1)
+#define KVM_REG_MIPS_R2         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  2)
+#define KVM_REG_MIPS_R3         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  3)
+#define KVM_REG_MIPS_R4         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  4)
+#define KVM_REG_MIPS_R5         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  5)
+#define KVM_REG_MIPS_R6         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  6)
+#define KVM_REG_MIPS_R7         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  7)
+#define KVM_REG_MIPS_R8         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  8)
+#define KVM_REG_MIPS_R9         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 |  9)
+#define KVM_REG_MIPS_R10        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 10)
+#define KVM_REG_MIPS_R11        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 11)
+#define KVM_REG_MIPS_R12        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 12)
+#define KVM_REG_MIPS_R13        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 13)
+#define KVM_REG_MIPS_R14        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 14)
+#define KVM_REG_MIPS_R15        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 15)
+#define KVM_REG_MIPS_R16        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 16)
+#define KVM_REG_MIPS_R17        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 17)
+#define KVM_REG_MIPS_R18        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 18)
+#define KVM_REG_MIPS_R19        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 19)
+#define KVM_REG_MIPS_R20        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 20)
+#define KVM_REG_MIPS_R21        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 21)
+#define KVM_REG_MIPS_R22        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 22)
+#define KVM_REG_MIPS_R23        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 23)
+#define KVM_REG_MIPS_R24        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 24)
+#define KVM_REG_MIPS_R25        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 25)
+#define KVM_REG_MIPS_R26        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 26)
+#define KVM_REG_MIPS_R27        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 27)
+#define KVM_REG_MIPS_R28        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 28)
+#define KVM_REG_MIPS_R29        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 29)
+#define KVM_REG_MIPS_R30        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 30)
+#define KVM_REG_MIPS_R31        (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 31)
+
+#define KVM_REG_MIPS_HI         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 32)
+#define KVM_REG_MIPS_LO         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 33)
+#define KVM_REG_MIPS_PC         (KVM_REG_MIPS_GP | KVM_REG_SIZE_U64 | 34)
+
+
+/*
+ * KVM_REG_MIPS_KVM - KVM specific control registers.
+ */
+
+/*
+ * CP0_Count control
+ * DC:    Set 0: Master disable CP0_Count and set COUNT_RESUME to now
+ *        Set 1: Master re-enable CP0_Count with unchanged bias, handling timer
+ *               interrupts since COUNT_RESUME
+ *        This can be used to freeze the timer to get a consistent snapshot of
+ *        the CP0_Count and timer interrupt pending state, while also resuming
+ *        safely without losing time or guest timer interrupts.
+ * Other: Reserved, do not change.
+ */
+#define KVM_REG_MIPS_COUNT_CTL      (KVM_REG_MIPS_KVM | KVM_REG_SIZE_U64 | 0)
+#define KVM_REG_MIPS_COUNT_CTL_DC       0x00000001
+
+/*
+ * CP0_Count resume monotonic nanoseconds
+ * The monotonic nanosecond time of the last set of COUNT_CTL.DC (master
+ * disable). Any reads and writes of Count related registers while
+ * COUNT_CTL.DC=1 will appear to occur at this time. When COUNT_CTL.DC is
+ * cleared again (master enable) any timer interrupts since this time will be
+ * emulated.
+ * Modifications to times in the future are rejected.
+ */
+#define KVM_REG_MIPS_COUNT_RESUME   (KVM_REG_MIPS_KVM | KVM_REG_SIZE_U64 | 1)
+/*
+ * CP0_Count rate in Hz
+ * Specifies the rate of the CP0_Count timer in Hz. Modifications occur without
+ * discontinuities in CP0_Count.
+ */
+#define KVM_REG_MIPS_COUNT_HZ       (KVM_REG_MIPS_KVM | KVM_REG_SIZE_U64 | 2)
+
+
+/*
+ * KVM_REG_MIPS_FPU - Floating Point and MIPS SIMD Architecture (MSA) registers.
+ *
+ *  bits[15..8]  - Register subset (see definitions below).
+ *  bits[7..5]   - Must be zero.
+ *  bits[4..0]   - Register number within register subset.
+ */
+
+#define KVM_REG_MIPS_FPR        (KVM_REG_MIPS_FPU | 0x0000000000000000ULL)
+#define KVM_REG_MIPS_FCR        (KVM_REG_MIPS_FPU | 0x0000000000000100ULL)
+#define KVM_REG_MIPS_MSACR      (KVM_REG_MIPS_FPU | 0x0000000000000200ULL)
+
+/*
+ * KVM_REG_MIPS_FPR - Floating point / Vector registers.
+ */
+#define KVM_REG_MIPS_FPR_32(n)  (KVM_REG_MIPS_FPR | KVM_REG_SIZE_U32  | (n))
+#define KVM_REG_MIPS_FPR_64(n)  (KVM_REG_MIPS_FPR | KVM_REG_SIZE_U64  | (n))
+#define KVM_REG_MIPS_VEC_128(n) (KVM_REG_MIPS_FPR | KVM_REG_SIZE_U128 | (n))
+
+/*
+ * KVM_REG_MIPS_FCR - Floating point control registers.
+ */
+#define KVM_REG_MIPS_FCR_IR     (KVM_REG_MIPS_FCR | KVM_REG_SIZE_U32 |  0)
+#define KVM_REG_MIPS_FCR_CSR    (KVM_REG_MIPS_FCR | KVM_REG_SIZE_U32 | 31)
+
+/*
+ * KVM_REG_MIPS_MSACR - MIPS SIMD Architecture (MSA) control registers.
+ */
+#define KVM_REG_MIPS_MSA_IR      (KVM_REG_MIPS_MSACR | KVM_REG_SIZE_U32 |  0)
+#define KVM_REG_MIPS_MSA_CSR     (KVM_REG_MIPS_MSACR | KVM_REG_SIZE_U32 |  1)
+
+
+/*
+ * KVM MIPS specific structures and definitions
+ *
+ */
+struct kvm_debug_exit_arch {
+        __u64 epc;
+};
+
+/* for KVM_SET_GUEST_DEBUG */
+struct kvm_guest_debug_arch {
+};
+
+/* definition of registers in kvm_run */
+struct kvm_sync_regs {
+};
+
+/* dummy definition */
+struct kvm_sregs {
+};
+
+struct kvm_mips_interrupt {
+        /* in */
+        __u32 cpu;
+        __u32 irq;
+};
+
+#endif /* __LINUX_KVM_MIPS_H */
diff --git a/tools/arch/mips/include/uapi/asm/mman.h b/tools/arch/mips/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..c02052965d50
--- /dev/null
+++ b/tools/arch/mips/include/uapi/asm/mman.h
@@ -0,0 +1,46 @@
+#ifndef TOOLS_ARCH_MIPS_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_MIPS_UAPI_ASM_MMAN_FIX_H
+#define MADV_DODUMP     17
+#define MADV_DOFORK     11
+#define MADV_DONTDUMP   16
+#define MADV_DONTFORK   10
+#define MADV_DONTNEED   4
+#define MADV_FREE       8
+#define MADV_HUGEPAGE   14
+#define MADV_HWPOISON    100
+#define MADV_MERGEABLE   12
+#define MADV_NOHUGEPAGE 15
+#define MADV_NORMAL     0
+#define MADV_RANDOM     1
+#define MADV_REMOVE     9
+#define MADV_SEQUENTIAL 2
+#define MADV_UNMERGEABLE 13
+#define MADV_WILLNEED   3
+#define MAP_ANONYMOUS   0x0800
+#define MAP_DENYWRITE   0x2000
+#define MAP_EXECUTABLE  0x4000
+#define MAP_FILE        0
+#define MAP_FIXED       0x010
+#define MAP_GROWSDOWN   0x1000
+#define MAP_HUGETLB     0x80000
+#define MAP_LOCKED      0x8000
+#define MAP_NONBLOCK    0x20000
+#define MAP_NORESERVE   0x0400
+#define MAP_POPULATE    0x10000
+#define MAP_PRIVATE     0x002
+#define MAP_SHARED      0x001
+#define MAP_STACK       0x40000
+#define PROT_EXEC       0x04
+#define PROT_GROWSDOWN  0x01000000
+#define PROT_GROWSUP    0x02000000
+#define PROT_NONE       0x00
+#define PROT_READ       0x01
+#define PROT_SEM        0x10
+#define PROT_WRITE      0x02
+/* MADV_SOFT_OFFLINE is undefined on mips, fix it for perf */
+#define MADV_SOFT_OFFLINE 101
+/* MAP_32BIT is undefined on mips, fix it for perf */
+#define MAP_32BIT       0
+/* MAP_UNINITIALIZED is undefined on mips, fix it for perf */
+#define MAP_UNINITIALIZED       0
+#endif
diff --git a/tools/arch/mn10300/include/uapi/asm/bitsperlong.h b/tools/arch/mn10300/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..6dc0bb0c13b2
--- /dev/null
+++ b/tools/arch/mn10300/include/uapi/asm/bitsperlong.h
@@ -0,0 +1 @@
+#include <asm-generic/bitsperlong.h>
diff --git a/tools/arch/mn10300/include/uapi/asm/mman.h b/tools/arch/mn10300/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..c1ea36d83acc
--- /dev/null
+++ b/tools/arch/mn10300/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_MN10300_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_MN10300_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on mn10300, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/parisc/include/uapi/asm/bitsperlong.h b/tools/arch/parisc/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..e0a23c7bdd43
--- /dev/null
+++ b/tools/arch/parisc/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,14 @@
+#ifndef __ASM_PARISC_BITSPERLONG_H
+#define __ASM_PARISC_BITSPERLONG_H
+
+#if defined(__LP64__)
+#define __BITS_PER_LONG 64
+#define SHIFT_PER_LONG 6
+#else
+#define __BITS_PER_LONG 32
+#define SHIFT_PER_LONG 5
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_PARISC_BITSPERLONG_H */
diff --git a/tools/arch/parisc/include/uapi/asm/mman.h b/tools/arch/parisc/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..03d8d5b7ae7f
--- /dev/null
+++ b/tools/arch/parisc/include/uapi/asm/mman.h
@@ -0,0 +1,47 @@
+#ifndef TOOLS_ARCH_PARISC_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_PARISC_UAPI_ASM_MMAN_FIX_H
+#define MADV_DODUMP     70
+#define MADV_DOFORK     11
+#define MADV_DONTDUMP   69
+#define MADV_DONTFORK   10
+#define MADV_DONTNEED   4
+#define MADV_FREE       8
+#define MADV_HUGEPAGE   67
+#define MADV_MERGEABLE   65
+#define MADV_NOHUGEPAGE 68
+#define MADV_NORMAL     0
+#define MADV_RANDOM     1
+#define MADV_REMOVE     9
+#define MADV_SEQUENTIAL 2
+#define MADV_UNMERGEABLE 66
+#define MADV_WILLNEED   3
+#define MAP_ANONYMOUS   0x10
+#define MAP_DENYWRITE   0x0800
+#define MAP_EXECUTABLE  0x1000
+#define MAP_FILE        0
+#define MAP_FIXED       0x04
+#define MAP_GROWSDOWN   0x8000
+#define MAP_HUGETLB     0x80000
+#define MAP_LOCKED      0x2000
+#define MAP_NONBLOCK    0x20000
+#define MAP_NORESERVE   0x4000
+#define MAP_POPULATE    0x10000
+#define MAP_PRIVATE     0x02
+#define MAP_SHARED      0x01
+#define MAP_STACK       0x40000
+#define PROT_EXEC       0x4
+#define PROT_GROWSDOWN  0x01000000
+#define PROT_GROWSUP    0x02000000
+#define PROT_NONE       0x0
+#define PROT_READ       0x1
+#define PROT_SEM        0x8
+#define PROT_WRITE      0x2
+/* MADV_HWPOISON is undefined on parisc, fix it for perf */
+#define MADV_HWPOISON   100
+/* MADV_SOFT_OFFLINE is undefined on parisc, fix it for perf */
+#define MADV_SOFT_OFFLINE 101
+/* MAP_32BIT is undefined on parisc, fix it for perf */
+#define MAP_32BIT       0
+/* MAP_UNINITIALIZED is undefined on parisc, fix it for perf */
+#define MAP_UNINITIALIZED       0
+#endif
diff --git a/tools/arch/powerpc/include/uapi/asm/bitsperlong.h b/tools/arch/powerpc/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..5f1659032c40
--- /dev/null
+++ b/tools/arch/powerpc/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_POWERPC_BITSPERLONG_H
+#define __ASM_POWERPC_BITSPERLONG_H
+
+#if defined(__powerpc64__)
+# define __BITS_PER_LONG 64
+#else
+# define __BITS_PER_LONG 32
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_POWERPC_BITSPERLONG_H */
diff --git a/tools/arch/powerpc/include/uapi/asm/kvm.h b/tools/arch/powerpc/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..c93cf35ce379
--- /dev/null
+++ b/tools/arch/powerpc/include/uapi/asm/kvm.h
@@ -0,0 +1,612 @@
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2, as
+ * published by the Free Software Foundation.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ * Copyright IBM Corp. 2007
+ *
+ * Authors: Hollis Blanchard <hollisb@us.ibm.com>
+ */
+
+#ifndef __LINUX_KVM_POWERPC_H
+#define __LINUX_KVM_POWERPC_H
+
+#include <linux/types.h>
+
+/* Select powerpc specific features in <linux/kvm.h> */
+#define __KVM_HAVE_SPAPR_TCE
+#define __KVM_HAVE_PPC_SMT
+#define __KVM_HAVE_IRQCHIP
+#define __KVM_HAVE_IRQ_LINE
+#define __KVM_HAVE_GUEST_DEBUG
+
+struct kvm_regs {
+        __u64 pc;
+        __u64 cr;
+        __u64 ctr;
+        __u64 lr;
+        __u64 xer;
+        __u64 msr;
+        __u64 srr0;
+        __u64 srr1;
+        __u64 pid;
+
+        __u64 sprg0;
+        __u64 sprg1;
+        __u64 sprg2;
+        __u64 sprg3;
+        __u64 sprg4;
+        __u64 sprg5;
+        __u64 sprg6;
+        __u64 sprg7;
+
+        __u64 gpr[32];
+};
+
+#define KVM_SREGS_E_IMPL_NONE   0
+#define KVM_SREGS_E_IMPL_FSL    1
+
+#define KVM_SREGS_E_FSL_PIDn    (1 << 0) /* PID1/PID2 */
+
+/*
+ * Feature bits indicate which sections of the sregs struct are valid,
+ * both in KVM_GET_SREGS and KVM_SET_SREGS.  On KVM_SET_SREGS, registers
+ * corresponding to unset feature bits will not be modified.  This allows
+ * restoring a checkpoint made without that feature, while keeping the
+ * default values of the new registers.
+ *
+ * KVM_SREGS_E_BASE contains:
+ * CSRR0/1 (refers to SRR2/3 on 40x)
+ * ESR
+ * DEAR
+ * MCSR
+ * TSR
+ * TCR
+ * DEC
+ * TB
+ * VRSAVE (USPRG0)
+ */
+#define KVM_SREGS_E_BASE                (1 << 0)
+
+/*
+ * KVM_SREGS_E_ARCH206 contains:
+ *
+ * PIR
+ * MCSRR0/1
+ * DECAR
+ * IVPR
+ */
+#define KVM_SREGS_E_ARCH206             (1 << 1)
+
+/*
+ * Contains EPCR, plus the upper half of 64-bit registers
+ * that are 32-bit on 32-bit implementations.
+ */
+#define KVM_SREGS_E_64                  (1 << 2)
+
+#define KVM_SREGS_E_SPRG8               (1 << 3)
+#define KVM_SREGS_E_MCIVPR              (1 << 4)
+
+/*
+ * IVORs are used -- contains IVOR0-15, plus additional IVORs
+ * in combination with an appropriate feature bit.
+ */
+#define KVM_SREGS_E_IVOR                (1 << 5)
+
+/*
+ * Contains MAS0-4, MAS6-7, TLBnCFG, MMUCFG.
+ * Also TLBnPS if MMUCFG[MAVN] = 1.
+ */
+#define KVM_SREGS_E_ARCH206_MMU         (1 << 6)
+
+/* DBSR, DBCR, IAC, DAC, DVC */
+#define KVM_SREGS_E_DEBUG               (1 << 7)
+
+/* Enhanced debug -- DSRR0/1, SPRG9 */
+#define KVM_SREGS_E_ED                  (1 << 8)
+
+/* Embedded Floating Point (SPE) -- IVOR32-34 if KVM_SREGS_E_IVOR */
+#define KVM_SREGS_E_SPE                 (1 << 9)
+
+/*
+ * DEPRECATED! USE ONE_REG FOR THIS ONE!
+ * External Proxy (EXP) -- EPR
+ */
+#define KVM_SREGS_EXP                   (1 << 10)
+
+/* External PID (E.PD) -- EPSC/EPLC */
+#define KVM_SREGS_E_PD                  (1 << 11)
+
+/* Processor Control (E.PC) -- IVOR36-37 if KVM_SREGS_E_IVOR */
+#define KVM_SREGS_E_PC                  (1 << 12)
+
+/* Page table (E.PT) -- EPTCFG */
+#define KVM_SREGS_E_PT                  (1 << 13)
+
+/* Embedded Performance Monitor (E.PM) -- IVOR35 if KVM_SREGS_E_IVOR */
+#define KVM_SREGS_E_PM                  (1 << 14)
+
+/*
+ * Special updates:
+ *
+ * Some registers may change even while a vcpu is not running.
+ * To avoid losing these changes, by default these registers are
+ * not updated by KVM_SET_SREGS.  To force an update, set the bit
+ * in u.e.update_special corresponding to the register to be updated.
+ *
+ * The update_special field is zero on return from KVM_GET_SREGS.
+ *
+ * When restoring a checkpoint, the caller can set update_special
+ * to 0xffffffff to ensure that everything is restored, even new features
+ * that the caller doesn't know about.
+ */
+#define KVM_SREGS_E_UPDATE_MCSR         (1 << 0)
+#define KVM_SREGS_E_UPDATE_TSR          (1 << 1)
+#define KVM_SREGS_E_UPDATE_DEC          (1 << 2)
+#define KVM_SREGS_E_UPDATE_DBSR         (1 << 3)
+
+/*
+ * In KVM_SET_SREGS, reserved/pad fields must be left untouched from a
+ * previous KVM_GET_REGS.
+ *
+ * Unless otherwise indicated, setting any register with KVM_SET_SREGS
+ * directly sets its value.  It does not trigger any special semantics such
+ * as write-one-to-clear.  Calling KVM_SET_SREGS on an unmodified struct
+ * just received from KVM_GET_SREGS is always a no-op.
+ */
+struct kvm_sregs {
+        __u32 pvr;
+        union {
+                struct {
+                        __u64 sdr1;
+                        struct {
+                                struct {
+                                        __u64 slbe;
+                                        __u64 slbv;
+                                } slb[64];
+                        } ppc64;
+                        struct {
+                                __u32 sr[16];
+                                __u64 ibat[8];
+                                __u64 dbat[8];
+                        } ppc32;
+                } s;
+                struct {
+                        union {
+                                struct { /* KVM_SREGS_E_IMPL_FSL */
+                                        __u32 features; /* KVM_SREGS_E_FSL_ */
+                                        __u32 svr;
+                                        __u64 mcar;
+                                        __u32 hid0;
+
+                                        /* KVM_SREGS_E_FSL_PIDn */
+                                        __u32 pid1, pid2;
+                                } fsl;
+                                __u8 pad[256];
+                        } impl;
+
+                        __u32 features; /* KVM_SREGS_E_ */
+                        __u32 impl_id;  /* KVM_SREGS_E_IMPL_ */
+                        __u32 update_special; /* KVM_SREGS_E_UPDATE_ */
+                        __u32 pir;      /* read-only */
+                        __u64 sprg8;
+                        __u64 sprg9;    /* E.ED */
+                        __u64 csrr0;
+                        __u64 dsrr0;    /* E.ED */
+                        __u64 mcsrr0;
+                        __u32 csrr1;
+                        __u32 dsrr1;    /* E.ED */
+                        __u32 mcsrr1;
+                        __u32 esr;
+                        __u64 dear;
+                        __u64 ivpr;
+                        __u64 mcivpr;
+                        __u64 mcsr;     /* KVM_SREGS_E_UPDATE_MCSR */
+
+                        __u32 tsr;      /* KVM_SREGS_E_UPDATE_TSR */
+                        __u32 tcr;
+                        __u32 decar;
+                        __u32 dec;      /* KVM_SREGS_E_UPDATE_DEC */
+
+                        /*
+                         * Userspace can read TB directly, but the
+                         * value reported here is consistent with "dec".
+                         *
+                         * Read-only.
+                         */
+                        __u64 tb;
+
+                        __u32 dbsr;     /* KVM_SREGS_E_UPDATE_DBSR */
+                        __u32 dbcr[3];
+                        /*
+                         * iac/dac registers are 64bit wide, while this API
+                         * interface provides only lower 32 bits on 64 bit
+                         * processors. ONE_REG interface is added for 64bit
+                         * iac/dac registers.
+                         */
+                        __u32 iac[4];
+                        __u32 dac[2];
+                        __u32 dvc[2];
+                        __u8 num_iac;   /* read-only */
+                        __u8 num_dac;   /* read-only */
+                        __u8 num_dvc;   /* read-only */
+                        __u8 pad;
+
+                        __u32 epr;      /* EXP */
+                        __u32 vrsave;   /* a.k.a. USPRG0 */
+                        __u32 epcr;     /* KVM_SREGS_E_64 */
+
+                        __u32 mas0;
+                        __u32 mas1;
+                        __u64 mas2;
+                        __u64 mas7_3;
+                        __u32 mas4;
+                        __u32 mas6;
+
+                        __u32 ivor_low[16]; /* IVOR0-15 */
+                        __u32 ivor_high[18]; /* IVOR32+, plus room to expand */
+
+                        __u32 mmucfg;   /* read-only */
+                        __u32 eptcfg;   /* E.PT, read-only */
+                        __u32 tlbcfg[4];/* read-only */
+                        __u32 tlbps[4]; /* read-only */
+
+                        __u32 eplc, epsc; /* E.PD */
+                } e;
+                __u8 pad[1020];
+        } u;
+};
+
+struct kvm_fpu {
+        __u64 fpr[32];
+};
+
+/*
+ * Defines for h/w breakpoint, watchpoint (read, write or both) and
+ * software breakpoint.
+ * These are used as "type" in KVM_SET_GUEST_DEBUG ioctl and "status"
+ * for KVM_DEBUG_EXIT.
+ */
+#define KVMPPC_DEBUG_NONE               0x0
+#define KVMPPC_DEBUG_BREAKPOINT         (1UL << 1)
+#define KVMPPC_DEBUG_WATCH_WRITE        (1UL << 2)
+#define KVMPPC_DEBUG_WATCH_READ         (1UL << 3)
+struct kvm_debug_exit_arch {
+        __u64 address;
+        /*
+         * exiting to userspace because of h/w breakpoint, watchpoint
+         * (read, write or both) and software breakpoint.
+         */
+        __u32 status;
+        __u32 reserved;
+};
+
+/* for KVM_SET_GUEST_DEBUG */
+struct kvm_guest_debug_arch {
+        struct {
+                /* H/W breakpoint/watchpoint address */
+                __u64 addr;
+                /*
+                 * Type denotes h/w breakpoint, read watchpoint, write
+                 * watchpoint or watchpoint (both read and write).
+                 */
+                __u32 type;
+                __u32 reserved;
+        } bp[16];
+};
+
+/* Debug related defines */
+/*
+ * kvm_guest_debug->control is a 32 bit field. The lower 16 bits are generic
+ * and upper 16 bits are architecture specific. Architecture specific defines
+ * that ioctl is for setting hardware breakpoint or software breakpoint.
+ */
+#define KVM_GUESTDBG_USE_SW_BP          0x00010000
+#define KVM_GUESTDBG_USE_HW_BP          0x00020000
+
+/* definition of registers in kvm_run */
+struct kvm_sync_regs {
+};
+
+#define KVM_INTERRUPT_SET       -1U
+#define KVM_INTERRUPT_UNSET     -2U
+#define KVM_INTERRUPT_SET_LEVEL -3U
+
+#define KVM_CPU_440             1
+#define KVM_CPU_E500V2          2
+#define KVM_CPU_3S_32           3
+#define KVM_CPU_3S_64           4
+#define KVM_CPU_E500MC          5
+
+/* for KVM_CAP_SPAPR_TCE */
+struct kvm_create_spapr_tce {
+        __u64 liobn;
+        __u32 window_size;
+};
+
+/* for KVM_CAP_SPAPR_TCE_64 */
+struct kvm_create_spapr_tce_64 {
+        __u64 liobn;
+        __u32 page_shift;
+        __u32 flags;
+        __u64 offset;   /* in pages */
+        __u64 size;     /* in pages */
+};
+
+/* for KVM_ALLOCATE_RMA */
+struct kvm_allocate_rma {
+        __u64 rma_size;
+};
+
+/* for KVM_CAP_PPC_RTAS */
+struct kvm_rtas_token_args {
+        char name[120];
+        __u64 token;    /* Use a token of 0 to undefine a mapping */
+};
+
+struct kvm_book3e_206_tlb_entry {
+        __u32 mas8;
+        __u32 mas1;
+        __u64 mas2;
+        __u64 mas7_3;
+};
+
+struct kvm_book3e_206_tlb_params {
+        /*
+         * For mmu types KVM_MMU_FSL_BOOKE_NOHV and KVM_MMU_FSL_BOOKE_HV:
+         *
+         * - The number of ways of TLB0 must be a power of two between 2 and
+         *   16.
+         * - TLB1 must be fully associative.
+         * - The size of TLB0 must be a multiple of the number of ways, and
+         *   the number of sets must be a power of two.
+         * - The size of TLB1 may not exceed 64 entries.
+         * - TLB0 supports 4 KiB pages.
+         * - The page sizes supported by TLB1 are as indicated by
+         *   TLB1CFG (if MMUCFG[MAVN] = 0) or TLB1PS (if MMUCFG[MAVN] = 1)
+         *   as returned by KVM_GET_SREGS.
+         * - TLB2 and TLB3 are reserved, and their entries in tlb_sizes[]
+         *   and tlb_ways[] must be zero.
+         *
+         * tlb_ways[n] = tlb_sizes[n] means the array is fully associative.
+         *
+         * KVM will adjust TLBnCFG based on the sizes configured here,
+         * though arrays greater than 2048 entries will have TLBnCFG[NENTRY]
+         * set to zero.
+         */
+        __u32 tlb_sizes[4];
+        __u32 tlb_ways[4];
+        __u32 reserved[8];
+};
+
+/* For KVM_PPC_GET_HTAB_FD */
+struct kvm_get_htab_fd {
+        __u64   flags;
+        __u64   start_index;
+        __u64   reserved[2];
+};
+
+/* Values for kvm_get_htab_fd.flags */
+#define KVM_GET_HTAB_BOLTED_ONLY        ((__u64)0x1)
+#define KVM_GET_HTAB_WRITE              ((__u64)0x2)
+
+/*
+ * Data read on the file descriptor is formatted as a series of
+ * records, each consisting of a header followed by a series of
+ * `n_valid' HPTEs (16 bytes each), which are all valid.  Following
+ * those valid HPTEs there are `n_invalid' invalid HPTEs, which
+ * are not represented explicitly in the stream.  The same format
+ * is used for writing.
+ */
+struct kvm_get_htab_header {
+        __u32   index;
+        __u16   n_valid;
+        __u16   n_invalid;
+};
+
+/* Per-vcpu XICS interrupt controller state */
+#define KVM_REG_PPC_ICP_STATE   (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x8c)
+
+#define  KVM_REG_PPC_ICP_CPPR_SHIFT     56      /* current proc priority */
+#define  KVM_REG_PPC_ICP_CPPR_MASK      0xff
+#define  KVM_REG_PPC_ICP_XISR_SHIFT     32      /* interrupt status field */
+#define  KVM_REG_PPC_ICP_XISR_MASK      0xffffff
+#define  KVM_REG_PPC_ICP_MFRR_SHIFT     24      /* pending IPI priority */
+#define  KVM_REG_PPC_ICP_MFRR_MASK      0xff
+#define  KVM_REG_PPC_ICP_PPRI_SHIFT     16      /* pending irq priority */
+#define  KVM_REG_PPC_ICP_PPRI_MASK      0xff
+
+/* Device control API: PPC-specific devices */
+#define KVM_DEV_MPIC_GRP_MISC           1
+#define   KVM_DEV_MPIC_BASE_ADDR        0       /* 64-bit */
+
+#define KVM_DEV_MPIC_GRP_REGISTER       2       /* 32-bit */
+#define KVM_DEV_MPIC_GRP_IRQ_ACTIVE     3       /* 32-bit */
+
+/* One-Reg API: PPC-specific registers */
+#define KVM_REG_PPC_HIOR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x1)
+#define KVM_REG_PPC_IAC1        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x2)
+#define KVM_REG_PPC_IAC2        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x3)
+#define KVM_REG_PPC_IAC3        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x4)
+#define KVM_REG_PPC_IAC4        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x5)
+#define KVM_REG_PPC_DAC1        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x6)
+#define KVM_REG_PPC_DAC2        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x7)
+#define KVM_REG_PPC_DABR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x8)
+#define KVM_REG_PPC_DSCR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x9)
+#define KVM_REG_PPC_PURR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa)
+#define KVM_REG_PPC_SPURR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb)
+#define KVM_REG_PPC_DAR         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xc)
+#define KVM_REG_PPC_DSISR       (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xd)
+#define KVM_REG_PPC_AMR         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xe)
+#define KVM_REG_PPC_UAMOR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xf)
+
+#define KVM_REG_PPC_MMCR0       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x10)
+#define KVM_REG_PPC_MMCR1       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x11)
+#define KVM_REG_PPC_MMCRA       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x12)
+#define KVM_REG_PPC_MMCR2       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x13)
+#define KVM_REG_PPC_MMCRS       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x14)
+#define KVM_REG_PPC_SIAR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x15)
+#define KVM_REG_PPC_SDAR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x16)
+#define KVM_REG_PPC_SIER        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x17)
+
+#define KVM_REG_PPC_PMC1        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x18)
+#define KVM_REG_PPC_PMC2        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x19)
+#define KVM_REG_PPC_PMC3        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1a)
+#define KVM_REG_PPC_PMC4        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1b)
+#define KVM_REG_PPC_PMC5        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1c)
+#define KVM_REG_PPC_PMC6        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1d)
+#define KVM_REG_PPC_PMC7        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1e)
+#define KVM_REG_PPC_PMC8        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x1f)
+
+/* 32 floating-point registers */
+#define KVM_REG_PPC_FPR0        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x20)
+#define KVM_REG_PPC_FPR(n)      (KVM_REG_PPC_FPR0 + (n))
+#define KVM_REG_PPC_FPR31       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x3f)
+
+/* 32 VMX/Altivec vector registers */
+#define KVM_REG_PPC_VR0         (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x40)
+#define KVM_REG_PPC_VR(n)       (KVM_REG_PPC_VR0 + (n))
+#define KVM_REG_PPC_VR31        (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x5f)
+
+/* 32 double-width FP registers for VSX */
+/* High-order halves overlap with FP regs */
+#define KVM_REG_PPC_VSR0        (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x60)
+#define KVM_REG_PPC_VSR(n)      (KVM_REG_PPC_VSR0 + (n))
+#define KVM_REG_PPC_VSR31       (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x7f)
+
+/* FP and vector status/control registers */
+#define KVM_REG_PPC_FPSCR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x80)
+/*
+ * VSCR register is documented as a 32-bit register in the ISA, but it can
+ * only be accesses via a vector register. Expose VSCR as a 32-bit register
+ * even though the kernel represents it as a 128-bit vector.
+ */
+#define KVM_REG_PPC_VSCR        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x81)
+
+/* Virtual processor areas */
+/* For SLB & DTL, address in high (first) half, length in low half */
+#define KVM_REG_PPC_VPA_ADDR    (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x82)
+#define KVM_REG_PPC_VPA_SLB     (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x83)
+#define KVM_REG_PPC_VPA_DTL     (KVM_REG_PPC | KVM_REG_SIZE_U128 | 0x84)
+
+#define KVM_REG_PPC_EPCR        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x85)
+#define KVM_REG_PPC_EPR         (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x86)
+
+/* Timer Status Register OR/CLEAR interface */
+#define KVM_REG_PPC_OR_TSR      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x87)
+#define KVM_REG_PPC_CLEAR_TSR   (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x88)
+#define KVM_REG_PPC_TCR         (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x89)
+#define KVM_REG_PPC_TSR         (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x8a)
+
+/* Debugging: Special instruction for software breakpoint */
+#define KVM_REG_PPC_DEBUG_INST  (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x8b)
+
+/* MMU registers */
+#define KVM_REG_PPC_MAS0        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x8c)
+#define KVM_REG_PPC_MAS1        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x8d)
+#define KVM_REG_PPC_MAS2        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x8e)
+#define KVM_REG_PPC_MAS7_3      (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x8f)
+#define KVM_REG_PPC_MAS4        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x90)
+#define KVM_REG_PPC_MAS6        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x91)
+#define KVM_REG_PPC_MMUCFG      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x92)
+/*
+ * TLBnCFG fields TLBnCFG_N_ENTRY and TLBnCFG_ASSOC can be changed only using
+ * KVM_CAP_SW_TLB ioctl
+ */
+#define KVM_REG_PPC_TLB0CFG     (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x93)
+#define KVM_REG_PPC_TLB1CFG     (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x94)
+#define KVM_REG_PPC_TLB2CFG     (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x95)
+#define KVM_REG_PPC_TLB3CFG     (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x96)
+#define KVM_REG_PPC_TLB0PS      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x97)
+#define KVM_REG_PPC_TLB1PS      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x98)
+#define KVM_REG_PPC_TLB2PS      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x99)
+#define KVM_REG_PPC_TLB3PS      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9a)
+#define KVM_REG_PPC_EPTCFG      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9b)
+
+/* Timebase offset */
+#define KVM_REG_PPC_TB_OFFSET   (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x9c)
+
+/* POWER8 registers */
+#define KVM_REG_PPC_SPMC1       (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9d)
+#define KVM_REG_PPC_SPMC2       (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0x9e)
+#define KVM_REG_PPC_IAMR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0x9f)
+#define KVM_REG_PPC_TFHAR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa0)
+#define KVM_REG_PPC_TFIAR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa1)
+#define KVM_REG_PPC_TEXASR      (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa2)
+#define KVM_REG_PPC_FSCR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa3)
+#define KVM_REG_PPC_PSPB        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xa4)
+#define KVM_REG_PPC_EBBHR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa5)
+#define KVM_REG_PPC_EBBRR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa6)
+#define KVM_REG_PPC_BESCR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa7)
+#define KVM_REG_PPC_TAR         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa8)
+#define KVM_REG_PPC_DPDES       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xa9)
+#define KVM_REG_PPC_DAWR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xaa)
+#define KVM_REG_PPC_DAWRX       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xab)
+#define KVM_REG_PPC_CIABR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xac)
+#define KVM_REG_PPC_IC          (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xad)
+#define KVM_REG_PPC_VTB         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xae)
+#define KVM_REG_PPC_CSIGR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xaf)
+#define KVM_REG_PPC_TACR        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb0)
+#define KVM_REG_PPC_TCSCR       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb1)
+#define KVM_REG_PPC_PID         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb2)
+#define KVM_REG_PPC_ACOP        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb3)
+
+#define KVM_REG_PPC_VRSAVE      (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb4)
+#define KVM_REG_PPC_LPCR        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb5)
+#define KVM_REG_PPC_LPCR_64     (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb5)
+#define KVM_REG_PPC_PPR         (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb6)
+
+/* Architecture compatibility level */
+#define KVM_REG_PPC_ARCH_COMPAT (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb7)
+
+#define KVM_REG_PPC_DABRX       (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xb8)
+#define KVM_REG_PPC_WORT        (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xb9)
+#define KVM_REG_PPC_SPRG9       (KVM_REG_PPC | KVM_REG_SIZE_U64 | 0xba)
+#define KVM_REG_PPC_DBSR        (KVM_REG_PPC | KVM_REG_SIZE_U32 | 0xbb)
+
+/* Transactional Memory checkpointed state:
+ * This is all GPRs, all VSX regs and a subset of SPRs
+ */
+#define KVM_REG_PPC_TM          (KVM_REG_PPC | 0x80000000)
+/* TM GPRs */
+#define KVM_REG_PPC_TM_GPR0     (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0)
+#define KVM_REG_PPC_TM_GPR(n)   (KVM_REG_PPC_TM_GPR0 + (n))
+#define KVM_REG_PPC_TM_GPR31    (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x1f)
+/* TM VSX */
+#define KVM_REG_PPC_TM_VSR0     (KVM_REG_PPC_TM | KVM_REG_SIZE_U128 | 0x20)
+#define KVM_REG_PPC_TM_VSR(n)   (KVM_REG_PPC_TM_VSR0 + (n))
+#define KVM_REG_PPC_TM_VSR63    (KVM_REG_PPC_TM | KVM_REG_SIZE_U128 | 0x5f)
+/* TM SPRS */
+#define KVM_REG_PPC_TM_CR       (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x60)
+#define KVM_REG_PPC_TM_LR       (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x61)
+#define KVM_REG_PPC_TM_CTR      (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x62)
+#define KVM_REG_PPC_TM_FPSCR    (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x63)
+#define KVM_REG_PPC_TM_AMR      (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x64)
+#define KVM_REG_PPC_TM_PPR      (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x65)
+#define KVM_REG_PPC_TM_VRSAVE   (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x66)
+#define KVM_REG_PPC_TM_VSCR     (KVM_REG_PPC_TM | KVM_REG_SIZE_U32 | 0x67)
+#define KVM_REG_PPC_TM_DSCR     (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x68)
+#define KVM_REG_PPC_TM_TAR      (KVM_REG_PPC_TM | KVM_REG_SIZE_U64 | 0x69)
+
+/* PPC64 eXternal Interrupt Controller Specification */
+#define KVM_DEV_XICS_GRP_SOURCES        1       /* 64-bit source attributes */
+
+/* Layout of 64-bit source attribute values */
+#define  KVM_XICS_DESTINATION_SHIFT     0
+#define  KVM_XICS_DESTINATION_MASK      0xffffffffULL
+#define  KVM_XICS_PRIORITY_SHIFT        32
+#define  KVM_XICS_PRIORITY_MASK         0xff
+#define  KVM_XICS_LEVEL_SENSITIVE       (1ULL << 40)
+#define  KVM_XICS_MASKED                (1ULL << 41)
+#define  KVM_XICS_PENDING               (1ULL << 42)
+
+#endif /* __LINUX_KVM_POWERPC_H */
diff --git a/tools/arch/powerpc/include/uapi/asm/mman.h b/tools/arch/powerpc/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..761db43172fe
--- /dev/null
+++ b/tools/arch/powerpc/include/uapi/asm/mman.h
@@ -0,0 +1,15 @@
+#ifndef TOOLS_ARCH_POWERPC_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_POWERPC_UAPI_ASM_MMAN_FIX_H
+#define MAP_DENYWRITE   0x0800
+#define MAP_EXECUTABLE  0x1000
+#define MAP_GROWSDOWN   0x0100
+#define MAP_HUGETLB     0x40000
+#define MAP_LOCKED      0x80
+#define MAP_NONBLOCK    0x10000
+#define MAP_NORESERVE   0x40
+#define MAP_POPULATE    0x8000
+#define MAP_STACK       0x20000
+#include <uapi/asm-generic/mman-common.h>
+/* MAP_32BIT is undefined on powerpc, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/powerpc/include/uapi/asm/perf_regs.h b/tools/arch/powerpc/include/uapi/asm/perf_regs.h
new file mode 100644
index 000000000000..6a93209748a1
--- /dev/null
+++ b/tools/arch/powerpc/include/uapi/asm/perf_regs.h
@@ -0,0 +1,50 @@
+#ifndef _UAPI_ASM_POWERPC_PERF_REGS_H
+#define _UAPI_ASM_POWERPC_PERF_REGS_H
+
+enum perf_event_powerpc_regs {
+        PERF_REG_POWERPC_R0,
+        PERF_REG_POWERPC_R1,
+        PERF_REG_POWERPC_R2,
+        PERF_REG_POWERPC_R3,
+        PERF_REG_POWERPC_R4,
+        PERF_REG_POWERPC_R5,
+        PERF_REG_POWERPC_R6,
+        PERF_REG_POWERPC_R7,
+        PERF_REG_POWERPC_R8,
+        PERF_REG_POWERPC_R9,
+        PERF_REG_POWERPC_R10,
+        PERF_REG_POWERPC_R11,
+        PERF_REG_POWERPC_R12,
+        PERF_REG_POWERPC_R13,
+        PERF_REG_POWERPC_R14,
+        PERF_REG_POWERPC_R15,
+        PERF_REG_POWERPC_R16,
+        PERF_REG_POWERPC_R17,
+        PERF_REG_POWERPC_R18,
+        PERF_REG_POWERPC_R19,
+        PERF_REG_POWERPC_R20,
+        PERF_REG_POWERPC_R21,
+        PERF_REG_POWERPC_R22,
+        PERF_REG_POWERPC_R23,
+        PERF_REG_POWERPC_R24,
+        PERF_REG_POWERPC_R25,
+        PERF_REG_POWERPC_R26,
+        PERF_REG_POWERPC_R27,
+        PERF_REG_POWERPC_R28,
+        PERF_REG_POWERPC_R29,
+        PERF_REG_POWERPC_R30,
+        PERF_REG_POWERPC_R31,
+        PERF_REG_POWERPC_NIP,
+        PERF_REG_POWERPC_MSR,
+        PERF_REG_POWERPC_ORIG_R3,
+        PERF_REG_POWERPC_CTR,
+        PERF_REG_POWERPC_LINK,
+        PERF_REG_POWERPC_XER,
+        PERF_REG_POWERPC_CCR,
+        PERF_REG_POWERPC_SOFTE,
+        PERF_REG_POWERPC_TRAP,
+        PERF_REG_POWERPC_DAR,
+        PERF_REG_POWERPC_DSISR,
+        PERF_REG_POWERPC_MAX,
+};
+#endif /* _UAPI_ASM_POWERPC_PERF_REGS_H */
diff --git a/tools/arch/s390/include/uapi/asm/bitsperlong.h b/tools/arch/s390/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..e351ea2ad43e
--- /dev/null
+++ b/tools/arch/s390/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_S390_BITSPERLONG_H
+#define __ASM_S390_BITSPERLONG_H
+
+#ifndef __s390x__
+#define __BITS_PER_LONG 32
+#else
+#define __BITS_PER_LONG 64
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_S390_BITSPERLONG_H */
diff --git a/tools/arch/s390/include/uapi/asm/kvm.h b/tools/arch/s390/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..a2ffec4139ad
--- /dev/null
+++ b/tools/arch/s390/include/uapi/asm/kvm.h
@@ -0,0 +1,233 @@
+#ifndef __LINUX_KVM_S390_H
+#define __LINUX_KVM_S390_H
+/*
+ * KVM s390 specific structures and definitions
+ *
+ * Copyright IBM Corp. 2008
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (version 2 only)
+ * as published by the Free Software Foundation.
+ *
+ *    Author(s): Carsten Otte <cotte@de.ibm.com>
+ *               Christian Borntraeger <borntraeger@de.ibm.com>
+ */
+#include <linux/types.h>
+
+#define __KVM_S390
+#define __KVM_HAVE_GUEST_DEBUG
+
+/* Device control API: s390-specific devices */
+#define KVM_DEV_FLIC_GET_ALL_IRQS       1
+#define KVM_DEV_FLIC_ENQUEUE            2
+#define KVM_DEV_FLIC_CLEAR_IRQS         3
+#define KVM_DEV_FLIC_APF_ENABLE         4
+#define KVM_DEV_FLIC_APF_DISABLE_WAIT   5
+#define KVM_DEV_FLIC_ADAPTER_REGISTER   6
+#define KVM_DEV_FLIC_ADAPTER_MODIFY     7
+#define KVM_DEV_FLIC_CLEAR_IO_IRQ       8
+/*
+ * We can have up to 4*64k pending subchannels + 8 adapter interrupts,
+ * as well as up  to ASYNC_PF_PER_VCPU*KVM_MAX_VCPUS pfault done interrupts.
+ * There are also sclp and machine checks. This gives us
+ * sizeof(kvm_s390_irq)*(4*65536+8+64*64+1+1) = 72 * 266250 = 19170000
+ * Lets round up to 8192 pages.
+ */
+#define KVM_S390_MAX_FLOAT_IRQS 266250
+#define KVM_S390_FLIC_MAX_BUFFER        0x2000000
+
+struct kvm_s390_io_adapter {
+        __u32 id;
+        __u8 isc;
+        __u8 maskable;
+        __u8 swap;
+        __u8 pad;
+};
+
+#define KVM_S390_IO_ADAPTER_MASK 1
+#define KVM_S390_IO_ADAPTER_MAP 2
+#define KVM_S390_IO_ADAPTER_UNMAP 3
+
+struct kvm_s390_io_adapter_req {
+        __u32 id;
+        __u8 type;
+        __u8 mask;
+        __u16 pad0;
+        __u64 addr;
+};
+
+/* kvm attr_group  on vm fd */
+#define KVM_S390_VM_MEM_CTRL            0
+#define KVM_S390_VM_TOD                 1
+#define KVM_S390_VM_CRYPTO              2
+#define KVM_S390_VM_CPU_MODEL           3
+
+/* kvm attributes for mem_ctrl */
+#define KVM_S390_VM_MEM_ENABLE_CMMA     0
+#define KVM_S390_VM_MEM_CLR_CMMA        1
+#define KVM_S390_VM_MEM_LIMIT_SIZE      2
+
+#define KVM_S390_NO_MEM_LIMIT           U64_MAX
+
+/* kvm attributes for KVM_S390_VM_TOD */
+#define KVM_S390_VM_TOD_LOW             0
+#define KVM_S390_VM_TOD_HIGH            1
+
+/* kvm attributes for KVM_S390_VM_CPU_MODEL */
+/* processor related attributes are r/w */
+#define KVM_S390_VM_CPU_PROCESSOR       0
+struct kvm_s390_vm_cpu_processor {
+        __u64 cpuid;
+        __u16 ibc;
+        __u8  pad[6];
+        __u64 fac_list[256];
+};
+
+/* machine related attributes are r/o */
+#define KVM_S390_VM_CPU_MACHINE         1
+struct kvm_s390_vm_cpu_machine {
+        __u64 cpuid;
+        __u32 ibc;
+        __u8  pad[4];
+        __u64 fac_mask[256];
+        __u64 fac_list[256];
+};
+
+#define KVM_S390_VM_CPU_PROCESSOR_FEAT  2
+#define KVM_S390_VM_CPU_MACHINE_FEAT    3
+
+#define KVM_S390_VM_CPU_FEAT_NR_BITS    1024
+#define KVM_S390_VM_CPU_FEAT_ESOP       0
+#define KVM_S390_VM_CPU_FEAT_SIEF2      1
+#define KVM_S390_VM_CPU_FEAT_64BSCAO    2
+#define KVM_S390_VM_CPU_FEAT_SIIF       3
+#define KVM_S390_VM_CPU_FEAT_GPERE      4
+#define KVM_S390_VM_CPU_FEAT_GSLS       5
+#define KVM_S390_VM_CPU_FEAT_IB         6
+#define KVM_S390_VM_CPU_FEAT_CEI        7
+#define KVM_S390_VM_CPU_FEAT_IBS        8
+#define KVM_S390_VM_CPU_FEAT_SKEY       9
+#define KVM_S390_VM_CPU_FEAT_CMMA       10
+#define KVM_S390_VM_CPU_FEAT_PFMFI      11
+#define KVM_S390_VM_CPU_FEAT_SIGPIF     12
+struct kvm_s390_vm_cpu_feat {
+        __u64 feat[16];
+};
+
+#define KVM_S390_VM_CPU_PROCESSOR_SUBFUNC       4
+#define KVM_S390_VM_CPU_MACHINE_SUBFUNC         5
+/* for "test bit" instructions MSB 0 bit ordering, for "query" raw blocks */
+struct kvm_s390_vm_cpu_subfunc {
+        __u8 plo[32];           /* always */
+        __u8 ptff[16];          /* with TOD-clock steering */
+        __u8 kmac[16];          /* with MSA */
+        __u8 kmc[16];           /* with MSA */
+        __u8 km[16];            /* with MSA */
+        __u8 kimd[16];          /* with MSA */
+        __u8 klmd[16];          /* with MSA */
+        __u8 pckmo[16];         /* with MSA3 */
+        __u8 kmctr[16];         /* with MSA4 */
+        __u8 kmf[16];           /* with MSA4 */
+        __u8 kmo[16];           /* with MSA4 */
+        __u8 pcc[16];           /* with MSA4 */
+        __u8 ppno[16];          /* with MSA5 */
+        __u8 reserved[1824];
+};
+
+/* kvm attributes for crypto */
+#define KVM_S390_VM_CRYPTO_ENABLE_AES_KW        0
+#define KVM_S390_VM_CRYPTO_ENABLE_DEA_KW        1
+#define KVM_S390_VM_CRYPTO_DISABLE_AES_KW       2
+#define KVM_S390_VM_CRYPTO_DISABLE_DEA_KW       3
+
+/* for KVM_GET_REGS and KVM_SET_REGS */
+struct kvm_regs {
+        /* general purpose regs for s390 */
+        __u64 gprs[16];
+};
+
+/* for KVM_GET_SREGS and KVM_SET_SREGS */
+struct kvm_sregs {
+        __u32 acrs[16];
+        __u64 crs[16];
+};
+
+/* for KVM_GET_FPU and KVM_SET_FPU */
+struct kvm_fpu {
+        __u32 fpc;
+        __u64 fprs[16];
+};
+
+#define KVM_GUESTDBG_USE_HW_BP          0x00010000
+
+#define KVM_HW_BP                       1
+#define KVM_HW_WP_WRITE                 2
+#define KVM_SINGLESTEP                  4
+
+struct kvm_debug_exit_arch {
+        __u64 addr;
+        __u8 type;
+        __u8 pad[7]; /* Should be set to 0 */
+};
+
+struct kvm_hw_breakpoint {
+        __u64 addr;
+        __u64 phys_addr;
+        __u64 len;
+        __u8 type;
+        __u8 pad[7]; /* Should be set to 0 */
+};
+
+/* for KVM_SET_GUEST_DEBUG */
+struct kvm_guest_debug_arch {
+        __u32 nr_hw_bp;
+        __u32 pad; /* Should be set to 0 */
+        struct kvm_hw_breakpoint __user *hw_bp;
+};
+
+/* for KVM_SYNC_PFAULT and KVM_REG_S390_PFTOKEN */
+#define KVM_S390_PFAULT_TOKEN_INVALID   0xffffffffffffffffULL
+
+#define KVM_SYNC_PREFIX (1UL << 0)
+#define KVM_SYNC_GPRS   (1UL << 1)
+#define KVM_SYNC_ACRS   (1UL << 2)
+#define KVM_SYNC_CRS    (1UL << 3)
+#define KVM_SYNC_ARCH0  (1UL << 4)
+#define KVM_SYNC_PFAULT (1UL << 5)
+#define KVM_SYNC_VRS    (1UL << 6)
+#define KVM_SYNC_RICCB  (1UL << 7)
+#define KVM_SYNC_FPRS   (1UL << 8)
+/* definition of registers in kvm_run */
+struct kvm_sync_regs {
+        __u64 prefix;   /* prefix register */
+        __u64 gprs[16]; /* general purpose registers */
+        __u32 acrs[16]; /* access registers */
+        __u64 crs[16];  /* control registers */
+        __u64 todpr;    /* tod programmable register [ARCH0] */
+        __u64 cputm;    /* cpu timer [ARCH0] */
+        __u64 ckc;      /* clock comparator [ARCH0] */
+        __u64 pp;       /* program parameter [ARCH0] */
+        __u64 gbea;     /* guest breaking-event address [ARCH0] */
+        __u64 pft;      /* pfault token [PFAULT] */
+        __u64 pfs;      /* pfault select [PFAULT] */
+        __u64 pfc;      /* pfault compare [PFAULT] */
+        union {
+                __u64 vrs[32][2];       /* vector registers (KVM_SYNC_VRS) */
+                __u64 fprs[16];         /* fp registers (KVM_SYNC_FPRS) */
+        };
+        __u8  reserved[512];    /* for future vector expansion */
+        __u32 fpc;              /* valid on KVM_SYNC_VRS or KVM_SYNC_FPRS */
+        __u8 padding[52];       /* riccb needs to be 64byte aligned */
+        __u8 riccb[64];         /* runtime instrumentation controls block */
+};
+
+#define KVM_REG_S390_TODPR      (KVM_REG_S390 | KVM_REG_SIZE_U32 | 0x1)
+#define KVM_REG_S390_EPOCHDIFF  (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x2)
+#define KVM_REG_S390_CPU_TIMER  (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x3)
+#define KVM_REG_S390_CLOCK_COMP (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x4)
+#define KVM_REG_S390_PFTOKEN    (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x5)
+#define KVM_REG_S390_PFCOMPARE  (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x6)
+#define KVM_REG_S390_PFSELECT   (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x7)
+#define KVM_REG_S390_PP         (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x8)
+#define KVM_REG_S390_GBEA       (KVM_REG_S390 | KVM_REG_SIZE_U64 | 0x9)
+#endif
diff --git a/tools/arch/s390/include/uapi/asm/kvm_perf.h b/tools/arch/s390/include/uapi/asm/kvm_perf.h
new file mode 100644
index 000000000000..397282727e21
--- /dev/null
+++ b/tools/arch/s390/include/uapi/asm/kvm_perf.h
@@ -0,0 +1,25 @@
+/*
+ * Definitions for perf-kvm on s390
+ *
+ * Copyright 2014 IBM Corp.
+ * Author(s): Alexander Yarygin <yarygin@linux.vnet.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License (version 2 only)
+ * as published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_KVM_PERF_S390_H
+#define __LINUX_KVM_PERF_S390_H
+
+#include <asm/sie.h>
+
+#define DECODE_STR_LEN 40
+
+#define VCPU_ID "id"
+
+#define KVM_ENTRY_TRACE "kvm:kvm_s390_sie_enter"
+#define KVM_EXIT_TRACE "kvm:kvm_s390_sie_exit"
+#define KVM_EXIT_REASON "icptcode"
+
+#endif
diff --git a/tools/arch/s390/include/uapi/asm/mman.h b/tools/arch/s390/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..b03dea9e1f56
--- /dev/null
+++ b/tools/arch/s390/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_S390_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_S390_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on s390, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/s390/include/uapi/asm/sie.h b/tools/arch/s390/include/uapi/asm/sie.h
new file mode 100644
index 000000000000..3ac634368939
--- /dev/null
+++ b/tools/arch/s390/include/uapi/asm/sie.h
@@ -0,0 +1,251 @@
+#ifndef _UAPI_ASM_S390_SIE_H
+#define _UAPI_ASM_S390_SIE_H
+
+#define diagnose_codes                                          \
+        { 0x10, "DIAG (0x10) release pages" },                  \
+        { 0x44, "DIAG (0x44) time slice end" },                 \
+        { 0x9c, "DIAG (0x9c) time slice end directed" },        \
+        { 0x204, "DIAG (0x204) logical-cpu utilization" },      \
+        { 0x258, "DIAG (0x258) page-reference services" },      \
+        { 0x288, "DIAG (0x288) watchdog functions" },           \
+        { 0x308, "DIAG (0x308) ipl functions" },                \
+        { 0x500, "DIAG (0x500) KVM virtio functions" },         \
+        { 0x501, "DIAG (0x501) KVM breakpoint" }
+
+#define sigp_order_codes                                        \
+        { 0x01, "SIGP sense" },                                 \
+        { 0x02, "SIGP external call" },                         \
+        { 0x03, "SIGP emergency signal" },                      \
+        { 0x04, "SIGP start" },                                 \
+        { 0x05, "SIGP stop" },                                  \
+        { 0x06, "SIGP restart" },                               \
+        { 0x09, "SIGP stop and store status" },                 \
+        { 0x0b, "SIGP initial cpu reset" },                     \
+        { 0x0c, "SIGP cpu reset" },                             \
+        { 0x0d, "SIGP set prefix" },                            \
+        { 0x0e, "SIGP store status at address" },               \
+        { 0x12, "SIGP set architecture" },                      \
+        { 0x13, "SIGP conditional emergency signal" },          \
+        { 0x15, "SIGP sense running" },                         \
+        { 0x16, "SIGP set multithreading"},                     \
+        { 0x17, "SIGP store additional status ait address"}
+
+#define icpt_prog_codes                                         \
+        { 0x0001, "Prog Operation" },                           \
+        { 0x0002, "Prog Privileged Operation" },                \
+        { 0x0003, "Prog Execute" },                             \
+        { 0x0004, "Prog Protection" },                          \
+        { 0x0005, "Prog Addressing" },                          \
+        { 0x0006, "Prog Specification" },                       \
+        { 0x0007, "Prog Data" },                                \
+        { 0x0008, "Prog Fixedpoint overflow" },                 \
+        { 0x0009, "Prog Fixedpoint divide" },                   \
+        { 0x000A, "Prog Decimal overflow" },                    \
+        { 0x000B, "Prog Decimal divide" },                      \
+        { 0x000C, "Prog HFP exponent overflow" },               \
+        { 0x000D, "Prog HFP exponent underflow" },              \
+        { 0x000E, "Prog HFP significance" },                    \
+        { 0x000F, "Prog HFP divide" },                          \
+        { 0x0010, "Prog Segment translation" },                 \
+        { 0x0011, "Prog Page translation" },                    \
+        { 0x0012, "Prog Translation specification" },           \
+        { 0x0013, "Prog Special operation" },                   \
+        { 0x0015, "Prog Operand" },                             \
+        { 0x0016, "Prog Trace table" },                         \
+        { 0x0017, "Prog ASNtranslation specification" },        \
+        { 0x001C, "Prog Spaceswitch event" },                   \
+        { 0x001D, "Prog HFP square root" },                     \
+        { 0x001F, "Prog PCtranslation specification" },         \
+        { 0x0020, "Prog AFX translation" },                     \
+        { 0x0021, "Prog ASX translation" },                     \
+        { 0x0022, "Prog LX translation" },                      \
+        { 0x0023, "Prog EX translation" },                      \
+        { 0x0024, "Prog Primary authority" },                   \
+        { 0x0025, "Prog Secondary authority" },                 \
+        { 0x0026, "Prog LFXtranslation exception" },            \
+        { 0x0027, "Prog LSXtranslation exception" },            \
+        { 0x0028, "Prog ALET specification" },                  \
+        { 0x0029, "Prog ALEN translation" },                    \
+        { 0x002A, "Prog ALE sequence" },                        \
+        { 0x002B, "Prog ASTE validity" },                       \
+        { 0x002C, "Prog ASTE sequence" },                       \
+        { 0x002D, "Prog Extended authority" },                  \
+        { 0x002E, "Prog LSTE sequence" },                       \
+        { 0x002F, "Prog ASTE instance" },                       \
+        { 0x0030, "Prog Stack full" },                          \
+        { 0x0031, "Prog Stack empty" },                         \
+        { 0x0032, "Prog Stack specification" },                 \
+        { 0x0033, "Prog Stack type" },                          \
+        { 0x0034, "Prog Stack operation" },                     \
+        { 0x0039, "Prog Region first translation" },            \
+        { 0x003A, "Prog Region second translation" },           \
+        { 0x003B, "Prog Region third translation" },            \
+        { 0x0040, "Prog Monitor event" },                       \
+        { 0x0080, "Prog PER event" },                           \
+        { 0x0119, "Prog Crypto operation" }
+
+#define exit_code_ipa0(ipa0, opcode, mnemonic)          \
+        { (ipa0 << 8 | opcode), #ipa0 " " mnemonic }
+#define exit_code(opcode, mnemonic)                     \
+        { opcode, mnemonic }
+
+#define icpt_insn_codes                         \
+        exit_code_ipa0(0x01, 0x01, "PR"),       \
+        exit_code_ipa0(0x01, 0x04, "PTFF"),     \
+        exit_code_ipa0(0x01, 0x07, "SCKPF"),    \
+        exit_code_ipa0(0xAA, 0x00, "RINEXT"),   \
+        exit_code_ipa0(0xAA, 0x01, "RION"),     \
+        exit_code_ipa0(0xAA, 0x02, "TRIC"),     \
+        exit_code_ipa0(0xAA, 0x03, "RIOFF"),    \
+        exit_code_ipa0(0xAA, 0x04, "RIEMIT"),   \
+        exit_code_ipa0(0xB2, 0x02, "STIDP"),    \
+        exit_code_ipa0(0xB2, 0x04, "SCK"),      \
+        exit_code_ipa0(0xB2, 0x05, "STCK"),     \
+        exit_code_ipa0(0xB2, 0x06, "SCKC"),     \
+        exit_code_ipa0(0xB2, 0x07, "STCKC"),    \
+        exit_code_ipa0(0xB2, 0x08, "SPT"),      \
+        exit_code_ipa0(0xB2, 0x09, "STPT"),     \
+        exit_code_ipa0(0xB2, 0x0d, "PTLB"),     \
+        exit_code_ipa0(0xB2, 0x10, "SPX"),      \
+        exit_code_ipa0(0xB2, 0x11, "STPX"),     \
+        exit_code_ipa0(0xB2, 0x12, "STAP"),     \
+        exit_code_ipa0(0xB2, 0x14, "SIE"),      \
+        exit_code_ipa0(0xB2, 0x16, "SETR"),     \
+        exit_code_ipa0(0xB2, 0x17, "STETR"),    \
+        exit_code_ipa0(0xB2, 0x18, "PC"),       \
+        exit_code_ipa0(0xB2, 0x20, "SERVC"),    \
+        exit_code_ipa0(0xB2, 0x21, "IPTE"),     \
+        exit_code_ipa0(0xB2, 0x28, "PT"),       \
+        exit_code_ipa0(0xB2, 0x29, "ISKE"),     \
+        exit_code_ipa0(0xB2, 0x2a, "RRBE"),     \
+        exit_code_ipa0(0xB2, 0x2b, "SSKE"),     \
+        exit_code_ipa0(0xB2, 0x2c, "TB"),       \
+        exit_code_ipa0(0xB2, 0x2e, "PGIN"),     \
+        exit_code_ipa0(0xB2, 0x2f, "PGOUT"),    \
+        exit_code_ipa0(0xB2, 0x30, "CSCH"),     \
+        exit_code_ipa0(0xB2, 0x31, "HSCH"),     \
+        exit_code_ipa0(0xB2, 0x32, "MSCH"),     \
+        exit_code_ipa0(0xB2, 0x33, "SSCH"),     \
+        exit_code_ipa0(0xB2, 0x34, "STSCH"),    \
+        exit_code_ipa0(0xB2, 0x35, "TSCH"),     \
+        exit_code_ipa0(0xB2, 0x36, "TPI"),      \
+        exit_code_ipa0(0xB2, 0x37, "SAL"),      \
+        exit_code_ipa0(0xB2, 0x38, "RSCH"),     \
+        exit_code_ipa0(0xB2, 0x39, "STCRW"),    \
+        exit_code_ipa0(0xB2, 0x3a, "STCPS"),    \
+        exit_code_ipa0(0xB2, 0x3b, "RCHP"),     \
+        exit_code_ipa0(0xB2, 0x3c, "SCHM"),     \
+        exit_code_ipa0(0xB2, 0x40, "BAKR"),     \
+        exit_code_ipa0(0xB2, 0x48, "PALB"),     \
+        exit_code_ipa0(0xB2, 0x4c, "TAR"),      \
+        exit_code_ipa0(0xB2, 0x50, "CSP"),      \
+        exit_code_ipa0(0xB2, 0x54, "MVPG"),     \
+        exit_code_ipa0(0xB2, 0x56, "STHYI"),    \
+        exit_code_ipa0(0xB2, 0x58, "BSG"),      \
+        exit_code_ipa0(0xB2, 0x5a, "BSA"),      \
+        exit_code_ipa0(0xB2, 0x5f, "CHSC"),     \
+        exit_code_ipa0(0xB2, 0x74, "SIGA"),     \
+        exit_code_ipa0(0xB2, 0x76, "XSCH"),     \
+        exit_code_ipa0(0xB2, 0x78, "STCKE"),    \
+        exit_code_ipa0(0xB2, 0x7c, "STCKF"),    \
+        exit_code_ipa0(0xB2, 0x7d, "STSI"),     \
+        exit_code_ipa0(0xB2, 0xb0, "STFLE"),    \
+        exit_code_ipa0(0xB2, 0xb1, "STFL"),     \
+        exit_code_ipa0(0xB2, 0xb2, "LPSWE"),    \
+        exit_code_ipa0(0xB2, 0xf8, "TEND"),     \
+        exit_code_ipa0(0xB2, 0xfc, "TABORT"),   \
+        exit_code_ipa0(0xB9, 0x1e, "KMAC"),     \
+        exit_code_ipa0(0xB9, 0x28, "PCKMO"),    \
+        exit_code_ipa0(0xB9, 0x2a, "KMF"),      \
+        exit_code_ipa0(0xB9, 0x2b, "KMO"),      \
+        exit_code_ipa0(0xB9, 0x2d, "KMCTR"),    \
+        exit_code_ipa0(0xB9, 0x2e, "KM"),       \
+        exit_code_ipa0(0xB9, 0x2f, "KMC"),      \
+        exit_code_ipa0(0xB9, 0x3e, "KIMD"),     \
+        exit_code_ipa0(0xB9, 0x3f, "KLMD"),     \
+        exit_code_ipa0(0xB9, 0x8a, "CSPG"),     \
+        exit_code_ipa0(0xB9, 0x8d, "EPSW"),     \
+        exit_code_ipa0(0xB9, 0x8e, "IDTE"),     \
+        exit_code_ipa0(0xB9, 0x8f, "CRDTE"),    \
+        exit_code_ipa0(0xB9, 0x9c, "EQBS"),     \
+        exit_code_ipa0(0xB9, 0xa2, "PTF"),      \
+        exit_code_ipa0(0xB9, 0xab, "ESSA"),     \
+        exit_code_ipa0(0xB9, 0xae, "RRBM"),     \
+        exit_code_ipa0(0xB9, 0xaf, "PFMF"),     \
+        exit_code_ipa0(0xE3, 0x03, "LRAG"),     \
+        exit_code_ipa0(0xE3, 0x13, "LRAY"),     \
+        exit_code_ipa0(0xE3, 0x25, "NTSTG"),    \
+        exit_code_ipa0(0xE5, 0x00, "LASP"),     \
+        exit_code_ipa0(0xE5, 0x01, "TPROT"),    \
+        exit_code_ipa0(0xE5, 0x60, "TBEGIN"),   \
+        exit_code_ipa0(0xE5, 0x61, "TBEGINC"),  \
+        exit_code_ipa0(0xEB, 0x25, "STCTG"),    \
+        exit_code_ipa0(0xEB, 0x2f, "LCTLG"),    \
+        exit_code_ipa0(0xEB, 0x60, "LRIC"),     \
+        exit_code_ipa0(0xEB, 0x61, "STRIC"),    \
+        exit_code_ipa0(0xEB, 0x62, "MRIC"),     \
+        exit_code_ipa0(0xEB, 0x8a, "SQBS"),     \
+        exit_code_ipa0(0xC8, 0x01, "ECTG"),     \
+        exit_code(0x0a, "SVC"),                 \
+        exit_code(0x80, "SSM"),                 \
+        exit_code(0x82, "LPSW"),                \
+        exit_code(0x83, "DIAG"),                \
+        exit_code(0xae, "SIGP"),                \
+        exit_code(0xac, "STNSM"),               \
+        exit_code(0xad, "STOSM"),               \
+        exit_code(0xb1, "LRA"),                 \
+        exit_code(0xb6, "STCTL"),               \
+        exit_code(0xb7, "LCTL"),                \
+        exit_code(0xee, "PLO")
+
+#define sie_intercept_code                                      \
+        { 0x00, "Host interruption" },                          \
+        { 0x04, "Instruction" },                                \
+        { 0x08, "Program interruption" },                       \
+        { 0x0c, "Instruction and program interruption" },       \
+        { 0x10, "External request" },                           \
+        { 0x14, "External interruption" },                      \
+        { 0x18, "I/O request" },                                \
+        { 0x1c, "Wait state" },                                 \
+        { 0x20, "Validity" },                                   \
+        { 0x28, "Stop request" },                               \
+        { 0x2c, "Operation exception" },                        \
+        { 0x38, "Partial-execution" },                          \
+        { 0x3c, "I/O interruption" },                           \
+        { 0x40, "I/O instruction" },                            \
+        { 0x48, "Timing subset" }
+
+/*
+ * This is the simple interceptable instructions decoder.
+ *
+ * It will be used as userspace interface and it can be used in places
+ * that does not allow to use general decoder functions,
+ * such as trace events declarations.
+ *
+ * Some userspace tools may want to parse this code
+ * and would be confused by switch(), if() and other statements,
+ * but they can understand conditional operator.
+ */
+#define INSN_DECODE_IPA0(ipa0, insn, rshift, mask)              \
+        (insn >> 56) == (ipa0) ?                                \
+                ((ipa0 << 8) | ((insn >> rshift) & mask)) :
+
+#define INSN_DECODE(insn) (insn >> 56)
+
+/*
+ * The macro icpt_insn_decoder() takes an intercepted instruction
+ * and returns a key, which can be used to find a mnemonic name
+ * of the instruction in the icpt_insn_codes table.
+ */
+#define icpt_insn_decoder(insn) (               \
+        INSN_DECODE_IPA0(0x01, insn, 48, 0xff)  \
+        INSN_DECODE_IPA0(0xaa, insn, 48, 0x0f)  \
+        INSN_DECODE_IPA0(0xb2, insn, 48, 0xff)  \
+        INSN_DECODE_IPA0(0xb9, insn, 48, 0xff)  \
+        INSN_DECODE_IPA0(0xe3, insn, 48, 0xff)  \
+        INSN_DECODE_IPA0(0xe5, insn, 48, 0xff)  \
+        INSN_DECODE_IPA0(0xeb, insn, 16, 0xff)  \
+        INSN_DECODE_IPA0(0xc8, insn, 48, 0x0f)  \
+        INSN_DECODE(insn))
+
+#endif /* _UAPI_ASM_S390_SIE_H */
diff --git a/tools/arch/score/include/uapi/asm/bitsperlong.h b/tools/arch/score/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..86ff337aa459
--- /dev/null
+++ b/tools/arch/score/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,6 @@
+#ifndef _ASM_SCORE_BITSPERLONG_H
+#define _ASM_SCORE_BITSPERLONG_H
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* _ASM_SCORE_BITSPERLONG_H */
diff --git a/tools/arch/score/include/uapi/asm/mman.h b/tools/arch/score/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..2f8fb89944fd
--- /dev/null
+++ b/tools/arch/score/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_SCORE_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_SCORE_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on score, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/sh/include/uapi/asm/mman.h b/tools/arch/sh/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..26504f6f060e
--- /dev/null
+++ b/tools/arch/sh/include/uapi/asm/mman.h
@@ -0,0 +1,6 @@
+#ifndef TOOLS_ARCH_SH_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_SH_UAPI_ASM_MMAN_FIX_H
+#include <uapi/asm-generic/mman.h>
+/* MAP_32BIT is undefined on sh, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/sparc/include/uapi/asm/bitsperlong.h b/tools/arch/sparc/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..b62dd907d7c3
--- /dev/null
+++ b/tools/arch/sparc/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_ALPHA_BITSPERLONG_H
+#define __ASM_ALPHA_BITSPERLONG_H
+
+#if defined(__sparc__) && defined(__arch64__)
+#define __BITS_PER_LONG 64
+#else
+#define __BITS_PER_LONG 32
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_ALPHA_BITSPERLONG_H */
diff --git a/tools/arch/sparc/include/uapi/asm/mman.h b/tools/arch/sparc/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..8640525de991
--- /dev/null
+++ b/tools/arch/sparc/include/uapi/asm/mman.h
@@ -0,0 +1,15 @@
+#ifndef TOOLS_ARCH_SPARC_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_SPARC_UAPI_ASM_MMAN_FIX_H
+#define MAP_DENYWRITE   0x0800
+#define MAP_EXECUTABLE  0x1000
+#define MAP_GROWSDOWN   0x0200
+#define MAP_HUGETLB     0x40000
+#define MAP_LOCKED      0x100
+#define MAP_NONBLOCK    0x10000
+#define MAP_NORESERVE   0x40
+#define MAP_POPULATE    0x8000
+#define MAP_STACK       0x20000
+#include <uapi/asm-generic/mman-common.h>
+/* MAP_32BIT is undefined on sparc, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/tile/include/uapi/asm/bitsperlong.h b/tools/arch/tile/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..58c771f2af2f
--- /dev/null
+++ b/tools/arch/tile/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2010 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   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, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ */
+
+#ifndef _ASM_TILE_BITSPERLONG_H
+#define _ASM_TILE_BITSPERLONG_H
+
+#ifdef __LP64__
+# define __BITS_PER_LONG 64
+#else
+# define __BITS_PER_LONG 32
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* _ASM_TILE_BITSPERLONG_H */
diff --git a/tools/arch/tile/include/uapi/asm/mman.h b/tools/arch/tile/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..7116c4b928b3
--- /dev/null
+++ b/tools/arch/tile/include/uapi/asm/mman.h
@@ -0,0 +1,15 @@
+#ifndef TOOLS_ARCH_TILE_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_TILE_UAPI_ASM_MMAN_FIX_H
+#define MAP_DENYWRITE   0x0800
+#define MAP_EXECUTABLE  0x1000
+#define MAP_GROWSDOWN   0x0100
+#define MAP_HUGETLB     0x4000
+#define MAP_LOCKED      0x0200
+#define MAP_NONBLOCK    0x0080
+#define MAP_NORESERVE   0x0400
+#define MAP_POPULATE    0x0040
+#define MAP_STACK       MAP_GROWSDOWN
+#include <uapi/asm-generic/mman-common.h>
+/* MAP_32BIT is undefined on tile, fix it for perf */
+#define MAP_32BIT       0
+#endif
diff --git a/tools/arch/x86/include/asm/cpufeatures.h b/tools/arch/x86/include/asm/cpufeatures.h
new file mode 100644
index 000000000000..1188bc849ee3
--- /dev/null
+++ b/tools/arch/x86/include/asm/cpufeatures.h
@@ -0,0 +1,312 @@
+#ifndef _ASM_X86_CPUFEATURES_H
+#define _ASM_X86_CPUFEATURES_H
+
+#ifndef _ASM_X86_REQUIRED_FEATURES_H
+#include <asm/required-features.h>
+#endif
+
+#ifndef _ASM_X86_DISABLED_FEATURES_H
+#include <asm/disabled-features.h>
+#endif
+
+/*
+ * Defines x86 CPU feature bits
+ */
+#define NCAPINTS        18      /* N 32-bit words worth of info */
+#define NBUGINTS        1       /* N 32-bit bug flags */
+
+/*
+ * Note: If the comment begins with a quoted string, that string is used
+ * in /proc/cpuinfo instead of the macro name.  If the string is "",
+ * this feature bit is not displayed in /proc/cpuinfo at all.
+ */
+
+/* Intel-defined CPU features, CPUID level 0x00000001 (edx), word 0 */
+#define X86_FEATURE_FPU         ( 0*32+ 0) /* Onboard FPU */
+#define X86_FEATURE_VME         ( 0*32+ 1) /* Virtual Mode Extensions */
+#define X86_FEATURE_DE          ( 0*32+ 2) /* Debugging Extensions */
+#define X86_FEATURE_PSE         ( 0*32+ 3) /* Page Size Extensions */
+#define X86_FEATURE_TSC         ( 0*32+ 4) /* Time Stamp Counter */
+#define X86_FEATURE_MSR         ( 0*32+ 5) /* Model-Specific Registers */
+#define X86_FEATURE_PAE         ( 0*32+ 6) /* Physical Address Extensions */
+#define X86_FEATURE_MCE         ( 0*32+ 7) /* Machine Check Exception */
+#define X86_FEATURE_CX8         ( 0*32+ 8) /* CMPXCHG8 instruction */
+#define X86_FEATURE_APIC        ( 0*32+ 9) /* Onboard APIC */
+#define X86_FEATURE_SEP         ( 0*32+11) /* SYSENTER/SYSEXIT */
+#define X86_FEATURE_MTRR        ( 0*32+12) /* Memory Type Range Registers */
+#define X86_FEATURE_PGE         ( 0*32+13) /* Page Global Enable */
+#define X86_FEATURE_MCA         ( 0*32+14) /* Machine Check Architecture */
+#define X86_FEATURE_CMOV        ( 0*32+15) /* CMOV instructions */
+                                          /* (plus FCMOVcc, FCOMI with FPU) */
+#define X86_FEATURE_PAT         ( 0*32+16) /* Page Attribute Table */
+#define X86_FEATURE_PSE36       ( 0*32+17) /* 36-bit PSEs */
+#define X86_FEATURE_PN          ( 0*32+18) /* Processor serial number */
+#define X86_FEATURE_CLFLUSH     ( 0*32+19) /* CLFLUSH instruction */
+#define X86_FEATURE_DS          ( 0*32+21) /* "dts" Debug Store */
+#define X86_FEATURE_ACPI        ( 0*32+22) /* ACPI via MSR */
+#define X86_FEATURE_MMX         ( 0*32+23) /* Multimedia Extensions */
+#define X86_FEATURE_FXSR        ( 0*32+24) /* FXSAVE/FXRSTOR, CR4.OSFXSR */
+#define X86_FEATURE_XMM         ( 0*32+25) /* "sse" */
+#define X86_FEATURE_XMM2        ( 0*32+26) /* "sse2" */
+#define X86_FEATURE_SELFSNOOP   ( 0*32+27) /* "ss" CPU self snoop */
+#define X86_FEATURE_HT          ( 0*32+28) /* Hyper-Threading */
+#define X86_FEATURE_ACC         ( 0*32+29) /* "tm" Automatic clock control */
+#define X86_FEATURE_IA64        ( 0*32+30) /* IA-64 processor */
+#define X86_FEATURE_PBE         ( 0*32+31) /* Pending Break Enable */
+
+/* AMD-defined CPU features, CPUID level 0x80000001, word 1 */
+/* Don't duplicate feature flags which are redundant with Intel! */
+#define X86_FEATURE_SYSCALL     ( 1*32+11) /* SYSCALL/SYSRET */
+#define X86_FEATURE_MP          ( 1*32+19) /* MP Capable. */
+#define X86_FEATURE_NX          ( 1*32+20) /* Execute Disable */
+#define X86_FEATURE_MMXEXT      ( 1*32+22) /* AMD MMX extensions */
+#define X86_FEATURE_FXSR_OPT    ( 1*32+25) /* FXSAVE/FXRSTOR optimizations */
+#define X86_FEATURE_GBPAGES     ( 1*32+26) /* "pdpe1gb" GB pages */
+#define X86_FEATURE_RDTSCP      ( 1*32+27) /* RDTSCP */
+#define X86_FEATURE_LM          ( 1*32+29) /* Long Mode (x86-64) */
+#define X86_FEATURE_3DNOWEXT    ( 1*32+30) /* AMD 3DNow! extensions */
+#define X86_FEATURE_3DNOW       ( 1*32+31) /* 3DNow! */
+
+/* Transmeta-defined CPU features, CPUID level 0x80860001, word 2 */
+#define X86_FEATURE_RECOVERY    ( 2*32+ 0) /* CPU in recovery mode */
+#define X86_FEATURE_LONGRUN     ( 2*32+ 1) /* Longrun power control */
+#define X86_FEATURE_LRTI        ( 2*32+ 3) /* LongRun table interface */
+
+/* Other features, Linux-defined mapping, word 3 */
+/* This range is used for feature bits which conflict or are synthesized */
+#define X86_FEATURE_CXMMX       ( 3*32+ 0) /* Cyrix MMX extensions */
+#define X86_FEATURE_K6_MTRR     ( 3*32+ 1) /* AMD K6 nonstandard MTRRs */
+#define X86_FEATURE_CYRIX_ARR   ( 3*32+ 2) /* Cyrix ARRs (= MTRRs) */
+#define X86_FEATURE_CENTAUR_MCR ( 3*32+ 3) /* Centaur MCRs (= MTRRs) */
+/* cpu types for specific tunings: */
+#define X86_FEATURE_K8          ( 3*32+ 4) /* "" Opteron, Athlon64 */
+#define X86_FEATURE_K7          ( 3*32+ 5) /* "" Athlon */
+#define X86_FEATURE_P3          ( 3*32+ 6) /* "" P3 */
+#define X86_FEATURE_P4          ( 3*32+ 7) /* "" P4 */
+#define X86_FEATURE_CONSTANT_TSC ( 3*32+ 8) /* TSC ticks at a constant rate */
+#define X86_FEATURE_UP          ( 3*32+ 9) /* smp kernel running on up */
+#define X86_FEATURE_ART         ( 3*32+10) /* Platform has always running timer (ART) */
+#define X86_FEATURE_ARCH_PERFMON ( 3*32+11) /* Intel Architectural PerfMon */
+#define X86_FEATURE_PEBS        ( 3*32+12) /* Precise-Event Based Sampling */
+#define X86_FEATURE_BTS         ( 3*32+13) /* Branch Trace Store */
+#define X86_FEATURE_SYSCALL32   ( 3*32+14) /* "" syscall in ia32 userspace */
+#define X86_FEATURE_SYSENTER32  ( 3*32+15) /* "" sysenter in ia32 userspace */
+#define X86_FEATURE_REP_GOOD    ( 3*32+16) /* rep microcode works well */
+#define X86_FEATURE_MFENCE_RDTSC ( 3*32+17) /* "" Mfence synchronizes RDTSC */
+#define X86_FEATURE_LFENCE_RDTSC ( 3*32+18) /* "" Lfence synchronizes RDTSC */
+#define X86_FEATURE_ACC_POWER   ( 3*32+19) /* AMD Accumulated Power Mechanism */
+#define X86_FEATURE_NOPL        ( 3*32+20) /* The NOPL (0F 1F) instructions */
+#define X86_FEATURE_ALWAYS      ( 3*32+21) /* "" Always-present feature */
+#define X86_FEATURE_XTOPOLOGY   ( 3*32+22) /* cpu topology enum extensions */
+#define X86_FEATURE_TSC_RELIABLE ( 3*32+23) /* TSC is known to be reliable */
+#define X86_FEATURE_NONSTOP_TSC ( 3*32+24) /* TSC does not stop in C states */
+/* free, was #define X86_FEATURE_CLFLUSH_MONITOR ( 3*32+25) * "" clflush reqd with monitor */
+#define X86_FEATURE_EXTD_APICID ( 3*32+26) /* has extended APICID (8 bits) */
+#define X86_FEATURE_AMD_DCM     ( 3*32+27) /* multi-node processor */
+#define X86_FEATURE_APERFMPERF  ( 3*32+28) /* APERFMPERF */
+#define X86_FEATURE_EAGER_FPU   ( 3*32+29) /* "eagerfpu" Non lazy FPU restore */
+#define X86_FEATURE_NONSTOP_TSC_S3 ( 3*32+30) /* TSC doesn't stop in S3 state */
+
+/* Intel-defined CPU features, CPUID level 0x00000001 (ecx), word 4 */
+#define X86_FEATURE_XMM3        ( 4*32+ 0) /* "pni" SSE-3 */
+#define X86_FEATURE_PCLMULQDQ   ( 4*32+ 1) /* PCLMULQDQ instruction */
+#define X86_FEATURE_DTES64      ( 4*32+ 2) /* 64-bit Debug Store */
+#define X86_FEATURE_MWAIT       ( 4*32+ 3) /* "monitor" Monitor/Mwait support */
+#define X86_FEATURE_DSCPL       ( 4*32+ 4) /* "ds_cpl" CPL Qual. Debug Store */
+#define X86_FEATURE_VMX         ( 4*32+ 5) /* Hardware virtualization */
+#define X86_FEATURE_SMX         ( 4*32+ 6) /* Safer mode */
+#define X86_FEATURE_EST         ( 4*32+ 7) /* Enhanced SpeedStep */
+#define X86_FEATURE_TM2         ( 4*32+ 8) /* Thermal Monitor 2 */
+#define X86_FEATURE_SSSE3       ( 4*32+ 9) /* Supplemental SSE-3 */
+#define X86_FEATURE_CID         ( 4*32+10) /* Context ID */
+#define X86_FEATURE_SDBG        ( 4*32+11) /* Silicon Debug */
+#define X86_FEATURE_FMA         ( 4*32+12) /* Fused multiply-add */
+#define X86_FEATURE_CX16        ( 4*32+13) /* CMPXCHG16B */
+#define X86_FEATURE_XTPR        ( 4*32+14) /* Send Task Priority Messages */
+#define X86_FEATURE_PDCM        ( 4*32+15) /* Performance Capabilities */
+#define X86_FEATURE_PCID        ( 4*32+17) /* Process Context Identifiers */
+#define X86_FEATURE_DCA         ( 4*32+18) /* Direct Cache Access */
+#define X86_FEATURE_XMM4_1      ( 4*32+19) /* "sse4_1" SSE-4.1 */
+#define X86_FEATURE_XMM4_2      ( 4*32+20) /* "sse4_2" SSE-4.2 */
+#define X86_FEATURE_X2APIC      ( 4*32+21) /* x2APIC */
+#define X86_FEATURE_MOVBE       ( 4*32+22) /* MOVBE instruction */
+#define X86_FEATURE_POPCNT      ( 4*32+23) /* POPCNT instruction */
+#define X86_FEATURE_TSC_DEADLINE_TIMER  ( 4*32+24) /* Tsc deadline timer */
+#define X86_FEATURE_AES         ( 4*32+25) /* AES instructions */
+#define X86_FEATURE_XSAVE       ( 4*32+26) /* XSAVE/XRSTOR/XSETBV/XGETBV */
+#define X86_FEATURE_OSXSAVE     ( 4*32+27) /* "" XSAVE enabled in the OS */
+#define X86_FEATURE_AVX         ( 4*32+28) /* Advanced Vector Extensions */
+#define X86_FEATURE_F16C        ( 4*32+29) /* 16-bit fp conversions */
+#define X86_FEATURE_RDRAND      ( 4*32+30) /* The RDRAND instruction */
+#define X86_FEATURE_HYPERVISOR  ( 4*32+31) /* Running on a hypervisor */
+
+/* VIA/Cyrix/Centaur-defined CPU features, CPUID level 0xC0000001, word 5 */
+#define X86_FEATURE_XSTORE      ( 5*32+ 2) /* "rng" RNG present (xstore) */
+#define X86_FEATURE_XSTORE_EN   ( 5*32+ 3) /* "rng_en" RNG enabled */
+#define X86_FEATURE_XCRYPT      ( 5*32+ 6) /* "ace" on-CPU crypto (xcrypt) */
+#define X86_FEATURE_XCRYPT_EN   ( 5*32+ 7) /* "ace_en" on-CPU crypto enabled */
+#define X86_FEATURE_ACE2        ( 5*32+ 8) /* Advanced Cryptography Engine v2 */
+#define X86_FEATURE_ACE2_EN     ( 5*32+ 9) /* ACE v2 enabled */
+#define X86_FEATURE_PHE         ( 5*32+10) /* PadLock Hash Engine */
+#define X86_FEATURE_PHE_EN      ( 5*32+11) /* PHE enabled */
+#define X86_FEATURE_PMM         ( 5*32+12) /* PadLock Montgomery Multiplier */
+#define X86_FEATURE_PMM_EN      ( 5*32+13) /* PMM enabled */
+
+/* More extended AMD flags: CPUID level 0x80000001, ecx, word 6 */
+#define X86_FEATURE_LAHF_LM     ( 6*32+ 0) /* LAHF/SAHF in long mode */
+#define X86_FEATURE_CMP_LEGACY  ( 6*32+ 1) /* If yes HyperThreading not valid */
+#define X86_FEATURE_SVM         ( 6*32+ 2) /* Secure virtual machine */
+#define X86_FEATURE_EXTAPIC     ( 6*32+ 3) /* Extended APIC space */
+#define X86_FEATURE_CR8_LEGACY  ( 6*32+ 4) /* CR8 in 32-bit mode */
+#define X86_FEATURE_ABM         ( 6*32+ 5) /* Advanced bit manipulation */
+#define X86_FEATURE_SSE4A       ( 6*32+ 6) /* SSE-4A */
+#define X86_FEATURE_MISALIGNSSE ( 6*32+ 7) /* Misaligned SSE mode */
+#define X86_FEATURE_3DNOWPREFETCH ( 6*32+ 8) /* 3DNow prefetch instructions */
+#define X86_FEATURE_OSVW        ( 6*32+ 9) /* OS Visible Workaround */
+#define X86_FEATURE_IBS         ( 6*32+10) /* Instruction Based Sampling */
+#define X86_FEATURE_XOP         ( 6*32+11) /* extended AVX instructions */
+#define X86_FEATURE_SKINIT      ( 6*32+12) /* SKINIT/STGI instructions */
+#define X86_FEATURE_WDT         ( 6*32+13) /* Watchdog timer */
+#define X86_FEATURE_LWP         ( 6*32+15) /* Light Weight Profiling */
+#define X86_FEATURE_FMA4        ( 6*32+16) /* 4 operands MAC instructions */
+#define X86_FEATURE_TCE         ( 6*32+17) /* translation cache extension */
+#define X86_FEATURE_NODEID_MSR  ( 6*32+19) /* NodeId MSR */
+#define X86_FEATURE_TBM         ( 6*32+21) /* trailing bit manipulations */
+#define X86_FEATURE_TOPOEXT     ( 6*32+22) /* topology extensions CPUID leafs */
+#define X86_FEATURE_PERFCTR_CORE ( 6*32+23) /* core performance counter extensions */
+#define X86_FEATURE_PERFCTR_NB  ( 6*32+24) /* NB performance counter extensions */
+#define X86_FEATURE_BPEXT       (6*32+26) /* data breakpoint extension */
+#define X86_FEATURE_PTSC        ( 6*32+27) /* performance time-stamp counter */
+#define X86_FEATURE_PERFCTR_L2  ( 6*32+28) /* L2 performance counter extensions */
+#define X86_FEATURE_MWAITX      ( 6*32+29) /* MWAIT extension (MONITORX/MWAITX) */
+
+/*
+ * Auxiliary flags: Linux defined - For features scattered in various
+ * CPUID levels like 0x6, 0xA etc, word 7.
+ *
+ * Reuse free bits when adding new feature flags!
+ */
+
+#define X86_FEATURE_CPB         ( 7*32+ 2) /* AMD Core Performance Boost */
+#define X86_FEATURE_EPB         ( 7*32+ 3) /* IA32_ENERGY_PERF_BIAS support */
+
+#define X86_FEATURE_HW_PSTATE   ( 7*32+ 8) /* AMD HW-PState */
+#define X86_FEATURE_PROC_FEEDBACK ( 7*32+ 9) /* AMD ProcFeedbackInterface */
+
+#define X86_FEATURE_INTEL_PT    ( 7*32+15) /* Intel Processor Trace */
+
+/* Virtualization flags: Linux defined, word 8 */
+#define X86_FEATURE_TPR_SHADOW  ( 8*32+ 0) /* Intel TPR Shadow */
+#define X86_FEATURE_VNMI        ( 8*32+ 1) /* Intel Virtual NMI */
+#define X86_FEATURE_FLEXPRIORITY ( 8*32+ 2) /* Intel FlexPriority */
+#define X86_FEATURE_EPT         ( 8*32+ 3) /* Intel Extended Page Table */
+#define X86_FEATURE_VPID        ( 8*32+ 4) /* Intel Virtual Processor ID */
+
+#define X86_FEATURE_VMMCALL     ( 8*32+15) /* Prefer vmmcall to vmcall */
+#define X86_FEATURE_XENPV       ( 8*32+16) /* "" Xen paravirtual guest */
+
+
+/* Intel-defined CPU features, CPUID level 0x00000007:0 (ebx), word 9 */
+#define X86_FEATURE_FSGSBASE    ( 9*32+ 0) /* {RD/WR}{FS/GS}BASE instructions*/
+#define X86_FEATURE_TSC_ADJUST  ( 9*32+ 1) /* TSC adjustment MSR 0x3b */
+#define X86_FEATURE_BMI1        ( 9*32+ 3) /* 1st group bit manipulation extensions */
+#define X86_FEATURE_HLE         ( 9*32+ 4) /* Hardware Lock Elision */
+#define X86_FEATURE_AVX2        ( 9*32+ 5) /* AVX2 instructions */
+#define X86_FEATURE_SMEP        ( 9*32+ 7) /* Supervisor Mode Execution Protection */
+#define X86_FEATURE_BMI2        ( 9*32+ 8) /* 2nd group bit manipulation extensions */
+#define X86_FEATURE_ERMS        ( 9*32+ 9) /* Enhanced REP MOVSB/STOSB */
+#define X86_FEATURE_INVPCID     ( 9*32+10) /* Invalidate Processor Context ID */
+#define X86_FEATURE_RTM         ( 9*32+11) /* Restricted Transactional Memory */
+#define X86_FEATURE_CQM         ( 9*32+12) /* Cache QoS Monitoring */
+#define X86_FEATURE_MPX         ( 9*32+14) /* Memory Protection Extension */
+#define X86_FEATURE_AVX512F     ( 9*32+16) /* AVX-512 Foundation */
+#define X86_FEATURE_AVX512DQ    ( 9*32+17) /* AVX-512 DQ (Double/Quad granular) Instructions */
+#define X86_FEATURE_RDSEED      ( 9*32+18) /* The RDSEED instruction */
+#define X86_FEATURE_ADX         ( 9*32+19) /* The ADCX and ADOX instructions */
+#define X86_FEATURE_SMAP        ( 9*32+20) /* Supervisor Mode Access Prevention */
+#define X86_FEATURE_CLFLUSHOPT  ( 9*32+23) /* CLFLUSHOPT instruction */
+#define X86_FEATURE_CLWB        ( 9*32+24) /* CLWB instruction */
+#define X86_FEATURE_AVX512PF    ( 9*32+26) /* AVX-512 Prefetch */
+#define X86_FEATURE_AVX512ER    ( 9*32+27) /* AVX-512 Exponential and Reciprocal */
+#define X86_FEATURE_AVX512CD    ( 9*32+28) /* AVX-512 Conflict Detection */
+#define X86_FEATURE_SHA_NI      ( 9*32+29) /* SHA1/SHA256 Instruction Extensions */
+#define X86_FEATURE_AVX512BW    ( 9*32+30) /* AVX-512 BW (Byte/Word granular) Instructions */
+#define X86_FEATURE_AVX512VL    ( 9*32+31) /* AVX-512 VL (128/256 Vector Length) Extensions */
+
+/* Extended state features, CPUID level 0x0000000d:1 (eax), word 10 */
+#define X86_FEATURE_XSAVEOPT    (10*32+ 0) /* XSAVEOPT */
+#define X86_FEATURE_XSAVEC      (10*32+ 1) /* XSAVEC */
+#define X86_FEATURE_XGETBV1     (10*32+ 2) /* XGETBV with ECX = 1 */
+#define X86_FEATURE_XSAVES      (10*32+ 3) /* XSAVES/XRSTORS */
+
+/* Intel-defined CPU QoS Sub-leaf, CPUID level 0x0000000F:0 (edx), word 11 */
+#define X86_FEATURE_CQM_LLC     (11*32+ 1) /* LLC QoS if 1 */
+
+/* Intel-defined CPU QoS Sub-leaf, CPUID level 0x0000000F:1 (edx), word 12 */
+#define X86_FEATURE_CQM_OCCUP_LLC (12*32+ 0) /* LLC occupancy monitoring if 1 */
+#define X86_FEATURE_CQM_MBM_TOTAL (12*32+ 1) /* LLC Total MBM monitoring */
+#define X86_FEATURE_CQM_MBM_LOCAL (12*32+ 2) /* LLC Local MBM monitoring */
+
+/* AMD-defined CPU features, CPUID level 0x80000008 (ebx), word 13 */
+#define X86_FEATURE_CLZERO      (13*32+0) /* CLZERO instruction */
+#define X86_FEATURE_IRPERF      (13*32+1) /* Instructions Retired Count */
+
+/* Thermal and Power Management Leaf, CPUID level 0x00000006 (eax), word 14 */
+#define X86_FEATURE_DTHERM      (14*32+ 0) /* Digital Thermal Sensor */
+#define X86_FEATURE_IDA         (14*32+ 1) /* Intel Dynamic Acceleration */
+#define X86_FEATURE_ARAT        (14*32+ 2) /* Always Running APIC Timer */
+#define X86_FEATURE_PLN         (14*32+ 4) /* Intel Power Limit Notification */
+#define X86_FEATURE_PTS         (14*32+ 6) /* Intel Package Thermal Status */
+#define X86_FEATURE_HWP         (14*32+ 7) /* Intel Hardware P-states */
+#define X86_FEATURE_HWP_NOTIFY  (14*32+ 8) /* HWP Notification */
+#define X86_FEATURE_HWP_ACT_WINDOW (14*32+ 9) /* HWP Activity Window */
+#define X86_FEATURE_HWP_EPP     (14*32+10) /* HWP Energy Perf. Preference */
+#define X86_FEATURE_HWP_PKG_REQ (14*32+11) /* HWP Package Level Request */
+
+/* AMD SVM Feature Identification, CPUID level 0x8000000a (edx), word 15 */
+#define X86_FEATURE_NPT         (15*32+ 0) /* Nested Page Table support */
+#define X86_FEATURE_LBRV        (15*32+ 1) /* LBR Virtualization support */
+#define X86_FEATURE_SVML        (15*32+ 2) /* "svm_lock" SVM locking MSR */
+#define X86_FEATURE_NRIPS       (15*32+ 3) /* "nrip_save" SVM next_rip save */
+#define X86_FEATURE_TSCRATEMSR  (15*32+ 4) /* "tsc_scale" TSC scaling support */
+#define X86_FEATURE_VMCBCLEAN   (15*32+ 5) /* "vmcb_clean" VMCB clean bits support */
+#define X86_FEATURE_FLUSHBYASID (15*32+ 6) /* flush-by-ASID support */
+#define X86_FEATURE_DECODEASSISTS (15*32+ 7) /* Decode Assists support */
+#define X86_FEATURE_PAUSEFILTER (15*32+10) /* filtered pause intercept */
+#define X86_FEATURE_PFTHRESHOLD (15*32+12) /* pause filter threshold */
+#define X86_FEATURE_AVIC        (15*32+13) /* Virtual Interrupt Controller */
+
+/* Intel-defined CPU features, CPUID level 0x00000007:0 (ecx), word 16 */
+#define X86_FEATURE_PKU         (16*32+ 3) /* Protection Keys for Userspace */
+#define X86_FEATURE_OSPKE       (16*32+ 4) /* OS Protection Keys Enable */
+
+/* AMD-defined CPU features, CPUID level 0x80000007 (ebx), word 17 */
+#define X86_FEATURE_OVERFLOW_RECOV (17*32+0) /* MCA overflow recovery support */
+#define X86_FEATURE_SUCCOR      (17*32+1) /* Uncorrectable error containment and recovery */
+#define X86_FEATURE_SMCA        (17*32+3) /* Scalable MCA */
+
+/*
+ * BUG word(s)
+ */
+#define X86_BUG(x)              (NCAPINTS*32 + (x))
+
+#define X86_BUG_F00F            X86_BUG(0) /* Intel F00F */
+#define X86_BUG_FDIV            X86_BUG(1) /* FPU FDIV */
+#define X86_BUG_COMA            X86_BUG(2) /* Cyrix 6x86 coma */
+#define X86_BUG_AMD_TLB_MMATCH  X86_BUG(3) /* "tlb_mmatch" AMD Erratum 383 */
+#define X86_BUG_AMD_APIC_C1E    X86_BUG(4) /* "apic_c1e" AMD Erratum 400 */
+#define X86_BUG_11AP            X86_BUG(5) /* Bad local APIC aka 11AP */
+#define X86_BUG_FXSAVE_LEAK     X86_BUG(6) /* FXSAVE leaks FOP/FIP/FOP */
+#define X86_BUG_CLFLUSH_MONITOR X86_BUG(7) /* AAI65, CLFLUSH required before MONITOR */
+#define X86_BUG_SYSRET_SS_ATTRS X86_BUG(8) /* SYSRET doesn't fix up SS attrs */
+#ifdef CONFIG_X86_32
+/*
+ * 64-bit kernels don't use X86_BUG_ESPFIX.  Make the define conditional
+ * to avoid confusion.
+ */
+#define X86_BUG_ESPFIX          X86_BUG(9) /* "" IRET to 16-bit SS corrupts ESP/RSP high bits */
+#endif
+#define X86_BUG_NULL_SEG        X86_BUG(10) /* Nulling a selector preserves the base */
+#define X86_BUG_SWAPGS_FENCE    X86_BUG(11) /* SWAPGS without input dep on GS */
+#define X86_BUG_MONITOR         X86_BUG(12) /* IPI required to wake up remote CPU */
+#endif /* _ASM_X86_CPUFEATURES_H */
diff --git a/tools/arch/x86/include/asm/disabled-features.h b/tools/arch/x86/include/asm/disabled-features.h
new file mode 100644
index 000000000000..85599ad4d024
--- /dev/null
+++ b/tools/arch/x86/include/asm/disabled-features.h
@@ -0,0 +1,62 @@
+#ifndef _ASM_X86_DISABLED_FEATURES_H
+#define _ASM_X86_DISABLED_FEATURES_H
+
+/* These features, although they might be available in a CPU
+ * will not be used because the compile options to support
+ * them are not present.
+ *
+ * This code allows them to be checked and disabled at
+ * compile time without an explicit #ifdef.  Use
+ * cpu_feature_enabled().
+ */
+
+#ifdef CONFIG_X86_INTEL_MPX
+# define DISABLE_MPX    0
+#else
+# define DISABLE_MPX    (1<<(X86_FEATURE_MPX & 31))
+#endif
+
+#ifdef CONFIG_X86_64
+# define DISABLE_VME            (1<<(X86_FEATURE_VME & 31))
+# define DISABLE_K6_MTRR        (1<<(X86_FEATURE_K6_MTRR & 31))
+# define DISABLE_CYRIX_ARR      (1<<(X86_FEATURE_CYRIX_ARR & 31))
+# define DISABLE_CENTAUR_MCR    (1<<(X86_FEATURE_CENTAUR_MCR & 31))
+#else
+# define DISABLE_VME            0
+# define DISABLE_K6_MTRR        0
+# define DISABLE_CYRIX_ARR      0
+# define DISABLE_CENTAUR_MCR    0
+#endif /* CONFIG_X86_64 */
+
+#ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS
+# define DISABLE_PKU            0
+# define DISABLE_OSPKE          0
+#else
+# define DISABLE_PKU            (1<<(X86_FEATURE_PKU & 31))
+# define DISABLE_OSPKE          (1<<(X86_FEATURE_OSPKE & 31))
+#endif /* CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS */
+
+/*
+ * Make sure to add features to the correct mask
+ */
+#define DISABLED_MASK0  (DISABLE_VME)
+#define DISABLED_MASK1  0
+#define DISABLED_MASK2  0
+#define DISABLED_MASK3  (DISABLE_CYRIX_ARR|DISABLE_CENTAUR_MCR|DISABLE_K6_MTRR)
+#define DISABLED_MASK4  0
+#define DISABLED_MASK5  0
+#define DISABLED_MASK6  0
+#define DISABLED_MASK7  0
+#define DISABLED_MASK8  0
+#define DISABLED_MASK9  (DISABLE_MPX)
+#define DISABLED_MASK10 0
+#define DISABLED_MASK11 0
+#define DISABLED_MASK12 0
+#define DISABLED_MASK13 0
+#define DISABLED_MASK14 0
+#define DISABLED_MASK15 0
+#define DISABLED_MASK16 (DISABLE_PKU|DISABLE_OSPKE)
+#define DISABLED_MASK17 0
+#define DISABLED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 18)
+
+#endif /* _ASM_X86_DISABLED_FEATURES_H */
diff --git a/tools/arch/x86/include/asm/required-features.h b/tools/arch/x86/include/asm/required-features.h
new file mode 100644
index 000000000000..fac9a5c0abe9
--- /dev/null
+++ b/tools/arch/x86/include/asm/required-features.h
@@ -0,0 +1,105 @@
+#ifndef _ASM_X86_REQUIRED_FEATURES_H
+#define _ASM_X86_REQUIRED_FEATURES_H
+
+/* Define minimum CPUID feature set for kernel These bits are checked
+   really early to actually display a visible error message before the
+   kernel dies.  Make sure to assign features to the proper mask!
+
+   Some requirements that are not in CPUID yet are also in the
+   CONFIG_X86_MINIMUM_CPU_FAMILY which is checked too.
+
+   The real information is in arch/x86/Kconfig.cpu, this just converts
+   the CONFIGs into a bitmask */
+
+#ifndef CONFIG_MATH_EMULATION
+# define NEED_FPU       (1<<(X86_FEATURE_FPU & 31))
+#else
+# define NEED_FPU       0
+#endif
+
+#if defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
+# define NEED_PAE       (1<<(X86_FEATURE_PAE & 31))
+#else
+# define NEED_PAE       0
+#endif
+
+#ifdef CONFIG_X86_CMPXCHG64
+# define NEED_CX8       (1<<(X86_FEATURE_CX8 & 31))
+#else
+# define NEED_CX8       0
+#endif
+
+#if defined(CONFIG_X86_CMOV) || defined(CONFIG_X86_64)
+# define NEED_CMOV      (1<<(X86_FEATURE_CMOV & 31))
+#else
+# define NEED_CMOV      0
+#endif
+
+#ifdef CONFIG_X86_USE_3DNOW
+# define NEED_3DNOW     (1<<(X86_FEATURE_3DNOW & 31))
+#else
+# define NEED_3DNOW     0
+#endif
+
+#if defined(CONFIG_X86_P6_NOP) || defined(CONFIG_X86_64)
+# define NEED_NOPL      (1<<(X86_FEATURE_NOPL & 31))
+#else
+# define NEED_NOPL      0
+#endif
+
+#ifdef CONFIG_MATOM
+# define NEED_MOVBE     (1<<(X86_FEATURE_MOVBE & 31))
+#else
+# define NEED_MOVBE     0
+#endif
+
+#ifdef CONFIG_X86_64
+#ifdef CONFIG_PARAVIRT
+/* Paravirtualized systems may not have PSE or PGE available */
+#define NEED_PSE        0
+#define NEED_PGE        0
+#else
+#define NEED_PSE        (1<<(X86_FEATURE_PSE) & 31)
+#define NEED_PGE        (1<<(X86_FEATURE_PGE) & 31)
+#endif
+#define NEED_MSR        (1<<(X86_FEATURE_MSR & 31))
+#define NEED_FXSR       (1<<(X86_FEATURE_FXSR & 31))
+#define NEED_XMM        (1<<(X86_FEATURE_XMM & 31))
+#define NEED_XMM2       (1<<(X86_FEATURE_XMM2 & 31))
+#define NEED_LM         (1<<(X86_FEATURE_LM & 31))
+#else
+#define NEED_PSE        0
+#define NEED_MSR        0
+#define NEED_PGE        0
+#define NEED_FXSR       0
+#define NEED_XMM        0
+#define NEED_XMM2       0
+#define NEED_LM         0
+#endif
+
+#define REQUIRED_MASK0  (NEED_FPU|NEED_PSE|NEED_MSR|NEED_PAE|\
+                         NEED_CX8|NEED_PGE|NEED_FXSR|NEED_CMOV|\
+                         NEED_XMM|NEED_XMM2)
+#define SSE_MASK        (NEED_XMM|NEED_XMM2)
+
+#define REQUIRED_MASK1  (NEED_LM|NEED_3DNOW)
+
+#define REQUIRED_MASK2  0
+#define REQUIRED_MASK3  (NEED_NOPL)
+#define REQUIRED_MASK4  (NEED_MOVBE)
+#define REQUIRED_MASK5  0
+#define REQUIRED_MASK6  0
+#define REQUIRED_MASK7  0
+#define REQUIRED_MASK8  0
+#define REQUIRED_MASK9  0
+#define REQUIRED_MASK10 0
+#define REQUIRED_MASK11 0
+#define REQUIRED_MASK12 0
+#define REQUIRED_MASK13 0
+#define REQUIRED_MASK14 0
+#define REQUIRED_MASK15 0
+#define REQUIRED_MASK16 0
+#define REQUIRED_MASK17 0
+#define REQUIRED_MASK_CHECK BUILD_BUG_ON_ZERO(NCAPINTS != 18)
+
+#endif /* _ASM_X86_REQUIRED_FEATURES_H */
diff --git a/tools/arch/x86/include/asm/unistd_32.h b/tools/arch/x86/include/asm/unistd_32.h
new file mode 100644
index 000000000000..88b3f8c8920c
--- /dev/null
+++ b/tools/arch/x86/include/asm/unistd_32.h
@@ -0,0 +1,12 @@
+#ifndef __NR_perf_event_open
+# define __NR_perf_event_open 336
+#endif
+#ifndef __NR_futex
+# define __NR_futex 240
+#endif
+#ifndef __NR_gettid
+# define __NR_gettid 224
+#endif
+#ifndef __NR_getcpu
+# define __NR_getcpu 318
+#endif
diff --git a/tools/arch/x86/include/asm/unistd_64.h b/tools/arch/x86/include/asm/unistd_64.h
new file mode 100644
index 000000000000..fbdb70ee8837
--- /dev/null
+++ b/tools/arch/x86/include/asm/unistd_64.h
@@ -0,0 +1,12 @@
+#ifndef __NR_perf_event_open
+# define __NR_perf_event_open 298
+#endif
+#ifndef __NR_futex
+# define __NR_futex 202
+#endif
+#ifndef __NR_gettid
+# define __NR_gettid 186
+#endif
+#ifndef __NR_getcpu
+# define __NR_getcpu 309
+#endif
diff --git a/tools/arch/x86/include/uapi/asm/bitsperlong.h b/tools/arch/x86/include/uapi/asm/bitsperlong.h
new file mode 100644
index 000000000000..6e23c543cd80
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/bitsperlong.h
@@ -0,0 +1,12 @@
+#ifndef __ASM_X86_BITSPERLONG_H
+#define __ASM_X86_BITSPERLONG_H
+
+#if defined(__x86_64__) && !defined(__ILP32__)
+# define __BITS_PER_LONG 64
+#else
+# define __BITS_PER_LONG 32
+#endif
+
+#include <asm-generic/bitsperlong.h>
+
+#endif /* __ASM_X86_BITSPERLONG_H */
diff --git a/tools/arch/x86/include/uapi/asm/kvm.h b/tools/arch/x86/include/uapi/asm/kvm.h
new file mode 100644
index 000000000000..739c0c594022
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/kvm.h
@@ -0,0 +1,360 @@
+#ifndef _ASM_X86_KVM_H
+#define _ASM_X86_KVM_H
+
+/*
+ * KVM x86 specific structures and definitions
+ *
+ */
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+
+#define DE_VECTOR 0
+#define DB_VECTOR 1
+#define BP_VECTOR 3
+#define OF_VECTOR 4
+#define BR_VECTOR 5
+#define UD_VECTOR 6
+#define NM_VECTOR 7
+#define DF_VECTOR 8
+#define TS_VECTOR 10
+#define NP_VECTOR 11
+#define SS_VECTOR 12
+#define GP_VECTOR 13
+#define PF_VECTOR 14
+#define MF_VECTOR 16
+#define AC_VECTOR 17
+#define MC_VECTOR 18
+#define XM_VECTOR 19
+#define VE_VECTOR 20
+
+/* Select x86 specific features in <linux/kvm.h> */
+#define __KVM_HAVE_PIT
+#define __KVM_HAVE_IOAPIC
+#define __KVM_HAVE_IRQ_LINE
+#define __KVM_HAVE_MSI
+#define __KVM_HAVE_USER_NMI
+#define __KVM_HAVE_GUEST_DEBUG
+#define __KVM_HAVE_MSIX
+#define __KVM_HAVE_MCE
+#define __KVM_HAVE_PIT_STATE2
+#define __KVM_HAVE_XEN_HVM
+#define __KVM_HAVE_VCPU_EVENTS
+#define __KVM_HAVE_DEBUGREGS
+#define __KVM_HAVE_XSAVE
+#define __KVM_HAVE_XCRS
+#define __KVM_HAVE_READONLY_MEM
+
+/* Architectural interrupt line count. */
+#define KVM_NR_INTERRUPTS 256
+
+struct kvm_memory_alias {
+        __u32 slot;  /* this has a different namespace than memory slots */
+        __u32 flags;
+        __u64 guest_phys_addr;
+        __u64 memory_size;
+        __u64 target_phys_addr;
+};
+
+/* for KVM_GET_IRQCHIP and KVM_SET_IRQCHIP */
+struct kvm_pic_state {
+        __u8 last_irr;  /* edge detection */
+        __u8 irr;               /* interrupt request register */
+        __u8 imr;               /* interrupt mask register */
+        __u8 isr;               /* interrupt service register */
+        __u8 priority_add;      /* highest irq priority */
+        __u8 irq_base;
+        __u8 read_reg_select;
+        __u8 poll;
+        __u8 special_mask;
+        __u8 init_state;
+        __u8 auto_eoi;
+        __u8 rotate_on_auto_eoi;
+        __u8 special_fully_nested_mode;
+        __u8 init4;             /* true if 4 byte init */
+        __u8 elcr;              /* PIIX edge/trigger selection */
+        __u8 elcr_mask;
+};
+
+#define KVM_IOAPIC_NUM_PINS  24
+struct kvm_ioapic_state {
+        __u64 base_address;
+        __u32 ioregsel;
+        __u32 id;
+        __u32 irr;
+        __u32 pad;
+        union {
+                __u64 bits;
+                struct {
+                        __u8 vector;
+                        __u8 delivery_mode:3;
+                        __u8 dest_mode:1;
+                        __u8 delivery_status:1;
+                        __u8 polarity:1;
+                        __u8 remote_irr:1;
+                        __u8 trig_mode:1;
+                        __u8 mask:1;
+                        __u8 reserve:7;
+                        __u8 reserved[4];
+                        __u8 dest_id;
+                } fields;
+        } redirtbl[KVM_IOAPIC_NUM_PINS];
+};
+
+#define KVM_IRQCHIP_PIC_MASTER   0
+#define KVM_IRQCHIP_PIC_SLAVE    1
+#define KVM_IRQCHIP_IOAPIC       2
+#define KVM_NR_IRQCHIPS          3
+
+#define KVM_RUN_X86_SMM          (1 << 0)
+
+/* for KVM_GET_REGS and KVM_SET_REGS */
+struct kvm_regs {
+        /* out (KVM_GET_REGS) / in (KVM_SET_REGS) */
+        __u64 rax, rbx, rcx, rdx;
+        __u64 rsi, rdi, rsp, rbp;
+        __u64 r8,  r9,  r10, r11;
+        __u64 r12, r13, r14, r15;
+        __u64 rip, rflags;
+};
+
+/* for KVM_GET_LAPIC and KVM_SET_LAPIC */
+#define KVM_APIC_REG_SIZE 0x400
+struct kvm_lapic_state {
+        char regs[KVM_APIC_REG_SIZE];
+};
+
+struct kvm_segment {
+        __u64 base;
+        __u32 limit;
+        __u16 selector;
+        __u8  type;
+        __u8  present, dpl, db, s, l, g, avl;
+        __u8  unusable;
+        __u8  padding;
+};
+
+struct kvm_dtable {
+        __u64 base;
+        __u16 limit;
+        __u16 padding[3];
+};
+
+
+/* for KVM_GET_SREGS and KVM_SET_SREGS */
+struct kvm_sregs {
+        /* out (KVM_GET_SREGS) / in (KVM_SET_SREGS) */
+        struct kvm_segment cs, ds, es, fs, gs, ss;
+        struct kvm_segment tr, ldt;
+        struct kvm_dtable gdt, idt;
+        __u64 cr0, cr2, cr3, cr4, cr8;
+        __u64 efer;
+        __u64 apic_base;
+        __u64 interrupt_bitmap[(KVM_NR_INTERRUPTS + 63) / 64];
+};
+
+/* for KVM_GET_FPU and KVM_SET_FPU */
+struct kvm_fpu {
+        __u8  fpr[8][16];
+        __u16 fcw;
+        __u16 fsw;
+        __u8  ftwx;  /* in fxsave format */
+        __u8  pad1;
+        __u16 last_opcode;
+        __u64 last_ip;
+        __u64 last_dp;
+        __u8  xmm[16][16];
+        __u32 mxcsr;
+        __u32 pad2;
+};
+
+struct kvm_msr_entry {
+        __u32 index;
+        __u32 reserved;
+        __u64 data;
+};
+
+/* for KVM_GET_MSRS and KVM_SET_MSRS */
+struct kvm_msrs {
+        __u32 nmsrs; /* number of msrs in entries */
+        __u32 pad;
+
+        struct kvm_msr_entry entries[0];
+};
+
+/* for KVM_GET_MSR_INDEX_LIST */
+struct kvm_msr_list {
+        __u32 nmsrs; /* number of msrs in entries */
+        __u32 indices[0];
+};
+
+
+struct kvm_cpuid_entry {
+        __u32 function;
+        __u32 eax;
+        __u32 ebx;
+        __u32 ecx;
+        __u32 edx;
+        __u32 padding;
+};
+
+/* for KVM_SET_CPUID */
+struct kvm_cpuid {
+        __u32 nent;
+        __u32 padding;
+        struct kvm_cpuid_entry entries[0];
+};
+
+struct kvm_cpuid_entry2 {
+        __u32 function;
+        __u32 index;
+        __u32 flags;
+        __u32 eax;
+        __u32 ebx;
+        __u32 ecx;
+        __u32 edx;
+        __u32 padding[3];
+};
+
+#define KVM_CPUID_FLAG_SIGNIFCANT_INDEX         (1 << 0)
+#define KVM_CPUID_FLAG_STATEFUL_FUNC            (1 << 1)
+#define KVM_CPUID_FLAG_STATE_READ_NEXT          (1 << 2)
+
+/* for KVM_SET_CPUID2 */
+struct kvm_cpuid2 {
+        __u32 nent;
+        __u32 padding;
+        struct kvm_cpuid_entry2 entries[0];
+};
+
+/* for KVM_GET_PIT and KVM_SET_PIT */
+struct kvm_pit_channel_state {
+        __u32 count; /* can be 65536 */
+        __u16 latched_count;
+        __u8 count_latched;
+        __u8 status_latched;
+        __u8 status;
+        __u8 read_state;
+        __u8 write_state;
+        __u8 write_latch;
+        __u8 rw_mode;
+        __u8 mode;
+        __u8 bcd;
+        __u8 gate;
+        __s64 count_load_time;
+};
+
+struct kvm_debug_exit_arch {
+        __u32 exception;
+        __u32 pad;
+        __u64 pc;
+        __u64 dr6;
+        __u64 dr7;
+};
+
+#define KVM_GUESTDBG_USE_SW_BP          0x00010000
+#define KVM_GUESTDBG_USE_HW_BP          0x00020000
+#define KVM_GUESTDBG_INJECT_DB          0x00040000
+#define KVM_GUESTDBG_INJECT_BP          0x00080000
+
+/* for KVM_SET_GUEST_DEBUG */
+struct kvm_guest_debug_arch {
+        __u64 debugreg[8];
+};
+
+struct kvm_pit_state {
+        struct kvm_pit_channel_state channels[3];
+};
+
+#define KVM_PIT_FLAGS_HPET_LEGACY  0x00000001
+
+struct kvm_pit_state2 {
+        struct kvm_pit_channel_state channels[3];
+        __u32 flags;
+        __u32 reserved[9];
+};
+
+struct kvm_reinject_control {
+        __u8 pit_reinject;
+        __u8 reserved[31];
+};
+
+/* When set in flags, include corresponding fields on KVM_SET_VCPU_EVENTS */
+#define KVM_VCPUEVENT_VALID_NMI_PENDING 0x00000001
+#define KVM_VCPUEVENT_VALID_SIPI_VECTOR 0x00000002
+#define KVM_VCPUEVENT_VALID_SHADOW      0x00000004
+#define KVM_VCPUEVENT_VALID_SMM         0x00000008
+
+/* Interrupt shadow states */
+#define KVM_X86_SHADOW_INT_MOV_SS       0x01
+#define KVM_X86_SHADOW_INT_STI          0x02
+
+/* for KVM_GET/SET_VCPU_EVENTS */
+struct kvm_vcpu_events {
+        struct {
+                __u8 injected;
+                __u8 nr;
+                __u8 has_error_code;
+                __u8 pad;
+                __u32 error_code;
+        } exception;
+        struct {
+                __u8 injected;
+                __u8 nr;
+                __u8 soft;
+                __u8 shadow;
+        } interrupt;
+        struct {
+                __u8 injected;
+                __u8 pending;
+                __u8 masked;
+                __u8 pad;
+        } nmi;
+        __u32 sipi_vector;
+        __u32 flags;
+        struct {
+                __u8 smm;
+                __u8 pending;
+                __u8 smm_inside_nmi;
+                __u8 latched_init;
+        } smi;
+        __u32 reserved[9];
+};
+
+/* for KVM_GET/SET_DEBUGREGS */
+struct kvm_debugregs {
+        __u64 db[4];
+        __u64 dr6;
+        __u64 dr7;
+        __u64 flags;
+        __u64 reserved[9];
+};
+
+/* for KVM_CAP_XSAVE */
+struct kvm_xsave {
+        __u32 region[1024];
+};
+
+#define KVM_MAX_XCRS    16
+
+struct kvm_xcr {
+        __u32 xcr;
+        __u32 reserved;
+        __u64 value;
+};
+
+struct kvm_xcrs {
+        __u32 nr_xcrs;
+        __u32 flags;
+        struct kvm_xcr xcrs[KVM_MAX_XCRS];
+        __u64 padding[16];
+};
+
+/* definition of registers in kvm_run */
+struct kvm_sync_regs {
+};
+
+#define KVM_X86_QUIRK_LINT0_REENABLED   (1 << 0)
+#define KVM_X86_QUIRK_CD_NW_CLEARED     (1 << 1)
+
+#endif /* _ASM_X86_KVM_H */
diff --git a/tools/arch/x86/include/uapi/asm/kvm_perf.h b/tools/arch/x86/include/uapi/asm/kvm_perf.h
new file mode 100644
index 000000000000..3bb964f88aa1
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/kvm_perf.h
@@ -0,0 +1,16 @@
+#ifndef _ASM_X86_KVM_PERF_H
+#define _ASM_X86_KVM_PERF_H
+
+#include <asm/svm.h>
+#include <asm/vmx.h>
+#include <asm/kvm.h>
+
+#define DECODE_STR_LEN 20
+
+#define VCPU_ID "vcpu_id"
+
+#define KVM_ENTRY_TRACE "kvm:kvm_entry"
+#define KVM_EXIT_TRACE "kvm:kvm_exit"
+#define KVM_EXIT_REASON "exit_reason"
+
+#endif /* _ASM_X86_KVM_PERF_H */
diff --git a/tools/arch/x86/include/uapi/asm/mman.h b/tools/arch/x86/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..b73c1af8b1dd
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/mman.h
@@ -0,0 +1,5 @@
+#ifndef TOOLS_ARCH_X86_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_X86_UAPI_ASM_MMAN_FIX_H
+#define MAP_32BIT       0x40
+#include <uapi/asm-generic/mman.h>
+#endif
diff --git a/tools/arch/x86/include/uapi/asm/perf_regs.h b/tools/arch/x86/include/uapi/asm/perf_regs.h
new file mode 100644
index 000000000000..3f2207bfd17b
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/perf_regs.h
@@ -0,0 +1,33 @@
+#ifndef _ASM_X86_PERF_REGS_H
+#define _ASM_X86_PERF_REGS_H
+
+enum perf_event_x86_regs {
+        PERF_REG_X86_AX,
+        PERF_REG_X86_BX,
+        PERF_REG_X86_CX,
+        PERF_REG_X86_DX,
+        PERF_REG_X86_SI,
+        PERF_REG_X86_DI,
+        PERF_REG_X86_BP,
+        PERF_REG_X86_SP,
+        PERF_REG_X86_IP,
+        PERF_REG_X86_FLAGS,
+        PERF_REG_X86_CS,
+        PERF_REG_X86_SS,
+        PERF_REG_X86_DS,
+        PERF_REG_X86_ES,
+        PERF_REG_X86_FS,
+        PERF_REG_X86_GS,
+        PERF_REG_X86_R8,
+        PERF_REG_X86_R9,
+        PERF_REG_X86_R10,
+        PERF_REG_X86_R11,
+        PERF_REG_X86_R12,
+        PERF_REG_X86_R13,
+        PERF_REG_X86_R14,
+        PERF_REG_X86_R15,
+
+        PERF_REG_X86_32_MAX = PERF_REG_X86_GS + 1,
+        PERF_REG_X86_64_MAX = PERF_REG_X86_R15 + 1,
+};
+#endif /* _ASM_X86_PERF_REGS_H */
diff --git a/tools/arch/x86/include/uapi/asm/svm.h b/tools/arch/x86/include/uapi/asm/svm.h
new file mode 100644
index 000000000000..3725e145aa58
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/svm.h
@@ -0,0 +1,178 @@
+#ifndef _UAPI__SVM_H
+#define _UAPI__SVM_H
+
+#define SVM_EXIT_READ_CR0      0x000
+#define SVM_EXIT_READ_CR2      0x002
+#define SVM_EXIT_READ_CR3      0x003
+#define SVM_EXIT_READ_CR4      0x004
+#define SVM_EXIT_READ_CR8      0x008
+#define SVM_EXIT_WRITE_CR0     0x010
+#define SVM_EXIT_WRITE_CR2     0x012
+#define SVM_EXIT_WRITE_CR3     0x013
+#define SVM_EXIT_WRITE_CR4     0x014
+#define SVM_EXIT_WRITE_CR8     0x018
+#define SVM_EXIT_READ_DR0      0x020
+#define SVM_EXIT_READ_DR1      0x021
+#define SVM_EXIT_READ_DR2      0x022
+#define SVM_EXIT_READ_DR3      0x023
+#define SVM_EXIT_READ_DR4      0x024
+#define SVM_EXIT_READ_DR5      0x025
+#define SVM_EXIT_READ_DR6      0x026
+#define SVM_EXIT_READ_DR7      0x027
+#define SVM_EXIT_WRITE_DR0     0x030
+#define SVM_EXIT_WRITE_DR1     0x031
+#define SVM_EXIT_WRITE_DR2     0x032
+#define SVM_EXIT_WRITE_DR3     0x033
+#define SVM_EXIT_WRITE_DR4     0x034
+#define SVM_EXIT_WRITE_DR5     0x035
+#define SVM_EXIT_WRITE_DR6     0x036
+#define SVM_EXIT_WRITE_DR7     0x037
+#define SVM_EXIT_EXCP_BASE     0x040
+#define SVM_EXIT_INTR          0x060
+#define SVM_EXIT_NMI           0x061
+#define SVM_EXIT_SMI           0x062
+#define SVM_EXIT_INIT          0x063
+#define SVM_EXIT_VINTR         0x064
+#define SVM_EXIT_CR0_SEL_WRITE 0x065
+#define SVM_EXIT_IDTR_READ     0x066
+#define SVM_EXIT_GDTR_READ     0x067
+#define SVM_EXIT_LDTR_READ     0x068
+#define SVM_EXIT_TR_READ       0x069
+#define SVM_EXIT_IDTR_WRITE    0x06a
+#define SVM_EXIT_GDTR_WRITE    0x06b
+#define SVM_EXIT_LDTR_WRITE    0x06c
+#define SVM_EXIT_TR_WRITE      0x06d
+#define SVM_EXIT_RDTSC         0x06e
+#define SVM_EXIT_RDPMC         0x06f
+#define SVM_EXIT_PUSHF         0x070
+#define SVM_EXIT_POPF          0x071
+#define SVM_EXIT_CPUID         0x072
+#define SVM_EXIT_RSM           0x073
+#define SVM_EXIT_IRET          0x074
+#define SVM_EXIT_SWINT         0x075
+#define SVM_EXIT_INVD          0x076
+#define SVM_EXIT_PAUSE         0x077
+#define SVM_EXIT_HLT           0x078
+#define SVM_EXIT_INVLPG        0x079
+#define SVM_EXIT_INVLPGA       0x07a
+#define SVM_EXIT_IOIO          0x07b
+#define SVM_EXIT_MSR           0x07c
+#define SVM_EXIT_TASK_SWITCH   0x07d
+#define SVM_EXIT_FERR_FREEZE   0x07e
+#define SVM_EXIT_SHUTDOWN      0x07f
+#define SVM_EXIT_VMRUN         0x080
+#define SVM_EXIT_VMMCALL       0x081
+#define SVM_EXIT_VMLOAD        0x082
+#define SVM_EXIT_VMSAVE        0x083
+#define SVM_EXIT_STGI          0x084
+#define SVM_EXIT_CLGI          0x085
+#define SVM_EXIT_SKINIT        0x086
+#define SVM_EXIT_RDTSCP        0x087
+#define SVM_EXIT_ICEBP         0x088
+#define SVM_EXIT_WBINVD        0x089
+#define SVM_EXIT_MONITOR       0x08a
+#define SVM_EXIT_MWAIT         0x08b
+#define SVM_EXIT_MWAIT_COND    0x08c
+#define SVM_EXIT_XSETBV        0x08d
+#define SVM_EXIT_NPF           0x400
+#define SVM_EXIT_AVIC_INCOMPLETE_IPI            0x401
+#define SVM_EXIT_AVIC_UNACCELERATED_ACCESS      0x402
+
+#define SVM_EXIT_ERR           -1
+
+#define SVM_EXIT_REASONS \
+        { SVM_EXIT_READ_CR0,    "read_cr0" }, \
+        { SVM_EXIT_READ_CR2,    "read_cr2" }, \
+        { SVM_EXIT_READ_CR3,    "read_cr3" }, \
+        { SVM_EXIT_READ_CR4,    "read_cr4" }, \
+        { SVM_EXIT_READ_CR8,    "read_cr8" }, \
+        { SVM_EXIT_WRITE_CR0,   "write_cr0" }, \
+        { SVM_EXIT_WRITE_CR2,   "write_cr2" }, \
+        { SVM_EXIT_WRITE_CR3,   "write_cr3" }, \
+        { SVM_EXIT_WRITE_CR4,   "write_cr4" }, \
+        { SVM_EXIT_WRITE_CR8,   "write_cr8" }, \
+        { SVM_EXIT_READ_DR0,    "read_dr0" }, \
+        { SVM_EXIT_READ_DR1,    "read_dr1" }, \
+        { SVM_EXIT_READ_DR2,    "read_dr2" }, \
+        { SVM_EXIT_READ_DR3,    "read_dr3" }, \
+        { SVM_EXIT_READ_DR4,    "read_dr4" }, \
+        { SVM_EXIT_READ_DR5,    "read_dr5" }, \
+        { SVM_EXIT_READ_DR6,    "read_dr6" }, \
+        { SVM_EXIT_READ_DR7,    "read_dr7" }, \
+        { SVM_EXIT_WRITE_DR0,   "write_dr0" }, \
+        { SVM_EXIT_WRITE_DR1,   "write_dr1" }, \
+        { SVM_EXIT_WRITE_DR2,   "write_dr2" }, \
+        { SVM_EXIT_WRITE_DR3,   "write_dr3" }, \
+        { SVM_EXIT_WRITE_DR4,   "write_dr4" }, \
+        { SVM_EXIT_WRITE_DR5,   "write_dr5" }, \
+        { SVM_EXIT_WRITE_DR6,   "write_dr6" }, \
+        { SVM_EXIT_WRITE_DR7,   "write_dr7" }, \
+        { SVM_EXIT_EXCP_BASE + DE_VECTOR,       "DE excp" }, \
+        { SVM_EXIT_EXCP_BASE + DB_VECTOR,       "DB excp" }, \
+        { SVM_EXIT_EXCP_BASE + BP_VECTOR,       "BP excp" }, \
+        { SVM_EXIT_EXCP_BASE + OF_VECTOR,       "OF excp" }, \
+        { SVM_EXIT_EXCP_BASE + BR_VECTOR,       "BR excp" }, \
+        { SVM_EXIT_EXCP_BASE + UD_VECTOR,       "UD excp" }, \
+        { SVM_EXIT_EXCP_BASE + NM_VECTOR,       "NM excp" }, \
+        { SVM_EXIT_EXCP_BASE + DF_VECTOR,       "DF excp" }, \
+        { SVM_EXIT_EXCP_BASE + TS_VECTOR,       "TS excp" }, \
+        { SVM_EXIT_EXCP_BASE + NP_VECTOR,       "NP excp" }, \
+        { SVM_EXIT_EXCP_BASE + SS_VECTOR,       "SS excp" }, \
+        { SVM_EXIT_EXCP_BASE + GP_VECTOR,       "GP excp" }, \
+        { SVM_EXIT_EXCP_BASE + PF_VECTOR,       "PF excp" }, \
+        { SVM_EXIT_EXCP_BASE + MF_VECTOR,       "MF excp" }, \
+        { SVM_EXIT_EXCP_BASE + AC_VECTOR,       "AC excp" }, \
+        { SVM_EXIT_EXCP_BASE + MC_VECTOR,       "MC excp" }, \
+        { SVM_EXIT_EXCP_BASE + XM_VECTOR,       "XF excp" }, \
+        { SVM_EXIT_INTR,        "interrupt" }, \
+        { SVM_EXIT_NMI,         "nmi" }, \
+        { SVM_EXIT_SMI,         "smi" }, \
+        { SVM_EXIT_INIT,        "init" }, \
+        { SVM_EXIT_VINTR,       "vintr" }, \
+        { SVM_EXIT_CR0_SEL_WRITE, "cr0_sel_write" }, \
+        { SVM_EXIT_IDTR_READ,   "read_idtr" }, \
+        { SVM_EXIT_GDTR_READ,   "read_gdtr" }, \
+        { SVM_EXIT_LDTR_READ,   "read_ldtr" }, \
+        { SVM_EXIT_TR_READ,     "read_rt" }, \
+        { SVM_EXIT_IDTR_WRITE,  "write_idtr" }, \
+        { SVM_EXIT_GDTR_WRITE,  "write_gdtr" }, \
+        { SVM_EXIT_LDTR_WRITE,  "write_ldtr" }, \
+        { SVM_EXIT_TR_WRITE,    "write_rt" }, \
+        { SVM_EXIT_RDTSC,       "rdtsc" }, \
+        { SVM_EXIT_RDPMC,       "rdpmc" }, \
+        { SVM_EXIT_PUSHF,       "pushf" }, \
+        { SVM_EXIT_POPF,        "popf" }, \
+        { SVM_EXIT_CPUID,       "cpuid" }, \
+        { SVM_EXIT_RSM,         "rsm" }, \
+        { SVM_EXIT_IRET,        "iret" }, \
+        { SVM_EXIT_SWINT,       "swint" }, \
+        { SVM_EXIT_INVD,        "invd" }, \
+        { SVM_EXIT_PAUSE,       "pause" }, \
+        { SVM_EXIT_HLT,         "hlt" }, \
+        { SVM_EXIT_INVLPG,      "invlpg" }, \
+        { SVM_EXIT_INVLPGA,     "invlpga" }, \
+        { SVM_EXIT_IOIO,        "io" }, \
+        { SVM_EXIT_MSR,         "msr" }, \
+        { SVM_EXIT_TASK_SWITCH, "task_switch" }, \
+        { SVM_EXIT_FERR_FREEZE, "ferr_freeze" }, \
+        { SVM_EXIT_SHUTDOWN,    "shutdown" }, \
+        { SVM_EXIT_VMRUN,       "vmrun" }, \
+        { SVM_EXIT_VMMCALL,     "hypercall" }, \
+        { SVM_EXIT_VMLOAD,      "vmload" }, \
+        { SVM_EXIT_VMSAVE,      "vmsave" }, \
+        { SVM_EXIT_STGI,        "stgi" }, \
+        { SVM_EXIT_CLGI,        "clgi" }, \
+        { SVM_EXIT_SKINIT,      "skinit" }, \
+        { SVM_EXIT_RDTSCP,      "rdtscp" }, \
+        { SVM_EXIT_ICEBP,       "icebp" }, \
+        { SVM_EXIT_WBINVD,      "wbinvd" }, \
+        { SVM_EXIT_MONITOR,     "monitor" }, \
+        { SVM_EXIT_MWAIT,       "mwait" }, \
+        { SVM_EXIT_XSETBV,      "xsetbv" }, \
+        { SVM_EXIT_NPF,         "npf" }, \
+        { SVM_EXIT_AVIC_INCOMPLETE_IPI,         "avic_incomplete_ipi" }, \
+        { SVM_EXIT_AVIC_UNACCELERATED_ACCESS,   "avic_unaccelerated_access" }, \
+        { SVM_EXIT_ERR,         "invalid_guest_state" }
+
+
+#endif /* _UAPI__SVM_H */
diff --git a/tools/arch/x86/include/uapi/asm/vmx.h b/tools/arch/x86/include/uapi/asm/vmx.h
new file mode 100644
index 000000000000..37fee272618f
--- /dev/null
+++ b/tools/arch/x86/include/uapi/asm/vmx.h
@@ -0,0 +1,134 @@
+/*
+ * vmx.h: VMX Architecture related definitions
+ * Copyright (c) 2004, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+ * Place - Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * A few random additions are:
+ * Copyright (C) 2006 Qumranet
+ *    Avi Kivity <avi@qumranet.com>
+ *    Yaniv Kamay <yaniv@qumranet.com>
+ *
+ */
+#ifndef _UAPIVMX_H
+#define _UAPIVMX_H
+
+
+#define VMX_EXIT_REASONS_FAILED_VMENTRY         0x80000000
+
+#define EXIT_REASON_EXCEPTION_NMI       0
+#define EXIT_REASON_EXTERNAL_INTERRUPT  1
+#define EXIT_REASON_TRIPLE_FAULT        2
+
+#define EXIT_REASON_PENDING_INTERRUPT   7
+#define EXIT_REASON_NMI_WINDOW          8
+#define EXIT_REASON_TASK_SWITCH         9
+#define EXIT_REASON_CPUID               10
+#define EXIT_REASON_HLT                 12
+#define EXIT_REASON_INVD                13
+#define EXIT_REASON_INVLPG              14
+#define EXIT_REASON_RDPMC               15
+#define EXIT_REASON_RDTSC               16
+#define EXIT_REASON_VMCALL              18
+#define EXIT_REASON_VMCLEAR             19
+#define EXIT_REASON_VMLAUNCH            20
+#define EXIT_REASON_VMPTRLD             21
+#define EXIT_REASON_VMPTRST             22
+#define EXIT_REASON_VMREAD              23
+#define EXIT_REASON_VMRESUME            24
+#define EXIT_REASON_VMWRITE             25
+#define EXIT_REASON_VMOFF               26
+#define EXIT_REASON_VMON                27
+#define EXIT_REASON_CR_ACCESS           28
+#define EXIT_REASON_DR_ACCESS           29
+#define EXIT_REASON_IO_INSTRUCTION      30
+#define EXIT_REASON_MSR_READ            31
+#define EXIT_REASON_MSR_WRITE           32
+#define EXIT_REASON_INVALID_STATE       33
+#define EXIT_REASON_MSR_LOAD_FAIL       34
+#define EXIT_REASON_MWAIT_INSTRUCTION   36
+#define EXIT_REASON_MONITOR_TRAP_FLAG   37
+#define EXIT_REASON_MONITOR_INSTRUCTION 39
+#define EXIT_REASON_PAUSE_INSTRUCTION   40
+#define EXIT_REASON_MCE_DURING_VMENTRY  41
+#define EXIT_REASON_TPR_BELOW_THRESHOLD 43
+#define EXIT_REASON_APIC_ACCESS         44
+#define EXIT_REASON_EOI_INDUCED         45
+#define EXIT_REASON_EPT_VIOLATION       48
+#define EXIT_REASON_EPT_MISCONFIG       49
+#define EXIT_REASON_INVEPT              50
+#define EXIT_REASON_RDTSCP              51
+#define EXIT_REASON_PREEMPTION_TIMER    52
+#define EXIT_REASON_INVVPID             53
+#define EXIT_REASON_WBINVD              54
+#define EXIT_REASON_XSETBV              55
+#define EXIT_REASON_APIC_WRITE          56
+#define EXIT_REASON_INVPCID             58
+#define EXIT_REASON_PML_FULL            62
+#define EXIT_REASON_XSAVES              63
+#define EXIT_REASON_XRSTORS             64
+
+#define VMX_EXIT_REASONS \
+        { EXIT_REASON_EXCEPTION_NMI,         "EXCEPTION_NMI" }, \
+        { EXIT_REASON_EXTERNAL_INTERRUPT,    "EXTERNAL_INTERRUPT" }, \
+        { EXIT_REASON_TRIPLE_FAULT,          "TRIPLE_FAULT" }, \
+        { EXIT_REASON_PENDING_INTERRUPT,     "PENDING_INTERRUPT" }, \
+        { EXIT_REASON_NMI_WINDOW,            "NMI_WINDOW" }, \
+        { EXIT_REASON_TASK_SWITCH,           "TASK_SWITCH" }, \
+        { EXIT_REASON_CPUID,                 "CPUID" }, \
+        { EXIT_REASON_HLT,                   "HLT" }, \
+        { EXIT_REASON_INVLPG,                "INVLPG" }, \
+        { EXIT_REASON_RDPMC,                 "RDPMC" }, \
+        { EXIT_REASON_RDTSC,                 "RDTSC" }, \
+        { EXIT_REASON_VMCALL,                "VMCALL" }, \
+        { EXIT_REASON_VMCLEAR,               "VMCLEAR" }, \
+        { EXIT_REASON_VMLAUNCH,              "VMLAUNCH" }, \
+        { EXIT_REASON_VMPTRLD,               "VMPTRLD" }, \
+        { EXIT_REASON_VMPTRST,               "VMPTRST" }, \
+        { EXIT_REASON_VMREAD,                "VMREAD" }, \
+        { EXIT_REASON_VMRESUME,              "VMRESUME" }, \
+        { EXIT_REASON_VMWRITE,               "VMWRITE" }, \
+        { EXIT_REASON_VMOFF,                 "VMOFF" }, \
+        { EXIT_REASON_VMON,                  "VMON" }, \
+        { EXIT_REASON_CR_ACCESS,             "CR_ACCESS" }, \
+        { EXIT_REASON_DR_ACCESS,             "DR_ACCESS" }, \
+        { EXIT_REASON_IO_INSTRUCTION,        "IO_INSTRUCTION" }, \
+        { EXIT_REASON_MSR_READ,              "MSR_READ" }, \
+        { EXIT_REASON_MSR_WRITE,             "MSR_WRITE" }, \
+        { EXIT_REASON_MWAIT_INSTRUCTION,     "MWAIT_INSTRUCTION" }, \
+        { EXIT_REASON_MONITOR_TRAP_FLAG,     "MONITOR_TRAP_FLAG" }, \
+        { EXIT_REASON_MONITOR_INSTRUCTION,   "MONITOR_INSTRUCTION" }, \
+        { EXIT_REASON_PAUSE_INSTRUCTION,     "PAUSE_INSTRUCTION" }, \
+        { EXIT_REASON_MCE_DURING_VMENTRY,    "MCE_DURING_VMENTRY" }, \
+        { EXIT_REASON_TPR_BELOW_THRESHOLD,   "TPR_BELOW_THRESHOLD" }, \
+        { EXIT_REASON_APIC_ACCESS,           "APIC_ACCESS" }, \
+        { EXIT_REASON_EPT_VIOLATION,         "EPT_VIOLATION" }, \
+        { EXIT_REASON_EPT_MISCONFIG,         "EPT_MISCONFIG" }, \
+        { EXIT_REASON_INVEPT,                "INVEPT" }, \
+        { EXIT_REASON_PREEMPTION_TIMER,      "PREEMPTION_TIMER" }, \
+        { EXIT_REASON_WBINVD,                "WBINVD" }, \
+        { EXIT_REASON_APIC_WRITE,            "APIC_WRITE" }, \
+        { EXIT_REASON_EOI_INDUCED,           "EOI_INDUCED" }, \
+        { EXIT_REASON_INVALID_STATE,         "INVALID_STATE" }, \
+        { EXIT_REASON_MSR_LOAD_FAIL,         "MSR_LOAD_FAIL" }, \
+        { EXIT_REASON_INVD,                  "INVD" }, \
+        { EXIT_REASON_INVVPID,               "INVVPID" }, \
+        { EXIT_REASON_INVPCID,               "INVPCID" }, \
+        { EXIT_REASON_XSAVES,                "XSAVES" }, \
+        { EXIT_REASON_XRSTORS,               "XRSTORS" }
+
+#define VMX_ABORT_SAVE_GUEST_MSR_FAIL        1
+#define VMX_ABORT_LOAD_HOST_MSR_FAIL         4
+
+#endif /* _UAPIVMX_H */
diff --git a/tools/arch/x86/lib/memcpy_64.S b/tools/arch/x86/lib/memcpy_64.S
new file mode 100644
index 000000000000..49e6ebac7e73
--- /dev/null
+++ b/tools/arch/x86/lib/memcpy_64.S
@@ -0,0 +1,297 @@
+/* Copyright 2002 Andi Kleen */
+
+#include <linux/linkage.h>
+#include <asm/errno.h>
+#include <asm/cpufeatures.h>
+#include <asm/alternative-asm.h>
+
+/*
+ * We build a jump to memcpy_orig by default which gets NOPped out on
+ * the majority of x86 CPUs which set REP_GOOD. In addition, CPUs which
+ * have the enhanced REP MOVSB/STOSB feature (ERMS), change those NOPs
+ * to a jmp to memcpy_erms which does the REP; MOVSB mem copy.
+ */
+
+.weak memcpy
+
+/*
+ * memcpy - Copy a memory block.
+ *
+ * Input:
+ *  rdi destination
+ *  rsi source
+ *  rdx count
+ *
+ * Output:
+ * rax original destination
+ */
+ENTRY(__memcpy)
+ENTRY(memcpy)
+        ALTERNATIVE_2 "jmp memcpy_orig", "", X86_FEATURE_REP_GOOD, \
+                      "jmp memcpy_erms", X86_FEATURE_ERMS
+
+        movq %rdi, %rax
+        movq %rdx, %rcx
+        shrq $3, %rcx
+        andl $7, %edx
+        rep movsq
+        movl %edx, %ecx
+        rep movsb
+        ret
+ENDPROC(memcpy)
+ENDPROC(__memcpy)
+
+/*
+ * memcpy_erms() - enhanced fast string memcpy. This is faster and
+ * simpler than memcpy. Use memcpy_erms when possible.
+ */
+ENTRY(memcpy_erms)
+        movq %rdi, %rax
+        movq %rdx, %rcx
+        rep movsb
+        ret
+ENDPROC(memcpy_erms)
+
+ENTRY(memcpy_orig)
+        movq %rdi, %rax
+
+        cmpq $0x20, %rdx
+        jb .Lhandle_tail
+
+        /*
+         * We check whether memory false dependence could occur,
+         * then jump to corresponding copy mode.
+         */
+        cmp  %dil, %sil
+        jl .Lcopy_backward
+        subq $0x20, %rdx
+.Lcopy_forward_loop:
+        subq $0x20,     %rdx
+
+        /*
+         * Move in blocks of 4x8 bytes:
+         */
+        movq 0*8(%rsi), %r8
+        movq 1*8(%rsi), %r9
+        movq 2*8(%rsi), %r10
+        movq 3*8(%rsi), %r11
+        leaq 4*8(%rsi), %rsi
+
+        movq %r8,       0*8(%rdi)
+        movq %r9,       1*8(%rdi)
+        movq %r10,      2*8(%rdi)
+        movq %r11,      3*8(%rdi)
+        leaq 4*8(%rdi), %rdi
+        jae  .Lcopy_forward_loop
+        addl $0x20,     %edx
+        jmp  .Lhandle_tail
+
+.Lcopy_backward:
+        /*
+         * Calculate copy position to tail.
+         */
+        addq %rdx,      %rsi
+        addq %rdx,      %rdi
+        subq $0x20,     %rdx
+        /*
+         * At most 3 ALU operations in one cycle,
+         * so append NOPS in the same 16 bytes trunk.
+         */
+        .p2align 4
+.Lcopy_backward_loop:
+        subq $0x20,     %rdx
+        movq -1*8(%rsi),        %r8
+        movq -2*8(%rsi),        %r9
+        movq -3*8(%rsi),        %r10
+        movq -4*8(%rsi),        %r11
+        leaq -4*8(%rsi),        %rsi
+        movq %r8,               -1*8(%rdi)
+        movq %r9,               -2*8(%rdi)
+        movq %r10,              -3*8(%rdi)
+        movq %r11,              -4*8(%rdi)
+        leaq -4*8(%rdi),        %rdi
+        jae  .Lcopy_backward_loop
+
+        /*
+         * Calculate copy position to head.
+         */
+        addl $0x20,     %edx
+        subq %rdx,      %rsi
+        subq %rdx,      %rdi
+.Lhandle_tail:
+        cmpl $16,       %edx
+        jb   .Lless_16bytes
+
+        /*
+         * Move data from 16 bytes to 31 bytes.
+         */
+        movq 0*8(%rsi), %r8
+        movq 1*8(%rsi), %r9
+        movq -2*8(%rsi, %rdx),  %r10
+        movq -1*8(%rsi, %rdx),  %r11
+        movq %r8,       0*8(%rdi)
+        movq %r9,       1*8(%rdi)
+        movq %r10,      -2*8(%rdi, %rdx)
+        movq %r11,      -1*8(%rdi, %rdx)
+        retq
+        .p2align 4
+.Lless_16bytes:
+        cmpl $8,        %edx
+        jb   .Lless_8bytes
+        /*
+         * Move data from 8 bytes to 15 bytes.
+         */
+        movq 0*8(%rsi), %r8
+        movq -1*8(%rsi, %rdx),  %r9
+        movq %r8,       0*8(%rdi)
+        movq %r9,       -1*8(%rdi, %rdx)
+        retq
+        .p2align 4
+.Lless_8bytes:
+        cmpl $4,        %edx
+        jb   .Lless_3bytes
+
+        /*
+         * Move data from 4 bytes to 7 bytes.
+         */
+        movl (%rsi), %ecx
+        movl -4(%rsi, %rdx), %r8d
+        movl %ecx, (%rdi)
+        movl %r8d, -4(%rdi, %rdx)
+        retq
+        .p2align 4
+.Lless_3bytes:
+        subl $1, %edx
+        jb .Lend
+        /*
+         * Move data from 1 bytes to 3 bytes.
+         */
+        movzbl (%rsi), %ecx
+        jz .Lstore_1byte
+        movzbq 1(%rsi), %r8
+        movzbq (%rsi, %rdx), %r9
+        movb %r8b, 1(%rdi)
+        movb %r9b, (%rdi, %rdx)
+.Lstore_1byte:
+        movb %cl, (%rdi)
+
+.Lend:
+        retq
+ENDPROC(memcpy_orig)
+
+#ifndef CONFIG_UML
+/*
+ * memcpy_mcsafe_unrolled - memory copy with machine check exception handling
+ * Note that we only catch machine checks when reading the source addresses.
+ * Writes to target are posted and don't generate machine checks.
+ */
+ENTRY(memcpy_mcsafe_unrolled)
+        cmpl $8, %edx
+        /* Less than 8 bytes? Go to byte copy loop */
+        jb .L_no_whole_words
+
+        /* Check for bad alignment of source */
+        testl $7, %esi
+        /* Already aligned */
+        jz .L_8byte_aligned
+
+        /* Copy one byte at a time until source is 8-byte aligned */
+        movl %esi, %ecx
+        andl $7, %ecx
+        subl $8, %ecx
+        negl %ecx
+        subl %ecx, %edx
+.L_copy_leading_bytes:
+        movb (%rsi), %al
+        movb %al, (%rdi)
+        incq %rsi
+        incq %rdi
+        decl %ecx
+        jnz .L_copy_leading_bytes
+
+.L_8byte_aligned:
+        /* Figure out how many whole cache lines (64-bytes) to copy */
+        movl %edx, %ecx
+        andl $63, %edx
+        shrl $6, %ecx
+        jz .L_no_whole_cache_lines
+
+        /* Loop copying whole cache lines */
+.L_cache_w0: movq (%rsi), %r8
+.L_cache_w1: movq 1*8(%rsi), %r9
+.L_cache_w2: movq 2*8(%rsi), %r10
+.L_cache_w3: movq 3*8(%rsi), %r11
+        movq %r8, (%rdi)
+        movq %r9, 1*8(%rdi)
+        movq %r10, 2*8(%rdi)
+        movq %r11, 3*8(%rdi)
+.L_cache_w4: movq 4*8(%rsi), %r8
+.L_cache_w5: movq 5*8(%rsi), %r9
+.L_cache_w6: movq 6*8(%rsi), %r10
+.L_cache_w7: movq 7*8(%rsi), %r11
+        movq %r8, 4*8(%rdi)
+        movq %r9, 5*8(%rdi)
+        movq %r10, 6*8(%rdi)
+        movq %r11, 7*8(%rdi)
+        leaq 64(%rsi), %rsi
+        leaq 64(%rdi), %rdi
+        decl %ecx
+        jnz .L_cache_w0
+
+        /* Are there any trailing 8-byte words? */
+.L_no_whole_cache_lines:
+        movl %edx, %ecx
+        andl $7, %edx
+        shrl $3, %ecx
+        jz .L_no_whole_words
+
+        /* Copy trailing words */
+.L_copy_trailing_words:
+        movq (%rsi), %r8
+        mov %r8, (%rdi)
+        leaq 8(%rsi), %rsi
+        leaq 8(%rdi), %rdi
+        decl %ecx
+        jnz .L_copy_trailing_words
+
+        /* Any trailing bytes? */
+.L_no_whole_words:
+        andl %edx, %edx
+        jz .L_done_memcpy_trap
+
+        /* Copy trailing bytes */
+        movl %edx, %ecx
+.L_copy_trailing_bytes:
+        movb (%rsi), %al
+        movb %al, (%rdi)
+        incq %rsi
+        incq %rdi
+        decl %ecx
+        jnz .L_copy_trailing_bytes
+
+        /* Copy successful. Return zero */
+.L_done_memcpy_trap:
+        xorq %rax, %rax
+        ret
+ENDPROC(memcpy_mcsafe_unrolled)
+
+        .section .fixup, "ax"
+        /* Return -EFAULT for any failure */
+.L_memcpy_mcsafe_fail:
+        mov     $-EFAULT, %rax
+        ret
+
+        .previous
+
+        _ASM_EXTABLE_FAULT(.L_copy_leading_bytes, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w0, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w1, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w3, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w3, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w4, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w5, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w6, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_cache_w7, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_copy_trailing_words, .L_memcpy_mcsafe_fail)
+        _ASM_EXTABLE_FAULT(.L_copy_trailing_bytes, .L_memcpy_mcsafe_fail)
+#endif
diff --git a/tools/arch/x86/lib/memset_64.S b/tools/arch/x86/lib/memset_64.S
new file mode 100644
index 000000000000..e1229ecd2a82
--- /dev/null
+++ b/tools/arch/x86/lib/memset_64.S
@@ -0,0 +1,138 @@
+/* Copyright 2002 Andi Kleen, SuSE Labs */
+
+#include <linux/linkage.h>
+#include <asm/cpufeatures.h>
+#include <asm/alternative-asm.h>
+
+.weak memset
+
+/*
+ * ISO C memset - set a memory block to a byte value. This function uses fast
+ * string to get better performance than the original function. The code is
+ * simpler and shorter than the original function as well.
+ *
+ * rdi   destination
+ * rsi   value (char)
+ * rdx   count (bytes)
+ *
+ * rax   original destination
+ */
+ENTRY(memset)
+ENTRY(__memset)
+        /*
+         * Some CPUs support enhanced REP MOVSB/STOSB feature. It is recommended
+         * to use it when possible. If not available, use fast string instructions.
+         *
+         * Otherwise, use original memset function.
+         */
+        ALTERNATIVE_2 "jmp memset_orig", "", X86_FEATURE_REP_GOOD, \
+                      "jmp memset_erms", X86_FEATURE_ERMS
+
+        movq %rdi,%r9
+        movq %rdx,%rcx
+        andl $7,%edx
+        shrq $3,%rcx
+        /* expand byte value  */
+        movzbl %sil,%esi
+        movabs $0x0101010101010101,%rax
+        imulq %rsi,%rax
+        rep stosq
+        movl %edx,%ecx
+        rep stosb
+        movq %r9,%rax
+        ret
+ENDPROC(memset)
+ENDPROC(__memset)
+
+/*
+ * ISO C memset - set a memory block to a byte value. This function uses
+ * enhanced rep stosb to override the fast string function.
+ * The code is simpler and shorter than the fast string function as well.
+ *
+ * rdi   destination
+ * rsi   value (char)
+ * rdx   count (bytes)
+ *
+ * rax   original destination
+ */
+ENTRY(memset_erms)
+        movq %rdi,%r9
+        movb %sil,%al
+        movq %rdx,%rcx
+        rep stosb
+        movq %r9,%rax
+        ret
+ENDPROC(memset_erms)
+
+ENTRY(memset_orig)
+        movq %rdi,%r10
+
+        /* expand byte value  */
+        movzbl %sil,%ecx
+        movabs $0x0101010101010101,%rax
+        imulq  %rcx,%rax
+
+        /* align dst */
+        movl  %edi,%r9d
+        andl  $7,%r9d
+        jnz  .Lbad_alignment
+.Lafter_bad_alignment:
+
+        movq  %rdx,%rcx
+        shrq  $6,%rcx
+        jz       .Lhandle_tail
+
+        .p2align 4
+.Lloop_64:
+        decq  %rcx
+        movq  %rax,(%rdi)
+        movq  %rax,8(%rdi)
+        movq  %rax,16(%rdi)
+        movq  %rax,24(%rdi)
+        movq  %rax,32(%rdi)
+        movq  %rax,40(%rdi)
+        movq  %rax,48(%rdi)
+        movq  %rax,56(%rdi)
+        leaq  64(%rdi),%rdi
+        jnz    .Lloop_64
+
+        /* Handle tail in loops. The loops should be faster than hard
+           to predict jump tables. */
+        .p2align 4
+.Lhandle_tail:
+        movl    %edx,%ecx
+        andl    $63&(~7),%ecx
+        jz              .Lhandle_7
+        shrl    $3,%ecx
+        .p2align 4
+.Lloop_8:
+        decl   %ecx
+        movq  %rax,(%rdi)
+        leaq  8(%rdi),%rdi
+        jnz    .Lloop_8
+
+.Lhandle_7:
+        andl    $7,%edx
+        jz      .Lende
+        .p2align 4
+.Lloop_1:
+        decl    %edx
+        movb    %al,(%rdi)
+        leaq    1(%rdi),%rdi
+        jnz     .Lloop_1
+
+.Lende:
+        movq    %r10,%rax
+        ret
+
+.Lbad_alignment:
+        cmpq $7,%rdx
+        jbe     .Lhandle_7
+        movq %rax,(%rdi)        /* unaligned store */
+        movq $8,%r8
+        subq %r9,%r8
+        addq %r8,%rdi
+        subq %r8,%rdx
+        jmp .Lafter_bad_alignment
+.Lfinal:
+ENDPROC(memset_orig)
diff --git a/tools/arch/xtensa/include/uapi/asm/mman.h b/tools/arch/xtensa/include/uapi/asm/mman.h
new file mode 100644
index 000000000000..4453195c450c
--- /dev/null
+++ b/tools/arch/xtensa/include/uapi/asm/mman.h
@@ -0,0 +1,47 @@
+#ifndef TOOLS_ARCH_XTENSA_UAPI_ASM_MMAN_FIX_H
+#define TOOLS_ARCH_XTENSA_UAPI_ASM_MMAN_FIX_H
+#define MADV_DODUMP     17
+#define MADV_DOFORK     11
+#define MADV_DONTDUMP   16
+#define MADV_DONTFORK   10
+#define MADV_DONTNEED   4
+#define MADV_FREE       8
+#define MADV_HUGEPAGE   14
+#define MADV_MERGEABLE   12
+#define MADV_NOHUGEPAGE 15
+#define MADV_NORMAL     0
+#define MADV_RANDOM     1
+#define MADV_REMOVE     9
+#define MADV_SEQUENTIAL 2
+#define MADV_UNMERGEABLE 13
+#define MADV_WILLNEED   3
+#define MAP_ANONYMOUS   0x0800
+#define MAP_DENYWRITE   0x2000
+#define MAP_EXECUTABLE  0x4000
+#define MAP_FILE        0
+#define MAP_FIXED       0x010
+#define MAP_GROWSDOWN   0x1000
+#define MAP_HUGETLB     0x80000
+#define MAP_LOCKED      0x8000
+#define MAP_NONBLOCK    0x20000
+#define MAP_NORESERVE   0x0400
+#define MAP_POPULATE    0x10000
+#define MAP_PRIVATE     0x002
+#define MAP_SHARED      0x001
+#define MAP_STACK       0x40000
+#define PROT_EXEC       0x4
+#define PROT_GROWSDOWN  0x01000000
+#define PROT_GROWSUP    0x02000000
+#define PROT_NONE       0x0
+#define PROT_READ       0x1
+#define PROT_SEM        0x10
+#define PROT_WRITE      0x2
+/* MADV_HWPOISON is undefined on xtensa, fix it for perf */
+#define MADV_HWPOISON   100
+/* MADV_SOFT_OFFLINE is undefined on xtensa, fix it for perf */
+#define MADV_SOFT_OFFLINE 101
+/* MAP_32BIT is undefined on xtensa, fix it for perf */
+#define MAP_32BIT       0
+/* MAP_UNINITIALIZED is undefined on xtensa, fix it for perf */
+#define MAP_UNINITIALIZED       0
+#endif
diff --git a/tools/build/Build b/tools/build/Build
index 63a6c34c0c88..76d1a4960973 100644
--- a/tools/build/Build
+++ b/tools/build/Build
@@ -1 +1,3 @@
+hostprogs := fixdep
+
 fixdep-y := fixdep.o
diff --git a/tools/build/Build.include b/tools/build/Build.include
index 4d000bc959b4..1dcb95e76f70 100644
--- a/tools/build/Build.include
+++ b/tools/build/Build.include
@@ -90,3 +90,9 @@ if_changed = $(if $(strip $(any-prereq) $(arg-check)),             \
 # - per object C flags
 # - BUILD_STR macro to allow '-D"$(variable)"' constructs
 c_flags = -Wp,-MD,$(depfile),-MT,$@ $(CFLAGS) -D"BUILD_STR(s)=\#s" $(CFLAGS_$(basetarget).o) $(CFLAGS_$(obj))
+cxx_flags = -Wp,-MD,$(depfile),-MT,$@ $(CXXFLAGS) -D"BUILD_STR(s)=\#s" $(CXXFLAGS_$(basetarget).o) $(CXXFLAGS_$(obj))
+
+###
+## HOSTCC C flags
+
+host_c_flags = -Wp,-MD,$(depfile),-MT,$@ $(CHOSTFLAGS) -D"BUILD_STR(s)=\#s" $(CHOSTFLAGS_$(basetarget).o) $(CHOSTFLAGS_$(obj))
diff --git a/tools/build/Makefile b/tools/build/Makefile
index 0d5a0e3a8fa9..8332959fbca4 100644
--- a/tools/build/Makefile
+++ b/tools/build/Makefile
@@ -14,6 +14,12 @@ endef
 $(call allow-override,CC,$(CROSS_COMPILE)gcc)
 $(call allow-override,LD,$(CROSS_COMPILE)ld)
 
+HOSTCC ?= gcc
+HOSTLD ?= ld
+HOSTAR ?= ar
+
+export HOSTCC HOSTLD HOSTAR
+
 ifeq ($(V),1)
   Q =
 else
@@ -36,7 +42,7 @@ $(OUTPUT)fixdep-in.o: FORCE
         $(Q)$(MAKE) $(build)=fixdep
 
 $(OUTPUT)fixdep: $(OUTPUT)fixdep-in.o
-        $(QUIET_LINK)$(CC) $(LDFLAGS) -o $@ $<
+        $(QUIET_LINK)$(HOSTCC) $(LDFLAGS) -o $@ $<
 
 FORCE:
 
diff --git a/tools/build/Makefile.build b/tools/build/Makefile.build
index 27f3583193e6..99c0ccd2f176 100644
--- a/tools/build/Makefile.build
+++ b/tools/build/Makefile.build
@@ -58,6 +58,12 @@ quiet_cmd_mkdir = MKDIR    $(dir $@)
 quiet_cmd_cc_o_c = CC       $@
       cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
 
+quiet_cmd_host_cc_o_c = HOSTCC   $@
+      cmd_host_cc_o_c = $(HOSTCC) $(host_c_flags) -c -o $@ $<
+
+quiet_cmd_cxx_o_c = CXX      $@
+      cmd_cxx_o_c = $(CXX) $(cxx_flags) -c -o $@ $<
+
 quiet_cmd_cpp_i_c = CPP      $@
       cmd_cpp_i_c = $(CC) $(c_flags) -E -o $@ $<
 
@@ -70,16 +76,28 @@ quiet_cmd_gen = GEN      $@
 # If there's nothing to link, create empty $@ object.
 quiet_cmd_ld_multi = LD       $@
       cmd_ld_multi = $(if $(strip $(obj-y)),\
-                       $(LD) -r -o $@  $(filter $(obj-y),$^),rm -f $@; $(AR) rcs $@)
+                     $(LD) -r -o $@  $(filter $(obj-y),$^),rm -f $@; $(AR) rcs $@)
+
+quiet_cmd_host_ld_multi = HOSTLD   $@
+      cmd_host_ld_multi = $(if $(strip $(obj-y)),\
+                          $(HOSTLD) -r -o $@  $(filter $(obj-y),$^),rm -f $@; $(HOSTAR) rcs $@)
+
+ifneq ($(filter $(obj),$(hostprogs)),)
+  host = host_
+endif
 
 # Build rules
 $(OUTPUT)%.o: %.c FORCE
         $(call rule_mkdir)
-        $(call if_changed_dep,cc_o_c)
+        $(call if_changed_dep,$(host)cc_o_c)
+
+$(OUTPUT)%.o: %.cpp FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cxx_o_c)
 
 $(OUTPUT)%.o: %.S FORCE
         $(call rule_mkdir)
-        $(call if_changed_dep,cc_o_c)
+        $(call if_changed_dep,$(host)cc_o_c)
 
 $(OUTPUT)%.i: %.c FORCE
         $(call rule_mkdir)
@@ -119,7 +137,7 @@ $(sort $(subdir-obj-y)): $(subdir-y) ;
 
 $(in-target): $(obj-y) FORCE
         $(call rule_mkdir)
-        $(call if_changed,ld_multi)
+        $(call if_changed,$(host)ld_multi)
 
 __build: $(in-target)
         @:
diff --git a/tools/build/Makefile.feature b/tools/build/Makefile.feature
index 57c8f98874e8..ae52e029dd22 100644
--- a/tools/build/Makefile.feature
+++ b/tools/build/Makefile.feature
@@ -7,7 +7,7 @@ endif
 
 feature_check = $(eval $(feature_check_code))
 define feature_check_code
-  feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C $(feature_dir) $(OUTPUT_FEATURES)test-$1.bin >/dev/null 2>/dev/null && echo 1 || echo 0)
+  feature-$(1) := $(shell $(MAKE) OUTPUT=$(OUTPUT_FEATURES) CFLAGS="$(EXTRA_CFLAGS) $(FEATURE_CHECK_CFLAGS-$(1))" CXXFLAGS="$(EXTRA_CXXFLAGS) $(FEATURE_CHECK_CXXFLAGS-$(1))" LDFLAGS="$(LDFLAGS) $(FEATURE_CHECK_LDFLAGS-$(1))" -C $(feature_dir) $(OUTPUT_FEATURES)test-$1.bin >/dev/null 2>/dev/null && echo 1 || echo 0)
 endef
 
 feature_set = $(eval $(feature_set_code))
@@ -40,6 +40,8 @@ FEATURE_TESTS_BASIC :=			\
         libbfd                          \
         libelf                          \
         libelf-getphdrnum               \
+        libelf-gelf_getnote             \
+        libelf-getshdrstrndx            \
         libelf-mmap                     \
         libnuma                         \
         numa_num_possible_cpus          \
@@ -60,7 +62,8 @@ FEATURE_TESTS_BASIC :=			\
         zlib                            \
         lzma                            \
         get_cpuid                       \
-        bpf
+        bpf                             \
+        sdt
 
 # FEATURE_TESTS_BASIC + FEATURE_TESTS_EXTRA is the complete list
 # of all feature tests
diff --git a/tools/build/Makefile.include b/tools/build/Makefile.include
index be630bed66d2..ad22e4e7bc59 100644
--- a/tools/build/Makefile.include
+++ b/tools/build/Makefile.include
@@ -1,10 +1,6 @@
 build := -f $(srctree)/tools/build/Makefile.build dir=. obj
 
-ifdef CROSS_COMPILE
-fixdep:
-else
 fixdep:
         $(Q)$(MAKE) -C $(srctree)/tools/build CFLAGS= LDFLAGS= $(OUTPUT)fixdep
-endif
 
 .PHONY: fixdep
diff --git a/tools/build/feature/Makefile b/tools/build/feature/Makefile
index 3d88f09e188b..ac9c477a2a48 100644
--- a/tools/build/feature/Makefile
+++ b/tools/build/feature/Makefile
@@ -17,6 +17,8 @@ FILES=					\
         test-cplus-demangle.bin         \
         test-libelf.bin                 \
         test-libelf-getphdrnum.bin      \
+        test-libelf-gelf_getnote.bin    \
+        test-libelf-getshdrstrndx.bin   \
         test-libelf-mmap.bin            \
         test-libnuma.bin                \
         test-numa_num_possible_cpus.bin \
@@ -43,11 +45,14 @@ FILES=					\
         test-zlib.bin                   \
         test-lzma.bin                   \
         test-bpf.bin                    \
-        test-get_cpuid.bin
+        test-get_cpuid.bin              \
+        test-sdt.bin                    \
+        test-cxx.bin
 
 FILES := $(addprefix $(OUTPUT),$(FILES))
 
 CC := $(CROSS_COMPILE)gcc -MD
+CXX := $(CROSS_COMPILE)g++ -MD
 PKG_CONFIG := $(CROSS_COMPILE)pkg-config
 
 all: $(FILES)
@@ -55,6 +60,9 @@ all: $(FILES)
 __BUILD = $(CC) $(CFLAGS) -Wall -Werror -o $@ $(patsubst %.bin,%.c,$(@F)) $(LDFLAGS)
   BUILD = $(__BUILD) > $(@:.bin=.make.output) 2>&1
 
+__BUILDXX = $(CXX) $(CXXFLAGS) -Wall -Werror -o $@ $(patsubst %.bin,%.cpp,$(@F)) $(LDFLAGS)
+  BUILDXX = $(__BUILDXX) > $(@:.bin=.make.output) 2>&1
+
 ###############################
 
 $(OUTPUT)test-all.bin:
@@ -98,6 +106,12 @@ $(OUTPUT)test-libelf-mmap.bin:
 $(OUTPUT)test-libelf-getphdrnum.bin:
         $(BUILD) -lelf
 
+$(OUTPUT)test-libelf-gelf_getnote.bin:
+        $(BUILD) -lelf
+
+$(OUTPUT)test-libelf-getshdrstrndx.bin:
+        $(BUILD) -lelf
+
 $(OUTPUT)test-libnuma.bin:
         $(BUILD) -lnuma
 
@@ -205,6 +219,12 @@ $(OUTPUT)test-get_cpuid.bin:
 $(OUTPUT)test-bpf.bin:
         $(BUILD)
 
+$(OUTPUT)test-sdt.bin:
+        $(BUILD)
+
+$(OUTPUT)test-cxx.bin:
+        $(BUILDXX) -std=gnu++11
+
 -include $(OUTPUT)*.d
 
 ###############################
diff --git a/tools/build/feature/test-all.c b/tools/build/feature/test-all.c
index a282e8cb84f3..699e43627397 100644
--- a/tools/build/feature/test-all.c
+++ b/tools/build/feature/test-all.c
@@ -49,6 +49,14 @@
 # include "test-libelf-getphdrnum.c"
 #undef main
 
+#define main main_test_libelf_gelf_getnote
+# include "test-libelf-gelf_getnote.c"
+#undef main
+
+#define main main_test_libelf_getshdrstrndx
+# include "test-libelf-getshdrstrndx.c"
+#undef main
+
 #define main main_test_libunwind
 # include "test-libunwind.c"
 #undef main
@@ -137,6 +145,10 @@
 # include "test-libcrypto.c"
 #undef main
 
+#define main main_test_sdt
+# include "test-sdt.c"
+#undef main
+
 int main(int argc, char *argv[])
 {
         main_test_libpython();
@@ -149,6 +161,8 @@ int main(int argc, char *argv[])
         main_test_dwarf();
         main_test_dwarf_getlocations();
         main_test_libelf_getphdrnum();
+        main_test_libelf_gelf_getnote();
+        main_test_libelf_getshdrstrndx();
         main_test_libunwind();
         main_test_libaudit();
         main_test_libslang();
@@ -168,6 +182,7 @@ int main(int argc, char *argv[])
         main_test_get_cpuid();
         main_test_bpf();
         main_test_libcrypto();
+        main_test_sdt();
 
         return 0;
 }
diff --git a/tools/build/feature/test-cxx.cpp b/tools/build/feature/test-cxx.cpp
new file mode 100644
index 000000000000..b1dee9a31d6c
--- /dev/null
+++ b/tools/build/feature/test-cxx.cpp
@@ -0,0 +1,15 @@
+#include <iostream>
+#include <memory>
+
+static void print_str(std::string s)
+{
+        std::cout << s << std::endl;
+}
+
+int main()
+{
+        std::string s("Hello World!");
+        print_str(std::move(s));
+        std::cout << "|" << s << "|" << std::endl;
+        return 0;
+}
diff --git a/tools/build/feature/test-libelf-gelf_getnote.c b/tools/build/feature/test-libelf-gelf_getnote.c
new file mode 100644
index 000000000000..d78cf4d5271f
--- /dev/null
+++ b/tools/build/feature/test-libelf-gelf_getnote.c
@@ -0,0 +1,7 @@
+#include <stdlib.h>
+#include <gelf.h>
+
+int main(void)
+{
+        return gelf_getnote(NULL, 0, NULL, NULL, NULL);
+}
diff --git a/tools/build/feature/test-libelf-getshdrstrndx.c b/tools/build/feature/test-libelf-getshdrstrndx.c
new file mode 100644
index 000000000000..f0c3b47cce28
--- /dev/null
+++ b/tools/build/feature/test-libelf-getshdrstrndx.c
@@ -0,0 +1,8 @@
+#include <libelf.h>
+
+int main(void)
+{
+        size_t dst;
+
+        return elf_getshdrstrndx(0, &dst);
+}
diff --git a/tools/build/feature/test-sdt.c b/tools/build/feature/test-sdt.c
new file mode 100644
index 000000000000..e4531a6e80ea
--- /dev/null
+++ b/tools/build/feature/test-sdt.c
@@ -0,0 +1,7 @@
+#include <sys/sdt.h>
+
+int main(void)
+{
+        DTRACE_PROBE(provider, name);
+        return 0;
+}
diff --git a/tools/gpio/Build b/tools/gpio/Build
new file mode 100644
index 000000000000..620c1937d957
--- /dev/null
+++ b/tools/gpio/Build
@@ -0,0 +1,3 @@
+lsgpio-y += lsgpio.o gpio-utils.o
+gpio-hammer-y += gpio-hammer.o gpio-utils.o
+gpio-event-mon-y += gpio-event-mon.o gpio-utils.o
diff --git a/tools/gpio/Makefile b/tools/gpio/Makefile
index c155d6bc47a7..250a891e6ef0 100644
--- a/tools/gpio/Makefile
+++ b/tools/gpio/Makefile
@@ -1,12 +1,75 @@
+include ../scripts/Makefile.include
+
+bindir ?= /usr/bin
+
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+endif
+
+# Do not use make's built-in rules
+# (this improves performance and avoids hard-to-debug behaviour);
+MAKEFLAGS += -r
+
 CC = $(CROSS_COMPILE)gcc
-CFLAGS += -O2 -Wall -g -D_GNU_SOURCE
+LD = $(CROSS_COMPILE)ld
+CFLAGS += -O2 -Wall -g -D_GNU_SOURCE -I$(OUTPUT)include
+
+ALL_TARGETS := lsgpio gpio-hammer gpio-event-mon
+ALL_PROGRAMS := $(patsubst %,$(OUTPUT)%,$(ALL_TARGETS))
+
+all: $(ALL_PROGRAMS)
 
-all: lsgpio
+export srctree OUTPUT CC LD CFLAGS
+include $(srctree)/tools/build/Makefile.include
 
-lsgpio: lsgpio.o gpio-utils.o
+#
+# We need the following to be outside of kernel tree
+#
+$(OUTPUT)include/linux/gpio.h: ../../include/uapi/linux/gpio.h
+        mkdir -p $(OUTPUT)include/linux 2>&1 || true
+        ln -sf $(CURDIR)/../../include/uapi/linux/gpio.h $@
 
-%.o: %.c gpio-utils.h
+prepare: $(OUTPUT)include/linux/gpio.h
+
+#
+# lsgpio
+#
+LSGPIO_IN := $(OUTPUT)lsgpio-in.o
+$(LSGPIO_IN): prepare FORCE
+        $(Q)$(MAKE) $(build)=lsgpio
+$(OUTPUT)lsgpio: $(LSGPIO_IN)
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $< -o $@
+
+#
+# gpio-hammer
+#
+GPIO_HAMMER_IN := $(OUTPUT)gpio-hammer-in.o
+$(GPIO_HAMMER_IN): prepare FORCE
+        $(Q)$(MAKE) $(build)=gpio-hammer
+$(OUTPUT)gpio-hammer: $(GPIO_HAMMER_IN)
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $< -o $@
+
+#
+# gpio-event-mon
+#
+GPIO_EVENT_MON_IN := $(OUTPUT)gpio-event-mon-in.o
+$(GPIO_EVENT_MON_IN): prepare FORCE
+        $(Q)$(MAKE) $(build)=gpio-event-mon
+$(OUTPUT)gpio-event-mon: $(GPIO_EVENT_MON_IN)
+        $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $< -o $@
 
-.PHONY: clean
 clean:
-        rm -f *.o lsgpio
+        rm -f $(ALL_PROGRAMS)
+        rm -f $(OUTPUT)include/linux/gpio.h
+        find $(if $(OUTPUT),$(OUTPUT),.) -name '*.o' -delete -o -name '\.*.d' -delete
+
+install: $(ALL_PROGRAMS)
+        install -d -m 755 $(DESTDIR)$(bindir);          \
+        for program in $(ALL_PROGRAMS); do              \
+                install $$program $(DESTDIR)$(bindir);  \
+        done
+
+FORCE:
+
+.PHONY: all install clean FORCE prepare
diff --git a/tools/gpio/gpio-event-mon.c b/tools/gpio/gpio-event-mon.c
new file mode 100644
index 000000000000..1c14c2595158
--- /dev/null
+++ b/tools/gpio/gpio-event-mon.c
@@ -0,0 +1,192 @@
+/*
+ * gpio-event-mon - monitor GPIO line events from userspace
+ *
+ * Copyright (C) 2016 Linus Walleij
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * Usage:
+ *      gpio-event-mon -n <device-name> -o <offset>
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <errno.h>
+#include <string.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <sys/ioctl.h>
+#include <linux/gpio.h>
+
+int monitor_device(const char *device_name,
+                   unsigned int line,
+                   u_int32_t handleflags,
+                   u_int32_t eventflags,
+                   unsigned int loops)
+{
+        struct gpioevent_request req;
+        struct gpiohandle_data data;
+        char *chrdev_name;
+        int fd;
+        int ret;
+        int i = 0;
+
+        ret = asprintf(&chrdev_name, "/dev/%s", device_name);
+        if (ret < 0)
+                return -ENOMEM;
+
+        fd = open(chrdev_name, 0);
+        if (fd == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to open %s\n", chrdev_name);
+                goto exit_close_error;
+        }
+
+        req.lineoffset = line;
+        req.handleflags = handleflags;
+        req.eventflags = eventflags;
+        strcpy(req.consumer_label, "gpio-event-mon");
+
+        ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &req);
+        if (ret == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to issue GET EVENT "
+                        "IOCTL (%d)\n",
+                        ret);
+                goto exit_close_error;
+        }
+
+        /* Read initial states */
+        ret = ioctl(req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);
+        if (ret == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to issue GPIOHANDLE GET LINE "
+                        "VALUES IOCTL (%d)\n",
+                        ret);
+                goto exit_close_error;
+        }
+
+        fprintf(stdout, "Monitoring line %d on %s\n", line, device_name);
+        fprintf(stdout, "Initial line value: %d\n", data.values[0]);
+
+        while (1) {
+                struct gpioevent_data event;
+
+                ret = read(req.fd, &event, sizeof(event));
+                if (ret == -1) {
+                        if (errno == -EAGAIN) {
+                                fprintf(stderr, "nothing available\n");
+                                continue;
+                        } else {
+                                ret = -errno;
+                                fprintf(stderr, "Failed to read event (%d)\n",
+                                        ret);
+                                break;
+                        }
+                }
+
+                if (ret != sizeof(event)) {
+                        fprintf(stderr, "Reading event failed\n");
+                        ret = -EIO;
+                        break;
+                }
+                fprintf(stdout, "GPIO EVENT %" PRIu64 ": ", event.timestamp);
+                switch (event.id) {
+                case GPIOEVENT_EVENT_RISING_EDGE:
+                        fprintf(stdout, "rising edge");
+                        break;
+                case GPIOEVENT_EVENT_FALLING_EDGE:
+                        fprintf(stdout, "falling edge");
+                        break;
+                default:
+                        fprintf(stdout, "unknown event");
+                }
+                fprintf(stdout, "\n");
+
+                i++;
+                if (i == loops)
+                        break;
+        }
+
+exit_close_error:
+        if (close(fd) == -1)
+                perror("Failed to close GPIO character device file");
+        free(chrdev_name);
+        return ret;
+}
+
+void print_usage(void)
+{
+        fprintf(stderr, "Usage: gpio-event-mon [options]...\n"
+                "Listen to events on GPIO lines, 0->1 1->0\n"
+                "  -n <name>  Listen on GPIOs on a named device (must be stated)\n"
+                "  -o <n>     Offset to monitor\n"
+                "  -d         Set line as open drain\n"
+                "  -s         Set line as open source\n"
+                "  -r         Listen for rising edges\n"
+                "  -f         Listen for falling edges\n"
+                " [-c <n>]    Do <n> loops (optional, infinite loop if not stated)\n"
+                "  -?         This helptext\n"
+                "\n"
+                "Example:\n"
+                "gpio-event-mon -n gpiochip0 -o 4 -r -f\n"
+        );
+}
+
+int main(int argc, char **argv)
+{
+        const char *device_name = NULL;
+        unsigned int line = -1;
+        unsigned int loops = 0;
+        u_int32_t handleflags = GPIOHANDLE_REQUEST_INPUT;
+        u_int32_t eventflags = 0;
+        int c;
+
+        while ((c = getopt(argc, argv, "c:n:o:dsrf?")) != -1) {
+                switch (c) {
+                case 'c':
+                        loops = strtoul(optarg, NULL, 10);
+                        break;
+                case 'n':
+                        device_name = optarg;
+                        break;
+                case 'o':
+                        line = strtoul(optarg, NULL, 10);
+                        break;
+                case 'd':
+                        handleflags |= GPIOHANDLE_REQUEST_OPEN_DRAIN;
+                        break;
+                case 's':
+                        handleflags |= GPIOHANDLE_REQUEST_OPEN_SOURCE;
+                        break;
+                case 'r':
+                        eventflags |= GPIOEVENT_REQUEST_RISING_EDGE;
+                        break;
+                case 'f':
+                        eventflags |= GPIOEVENT_REQUEST_FALLING_EDGE;
+                        break;
+                case '?':
+                        print_usage();
+                        return -1;
+                }
+        }
+
+        if (!device_name || line == -1) {
+                print_usage();
+                return -1;
+        }
+        if (!eventflags) {
+                printf("No flags specified, listening on both rising and "
+                       "falling edges\n");
+                eventflags = GPIOEVENT_REQUEST_BOTH_EDGES;
+        }
+        return monitor_device(device_name, line, handleflags,
+                              eventflags, loops);
+}
diff --git a/tools/gpio/gpio-hammer.c b/tools/gpio/gpio-hammer.c
new file mode 100644
index 000000000000..37b3f141053d
--- /dev/null
+++ b/tools/gpio/gpio-hammer.c
@@ -0,0 +1,189 @@
+/*
+ * gpio-hammer - example swiss army knife to shake GPIO lines on a system
+ *
+ * Copyright (C) 2016 Linus Walleij
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * Usage:
+ *      gpio-hammer -n <device-name> -o <offset1> -o <offset2>
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <dirent.h>
+#include <errno.h>
+#include <string.h>
+#include <poll.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <sys/ioctl.h>
+#include <linux/gpio.h>
+
+int hammer_device(const char *device_name, unsigned int *lines, int nlines,
+                  unsigned int loops)
+{
+        struct gpiohandle_request req;
+        struct gpiohandle_data data;
+        char *chrdev_name;
+        char swirr[] = "-\\|/";
+        int fd;
+        int ret;
+        int i, j;
+        unsigned int iteration = 0;
+
+        ret = asprintf(&chrdev_name, "/dev/%s", device_name);
+        if (ret < 0)
+                return -ENOMEM;
+
+        fd = open(chrdev_name, 0);
+        if (fd == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to open %s\n", chrdev_name);
+                goto exit_close_error;
+        }
+
+        /* Request lines as output */
+        for (i = 0; i < nlines; i++)
+                req.lineoffsets[i] = lines[i];
+        req.flags = GPIOHANDLE_REQUEST_OUTPUT; /* Request as output */
+        strcpy(req.consumer_label, "gpio-hammer");
+        req.lines = nlines;
+        ret = ioctl(fd, GPIO_GET_LINEHANDLE_IOCTL, &req);
+        if (ret == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to issue GET LINEHANDLE "
+                        "IOCTL (%d)\n",
+                        ret);
+                goto exit_close_error;
+        }
+
+        /* Read initial states */
+        ret = ioctl(req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);
+        if (ret == -1) {
+                ret = -errno;
+                fprintf(stderr, "Failed to issue GPIOHANDLE GET LINE "
+                        "VALUES IOCTL (%d)\n",
+                        ret);
+                goto exit_close_error;
+        }
+        fprintf(stdout, "Hammer lines [");
+        for (i = 0; i < nlines; i++) {
+                fprintf(stdout, "%d", lines[i]);
+                if (i != (nlines - 1))
+                        fprintf(stdout, ", ");
+        }
+        fprintf(stdout, "] on %s, initial states: [", device_name);
+        for (i = 0; i < nlines; i++) {
+                fprintf(stdout, "%d", data.values[i]);
+                if (i != (nlines - 1))
+                        fprintf(stdout, ", ");
+        }
+        fprintf(stdout, "]\n");
+
+        /* Hammertime! */
+        j = 0;
+        while (1) {
+                /* Invert all lines so we blink */
+                for (i = 0; i < nlines; i++)
+                        data.values[i] = !data.values[i];
+
+                ret = ioctl(req.fd, GPIOHANDLE_SET_LINE_VALUES_IOCTL, &data);
+                if (ret == -1) {
+                        ret = -errno;
+                        fprintf(stderr, "Failed to issue GPIOHANDLE SET LINE "
+                                "VALUES IOCTL (%d)\n",
+                                ret);
+                        goto exit_close_error;
+                }
+                /* Re-read values to get status */
+                ret = ioctl(req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);
+                if (ret == -1) {
+                        ret = -errno;
+                        fprintf(stderr, "Failed to issue GPIOHANDLE GET LINE "
+                                "VALUES IOCTL (%d)\n",
+                                ret);
+                        goto exit_close_error;
+                }
+
+                fprintf(stdout, "[%c] ", swirr[j]);
+                j++;
+                if (j == sizeof(swirr)-1)
+                        j = 0;
+
+                fprintf(stdout, "[");
+                for (i = 0; i < nlines; i++) {
+                        fprintf(stdout, "%d: %d", lines[i], data.values[i]);
+                        if (i != (nlines - 1))
+                                fprintf(stdout, ", ");
+                }
+                fprintf(stdout, "]\r");
+                fflush(stdout);
+                sleep(1);
+                iteration++;
+                if (loops && iteration == loops)
+                        break;
+        }
+        fprintf(stdout, "\n");
+        ret = 0;
+
+exit_close_error:
+        if (close(fd) == -1)
+                perror("Failed to close GPIO character device file");
+        free(chrdev_name);
+        return ret;
+}
+
+void print_usage(void)
+{
+        fprintf(stderr, "Usage: gpio-hammer [options]...\n"
+                "Hammer GPIO lines, 0->1->0->1...\n"
+                "  -n <name>  Hammer GPIOs on a named device (must be stated)\n"
+                "  -o <n>     Offset[s] to hammer, at least one, several can be stated\n"
+                " [-c <n>]    Do <n> loops (optional, infinite loop if not stated)\n"
+                "  -?         This helptext\n"
+                "\n"
+                "Example:\n"
+                "gpio-hammer -n gpiochip0 -o 4\n"
+        );
+}
+
+int main(int argc, char **argv)
+{
+        const char *device_name = NULL;
+        unsigned int lines[GPIOHANDLES_MAX];
+        unsigned int loops = 0;
+        int nlines;
+        int c;
+        int i;
+
+        i = 0;
+        while ((c = getopt(argc, argv, "c:n:o:?")) != -1) {
+                switch (c) {
+                case 'c':
+                        loops = strtoul(optarg, NULL, 10);
+                        break;
+                case 'n':
+                        device_name = optarg;
+                        break;
+                case 'o':
+                        lines[i] = strtoul(optarg, NULL, 10);
+                        i++;
+                        break;
+                case '?':
+                        print_usage();
+                        return -1;
+                }
+        }
+        nlines = i;
+
+        if (!device_name || !nlines) {
+                print_usage();
+                return -1;
+        }
+        return hammer_device(device_name, lines, nlines, loops);
+}
diff --git a/tools/hv/bondvf.sh b/tools/hv/bondvf.sh
new file mode 100755
index 000000000000..8e960234013d
--- /dev/null
+++ b/tools/hv/bondvf.sh
@@ -0,0 +1,193 @@
+#!/bin/bash
+
+# This example script creates bonding network devices based on synthetic NIC
+# (the virtual network adapter usually provided by Hyper-V) and the matching
+# VF NIC (SRIOV virtual function). So the synthetic NIC and VF NIC can
+# function as one network device, and fail over to the synthetic NIC if VF is
+# down.
+#
+# Usage:
+# - After configured vSwitch and vNIC with SRIOV, start Linux virtual
+#   machine (VM)
+# - Run this scripts on the VM. It will create configuration files in
+#   distro specific directory.
+# - Reboot the VM, so that the bonding config are enabled.
+#
+# The config files are DHCP by default. You may edit them if you need to change
+# to Static IP or change other settings.
+#
+
+sysdir=/sys/class/net
+netvsc_cls={f8615163-df3e-46c5-913f-f2d2f965ed0e}
+bondcnt=0
+
+# Detect Distro
+if [ -f /etc/redhat-release ];
+then
+        cfgdir=/etc/sysconfig/network-scripts
+        distro=redhat
+elif grep -q 'Ubuntu' /etc/issue
+then
+        cfgdir=/etc/network
+        distro=ubuntu
+elif grep -q 'SUSE' /etc/issue
+then
+        cfgdir=/etc/sysconfig/network
+        distro=suse
+else
+        echo "Unsupported Distro"
+        exit 1
+fi
+
+echo Detected Distro: $distro, or compatible
+
+# Get a list of ethernet names
+list_eth=(`cd $sysdir && ls -d */ | cut -d/ -f1 | grep -v bond`)
+eth_cnt=${#list_eth[@]}
+
+echo List of net devices:
+
+# Get the MAC addresses
+for (( i=0; i < $eth_cnt; i++ ))
+do
+        list_mac[$i]=`cat $sysdir/${list_eth[$i]}/address`
+        echo ${list_eth[$i]}, ${list_mac[$i]}
+done
+
+# Find NIC with matching MAC
+for (( i=0; i < $eth_cnt-1; i++ ))
+do
+        for (( j=i+1; j < $eth_cnt; j++ ))
+        do
+                if [ "${list_mac[$i]}" = "${list_mac[$j]}" ]
+                then
+                        list_match[$i]=${list_eth[$j]}
+                        break
+                fi
+        done
+done
+
+function create_eth_cfg_redhat {
+        local fn=$cfgdir/ifcfg-$1
+
+        rm -f $fn
+        echo DEVICE=$1 >>$fn
+        echo TYPE=Ethernet >>$fn
+        echo BOOTPROTO=none >>$fn
+        echo ONBOOT=yes >>$fn
+        echo NM_CONTROLLED=no >>$fn
+        echo PEERDNS=yes >>$fn
+        echo IPV6INIT=yes >>$fn
+        echo MASTER=$2 >>$fn
+        echo SLAVE=yes >>$fn
+}
+
+function create_eth_cfg_pri_redhat {
+        create_eth_cfg_redhat $1 $2
+}
+
+function create_bond_cfg_redhat {
+        local fn=$cfgdir/ifcfg-$1
+
+        rm -f $fn
+        echo DEVICE=$1 >>$fn
+        echo TYPE=Bond >>$fn
+        echo BOOTPROTO=dhcp >>$fn
+        echo ONBOOT=yes >>$fn
+        echo NM_CONTROLLED=no >>$fn
+        echo PEERDNS=yes >>$fn
+        echo IPV6INIT=yes >>$fn
+        echo BONDING_MASTER=yes >>$fn
+        echo BONDING_OPTS=\"mode=active-backup miimon=100 primary=$2\" >>$fn
+}
+
+function create_eth_cfg_ubuntu {
+        local fn=$cfgdir/interfaces
+
+        echo $'\n'auto $1 >>$fn
+        echo iface $1 inet manual >>$fn
+        echo bond-master $2 >>$fn
+}
+
+function create_eth_cfg_pri_ubuntu {
+        local fn=$cfgdir/interfaces
+
+        create_eth_cfg_ubuntu $1 $2
+        echo bond-primary $1 >>$fn
+}
+
+function create_bond_cfg_ubuntu {
+        local fn=$cfgdir/interfaces
+
+        echo $'\n'auto $1 >>$fn
+        echo iface $1 inet dhcp >>$fn
+        echo bond-mode active-backup >>$fn
+        echo bond-miimon 100 >>$fn
+        echo bond-slaves none >>$fn
+}
+
+function create_eth_cfg_suse {
+        local fn=$cfgdir/ifcfg-$1
+
+        rm -f $fn
+        echo BOOTPROTO=none >>$fn
+        echo STARTMODE=auto >>$fn
+}
+
+function create_eth_cfg_pri_suse {
+        create_eth_cfg_suse $1
+}
+
+function create_bond_cfg_suse {
+        local fn=$cfgdir/ifcfg-$1
+
+        rm -f $fn
+        echo BOOTPROTO=dhcp >>$fn
+        echo STARTMODE=auto >>$fn
+        echo BONDING_MASTER=yes >>$fn
+        echo BONDING_SLAVE_0=$2 >>$fn
+        echo BONDING_SLAVE_1=$3 >>$fn
+        echo BONDING_MODULE_OPTS=\'mode=active-backup miimon=100 primary=$2\' >>$fn
+}
+
+function create_bond {
+        local bondname=bond$bondcnt
+        local primary
+        local secondary
+
+        local class_id1=`cat $sysdir/$1/device/class_id 2>/dev/null`
+        local class_id2=`cat $sysdir/$2/device/class_id 2>/dev/null`
+
+        if [ "$class_id1" = "$netvsc_cls" ]
+        then
+                primary=$2
+                secondary=$1
+        elif [ "$class_id2" = "$netvsc_cls" ]
+        then
+                primary=$1
+                secondary=$2
+        else
+                return 0
+        fi
+
+        echo $'\nBond name:' $bondname
+
+        echo configuring $primary
+        create_eth_cfg_pri_$distro $primary $bondname
+
+        echo configuring $secondary
+        create_eth_cfg_$distro $secondary $bondname
+
+        echo creating: $bondname with primary slave: $primary
+        create_bond_cfg_$distro $bondname $primary $secondary
+
+        let bondcnt=bondcnt+1
+}
+
+for (( i=0; i < $eth_cnt-1; i++ ))
+do
+        if [ -n "${list_match[$i]}" ]
+        then
+                create_bond ${list_eth[$i]} ${list_match[$i]}
+        fi
+done
diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 0d9f48ec42bb..bc7adb84e679 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -1433,7 +1433,7 @@ int main(int argc, char *argv[])
         openlog("KVP", 0, LOG_USER);
         syslog(LOG_INFO, "KVP starting; pid is:%d", getpid());
 
-        kvp_fd = open("/dev/vmbus/hv_kvp", O_RDWR);
+        kvp_fd = open("/dev/vmbus/hv_kvp", O_RDWR | O_CLOEXEC);
 
         if (kvp_fd < 0) {
                 syslog(LOG_ERR, "open /dev/vmbus/hv_kvp failed; error: %d %s",
diff --git a/tools/hv/hv_vss_daemon.c b/tools/hv/hv_vss_daemon.c
index 5d51d6ff08e6..e0829809c897 100644
--- a/tools/hv/hv_vss_daemon.c
+++ b/tools/hv/hv_vss_daemon.c
@@ -250,6 +250,9 @@ int main(int argc, char *argv[])
                                 syslog(LOG_ERR, "/etc/fstab and /proc/mounts");
                         }
                         break;
+                case VSS_OP_HOT_BACKUP:
+                        syslog(LOG_INFO, "VSS: op=CHECK HOT BACKUP\n");
+                        break;
                 default:
                         syslog(LOG_ERR, "Illegal op:%d\n", op);
                 }
diff --git a/tools/iio/Makefile b/tools/iio/Makefile
index 3a7a54f59713..5446d625e17d 100644
--- a/tools/iio/Makefile
+++ b/tools/iio/Makefile
@@ -1,16 +1,31 @@
 CC = $(CROSS_COMPILE)gcc
 CFLAGS += -Wall -g -D_GNU_SOURCE
 
-all: iio_event_monitor lsiio generic_buffer
+BINDIR=usr/bin
+INSTALL_PROGRAM=install -m 755 -p
+DEL_FILE=rm -f
+
+all: iio_event_monitor lsiio iio_generic_buffer
 
 iio_event_monitor: iio_event_monitor.o iio_utils.o
 
 lsiio: lsiio.o iio_utils.o
 
-generic_buffer: generic_buffer.o iio_utils.o
+iio_generic_buffer: iio_generic_buffer.o iio_utils.o
 
 %.o: %.c iio_utils.h
 
+install:
+        - mkdir -p $(INSTALL_ROOT)/$(BINDIR)
+        - $(INSTALL_PROGRAM) "iio_event_monitor" "$(INSTALL_ROOT)/$(BINDIR)/iio_event_monitor"
+        - $(INSTALL_PROGRAM) "lsiio" "$(INSTALL_ROOT)/$(BINDIR)/lsiio"
+        - $(INSTALL_PROGRAM) "iio_generic_buffer" "$(INSTALL_ROOT)/$(BINDIR)/iio_generic_buffer"
+
+uninstall:
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/iio_event_monitor"
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/lsiio"
+        $(DEL_FILE) "$(INSTALL_ROOT)/$(BINDIR)/iio_generic_buffer"
+
 .PHONY: clean
 clean:
-        rm -f *.o iio_event_monitor lsiio generic_buffer
+        rm -f *.o iio_event_monitor lsiio iio_generic_buffer
diff --git a/tools/iio/generic_buffer.c b/tools/iio/iio_generic_buffer.c
index 2429c78de940..f39c0e9c0d5c 100644
--- a/tools/iio/generic_buffer.c
+++ b/tools/iio/iio_generic_buffer.c
@@ -32,6 +32,8 @@
 #include <endian.h>
 #include <getopt.h>
 #include <inttypes.h>
+#include <stdbool.h>
+#include <signal.h>
 #include "iio_utils.h"
 
 /**
@@ -249,11 +251,82 @@ void print_usage(void)
                 "  -e         Disable wait for event (new data)\n"
                 "  -g         Use trigger-less mode\n"
                 "  -l <n>     Set buffer length to n samples\n"
-                "  -n <name>  Set device name (mandatory)\n"
-                "  -t <name>  Set trigger name\n"
+                "  --device-name -n <name>\n"
+                "  --device-num -N <num>\n"
+                "        Set device by name or number (mandatory)\n"
+                "  --trigger-name -t <name>\n"
+                "  --trigger-num -T <num>\n"
+                "        Set trigger by name or number\n"
                 "  -w <n>     Set delay between reads in us (event-less mode)\n");
 }
 
+enum autochan autochannels = AUTOCHANNELS_DISABLED;
+char *dev_dir_name = NULL;
+char *buf_dir_name = NULL;
+bool current_trigger_set = false;
+
+void cleanup(void)
+{
+        int ret;
+
+        /* Disable trigger */
+        if (dev_dir_name && current_trigger_set) {
+                /* Disconnect the trigger - just write a dummy name. */
+                ret = write_sysfs_string("trigger/current_trigger",
+                                         dev_dir_name, "NULL");
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable trigger: %s\n",
+                                strerror(-ret));
+                current_trigger_set = false;
+        }
+
+        /* Disable buffer */
+        if (buf_dir_name) {
+                ret = write_sysfs_int("enable", buf_dir_name, 0);
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable buffer: %s\n",
+                                strerror(-ret));
+        }
+
+        /* Disable channels if auto-enabled */
+        if (dev_dir_name && autochannels == AUTOCHANNELS_ACTIVE) {
+                ret = enable_disable_all_channels(dev_dir_name, 0);
+                if (ret)
+                        fprintf(stderr, "Failed to disable all channels\n");
+                autochannels = AUTOCHANNELS_DISABLED;
+        }
+}
+
+void sig_handler(int signum)
+{
+        fprintf(stderr, "Caught signal %d\n", signum);
+        cleanup();
+        exit(-signum);
+}
+
+void register_cleanup(void)
+{
+        struct sigaction sa = { .sa_handler = sig_handler };
+        const int signums[] = { SIGINT, SIGTERM, SIGABRT };
+        int ret, i;
+
+        for (i = 0; i < ARRAY_SIZE(signums); ++i) {
+                ret = sigaction(signums[i], &sa, NULL);
+                if (ret) {
+                        perror("Failed to register signal handler");
+                        exit(-1);
+                }
+        }
+}
+
+static const struct option longopts[] = {
+        { "device-name",        1, 0, 'n' },
+        { "device-num",         1, 0, 'N' },
+        { "trigger-name",       1, 0, 't' },
+        { "trigger-num",        1, 0, 'T' },
+        { },
+};
+
 int main(int argc, char **argv)
 {
         unsigned long num_loops = 2;
@@ -261,26 +334,25 @@ int main(int argc, char **argv)
         unsigned long buf_len = 128;
 
         int ret, c, i, j, toread;
-        int fp;
+        int fp = -1;
 
-        int num_channels;
+        int num_channels = 0;
         char *trigger_name = NULL, *device_name = NULL;
-        char *dev_dir_name, *buf_dir_name;
 
-        int datardytrigger = 1;
-        char *data;
+        char *data = NULL;
         ssize_t read_size;
-        int dev_num, trig_num;
-        char *buffer_access;
+        int dev_num = -1, trig_num = -1;
+        char *buffer_access = NULL;
         int scan_size;
         int noevents = 0;
         int notrigger = 0;
-        enum autochan autochannels = AUTOCHANNELS_DISABLED;
         char *dummy;
 
-        struct iio_channel_info *channels;
+        struct iio_channel_info *channels = NULL;
 
-        while ((c = getopt(argc, argv, "ac:egl:n:t:w:")) != -1) {
+        register_cleanup();
+
+        while ((c = getopt_long(argc, argv, "ac:egl:n:N:t:T:w:", longopts, NULL)) != -1) {
                 switch (c) {
                 case 'a':
                         autochannels = AUTOCHANNELS_ENABLED;
@@ -288,8 +360,10 @@ int main(int argc, char **argv)
                 case 'c':
                         errno = 0;
                         num_loops = strtoul(optarg, &dummy, 10);
-                        if (errno)
-                                return -errno;
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
 
                         break;
                 case 'e':
@@ -301,49 +375,102 @@ int main(int argc, char **argv)
                 case 'l':
                         errno = 0;
                         buf_len = strtoul(optarg, &dummy, 10);
-                        if (errno)
-                                return -errno;
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
 
                         break;
                 case 'n':
-                        device_name = optarg;
+                        device_name = strdup(optarg);
+                        break;
+                case 'N':
+                        errno = 0;
+                        dev_num = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
                         break;
                 case 't':
-                        trigger_name = optarg;
-                        datardytrigger = 0;
+                        trigger_name = strdup(optarg);
                         break;
-                case 'w':
+                case 'T':
                         errno = 0;
-                        timedelay = strtoul(optarg, &dummy, 10);
+                        trig_num = strtoul(optarg, &dummy, 10);
                         if (errno)
                                 return -errno;
                         break;
+                case 'w':
+                        errno = 0;
+                        timedelay = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+                        break;
                 case '?':
                         print_usage();
-                        return -1;
+                        ret = -1;
+                        goto error;
                 }
         }
 
-        if (!device_name) {
-                fprintf(stderr, "Device name not set\n");
-                print_usage();
-                return -1;
-        }
-
         /* Find the device requested */
-        dev_num = find_type_by_name(device_name, "iio:device");
-        if (dev_num < 0) {
-                fprintf(stderr, "Failed to find the %s\n", device_name);
-                return dev_num;
+        if (dev_num < 0 && !device_name) {
+                fprintf(stderr, "Device not set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num >= 0 && device_name) {
+                fprintf(stderr, "Only one of --device-num or --device-name needs to be set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num < 0) {
+                dev_num = find_type_by_name(device_name, "iio:device");
+                if (dev_num < 0) {
+                        fprintf(stderr, "Failed to find the %s\n", device_name);
+                        ret = dev_num;
+                        goto error;
+                }
         }
-
         printf("iio device number being used is %d\n", dev_num);
 
         ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
         if (ret < 0)
                 return -ENOMEM;
+        /* Fetch device_name if specified by number */
+        if (!device_name) {
+                device_name = malloc(IIO_MAX_NAME_LENGTH);
+                if (!device_name) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                ret = read_sysfs_string("name", dev_dir_name, device_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read name of device %d\n", dev_num);
+                        goto error;
+                }
+        }
 
-        if (!notrigger) {
+        if (notrigger) {
+                printf("trigger-less mode selected\n");
+        } else if (trig_num >= 0) {
+                char *trig_dev_name;
+                ret = asprintf(&trig_dev_name, "%strigger%d", iio_dir, trig_num);
+                if (ret < 0) {
+                        return -ENOMEM;
+                }
+                trigger_name = malloc(IIO_MAX_NAME_LENGTH);
+                ret = read_sysfs_string("name", trig_dev_name, trigger_name);
+                free(trig_dev_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read trigger%d name from\n", trig_num);
+                        return ret;
+                }
+                printf("iio trigger number being used is %d\n", trig_num);
+        } else {
                 if (!trigger_name) {
                         /*
                          * Build the trigger name. If it is device associated
@@ -354,7 +481,7 @@ int main(int argc, char **argv)
                                        "%s-dev%d", device_name, dev_num);
                         if (ret < 0) {
                                 ret = -ENOMEM;
-                                goto error_free_dev_dir_name;
+                                goto error;
                         }
                 }
 
@@ -367,7 +494,7 @@ int main(int argc, char **argv)
                                        "%s-trigger", device_name);
                         if (ret < 0) {
                                 ret = -ENOMEM;
-                                goto error_free_dev_dir_name;
+                                goto error;
                         }
                 }
 
@@ -376,12 +503,10 @@ int main(int argc, char **argv)
                         fprintf(stderr, "Failed to find the trigger %s\n",
                                 trigger_name);
                         ret = trig_num;
-                        goto error_free_triggername;
+                        goto error;
                 }
 
                 printf("iio trigger number being used is %d\n", trig_num);
-        } else {
-                printf("trigger-less mode selected\n");
         }
 
         /*
@@ -392,7 +517,7 @@ int main(int argc, char **argv)
         if (ret) {
                 fprintf(stderr, "Problem reading scan element information\n"
                         "diag %s\n", dev_dir_name);
-                goto error_free_triggername;
+                goto error;
         }
         if (num_channels && autochannels == AUTOCHANNELS_ENABLED) {
                 fprintf(stderr, "Auto-channels selected but some channels "
@@ -407,7 +532,7 @@ int main(int argc, char **argv)
                 ret = enable_disable_all_channels(dev_dir_name, 1);
                 if (ret) {
                         fprintf(stderr, "Failed to enable all channels\n");
-                        goto error_free_triggername;
+                        goto error;
                 }
 
                 /* This flags that we need to disable the channels again */
@@ -419,12 +544,12 @@ int main(int argc, char **argv)
                         fprintf(stderr, "Problem reading scan element "
                                 "information\n"
                                 "diag %s\n", dev_dir_name);
-                        goto error_disable_channels;
+                        goto error;
                 }
                 if (!num_channels) {
                         fprintf(stderr, "Still no channels after "
                                 "auto-enabling, giving up\n");
-                        goto error_disable_channels;
+                        goto error;
                 }
         }
 
@@ -436,7 +561,7 @@ int main(int argc, char **argv)
                         "/*_en or pass -a to autoenable channels and "
                         "try again.\n", dev_dir_name);
                 ret = -ENOENT;
-                goto error_free_triggername;
+                goto error;
         }
 
         /*
@@ -448,7 +573,7 @@ int main(int argc, char **argv)
                        "%siio:device%d/buffer", iio_dir, dev_num);
         if (ret < 0) {
                 ret = -ENOMEM;
-                goto error_free_channels;
+                goto error;
         }
 
         if (!notrigger) {
@@ -463,34 +588,34 @@ int main(int argc, char **argv)
                 if (ret < 0) {
                         fprintf(stderr,
                                 "Failed to write current_trigger file\n");
-                        goto error_free_buf_dir_name;
+                        goto error;
                 }
         }
 
         /* Setup ring buffer parameters */
         ret = write_sysfs_int("length", buf_dir_name, buf_len);
         if (ret < 0)
-                goto error_free_buf_dir_name;
+                goto error;
 
         /* Enable the buffer */
         ret = write_sysfs_int("enable", buf_dir_name, 1);
         if (ret < 0) {
                 fprintf(stderr,
                         "Failed to enable buffer: %s\n", strerror(-ret));
-                goto error_free_buf_dir_name;
+                goto error;
         }
 
         scan_size = size_from_channelarray(channels, num_channels);
         data = malloc(scan_size * buf_len);
         if (!data) {
                 ret = -ENOMEM;
-                goto error_free_buf_dir_name;
+                goto error;
         }
 
         ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
         if (ret < 0) {
                 ret = -ENOMEM;
-                goto error_free_data;
+                goto error;
         }
 
         /* Attempt to open non blocking the access dev */
@@ -498,7 +623,7 @@ int main(int argc, char **argv)
         if (fp == -1) { /* TODO: If it isn't there make the node */
                 ret = -errno;
                 fprintf(stderr, "Failed to open %s\n", buffer_access);
-                goto error_free_buffer_access;
+                goto error;
         }
 
         for (j = 0; j < num_loops; j++) {
@@ -511,7 +636,7 @@ int main(int argc, char **argv)
                         ret = poll(&pfd, 1, -1);
                         if (ret < 0) {
                                 ret = -errno;
-                                goto error_close_buffer_access;
+                                goto error;
                         } else if (ret == 0) {
                                 continue;
                         }
@@ -536,45 +661,21 @@ int main(int argc, char **argv)
                                      num_channels);
         }
 
-        /* Stop the buffer */
-        ret = write_sysfs_int("enable", buf_dir_name, 0);
-        if (ret < 0)
-                goto error_close_buffer_access;
+error:
+        cleanup();
 
-        if (!notrigger)
-                /* Disconnect the trigger - just write a dummy name. */
-                ret = write_sysfs_string("trigger/current_trigger",
-                                         dev_dir_name, "NULL");
-                if (ret < 0)
-                        fprintf(stderr, "Failed to write to %s\n",
-                                dev_dir_name);
-
-error_close_buffer_access:
-        if (close(fp) == -1)
+        if (fp >= 0 && close(fp) == -1)
                 perror("Failed to close buffer");
-
-error_free_buffer_access:
         free(buffer_access);
-error_free_data:
         free(data);
-error_free_buf_dir_name:
         free(buf_dir_name);
-error_free_channels:
         for (i = num_channels - 1; i >= 0; i--) {
                 free(channels[i].name);
                 free(channels[i].generic_name);
         }
         free(channels);
-error_free_triggername:
-        if (datardytrigger)
-                free(trigger_name);
-error_disable_channels:
-        if (autochannels == AUTOCHANNELS_ACTIVE) {
-                ret = enable_disable_all_channels(dev_dir_name, 0);
-                if (ret)
-                        fprintf(stderr, "Failed to disable all channels\n");
-        }
-error_free_dev_dir_name:
+        free(trigger_name);
+        free(device_name);
         free(dev_dir_name);
 
         return ret;
diff --git a/tools/iio/iio_utils.c b/tools/iio/iio_utils.c
index 5eb6793f3972..7a6d61c6c012 100644
--- a/tools/iio/iio_utils.c
+++ b/tools/iio/iio_utils.c
@@ -121,10 +121,6 @@ int iioutils_get_type(unsigned *is_signed, unsigned *bytes, unsigned *bits_used,
 
         ret = -ENOENT;
         while (ent = readdir(dp), ent)
-                /*
-                 * Do we allow devices to override a generic name with
-                 * a specific one?
-                 */
                 if ((strcmp(builtname, ent->d_name) == 0) ||
                     (strcmp(builtname_generic, ent->d_name) == 0)) {
                         ret = asprintf(&filename,
@@ -178,6 +174,13 @@ int iioutils_get_type(unsigned *is_signed, unsigned *bytes, unsigned *bits_used,
                         sysfsfp = 0;
                         free(filename);
                         filename = 0;
+
+                        /*
+                         * Avoid having a more generic entry overwriting
+                         * the settings.
+                         */
+                        if (strcmp(builtname, ent->d_name) == 0)
+                                break;
                 }
 
 error_close_sysfsfp:
diff --git a/tools/iio/lsiio.c b/tools/iio/lsiio.c
index 3d650e668252..ab0f5cf16025 100644
--- a/tools/iio/lsiio.c
+++ b/tools/iio/lsiio.c
@@ -51,7 +51,8 @@ static int dump_channels(const char *dev_dir_name)
 
         while (ent = readdir(dp), ent)
                 if (check_prefix(ent->d_name, "in_") &&
-                    check_postfix(ent->d_name, "_raw"))
+                   (check_postfix(ent->d_name, "_raw") ||
+                    check_postfix(ent->d_name, "_input")))
                         printf("   %-10s\n", ent->d_name);
 
         return (closedir(dp) == -1) ? -errno : 0;
diff --git a/tools/include/asm-generic/bitops/__ffs.h b/tools/include/asm-generic/bitops/__ffs.h
index c94175015a82..b3accfdf24b9 100644
--- a/tools/include/asm-generic/bitops/__ffs.h
+++ b/tools/include/asm-generic/bitops/__ffs.h
@@ -2,6 +2,7 @@
 #define _TOOLS_LINUX_ASM_GENERIC_BITOPS___FFS_H_
 
 #include <asm/types.h>
+#include <asm/bitsperlong.h>
 
 /**
  * __ffs - find first bit in word.
diff --git a/tools/include/asm-generic/bitops/__fls.h b/tools/include/asm-generic/bitops/__fls.h
index 494c9c615d1c..a60a7ccb6782 100644
--- a/tools/include/asm-generic/bitops/__fls.h
+++ b/tools/include/asm-generic/bitops/__fls.h
@@ -1 +1,43 @@
-#include "../../../../include/asm-generic/bitops/__fls.h"
+#ifndef _ASM_GENERIC_BITOPS___FLS_H_
+#define _ASM_GENERIC_BITOPS___FLS_H_
+
+#include <asm/types.h>
+
+/**
+ * __fls - find last (most-significant) set bit in a long word
+ * @word: the word to search
+ *
+ * Undefined if no set bit exists, so code should check against 0 first.
+ */
+static __always_inline unsigned long __fls(unsigned long word)
+{
+        int num = BITS_PER_LONG - 1;
+
+#if BITS_PER_LONG == 64
+        if (!(word & (~0ul << 32))) {
+                num -= 32;
+                word <<= 32;
+        }
+#endif
+        if (!(word & (~0ul << (BITS_PER_LONG-16)))) {
+                num -= 16;
+                word <<= 16;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-8)))) {
+                num -= 8;
+                word <<= 8;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-4)))) {
+                num -= 4;
+                word <<= 4;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-2)))) {
+                num -= 2;
+                word <<= 2;
+        }
+        if (!(word & (~0ul << (BITS_PER_LONG-1))))
+                num -= 1;
+        return num;
+}
+
+#endif /* _ASM_GENERIC_BITOPS___FLS_H_ */
diff --git a/tools/include/asm-generic/bitops/arch_hweight.h b/tools/include/asm-generic/bitops/arch_hweight.h
index 318bb2b202b0..6a211f40665c 100644
--- a/tools/include/asm-generic/bitops/arch_hweight.h
+++ b/tools/include/asm-generic/bitops/arch_hweight.h
@@ -1 +1,25 @@
-#include "../../../../include/asm-generic/bitops/arch_hweight.h"
+#ifndef _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_ARCH_HWEIGHT_H_
+
+#include <asm/types.h>
+
+static inline unsigned int __arch_hweight32(unsigned int w)
+{
+        return __sw_hweight32(w);
+}
+
+static inline unsigned int __arch_hweight16(unsigned int w)
+{
+        return __sw_hweight16(w);
+}
+
+static inline unsigned int __arch_hweight8(unsigned int w)
+{
+        return __sw_hweight8(w);
+}
+
+static inline unsigned long __arch_hweight64(__u64 w)
+{
+        return __sw_hweight64(w);
+}
+#endif /* _ASM_GENERIC_BITOPS_HWEIGHT_H_ */
diff --git a/tools/include/asm-generic/bitops/atomic.h b/tools/include/asm-generic/bitops/atomic.h
index 4bccd7c3d5d6..18663f59d72f 100644
--- a/tools/include/asm-generic/bitops/atomic.h
+++ b/tools/include/asm-generic/bitops/atomic.h
@@ -2,6 +2,7 @@
 #define _TOOLS_LINUX_ASM_GENERIC_BITOPS_ATOMIC_H_
 
 #include <asm/types.h>
+#include <asm/bitsperlong.h>
 
 static inline void set_bit(int nr, unsigned long *addr)
 {
diff --git a/tools/include/asm-generic/bitops/const_hweight.h b/tools/include/asm-generic/bitops/const_hweight.h
index 0afd644aff83..0a7e06623470 100644
--- a/tools/include/asm-generic/bitops/const_hweight.h
+++ b/tools/include/asm-generic/bitops/const_hweight.h
@@ -1 +1,43 @@
-#include "../../../../include/asm-generic/bitops/const_hweight.h"
+#ifndef _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
+#define _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_
+
+/*
+ * Compile time versions of __arch_hweightN()
+ */
+#define __const_hweight8(w)             \
+        ((unsigned int)                 \
+         ((!!((w) & (1ULL << 0))) +     \
+          (!!((w) & (1ULL << 1))) +     \
+          (!!((w) & (1ULL << 2))) +     \
+          (!!((w) & (1ULL << 3))) +     \
+          (!!((w) & (1ULL << 4))) +     \
+          (!!((w) & (1ULL << 5))) +     \
+          (!!((w) & (1ULL << 6))) +     \
+          (!!((w) & (1ULL << 7)))))
+
+#define __const_hweight16(w) (__const_hweight8(w)  + __const_hweight8((w)  >> 8 ))
+#define __const_hweight32(w) (__const_hweight16(w) + __const_hweight16((w) >> 16))
+#define __const_hweight64(w) (__const_hweight32(w) + __const_hweight32((w) >> 32))
+
+/*
+ * Generic interface.
+ */
+#define hweight8(w)  (__builtin_constant_p(w) ? __const_hweight8(w)  : __arch_hweight8(w))
+#define hweight16(w) (__builtin_constant_p(w) ? __const_hweight16(w) : __arch_hweight16(w))
+#define hweight32(w) (__builtin_constant_p(w) ? __const_hweight32(w) : __arch_hweight32(w))
+#define hweight64(w) (__builtin_constant_p(w) ? __const_hweight64(w) : __arch_hweight64(w))
+
+/*
+ * Interface for known constant arguments
+ */
+#define HWEIGHT8(w)  (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight8(w))
+#define HWEIGHT16(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight16(w))
+#define HWEIGHT32(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight32(w))
+#define HWEIGHT64(w) (BUILD_BUG_ON_ZERO(!__builtin_constant_p(w)) + __const_hweight64(w))
+
+/*
+ * Type invariant interface to the compile time constant hweight functions.
+ */
+#define HWEIGHT(w)   HWEIGHT64((u64)w)
+
+#endif /* _ASM_GENERIC_BITOPS_CONST_HWEIGHT_H_ */
diff --git a/tools/include/asm-generic/bitops/fls.h b/tools/include/asm-generic/bitops/fls.h
index 0e4995fa0248..0576d1f42f43 100644
--- a/tools/include/asm-generic/bitops/fls.h
+++ b/tools/include/asm-generic/bitops/fls.h
@@ -1 +1,41 @@
-#include "../../../../include/asm-generic/bitops/fls.h"
+#ifndef _ASM_GENERIC_BITOPS_FLS_H_
+#define _ASM_GENERIC_BITOPS_FLS_H_
+
+/**
+ * fls - find last (most-significant) bit set
+ * @x: the word to search
+ *
+ * This is defined the same way as ffs.
+ * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
+ */
+
+static __always_inline int fls(int x)
+{
+        int r = 32;
+
+        if (!x)
+                return 0;
+        if (!(x & 0xffff0000u)) {
+                x <<= 16;
+                r -= 16;
+        }
+        if (!(x & 0xff000000u)) {
+                x <<= 8;
+                r -= 8;
+        }
+        if (!(x & 0xf0000000u)) {
+                x <<= 4;
+                r -= 4;
+        }
+        if (!(x & 0xc0000000u)) {
+                x <<= 2;
+                r -= 2;
+        }
+        if (!(x & 0x80000000u)) {
+                x <<= 1;
+                r -= 1;
+        }
+        return r;
+}
+
+#endif /* _ASM_GENERIC_BITOPS_FLS_H_ */
diff --git a/tools/include/asm-generic/bitops/fls64.h b/tools/include/asm-generic/bitops/fls64.h
index 35bee0071e78..b097cf8444e3 100644
--- a/tools/include/asm-generic/bitops/fls64.h
+++ b/tools/include/asm-generic/bitops/fls64.h
@@ -1 +1,36 @@
-#include "../../../../include/asm-generic/bitops/fls64.h"
+#ifndef _ASM_GENERIC_BITOPS_FLS64_H_
+#define _ASM_GENERIC_BITOPS_FLS64_H_
+
+#include <asm/types.h>
+
+/**
+ * fls64 - find last set bit in a 64-bit word
+ * @x: the word to search
+ *
+ * This is defined in a similar way as the libc and compiler builtin
+ * ffsll, but returns the position of the most significant set bit.
+ *
+ * fls64(value) returns 0 if value is 0 or the position of the last
+ * set bit if value is nonzero. The last (most significant) bit is
+ * at position 64.
+ */
+#if BITS_PER_LONG == 32
+static __always_inline int fls64(__u64 x)
+{
+        __u32 h = x >> 32;
+        if (h)
+                return fls(h) + 32;
+        return fls(x);
+}
+#elif BITS_PER_LONG == 64
+static __always_inline int fls64(__u64 x)
+{
+        if (x == 0)
+                return 0;
+        return __fls(x) + 1;
+}
+#else
+#error BITS_PER_LONG not 32 or 64
+#endif
+
+#endif /* _ASM_GENERIC_BITOPS_FLS64_H_ */
diff --git a/tools/include/asm-generic/bitsperlong.h b/tools/include/asm-generic/bitsperlong.h
new file mode 100644
index 000000000000..45eca517efb3
--- /dev/null
+++ b/tools/include/asm-generic/bitsperlong.h
@@ -0,0 +1,20 @@
+#ifndef __ASM_GENERIC_BITS_PER_LONG
+#define __ASM_GENERIC_BITS_PER_LONG
+
+#include <uapi/asm-generic/bitsperlong.h>
+
+#ifdef __SIZEOF_LONG__
+#define BITS_PER_LONG (__CHAR_BIT__ * __SIZEOF_LONG__)
+#else
+#define BITS_PER_LONG __WORDSIZE
+#endif
+
+#if BITS_PER_LONG != __BITS_PER_LONG
+#error Inconsistent word size. Check asm/bitsperlong.h
+#endif
+
+#ifndef BITS_PER_LONG_LONG
+#define BITS_PER_LONG_LONG 64
+#endif
+
+#endif /* __ASM_GENERIC_BITS_PER_LONG */
diff --git a/tools/perf/util/include/asm/alternative-asm.h b/tools/include/asm/alternative-asm.h
index 3a3a0f16456a..2a4d1bfa2988 100644
--- a/tools/perf/util/include/asm/alternative-asm.h
+++ b/tools/include/asm/alternative-asm.h
@@ -1,5 +1,5 @@
-#ifndef _PERF_ASM_ALTERNATIVE_ASM_H
-#define _PERF_ASM_ALTERNATIVE_ASM_H
+#ifndef _TOOLS_ASM_ALTERNATIVE_ASM_H
+#define _TOOLS_ASM_ALTERNATIVE_ASM_H
 
 /* Just disable it so we can build arch/x86/lib/memcpy_64.S for perf bench: */
 
diff --git a/tools/include/linux/bitmap.h b/tools/include/linux/bitmap.h
index 28f5493da491..43c1c5021e4b 100644
--- a/tools/include/linux/bitmap.h
+++ b/tools/include/linux/bitmap.h
@@ -3,6 +3,7 @@
 
 #include <string.h>
 #include <linux/bitops.h>
+#include <stdlib.h>
 
 #define DECLARE_BITMAP(name,bits) \
         unsigned long name[BITS_TO_LONGS(bits)]
@@ -10,6 +11,8 @@
 int __bitmap_weight(const unsigned long *bitmap, int bits);
 void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
                  const unsigned long *bitmap2, int bits);
+int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+                 const unsigned long *bitmap2, unsigned int bits);
 
 #define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
 
@@ -65,4 +68,38 @@ static inline int test_and_set_bit(int nr, unsigned long *addr)
         return (old & mask) != 0;
 }
 
+/**
+ * bitmap_alloc - Allocate bitmap
+ * @nr: Bit to set
+ */
+static inline unsigned long *bitmap_alloc(int nbits)
+{
+        return calloc(1, BITS_TO_LONGS(nbits) * sizeof(unsigned long));
+}
+
+/*
+ * bitmap_scnprintf - print bitmap list into buffer
+ * @bitmap: bitmap
+ * @nbits: size of bitmap
+ * @buf: buffer to store output
+ * @size: size of @buf
+ */
+size_t bitmap_scnprintf(unsigned long *bitmap, int nbits,
+                        char *buf, size_t size);
+
+/**
+ * bitmap_and - Do logical and on bitmaps
+ * @dst: resulting bitmap
+ * @src1: operand 1
+ * @src2: operand 2
+ * @nbits: size of bitmap
+ */
+static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
+                             const unsigned long *src2, unsigned int nbits)
+{
+        if (small_const_nbits(nbits))
+                return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;
+        return __bitmap_and(dst, src1, src2, nbits);
+}
+
 #endif /* _PERF_BITOPS_H */
diff --git a/tools/include/linux/bitops.h b/tools/include/linux/bitops.h
index 5ad9ee1dd7f6..49c929a104ee 100644
--- a/tools/include/linux/bitops.h
+++ b/tools/include/linux/bitops.h
@@ -9,7 +9,9 @@
 #define __WORDSIZE (__SIZEOF_LONG__ * 8)
 #endif
 
-#define BITS_PER_LONG __WORDSIZE
+#ifndef BITS_PER_LONG
+# define BITS_PER_LONG __WORDSIZE
+#endif
 
 #define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
 #define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
diff --git a/tools/include/linux/compiler.h b/tools/include/linux/compiler.h
index fa7208a32d76..e33fc1df3935 100644
--- a/tools/include/linux/compiler.h
+++ b/tools/include/linux/compiler.h
@@ -9,6 +9,17 @@
 # define __always_inline        inline __attribute__((always_inline))
 #endif
 
+#ifdef __ANDROID__
+/*
+ * FIXME: Big hammer to get rid of tons of:
+ *   "warning: always_inline function might not be inlinable"
+ *
+ * At least on android-ndk-r12/platforms/android-24/arch-arm
+ */
+#undef __always_inline
+#define __always_inline inline
+#endif
+
 #define __user
 
 #ifndef __attribute_const__
diff --git a/tools/include/linux/coresight-pmu.h b/tools/include/linux/coresight-pmu.h
new file mode 100644
index 000000000000..7d410260661b
--- /dev/null
+++ b/tools/include/linux/coresight-pmu.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _LINUX_CORESIGHT_PMU_H
+#define _LINUX_CORESIGHT_PMU_H
+
+#define CORESIGHT_ETM_PMU_NAME "cs_etm"
+#define CORESIGHT_ETM_PMU_SEED  0x10
+
+/* ETMv3.5/PTM's ETMCR config bit */
+#define ETM_OPT_CYCACC  12
+#define ETM_OPT_TS      28
+
+static inline int coresight_get_trace_id(int cpu)
+{
+        /*
+         * A trace ID of value 0 is invalid, so let's start at some
+         * random value that fits in 7 bits and go from there.  Since
+         * the common convention is to have data trace IDs be I(N) + 1,
+         * set instruction trace IDs as a function of the CPU number.
+         */
+        return (CORESIGHT_ETM_PMU_SEED + (cpu * 2));
+}
+
+#endif
diff --git a/tools/include/linux/hash.h b/tools/include/linux/hash.h
index d026c6573018..ad6fa21d977b 100644
--- a/tools/include/linux/hash.h
+++ b/tools/include/linux/hash.h
@@ -1,5 +1,104 @@
-#include "../../../include/linux/hash.h"
+#ifndef _LINUX_HASH_H
+#define _LINUX_HASH_H
+/* Fast hashing routine for ints,  longs and pointers.
+   (C) 2002 Nadia Yvette Chambers, IBM */
 
-#ifndef _TOOLS_LINUX_HASH_H
-#define _TOOLS_LINUX_HASH_H
+#include <asm/types.h>
+#include <linux/compiler.h>
+
+/*
+ * The "GOLDEN_RATIO_PRIME" is used in ifs/btrfs/brtfs_inode.h and
+ * fs/inode.c.  It's not actually prime any more (the previous primes
+ * were actively bad for hashing), but the name remains.
+ */
+#if BITS_PER_LONG == 32
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_32
+#define hash_long(val, bits) hash_32(val, bits)
+#elif BITS_PER_LONG == 64
+#define hash_long(val, bits) hash_64(val, bits)
+#define GOLDEN_RATIO_PRIME GOLDEN_RATIO_64
+#else
+#error Wordsize not 32 or 64
+#endif
+
+/*
+ * This hash multiplies the input by a large odd number and takes the
+ * high bits.  Since multiplication propagates changes to the most
+ * significant end only, it is essential that the high bits of the
+ * product be used for the hash value.
+ *
+ * Chuck Lever verified the effectiveness of this technique:
+ * http://www.citi.umich.edu/techreports/reports/citi-tr-00-1.pdf
+ *
+ * Although a random odd number will do, it turns out that the golden
+ * ratio phi = (sqrt(5)-1)/2, or its negative, has particularly nice
+ * properties.  (See Knuth vol 3, section 6.4, exercise 9.)
+ *
+ * These are the negative, (1 - phi) = phi**2 = (3 - sqrt(5))/2,
+ * which is very slightly easier to multiply by and makes no
+ * difference to the hash distribution.
+ */
+#define GOLDEN_RATIO_32 0x61C88647
+#define GOLDEN_RATIO_64 0x61C8864680B583EBull
+
+#ifdef CONFIG_HAVE_ARCH_HASH
+/* This header may use the GOLDEN_RATIO_xx constants */
+#include <asm/hash.h>
+#endif
+
+/*
+ * The _generic versions exist only so lib/test_hash.c can compare
+ * the arch-optimized versions with the generic.
+ *
+ * Note that if you change these, any <asm/hash.h> that aren't updated
+ * to match need to have their HAVE_ARCH_* define values updated so the
+ * self-test will not false-positive.
+ */
+#ifndef HAVE_ARCH__HASH_32
+#define __hash_32 __hash_32_generic
+#endif
+static inline u32 __hash_32_generic(u32 val)
+{
+        return val * GOLDEN_RATIO_32;
+}
+
+#ifndef HAVE_ARCH_HASH_32
+#define hash_32 hash_32_generic
 #endif
+static inline u32 hash_32_generic(u32 val, unsigned int bits)
+{
+        /* High bits are more random, so use them. */
+        return __hash_32(val) >> (32 - bits);
+}
+
+#ifndef HAVE_ARCH_HASH_64
+#define hash_64 hash_64_generic
+#endif
+static __always_inline u32 hash_64_generic(u64 val, unsigned int bits)
+{
+#if BITS_PER_LONG == 64
+        /* 64x64-bit multiply is efficient on all 64-bit processors */
+        return val * GOLDEN_RATIO_64 >> (64 - bits);
+#else
+        /* Hash 64 bits using only 32x32-bit multiply. */
+        return hash_32((u32)val ^ __hash_32(val >> 32), bits);
+#endif
+}
+
+static inline u32 hash_ptr(const void *ptr, unsigned int bits)
+{
+        return hash_long((unsigned long)ptr, bits);
+}
+
+/* This really should be called fold32_ptr; it does no hashing to speak of. */
+static inline u32 hash32_ptr(const void *ptr)
+{
+        unsigned long val = (unsigned long)ptr;
+
+#if BITS_PER_LONG == 64
+        val ^= (val >> 32);
+#endif
+        return (u32)val;
+}
+
+#endif /* _LINUX_HASH_H */
diff --git a/tools/include/linux/kernel.h b/tools/include/linux/kernel.h
index 76df53539c2a..28607db02bd3 100644
--- a/tools/include/linux/kernel.h
+++ b/tools/include/linux/kernel.h
@@ -2,8 +2,7 @@
 #define __TOOLS_LINUX_KERNEL_H
 
 #include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include <stddef.h>
 #include <assert.h>
 
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
@@ -70,29 +69,8 @@
 #define cpu_to_le64(x)  (x)
 #define cpu_to_le32(x)  (x)
 
-static inline int
-vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
-{
-        int i;
-        ssize_t ssize = size;
-
-        i = vsnprintf(buf, size, fmt, args);
-
-        return (i >= ssize) ? (ssize - 1) : i;
-}
-
-static inline int scnprintf(char * buf, size_t size, const char * fmt, ...)
-{
-        va_list args;
-        ssize_t ssize = size;
-        int i;
-
-        va_start(args, fmt);
-        i = vsnprintf(buf, size, fmt, args);
-        va_end(args);
-
-        return (i >= ssize) ? (ssize - 1) : i;
-}
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
+int scnprintf(char * buf, size_t size, const char * fmt, ...);
 
 /*
  * This looks more complex than it should be. But we need to
diff --git a/tools/include/linux/poison.h b/tools/include/linux/poison.h
index 0c27bdf14233..51334edec506 100644
--- a/tools/include/linux/poison.h
+++ b/tools/include/linux/poison.h
@@ -1 +1,90 @@
-#include "../../../include/linux/poison.h"
+#ifndef _LINUX_POISON_H
+#define _LINUX_POISON_H
+
+/********** include/linux/list.h **********/
+
+/*
+ * Architectures might want to move the poison pointer offset
+ * into some well-recognized area such as 0xdead000000000000,
+ * that is also not mappable by user-space exploits:
+ */
+#ifdef CONFIG_ILLEGAL_POINTER_VALUE
+# define POISON_POINTER_DELTA _AC(CONFIG_ILLEGAL_POINTER_VALUE, UL)
+#else
+# define POISON_POINTER_DELTA 0
+#endif
+
+/*
+ * These are non-NULL pointers that will result in page faults
+ * under normal circumstances, used to verify that nobody uses
+ * non-initialized list entries.
+ */
+#define LIST_POISON1  ((void *) 0x100 + POISON_POINTER_DELTA)
+#define LIST_POISON2  ((void *) 0x200 + POISON_POINTER_DELTA)
+
+/********** include/linux/timer.h **********/
+/*
+ * Magic number "tsta" to indicate a static timer initializer
+ * for the object debugging code.
+ */
+#define TIMER_ENTRY_STATIC      ((void *) 0x300 + POISON_POINTER_DELTA)
+
+/********** mm/debug-pagealloc.c **********/
+#ifdef CONFIG_PAGE_POISONING_ZERO
+#define PAGE_POISON 0x00
+#else
+#define PAGE_POISON 0xaa
+#endif
+
+/********** mm/page_alloc.c ************/
+
+#define TAIL_MAPPING    ((void *) 0x400 + POISON_POINTER_DELTA)
+
+/********** mm/slab.c **********/
+/*
+ * Magic nums for obj red zoning.
+ * Placed in the first word before and the first word after an obj.
+ */
+#define RED_INACTIVE    0x09F911029D74E35BULL   /* when obj is inactive */
+#define RED_ACTIVE      0xD84156C5635688C0ULL   /* when obj is active */
+
+#define SLUB_RED_INACTIVE       0xbb
+#define SLUB_RED_ACTIVE         0xcc
+
+/* ...and for poisoning */
+#define POISON_INUSE    0x5a    /* for use-uninitialised poisoning */
+#define POISON_FREE     0x6b    /* for use-after-free poisoning */
+#define POISON_END      0xa5    /* end-byte of poisoning */
+
+/********** arch/$ARCH/mm/init.c **********/
+#define POISON_FREE_INITMEM     0xcc
+
+/********** arch/ia64/hp/common/sba_iommu.c **********/
+/*
+ * arch/ia64/hp/common/sba_iommu.c uses a 16-byte poison string with a
+ * value of "SBAIOMMU POISON\0" for spill-over poisoning.
+ */
+
+/********** fs/jbd/journal.c **********/
+#define JBD_POISON_FREE         0x5b
+#define JBD2_POISON_FREE        0x5c
+
+/********** drivers/base/dmapool.c **********/
+#define POOL_POISON_FREED       0xa7    /* !inuse */
+#define POOL_POISON_ALLOCATED   0xa9    /* !initted */
+
+/********** drivers/atm/ **********/
+#define ATM_POISON_FREE         0x12
+#define ATM_POISON              0xdeadbeef
+
+/********** kernel/mutexes **********/
+#define MUTEX_DEBUG_INIT        0x11
+#define MUTEX_DEBUG_FREE        0x22
+
+/********** lib/flex_array.c **********/
+#define FLEX_ARRAY_FREE 0x6c    /* for use-after-free poisoning */
+
+/********** security/ **********/
+#define KEY_DESTROY             0xbd
+
+#endif
diff --git a/tools/include/linux/string.h b/tools/include/linux/string.h
index e26223f1f287..f436d2420a18 100644
--- a/tools/include/linux/string.h
+++ b/tools/include/linux/string.h
@@ -8,8 +8,14 @@ void *memdup(const void *src, size_t len);
 
 int strtobool(const char *s, bool *res);
 
-#ifndef __UCLIBC__
+/*
+ * glibc based builds needs the extern while uClibc doesn't.
+ * However uClibc headers also define __GLIBC__ hence the hack below
+ */
+#if defined(__GLIBC__) && !defined(__UCLIBC__)
 extern size_t strlcpy(char *dest, const char *src, size_t size);
 #endif
 
+char *str_error_r(int errnum, char *buf, size_t buflen);
+
 #endif /* _LINUX_STRING_H_ */
diff --git a/tools/include/linux/time64.h b/tools/include/linux/time64.h
new file mode 100644
index 000000000000..df9265483d65
--- /dev/null
+++ b/tools/include/linux/time64.h
@@ -0,0 +1,12 @@
+#ifndef _TOOLS_LINUX_TIME64_H
+#define _TOOLS_LINUX_TIME64_H
+
+#define MSEC_PER_SEC    1000L
+#define USEC_PER_MSEC   1000L
+#define NSEC_PER_USEC   1000L
+#define NSEC_PER_MSEC   1000000L
+#define USEC_PER_SEC    1000000L
+#define NSEC_PER_SEC    1000000000L
+#define FSEC_PER_SEC    1000000000000000LL
+
+#endif /* _LINUX_TIME64_H */
diff --git a/tools/include/uapi/asm-generic/bitsperlong.h b/tools/include/uapi/asm-generic/bitsperlong.h
new file mode 100644
index 000000000000..23e6c416b85f
--- /dev/null
+++ b/tools/include/uapi/asm-generic/bitsperlong.h
@@ -0,0 +1,15 @@
+#ifndef _UAPI__ASM_GENERIC_BITS_PER_LONG
+#define _UAPI__ASM_GENERIC_BITS_PER_LONG
+
+/*
+ * There seems to be no way of detecting this automatically from user
+ * space, so 64 bit architectures should override this in their
+ * bitsperlong.h. In particular, an architecture that supports
+ * both 32 and 64 bit user space must not rely on CONFIG_64BIT
+ * to decide it, but rather check a compiler provided macro.
+ */
+#ifndef __BITS_PER_LONG
+#define __BITS_PER_LONG 32
+#endif
+
+#endif /* _UAPI__ASM_GENERIC_BITS_PER_LONG */
diff --git a/tools/include/uapi/asm-generic/mman-common.h b/tools/include/uapi/asm-generic/mman-common.h
new file mode 100644
index 000000000000..58274382a616
--- /dev/null
+++ b/tools/include/uapi/asm-generic/mman-common.h
@@ -0,0 +1,75 @@
+#ifndef __ASM_GENERIC_MMAN_COMMON_H
+#define __ASM_GENERIC_MMAN_COMMON_H
+
+/*
+ Author: Michael S. Tsirkin <mst@mellanox.co.il>, Mellanox Technologies Ltd.
+ Based on: asm-xxx/mman.h
+*/
+
+#define PROT_READ       0x1             /* page can be read */
+#define PROT_WRITE      0x2             /* page can be written */
+#define PROT_EXEC       0x4             /* page can be executed */
+#define PROT_SEM        0x8             /* page may be used for atomic ops */
+#define PROT_NONE       0x0             /* page can not be accessed */
+#define PROT_GROWSDOWN  0x01000000      /* mprotect flag: extend change to start of growsdown vma */
+#define PROT_GROWSUP    0x02000000      /* mprotect flag: extend change to end of growsup vma */
+
+#define MAP_SHARED      0x01            /* Share changes */
+#define MAP_PRIVATE     0x02            /* Changes are private */
+#define MAP_TYPE        0x0f            /* Mask for type of mapping */
+#define MAP_FIXED       0x10            /* Interpret addr exactly */
+#define MAP_ANONYMOUS   0x20            /* don't use a file */
+#ifdef CONFIG_MMAP_ALLOW_UNINITIALIZED
+# define MAP_UNINITIALIZED 0x4000000    /* For anonymous mmap, memory could be uninitialized */
+#else
+# define MAP_UNINITIALIZED 0x0          /* Don't support this flag */
+#endif
+
+/*
+ * Flags for mlock
+ */
+#define MLOCK_ONFAULT   0x01            /* Lock pages in range after they are faulted in, do not prefault */
+
+#define MS_ASYNC        1               /* sync memory asynchronously */
+#define MS_INVALIDATE   2               /* invalidate the caches */
+#define MS_SYNC         4               /* synchronous memory sync */
+
+#define MADV_NORMAL     0               /* no further special treatment */
+#define MADV_RANDOM     1               /* expect random page references */
+#define MADV_SEQUENTIAL 2               /* expect sequential page references */
+#define MADV_WILLNEED   3               /* will need these pages */
+#define MADV_DONTNEED   4               /* don't need these pages */
+
+/* common parameters: try to keep these consistent across architectures */
+#define MADV_FREE       8               /* free pages only if memory pressure */
+#define MADV_REMOVE     9               /* remove these pages & resources */
+#define MADV_DONTFORK   10              /* don't inherit across fork */
+#define MADV_DOFORK     11              /* do inherit across fork */
+#define MADV_HWPOISON   100             /* poison a page for testing */
+#define MADV_SOFT_OFFLINE 101           /* soft offline page for testing */
+
+#define MADV_MERGEABLE   12             /* KSM may merge identical pages */
+#define MADV_UNMERGEABLE 13             /* KSM may not merge identical pages */
+
+#define MADV_HUGEPAGE   14              /* Worth backing with hugepages */
+#define MADV_NOHUGEPAGE 15              /* Not worth backing with hugepages */
+
+#define MADV_DONTDUMP   16              /* Explicity exclude from the core dump,
+                                           overrides the coredump filter bits */
+#define MADV_DODUMP     17              /* Clear the MADV_DONTDUMP flag */
+
+/* compatibility flags */
+#define MAP_FILE        0
+
+/*
+ * When MAP_HUGETLB is set bits [26:31] encode the log2 of the huge page size.
+ * This gives us 6 bits, which is enough until someone invents 128 bit address
+ * spaces.
+ *
+ * Assume these are all power of twos.
+ * When 0 use the default page size.
+ */
+#define MAP_HUGE_SHIFT  26
+#define MAP_HUGE_MASK   0x3f
+
+#endif /* __ASM_GENERIC_MMAN_COMMON_H */
diff --git a/tools/include/uapi/asm-generic/mman.h b/tools/include/uapi/asm-generic/mman.h
new file mode 100644
index 000000000000..10fa7857777f
--- /dev/null
+++ b/tools/include/uapi/asm-generic/mman.h
@@ -0,0 +1,22 @@
+#ifndef __ASM_GENERIC_MMAN_H
+#define __ASM_GENERIC_MMAN_H
+
+#include <uapi/asm-generic/mman-common.h>
+
+#define MAP_GROWSDOWN   0x0100          /* stack-like segment */
+#define MAP_DENYWRITE   0x0800          /* ETXTBSY */
+#define MAP_EXECUTABLE  0x1000          /* mark it as an executable */
+#define MAP_LOCKED      0x2000          /* pages are locked */
+#define MAP_NORESERVE   0x4000          /* don't check for reservations */
+#define MAP_POPULATE    0x8000          /* populate (prefault) pagetables */
+#define MAP_NONBLOCK    0x10000         /* do not block on IO */
+#define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
+#define MAP_HUGETLB     0x40000         /* create a huge page mapping */
+
+/* Bits [26:31] are reserved, see mman-common.h for MAP_HUGETLB usage */
+
+#define MCL_CURRENT     1               /* lock all current mappings */
+#define MCL_FUTURE      2               /* lock all future mappings */
+#define MCL_ONFAULT     4               /* lock all pages that are faulted in */
+
+#endif /* __ASM_GENERIC_MMAN_H */
diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
new file mode 100644
index 000000000000..9e5fc168c8a3
--- /dev/null
+++ b/tools/include/uapi/linux/bpf.h
@@ -0,0 +1,473 @@
+/* Copyright (c) 2011-2014 PLUMgrid, http://plumgrid.com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+#ifndef _UAPI__LINUX_BPF_H__
+#define _UAPI__LINUX_BPF_H__
+
+#include <linux/types.h>
+#include <linux/bpf_common.h>
+
+/* Extended instruction set based on top of classic BPF */
+
+/* instruction classes */
+#define BPF_ALU64       0x07    /* alu mode in double word width */
+
+/* ld/ldx fields */
+#define BPF_DW          0x18    /* double word */
+#define BPF_XADD        0xc0    /* exclusive add */
+
+/* alu/jmp fields */
+#define BPF_MOV         0xb0    /* mov reg to reg */
+#define BPF_ARSH        0xc0    /* sign extending arithmetic shift right */
+
+/* change endianness of a register */
+#define BPF_END         0xd0    /* flags for endianness conversion: */
+#define BPF_TO_LE       0x00    /* convert to little-endian */
+#define BPF_TO_BE       0x08    /* convert to big-endian */
+#define BPF_FROM_LE     BPF_TO_LE
+#define BPF_FROM_BE     BPF_TO_BE
+
+#define BPF_JNE         0x50    /* jump != */
+#define BPF_JSGT        0x60    /* SGT is signed '>', GT in x86 */
+#define BPF_JSGE        0x70    /* SGE is signed '>=', GE in x86 */
+#define BPF_CALL        0x80    /* function call */
+#define BPF_EXIT        0x90    /* function return */
+
+/* Register numbers */
+enum {
+        BPF_REG_0 = 0,
+        BPF_REG_1,
+        BPF_REG_2,
+        BPF_REG_3,
+        BPF_REG_4,
+        BPF_REG_5,
+        BPF_REG_6,
+        BPF_REG_7,
+        BPF_REG_8,
+        BPF_REG_9,
+        BPF_REG_10,
+        __MAX_BPF_REG,
+};
+
+/* BPF has 10 general purpose 64-bit registers and stack frame. */
+#define MAX_BPF_REG     __MAX_BPF_REG
+
+struct bpf_insn {
+        __u8    code;           /* opcode */
+        __u8    dst_reg:4;      /* dest register */
+        __u8    src_reg:4;      /* source register */
+        __s16   off;            /* signed offset */
+        __s32   imm;            /* signed immediate constant */
+};
+
+/* BPF syscall commands, see bpf(2) man-page for details. */
+enum bpf_cmd {
+        BPF_MAP_CREATE,
+        BPF_MAP_LOOKUP_ELEM,
+        BPF_MAP_UPDATE_ELEM,
+        BPF_MAP_DELETE_ELEM,
+        BPF_MAP_GET_NEXT_KEY,
+        BPF_PROG_LOAD,
+        BPF_OBJ_PIN,
+        BPF_OBJ_GET,
+};
+
+enum bpf_map_type {
+        BPF_MAP_TYPE_UNSPEC,
+        BPF_MAP_TYPE_HASH,
+        BPF_MAP_TYPE_ARRAY,
+        BPF_MAP_TYPE_PROG_ARRAY,
+        BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+        BPF_MAP_TYPE_PERCPU_HASH,
+        BPF_MAP_TYPE_PERCPU_ARRAY,
+        BPF_MAP_TYPE_STACK_TRACE,
+        BPF_MAP_TYPE_CGROUP_ARRAY,
+};
+
+enum bpf_prog_type {
+        BPF_PROG_TYPE_UNSPEC,
+        BPF_PROG_TYPE_SOCKET_FILTER,
+        BPF_PROG_TYPE_KPROBE,
+        BPF_PROG_TYPE_SCHED_CLS,
+        BPF_PROG_TYPE_SCHED_ACT,
+        BPF_PROG_TYPE_TRACEPOINT,
+        BPF_PROG_TYPE_XDP,
+};
+
+#define BPF_PSEUDO_MAP_FD       1
+
+/* flags for BPF_MAP_UPDATE_ELEM command */
+#define BPF_ANY         0 /* create new element or update existing */
+#define BPF_NOEXIST     1 /* create new element if it didn't exist */
+#define BPF_EXIST       2 /* update existing element */
+
+#define BPF_F_NO_PREALLOC       (1U << 0)
+
+union bpf_attr {
+        struct { /* anonymous struct used by BPF_MAP_CREATE command */
+                __u32   map_type;       /* one of enum bpf_map_type */
+                __u32   key_size;       /* size of key in bytes */
+                __u32   value_size;     /* size of value in bytes */
+                __u32   max_entries;    /* max number of entries in a map */
+                __u32   map_flags;      /* prealloc or not */
+        };
+
+        struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
+                __u32           map_fd;
+                __aligned_u64   key;
+                union {
+                        __aligned_u64 value;
+                        __aligned_u64 next_key;
+                };
+                __u64           flags;
+        };
+
+        struct { /* anonymous struct used by BPF_PROG_LOAD command */
+                __u32           prog_type;      /* one of enum bpf_prog_type */
+                __u32           insn_cnt;
+                __aligned_u64   insns;
+                __aligned_u64   license;
+                __u32           log_level;      /* verbosity level of verifier */
+                __u32           log_size;       /* size of user buffer */
+                __aligned_u64   log_buf;        /* user supplied buffer */
+                __u32           kern_version;   /* checked when prog_type=kprobe */
+        };
+
+        struct { /* anonymous struct used by BPF_OBJ_* commands */
+                __aligned_u64   pathname;
+                __u32           bpf_fd;
+        };
+} __attribute__((aligned(8)));
+
+/* integer value in 'imm' field of BPF_CALL instruction selects which helper
+ * function eBPF program intends to call
+ */
+enum bpf_func_id {
+        BPF_FUNC_unspec,
+        BPF_FUNC_map_lookup_elem, /* void *map_lookup_elem(&map, &key) */
+        BPF_FUNC_map_update_elem, /* int map_update_elem(&map, &key, &value, flags) */
+        BPF_FUNC_map_delete_elem, /* int map_delete_elem(&map, &key) */
+        BPF_FUNC_probe_read,      /* int bpf_probe_read(void *dst, int size, void *src) */
+        BPF_FUNC_ktime_get_ns,    /* u64 bpf_ktime_get_ns(void) */
+        BPF_FUNC_trace_printk,    /* int bpf_trace_printk(const char *fmt, int fmt_size, ...) */
+        BPF_FUNC_get_prandom_u32, /* u32 prandom_u32(void) */
+        BPF_FUNC_get_smp_processor_id, /* u32 raw_smp_processor_id(void) */
+
+        /**
+         * skb_store_bytes(skb, offset, from, len, flags) - store bytes into packet
+         * @skb: pointer to skb
+         * @offset: offset within packet from skb->mac_header
+         * @from: pointer where to copy bytes from
+         * @len: number of bytes to store into packet
+         * @flags: bit 0 - if true, recompute skb->csum
+         *         other bits - reserved
+         * Return: 0 on success
+         */
+        BPF_FUNC_skb_store_bytes,
+
+        /**
+         * l3_csum_replace(skb, offset, from, to, flags) - recompute IP checksum
+         * @skb: pointer to skb
+         * @offset: offset within packet where IP checksum is located
+         * @from: old value of header field
+         * @to: new value of header field
+         * @flags: bits 0-3 - size of header field
+         *         other bits - reserved
+         * Return: 0 on success
+         */
+        BPF_FUNC_l3_csum_replace,
+
+        /**
+         * l4_csum_replace(skb, offset, from, to, flags) - recompute TCP/UDP checksum
+         * @skb: pointer to skb
+         * @offset: offset within packet where TCP/UDP checksum is located
+         * @from: old value of header field
+         * @to: new value of header field
+         * @flags: bits 0-3 - size of header field
+         *         bit 4 - is pseudo header
+         *         other bits - reserved
+         * Return: 0 on success
+         */
+        BPF_FUNC_l4_csum_replace,
+
+        /**
+         * bpf_tail_call(ctx, prog_array_map, index) - jump into another BPF program
+         * @ctx: context pointer passed to next program
+         * @prog_array_map: pointer to map which type is BPF_MAP_TYPE_PROG_ARRAY
+         * @index: index inside array that selects specific program to run
+         * Return: 0 on success
+         */
+        BPF_FUNC_tail_call,
+
+        /**
+         * bpf_clone_redirect(skb, ifindex, flags) - redirect to another netdev
+         * @skb: pointer to skb
+         * @ifindex: ifindex of the net device
+         * @flags: bit 0 - if set, redirect to ingress instead of egress
+         *         other bits - reserved
+         * Return: 0 on success
+         */
+        BPF_FUNC_clone_redirect,
+
+        /**
+         * u64 bpf_get_current_pid_tgid(void)
+         * Return: current->tgid << 32 | current->pid
+         */
+        BPF_FUNC_get_current_pid_tgid,
+
+        /**
+         * u64 bpf_get_current_uid_gid(void)
+         * Return: current_gid << 32 | current_uid
+         */
+        BPF_FUNC_get_current_uid_gid,
+
+        /**
+         * bpf_get_current_comm(char *buf, int size_of_buf)
+         * stores current->comm into buf
+         * Return: 0 on success
+         */
+        BPF_FUNC_get_current_comm,
+
+        /**
+         * bpf_get_cgroup_classid(skb) - retrieve a proc's classid
+         * @skb: pointer to skb
+         * Return: classid if != 0
+         */
+        BPF_FUNC_get_cgroup_classid,
+        BPF_FUNC_skb_vlan_push, /* bpf_skb_vlan_push(skb, vlan_proto, vlan_tci) */
+        BPF_FUNC_skb_vlan_pop,  /* bpf_skb_vlan_pop(skb) */
+
+        /**
+         * bpf_skb_[gs]et_tunnel_key(skb, key, size, flags)
+         * retrieve or populate tunnel metadata
+         * @skb: pointer to skb
+         * @key: pointer to 'struct bpf_tunnel_key'
+         * @size: size of 'struct bpf_tunnel_key'
+         * @flags: room for future extensions
+         * Retrun: 0 on success
+         */
+        BPF_FUNC_skb_get_tunnel_key,
+        BPF_FUNC_skb_set_tunnel_key,
+        BPF_FUNC_perf_event_read,       /* u64 bpf_perf_event_read(&map, index) */
+        /**
+         * bpf_redirect(ifindex, flags) - redirect to another netdev
+         * @ifindex: ifindex of the net device
+         * @flags: bit 0 - if set, redirect to ingress instead of egress
+         *         other bits - reserved
+         * Return: TC_ACT_REDIRECT
+         */
+        BPF_FUNC_redirect,
+
+        /**
+         * bpf_get_route_realm(skb) - retrieve a dst's tclassid
+         * @skb: pointer to skb
+         * Return: realm if != 0
+         */
+        BPF_FUNC_get_route_realm,
+
+        /**
+         * bpf_perf_event_output(ctx, map, index, data, size) - output perf raw sample
+         * @ctx: struct pt_regs*
+         * @map: pointer to perf_event_array map
+         * @index: index of event in the map
+         * @data: data on stack to be output as raw data
+         * @size: size of data
+         * Return: 0 on success
+         */
+        BPF_FUNC_perf_event_output,
+        BPF_FUNC_skb_load_bytes,
+
+        /**
+         * bpf_get_stackid(ctx, map, flags) - walk user or kernel stack and return id
+         * @ctx: struct pt_regs*
+         * @map: pointer to stack_trace map
+         * @flags: bits 0-7 - numer of stack frames to skip
+         *         bit 8 - collect user stack instead of kernel
+         *         bit 9 - compare stacks by hash only
+         *         bit 10 - if two different stacks hash into the same stackid
+         *                  discard old
+         *         other bits - reserved
+         * Return: >= 0 stackid on success or negative error
+         */
+        BPF_FUNC_get_stackid,
+
+        /**
+         * bpf_csum_diff(from, from_size, to, to_size, seed) - calculate csum diff
+         * @from: raw from buffer
+         * @from_size: length of from buffer
+         * @to: raw to buffer
+         * @to_size: length of to buffer
+         * @seed: optional seed
+         * Return: csum result
+         */
+        BPF_FUNC_csum_diff,
+
+        /**
+         * bpf_skb_[gs]et_tunnel_opt(skb, opt, size)
+         * retrieve or populate tunnel options metadata
+         * @skb: pointer to skb
+         * @opt: pointer to raw tunnel option data
+         * @size: size of @opt
+         * Return: 0 on success for set, option size for get
+         */
+        BPF_FUNC_skb_get_tunnel_opt,
+        BPF_FUNC_skb_set_tunnel_opt,
+
+        /**
+         * bpf_skb_change_proto(skb, proto, flags)
+         * Change protocol of the skb. Currently supported is
+         * v4 -> v6, v6 -> v4 transitions. The helper will also
+         * resize the skb. eBPF program is expected to fill the
+         * new headers via skb_store_bytes and lX_csum_replace.
+         * @skb: pointer to skb
+         * @proto: new skb->protocol type
+         * @flags: reserved
+         * Return: 0 on success or negative error
+         */
+        BPF_FUNC_skb_change_proto,
+
+        /**
+         * bpf_skb_change_type(skb, type)
+         * Change packet type of skb.
+         * @skb: pointer to skb
+         * @type: new skb->pkt_type type
+         * Return: 0 on success or negative error
+         */
+        BPF_FUNC_skb_change_type,
+
+        /**
+         * bpf_skb_under_cgroup(skb, map, index) - Check cgroup2 membership of skb
+         * @skb: pointer to skb
+         * @map: pointer to bpf_map in BPF_MAP_TYPE_CGROUP_ARRAY type
+         * @index: index of the cgroup in the bpf_map
+         * Return:
+         *   == 0 skb failed the cgroup2 descendant test
+         *   == 1 skb succeeded the cgroup2 descendant test
+         *    < 0 error
+         */
+        BPF_FUNC_skb_under_cgroup,
+
+        /**
+         * bpf_get_hash_recalc(skb)
+         * Retrieve and possibly recalculate skb->hash.
+         * @skb: pointer to skb
+         * Return: hash
+         */
+        BPF_FUNC_get_hash_recalc,
+
+        /**
+         * u64 bpf_get_current_task(void)
+         * Returns current task_struct
+         * Return: current
+         */
+        BPF_FUNC_get_current_task,
+
+        /**
+         * bpf_probe_write_user(void *dst, void *src, int len)
+         * safely attempt to write to a location
+         * @dst: destination address in userspace
+         * @src: source address on stack
+         * @len: number of bytes to copy
+         * Return: 0 on success or negative error
+         */
+        BPF_FUNC_probe_write_user,
+
+        __BPF_FUNC_MAX_ID,
+};
+
+/* All flags used by eBPF helper functions, placed here. */
+
+/* BPF_FUNC_skb_store_bytes flags. */
+#define BPF_F_RECOMPUTE_CSUM            (1ULL << 0)
+#define BPF_F_INVALIDATE_HASH           (1ULL << 1)
+
+/* BPF_FUNC_l3_csum_replace and BPF_FUNC_l4_csum_replace flags.
+ * First 4 bits are for passing the header field size.
+ */
+#define BPF_F_HDR_FIELD_MASK            0xfULL
+
+/* BPF_FUNC_l4_csum_replace flags. */
+#define BPF_F_PSEUDO_HDR                (1ULL << 4)
+#define BPF_F_MARK_MANGLED_0            (1ULL << 5)
+
+/* BPF_FUNC_clone_redirect and BPF_FUNC_redirect flags. */
+#define BPF_F_INGRESS                   (1ULL << 0)
+
+/* BPF_FUNC_skb_set_tunnel_key and BPF_FUNC_skb_get_tunnel_key flags. */
+#define BPF_F_TUNINFO_IPV6              (1ULL << 0)
+
+/* BPF_FUNC_get_stackid flags. */
+#define BPF_F_SKIP_FIELD_MASK           0xffULL
+#define BPF_F_USER_STACK                (1ULL << 8)
+#define BPF_F_FAST_STACK_CMP            (1ULL << 9)
+#define BPF_F_REUSE_STACKID             (1ULL << 10)
+
+/* BPF_FUNC_skb_set_tunnel_key flags. */
+#define BPF_F_ZERO_CSUM_TX              (1ULL << 1)
+#define BPF_F_DONT_FRAGMENT             (1ULL << 2)
+
+/* BPF_FUNC_perf_event_output and BPF_FUNC_perf_event_read flags. */
+#define BPF_F_INDEX_MASK                0xffffffffULL
+#define BPF_F_CURRENT_CPU               BPF_F_INDEX_MASK
+/* BPF_FUNC_perf_event_output for sk_buff input context. */
+#define BPF_F_CTXLEN_MASK               (0xfffffULL << 32)
+
+/* user accessible mirror of in-kernel sk_buff.
+ * new fields can only be added to the end of this structure
+ */
+struct __sk_buff {
+        __u32 len;
+        __u32 pkt_type;
+        __u32 mark;
+        __u32 queue_mapping;
+        __u32 protocol;
+        __u32 vlan_present;
+        __u32 vlan_tci;
+        __u32 vlan_proto;
+        __u32 priority;
+        __u32 ingress_ifindex;
+        __u32 ifindex;
+        __u32 tc_index;
+        __u32 cb[5];
+        __u32 hash;
+        __u32 tc_classid;
+        __u32 data;
+        __u32 data_end;
+};
+
+struct bpf_tunnel_key {
+        __u32 tunnel_id;
+        union {
+                __u32 remote_ipv4;
+                __u32 remote_ipv6[4];
+        };
+        __u8 tunnel_tos;
+        __u8 tunnel_ttl;
+        __u16 tunnel_ext;
+        __u32 tunnel_label;
+};
+
+/* User return codes for XDP prog type.
+ * A valid XDP program must return one of these defined values. All other
+ * return codes are reserved for future use. Unknown return codes will result
+ * in packet drop.
+ */
+enum xdp_action {
+        XDP_ABORTED = 0,
+        XDP_DROP,
+        XDP_PASS,
+        XDP_TX,
+};
+
+/* user accessible metadata for XDP packet hook
+ * new fields must be added to the end of this structure
+ */
+struct xdp_md {
+        __u32 data;
+        __u32 data_end;
+};
+
+#endif /* _UAPI__LINUX_BPF_H__ */
diff --git a/tools/include/uapi/linux/bpf_common.h b/tools/include/uapi/linux/bpf_common.h
new file mode 100644
index 000000000000..a5c220e0828f
--- /dev/null
+++ b/tools/include/uapi/linux/bpf_common.h
@@ -0,0 +1,55 @@
+#ifndef _UAPI__LINUX_BPF_COMMON_H__
+#define _UAPI__LINUX_BPF_COMMON_H__
+
+/* Instruction classes */
+#define BPF_CLASS(code) ((code) & 0x07)
+#define         BPF_LD          0x00
+#define         BPF_LDX         0x01
+#define         BPF_ST          0x02
+#define         BPF_STX         0x03
+#define         BPF_ALU         0x04
+#define         BPF_JMP         0x05
+#define         BPF_RET         0x06
+#define         BPF_MISC        0x07
+
+/* ld/ldx fields */
+#define BPF_SIZE(code)  ((code) & 0x18)
+#define         BPF_W           0x00
+#define         BPF_H           0x08
+#define         BPF_B           0x10
+#define BPF_MODE(code)  ((code) & 0xe0)
+#define         BPF_IMM         0x00
+#define         BPF_ABS         0x20
+#define         BPF_IND         0x40
+#define         BPF_MEM         0x60
+#define         BPF_LEN         0x80
+#define         BPF_MSH         0xa0
+
+/* alu/jmp fields */
+#define BPF_OP(code)    ((code) & 0xf0)
+#define         BPF_ADD         0x00
+#define         BPF_SUB         0x10
+#define         BPF_MUL         0x20
+#define         BPF_DIV         0x30
+#define         BPF_OR          0x40
+#define         BPF_AND         0x50
+#define         BPF_LSH         0x60
+#define         BPF_RSH         0x70
+#define         BPF_NEG         0x80
+#define         BPF_MOD         0x90
+#define         BPF_XOR         0xa0
+
+#define         BPF_JA          0x00
+#define         BPF_JEQ         0x10
+#define         BPF_JGT         0x20
+#define         BPF_JGE         0x30
+#define         BPF_JSET        0x40
+#define BPF_SRC(code)   ((code) & 0x08)
+#define         BPF_K           0x00
+#define         BPF_X           0x08
+
+#ifndef BPF_MAXINSNS
+#define BPF_MAXINSNS 4096
+#endif
+
+#endif /* _UAPI__LINUX_BPF_COMMON_H__ */
diff --git a/tools/include/uapi/linux/hw_breakpoint.h b/tools/include/uapi/linux/hw_breakpoint.h
new file mode 100644
index 000000000000..b04000a2296a
--- /dev/null
+++ b/tools/include/uapi/linux/hw_breakpoint.h
@@ -0,0 +1,30 @@
+#ifndef _UAPI_LINUX_HW_BREAKPOINT_H
+#define _UAPI_LINUX_HW_BREAKPOINT_H
+
+enum {
+        HW_BREAKPOINT_LEN_1 = 1,
+        HW_BREAKPOINT_LEN_2 = 2,
+        HW_BREAKPOINT_LEN_4 = 4,
+        HW_BREAKPOINT_LEN_8 = 8,
+};
+
+enum {
+        HW_BREAKPOINT_EMPTY     = 0,
+        HW_BREAKPOINT_R         = 1,
+        HW_BREAKPOINT_W         = 2,
+        HW_BREAKPOINT_RW        = HW_BREAKPOINT_R | HW_BREAKPOINT_W,
+        HW_BREAKPOINT_X         = 4,
+        HW_BREAKPOINT_INVALID   = HW_BREAKPOINT_RW | HW_BREAKPOINT_X,
+};
+
+enum bp_type_idx {
+        TYPE_INST       = 0,
+#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
+        TYPE_DATA       = 0,
+#else
+        TYPE_DATA       = 1,
+#endif
+        TYPE_MAX
+};
+
+#endif /* _UAPI_LINUX_HW_BREAKPOINT_H */
diff --git a/tools/include/uapi/linux/mman.h b/tools/include/uapi/linux/mman.h
new file mode 100644
index 000000000000..81d8edf11789
--- /dev/null
+++ b/tools/include/uapi/linux/mman.h
@@ -0,0 +1,13 @@
+#ifndef _UAPI_LINUX_MMAN_H
+#define _UAPI_LINUX_MMAN_H
+
+#include <uapi/asm/mman.h>
+
+#define MREMAP_MAYMOVE  1
+#define MREMAP_FIXED    2
+
+#define OVERCOMMIT_GUESS                0
+#define OVERCOMMIT_ALWAYS               1
+#define OVERCOMMIT_NEVER                2
+
+#endif /* _UAPI_LINUX_MMAN_H */
diff --git a/tools/include/uapi/linux/perf_event.h b/tools/include/uapi/linux/perf_event.h
new file mode 100644
index 000000000000..c66a485a24ac
--- /dev/null
+++ b/tools/include/uapi/linux/perf_event.h
@@ -0,0 +1,983 @@
+/*
+ * Performance events:
+ *
+ *    Copyright (C) 2008-2009, Thomas Gleixner <tglx@linutronix.de>
+ *    Copyright (C) 2008-2011, Red Hat, Inc., Ingo Molnar
+ *    Copyright (C) 2008-2011, Red Hat, Inc., Peter Zijlstra
+ *
+ * Data type definitions, declarations, prototypes.
+ *
+ *    Started by: Thomas Gleixner and Ingo Molnar
+ *
+ * For licencing details see kernel-base/COPYING
+ */
+#ifndef _UAPI_LINUX_PERF_EVENT_H
+#define _UAPI_LINUX_PERF_EVENT_H
+
+#include <linux/types.h>
+#include <linux/ioctl.h>
+#include <asm/byteorder.h>
+
+/*
+ * User-space ABI bits:
+ */
+
+/*
+ * attr.type
+ */
+enum perf_type_id {
+        PERF_TYPE_HARDWARE                      = 0,
+        PERF_TYPE_SOFTWARE                      = 1,
+        PERF_TYPE_TRACEPOINT                    = 2,
+        PERF_TYPE_HW_CACHE                      = 3,
+        PERF_TYPE_RAW                           = 4,
+        PERF_TYPE_BREAKPOINT                    = 5,
+
+        PERF_TYPE_MAX,                          /* non-ABI */
+};
+
+/*
+ * Generalized performance event event_id types, used by the
+ * attr.event_id parameter of the sys_perf_event_open()
+ * syscall:
+ */
+enum perf_hw_id {
+        /*
+         * Common hardware events, generalized by the kernel:
+         */
+        PERF_COUNT_HW_CPU_CYCLES                = 0,
+        PERF_COUNT_HW_INSTRUCTIONS              = 1,
+        PERF_COUNT_HW_CACHE_REFERENCES          = 2,
+        PERF_COUNT_HW_CACHE_MISSES              = 3,
+        PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
+        PERF_COUNT_HW_BRANCH_MISSES             = 5,
+        PERF_COUNT_HW_BUS_CYCLES                = 6,
+        PERF_COUNT_HW_STALLED_CYCLES_FRONTEND   = 7,
+        PERF_COUNT_HW_STALLED_CYCLES_BACKEND    = 8,
+        PERF_COUNT_HW_REF_CPU_CYCLES            = 9,
+
+        PERF_COUNT_HW_MAX,                      /* non-ABI */
+};
+
+/*
+ * Generalized hardware cache events:
+ *
+ *       { L1-D, L1-I, LLC, ITLB, DTLB, BPU, NODE } x
+ *       { read, write, prefetch } x
+ *       { accesses, misses }
+ */
+enum perf_hw_cache_id {
+        PERF_COUNT_HW_CACHE_L1D                 = 0,
+        PERF_COUNT_HW_CACHE_L1I                 = 1,
+        PERF_COUNT_HW_CACHE_LL                  = 2,
+        PERF_COUNT_HW_CACHE_DTLB                = 3,
+        PERF_COUNT_HW_CACHE_ITLB                = 4,
+        PERF_COUNT_HW_CACHE_BPU                 = 5,
+        PERF_COUNT_HW_CACHE_NODE                = 6,
+
+        PERF_COUNT_HW_CACHE_MAX,                /* non-ABI */
+};
+
+enum perf_hw_cache_op_id {
+        PERF_COUNT_HW_CACHE_OP_READ             = 0,
+        PERF_COUNT_HW_CACHE_OP_WRITE            = 1,
+        PERF_COUNT_HW_CACHE_OP_PREFETCH         = 2,
+
+        PERF_COUNT_HW_CACHE_OP_MAX,             /* non-ABI */
+};
+
+enum perf_hw_cache_op_result_id {
+        PERF_COUNT_HW_CACHE_RESULT_ACCESS       = 0,
+        PERF_COUNT_HW_CACHE_RESULT_MISS         = 1,
+
+        PERF_COUNT_HW_CACHE_RESULT_MAX,         /* non-ABI */
+};
+
+/*
+ * Special "software" events provided by the kernel, even if the hardware
+ * does not support performance events. These events measure various
+ * physical and sw events of the kernel (and allow the profiling of them as
+ * well):
+ */
+enum perf_sw_ids {
+        PERF_COUNT_SW_CPU_CLOCK                 = 0,
+        PERF_COUNT_SW_TASK_CLOCK                = 1,
+        PERF_COUNT_SW_PAGE_FAULTS               = 2,
+        PERF_COUNT_SW_CONTEXT_SWITCHES          = 3,
+        PERF_COUNT_SW_CPU_MIGRATIONS            = 4,
+        PERF_COUNT_SW_PAGE_FAULTS_MIN           = 5,
+        PERF_COUNT_SW_PAGE_FAULTS_MAJ           = 6,
+        PERF_COUNT_SW_ALIGNMENT_FAULTS          = 7,
+        PERF_COUNT_SW_EMULATION_FAULTS          = 8,
+        PERF_COUNT_SW_DUMMY                     = 9,
+        PERF_COUNT_SW_BPF_OUTPUT                = 10,
+
+        PERF_COUNT_SW_MAX,                      /* non-ABI */
+};
+
+/*
+ * Bits that can be set in attr.sample_type to request information
+ * in the overflow packets.
+ */
+enum perf_event_sample_format {
+        PERF_SAMPLE_IP                          = 1U << 0,
+        PERF_SAMPLE_TID                         = 1U << 1,
+        PERF_SAMPLE_TIME                        = 1U << 2,
+        PERF_SAMPLE_ADDR                        = 1U << 3,
+        PERF_SAMPLE_READ                        = 1U << 4,
+        PERF_SAMPLE_CALLCHAIN                   = 1U << 5,
+        PERF_SAMPLE_ID                          = 1U << 6,
+        PERF_SAMPLE_CPU                         = 1U << 7,
+        PERF_SAMPLE_PERIOD                      = 1U << 8,
+        PERF_SAMPLE_STREAM_ID                   = 1U << 9,
+        PERF_SAMPLE_RAW                         = 1U << 10,
+        PERF_SAMPLE_BRANCH_STACK                = 1U << 11,
+        PERF_SAMPLE_REGS_USER                   = 1U << 12,
+        PERF_SAMPLE_STACK_USER                  = 1U << 13,
+        PERF_SAMPLE_WEIGHT                      = 1U << 14,
+        PERF_SAMPLE_DATA_SRC                    = 1U << 15,
+        PERF_SAMPLE_IDENTIFIER                  = 1U << 16,
+        PERF_SAMPLE_TRANSACTION                 = 1U << 17,
+        PERF_SAMPLE_REGS_INTR                   = 1U << 18,
+
+        PERF_SAMPLE_MAX = 1U << 19,             /* non-ABI */
+};
+
+/*
+ * values to program into branch_sample_type when PERF_SAMPLE_BRANCH is set
+ *
+ * If the user does not pass priv level information via branch_sample_type,
+ * the kernel uses the event's priv level. Branch and event priv levels do
+ * not have to match. Branch priv level is checked for permissions.
+ *
+ * The branch types can be combined, however BRANCH_ANY covers all types
+ * of branches and therefore it supersedes all the other types.
+ */
+enum perf_branch_sample_type_shift {
+        PERF_SAMPLE_BRANCH_USER_SHIFT           = 0, /* user branches */
+        PERF_SAMPLE_BRANCH_KERNEL_SHIFT         = 1, /* kernel branches */
+        PERF_SAMPLE_BRANCH_HV_SHIFT             = 2, /* hypervisor branches */
+
+        PERF_SAMPLE_BRANCH_ANY_SHIFT            = 3, /* any branch types */
+        PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT       = 4, /* any call branch */
+        PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT     = 5, /* any return branch */
+        PERF_SAMPLE_BRANCH_IND_CALL_SHIFT       = 6, /* indirect calls */
+        PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT       = 7, /* transaction aborts */
+        PERF_SAMPLE_BRANCH_IN_TX_SHIFT          = 8, /* in transaction */
+        PERF_SAMPLE_BRANCH_NO_TX_SHIFT          = 9, /* not in transaction */
+        PERF_SAMPLE_BRANCH_COND_SHIFT           = 10, /* conditional branches */
+
+        PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT     = 11, /* call/ret stack */
+        PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT       = 12, /* indirect jumps */
+        PERF_SAMPLE_BRANCH_CALL_SHIFT           = 13, /* direct call */
+
+        PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT       = 14, /* no flags */
+        PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT      = 15, /* no cycles */
+
+        PERF_SAMPLE_BRANCH_MAX_SHIFT            /* non-ABI */
+};
+
+enum perf_branch_sample_type {
+        PERF_SAMPLE_BRANCH_USER         = 1U << PERF_SAMPLE_BRANCH_USER_SHIFT,
+        PERF_SAMPLE_BRANCH_KERNEL       = 1U << PERF_SAMPLE_BRANCH_KERNEL_SHIFT,
+        PERF_SAMPLE_BRANCH_HV           = 1U << PERF_SAMPLE_BRANCH_HV_SHIFT,
+
+        PERF_SAMPLE_BRANCH_ANY          = 1U << PERF_SAMPLE_BRANCH_ANY_SHIFT,
+        PERF_SAMPLE_BRANCH_ANY_CALL     = 1U << PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT,
+        PERF_SAMPLE_BRANCH_ANY_RETURN   = 1U << PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT,
+        PERF_SAMPLE_BRANCH_IND_CALL     = 1U << PERF_SAMPLE_BRANCH_IND_CALL_SHIFT,
+        PERF_SAMPLE_BRANCH_ABORT_TX     = 1U << PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT,
+        PERF_SAMPLE_BRANCH_IN_TX        = 1U << PERF_SAMPLE_BRANCH_IN_TX_SHIFT,
+        PERF_SAMPLE_BRANCH_NO_TX        = 1U << PERF_SAMPLE_BRANCH_NO_TX_SHIFT,
+        PERF_SAMPLE_BRANCH_COND         = 1U << PERF_SAMPLE_BRANCH_COND_SHIFT,
+
+        PERF_SAMPLE_BRANCH_CALL_STACK   = 1U << PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT,
+        PERF_SAMPLE_BRANCH_IND_JUMP     = 1U << PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT,
+        PERF_SAMPLE_BRANCH_CALL         = 1U << PERF_SAMPLE_BRANCH_CALL_SHIFT,
+
+        PERF_SAMPLE_BRANCH_NO_FLAGS     = 1U << PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT,
+        PERF_SAMPLE_BRANCH_NO_CYCLES    = 1U << PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT,
+
+        PERF_SAMPLE_BRANCH_MAX          = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT,
+};
+
+#define PERF_SAMPLE_BRANCH_PLM_ALL \
+        (PERF_SAMPLE_BRANCH_USER|\
+         PERF_SAMPLE_BRANCH_KERNEL|\
+         PERF_SAMPLE_BRANCH_HV)
+
+/*
+ * Values to determine ABI of the registers dump.
+ */
+enum perf_sample_regs_abi {
+        PERF_SAMPLE_REGS_ABI_NONE       = 0,
+        PERF_SAMPLE_REGS_ABI_32         = 1,
+        PERF_SAMPLE_REGS_ABI_64         = 2,
+};
+
+/*
+ * Values for the memory transaction event qualifier, mostly for
+ * abort events. Multiple bits can be set.
+ */
+enum {
+        PERF_TXN_ELISION        = (1 << 0), /* From elision */
+        PERF_TXN_TRANSACTION    = (1 << 1), /* From transaction */
+        PERF_TXN_SYNC           = (1 << 2), /* Instruction is related */
+        PERF_TXN_ASYNC          = (1 << 3), /* Instruction not related */
+        PERF_TXN_RETRY          = (1 << 4), /* Retry possible */
+        PERF_TXN_CONFLICT       = (1 << 5), /* Conflict abort */
+        PERF_TXN_CAPACITY_WRITE = (1 << 6), /* Capacity write abort */
+        PERF_TXN_CAPACITY_READ  = (1 << 7), /* Capacity read abort */
+
+        PERF_TXN_MAX            = (1 << 8), /* non-ABI */
+
+        /* bits 32..63 are reserved for the abort code */
+
+        PERF_TXN_ABORT_MASK  = (0xffffffffULL << 32),
+        PERF_TXN_ABORT_SHIFT = 32,
+};
+
+/*
+ * The format of the data returned by read() on a perf event fd,
+ * as specified by attr.read_format:
+ *
+ * struct read_format {
+ *      { u64           value;
+ *        { u64         time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
+ *        { u64         id;           } && PERF_FORMAT_ID
+ *      } && !PERF_FORMAT_GROUP
+ *
+ *      { u64           nr;
+ *        { u64         time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
+ *        { u64         time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
+ *        { u64         value;
+ *          { u64       id;           } && PERF_FORMAT_ID
+ *        }             cntr[nr];
+ *      } && PERF_FORMAT_GROUP
+ * };
+ */
+enum perf_event_read_format {
+        PERF_FORMAT_TOTAL_TIME_ENABLED          = 1U << 0,
+        PERF_FORMAT_TOTAL_TIME_RUNNING          = 1U << 1,
+        PERF_FORMAT_ID                          = 1U << 2,
+        PERF_FORMAT_GROUP                       = 1U << 3,
+
+        PERF_FORMAT_MAX = 1U << 4,              /* non-ABI */
+};
+
+#define PERF_ATTR_SIZE_VER0     64      /* sizeof first published struct */
+#define PERF_ATTR_SIZE_VER1     72      /* add: config2 */
+#define PERF_ATTR_SIZE_VER2     80      /* add: branch_sample_type */
+#define PERF_ATTR_SIZE_VER3     96      /* add: sample_regs_user */
+                                        /* add: sample_stack_user */
+#define PERF_ATTR_SIZE_VER4     104     /* add: sample_regs_intr */
+#define PERF_ATTR_SIZE_VER5     112     /* add: aux_watermark */
+
+/*
+ * Hardware event_id to monitor via a performance monitoring event:
+ *
+ * @sample_max_stack: Max number of frame pointers in a callchain,
+ *                    should be < /proc/sys/kernel/perf_event_max_stack
+ */
+struct perf_event_attr {
+
+        /*
+         * Major type: hardware/software/tracepoint/etc.
+         */
+        __u32                   type;
+
+        /*
+         * Size of the attr structure, for fwd/bwd compat.
+         */
+        __u32                   size;
+
+        /*
+         * Type specific configuration information.
+         */
+        __u64                   config;
+
+        union {
+                __u64           sample_period;
+                __u64           sample_freq;
+        };
+
+        __u64                   sample_type;
+        __u64                   read_format;
+
+        __u64                   disabled       :  1, /* off by default        */
+                                inherit        :  1, /* children inherit it   */
+                                pinned         :  1, /* must always be on PMU */
+                                exclusive      :  1, /* only group on PMU     */
+                                exclude_user   :  1, /* don't count user      */
+                                exclude_kernel :  1, /* ditto kernel          */
+                                exclude_hv     :  1, /* ditto hypervisor      */
+                                exclude_idle   :  1, /* don't count when idle */
+                                mmap           :  1, /* include mmap data     */
+                                comm           :  1, /* include comm data     */
+                                freq           :  1, /* use freq, not period  */
+                                inherit_stat   :  1, /* per task counts       */
+                                enable_on_exec :  1, /* next exec enables     */
+                                task           :  1, /* trace fork/exit       */
+                                watermark      :  1, /* wakeup_watermark      */
+                                /*
+                                 * precise_ip:
+                                 *
+                                 *  0 - SAMPLE_IP can have arbitrary skid
+                                 *  1 - SAMPLE_IP must have constant skid
+                                 *  2 - SAMPLE_IP requested to have 0 skid
+                                 *  3 - SAMPLE_IP must have 0 skid
+                                 *
+                                 *  See also PERF_RECORD_MISC_EXACT_IP
+                                 */
+                                precise_ip     :  2, /* skid constraint       */
+                                mmap_data      :  1, /* non-exec mmap data    */
+                                sample_id_all  :  1, /* sample_type all events */
+
+                                exclude_host   :  1, /* don't count in host   */
+                                exclude_guest  :  1, /* don't count in guest  */
+
+                                exclude_callchain_kernel : 1, /* exclude kernel callchains */
+                                exclude_callchain_user   : 1, /* exclude user callchains */
+                                mmap2          :  1, /* include mmap with inode data     */
+                                comm_exec      :  1, /* flag comm events that are due to an exec */
+                                use_clockid    :  1, /* use @clockid for time fields */
+                                context_switch :  1, /* context switch data */
+                                write_backward :  1, /* Write ring buffer from end to beginning */
+                                __reserved_1   : 36;
+
+        union {
+                __u32           wakeup_events;    /* wakeup every n events */
+                __u32           wakeup_watermark; /* bytes before wakeup   */
+        };
+
+        __u32                   bp_type;
+        union {
+                __u64           bp_addr;
+                __u64           config1; /* extension of config */
+        };
+        union {
+                __u64           bp_len;
+                __u64           config2; /* extension of config1 */
+        };
+        __u64   branch_sample_type; /* enum perf_branch_sample_type */
+
+        /*
+         * Defines set of user regs to dump on samples.
+         * See asm/perf_regs.h for details.
+         */
+        __u64   sample_regs_user;
+
+        /*
+         * Defines size of the user stack to dump on samples.
+         */
+        __u32   sample_stack_user;
+
+        __s32   clockid;
+        /*
+         * Defines set of regs to dump for each sample
+         * state captured on:
+         *  - precise = 0: PMU interrupt
+         *  - precise > 0: sampled instruction
+         *
+         * See asm/perf_regs.h for details.
+         */
+        __u64   sample_regs_intr;
+
+        /*
+         * Wakeup watermark for AUX area
+         */
+        __u32   aux_watermark;
+        __u16   sample_max_stack;
+        __u16   __reserved_2;   /* align to __u64 */
+};
+
+#define perf_flags(attr)        (*(&(attr)->read_format + 1))
+
+/*
+ * Ioctls that can be done on a perf event fd:
+ */
+#define PERF_EVENT_IOC_ENABLE           _IO ('$', 0)
+#define PERF_EVENT_IOC_DISABLE          _IO ('$', 1)
+#define PERF_EVENT_IOC_REFRESH          _IO ('$', 2)
+#define PERF_EVENT_IOC_RESET            _IO ('$', 3)
+#define PERF_EVENT_IOC_PERIOD           _IOW('$', 4, __u64)
+#define PERF_EVENT_IOC_SET_OUTPUT       _IO ('$', 5)
+#define PERF_EVENT_IOC_SET_FILTER       _IOW('$', 6, char *)
+#define PERF_EVENT_IOC_ID               _IOR('$', 7, __u64 *)
+#define PERF_EVENT_IOC_SET_BPF          _IOW('$', 8, __u32)
+#define PERF_EVENT_IOC_PAUSE_OUTPUT     _IOW('$', 9, __u32)
+
+enum perf_event_ioc_flags {
+        PERF_IOC_FLAG_GROUP             = 1U << 0,
+};
+
+/*
+ * Structure of the page that can be mapped via mmap
+ */
+struct perf_event_mmap_page {
+        __u32   version;                /* version number of this structure */
+        __u32   compat_version;         /* lowest version this is compat with */
+
+        /*
+         * Bits needed to read the hw events in user-space.
+         *
+         *   u32 seq, time_mult, time_shift, index, width;
+         *   u64 count, enabled, running;
+         *   u64 cyc, time_offset;
+         *   s64 pmc = 0;
+         *
+         *   do {
+         *     seq = pc->lock;
+         *     barrier()
+         *
+         *     enabled = pc->time_enabled;
+         *     running = pc->time_running;
+         *
+         *     if (pc->cap_usr_time && enabled != running) {
+         *       cyc = rdtsc();
+         *       time_offset = pc->time_offset;
+         *       time_mult   = pc->time_mult;
+         *       time_shift  = pc->time_shift;
+         *     }
+         *
+         *     index = pc->index;
+         *     count = pc->offset;
+         *     if (pc->cap_user_rdpmc && index) {
+         *       width = pc->pmc_width;
+         *       pmc = rdpmc(index - 1);
+         *     }
+         *
+         *     barrier();
+         *   } while (pc->lock != seq);
+         *
+         * NOTE: for obvious reason this only works on self-monitoring
+         *       processes.
+         */
+        __u32   lock;                   /* seqlock for synchronization */
+        __u32   index;                  /* hardware event identifier */
+        __s64   offset;                 /* add to hardware event value */
+        __u64   time_enabled;           /* time event active */
+        __u64   time_running;           /* time event on cpu */
+        union {
+                __u64   capabilities;
+                struct {
+                        __u64   cap_bit0                : 1, /* Always 0, deprecated, see commit 860f085b74e9 */
+                                cap_bit0_is_deprecated  : 1, /* Always 1, signals that bit 0 is zero */
+
+                                cap_user_rdpmc          : 1, /* The RDPMC instruction can be used to read counts */
+                                cap_user_time           : 1, /* The time_* fields are used */
+                                cap_user_time_zero      : 1, /* The time_zero field is used */
+                                cap_____res             : 59;
+                };
+        };
+
+        /*
+         * If cap_user_rdpmc this field provides the bit-width of the value
+         * read using the rdpmc() or equivalent instruction. This can be used
+         * to sign extend the result like:
+         *
+         *   pmc <<= 64 - width;
+         *   pmc >>= 64 - width; // signed shift right
+         *   count += pmc;
+         */
+        __u16   pmc_width;
+
+        /*
+         * If cap_usr_time the below fields can be used to compute the time
+         * delta since time_enabled (in ns) using rdtsc or similar.
+         *
+         *   u64 quot, rem;
+         *   u64 delta;
+         *
+         *   quot = (cyc >> time_shift);
+         *   rem = cyc & (((u64)1 << time_shift) - 1);
+         *   delta = time_offset + quot * time_mult +
+         *              ((rem * time_mult) >> time_shift);
+         *
+         * Where time_offset,time_mult,time_shift and cyc are read in the
+         * seqcount loop described above. This delta can then be added to
+         * enabled and possible running (if index), improving the scaling:
+         *
+         *   enabled += delta;
+         *   if (index)
+         *     running += delta;
+         *
+         *   quot = count / running;
+         *   rem  = count % running;
+         *   count = quot * enabled + (rem * enabled) / running;
+         */
+        __u16   time_shift;
+        __u32   time_mult;
+        __u64   time_offset;
+        /*
+         * If cap_usr_time_zero, the hardware clock (e.g. TSC) can be calculated
+         * from sample timestamps.
+         *
+         *   time = timestamp - time_zero;
+         *   quot = time / time_mult;
+         *   rem  = time % time_mult;
+         *   cyc = (quot << time_shift) + (rem << time_shift) / time_mult;
+         *
+         * And vice versa:
+         *
+         *   quot = cyc >> time_shift;
+         *   rem  = cyc & (((u64)1 << time_shift) - 1);
+         *   timestamp = time_zero + quot * time_mult +
+         *               ((rem * time_mult) >> time_shift);
+         */
+        __u64   time_zero;
+        __u32   size;                   /* Header size up to __reserved[] fields. */
+
+                /*
+                 * Hole for extension of the self monitor capabilities
+                 */
+
+        __u8    __reserved[118*8+4];    /* align to 1k. */
+
+        /*
+         * Control data for the mmap() data buffer.
+         *
+         * User-space reading the @data_head value should issue an smp_rmb(),
+         * after reading this value.
+         *
+         * When the mapping is PROT_WRITE the @data_tail value should be
+         * written by userspace to reflect the last read data, after issueing
+         * an smp_mb() to separate the data read from the ->data_tail store.
+         * In this case the kernel will not over-write unread data.
+         *
+         * See perf_output_put_handle() for the data ordering.
+         *
+         * data_{offset,size} indicate the location and size of the perf record
+         * buffer within the mmapped area.
+         */
+        __u64   data_head;              /* head in the data section */
+        __u64   data_tail;              /* user-space written tail */
+        __u64   data_offset;            /* where the buffer starts */
+        __u64   data_size;              /* data buffer size */
+
+        /*
+         * AUX area is defined by aux_{offset,size} fields that should be set
+         * by the userspace, so that
+         *
+         *   aux_offset >= data_offset + data_size
+         *
+         * prior to mmap()ing it. Size of the mmap()ed area should be aux_size.
+         *
+         * Ring buffer pointers aux_{head,tail} have the same semantics as
+         * data_{head,tail} and same ordering rules apply.
+         */
+        __u64   aux_head;
+        __u64   aux_tail;
+        __u64   aux_offset;
+        __u64   aux_size;
+};
+
+#define PERF_RECORD_MISC_CPUMODE_MASK           (7 << 0)
+#define PERF_RECORD_MISC_CPUMODE_UNKNOWN        (0 << 0)
+#define PERF_RECORD_MISC_KERNEL                 (1 << 0)
+#define PERF_RECORD_MISC_USER                   (2 << 0)
+#define PERF_RECORD_MISC_HYPERVISOR             (3 << 0)
+#define PERF_RECORD_MISC_GUEST_KERNEL           (4 << 0)
+#define PERF_RECORD_MISC_GUEST_USER             (5 << 0)
+
+/*
+ * Indicates that /proc/PID/maps parsing are truncated by time out.
+ */
+#define PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT (1 << 12)
+/*
+ * PERF_RECORD_MISC_MMAP_DATA and PERF_RECORD_MISC_COMM_EXEC are used on
+ * different events so can reuse the same bit position.
+ * Ditto PERF_RECORD_MISC_SWITCH_OUT.
+ */
+#define PERF_RECORD_MISC_MMAP_DATA              (1 << 13)
+#define PERF_RECORD_MISC_COMM_EXEC              (1 << 13)
+#define PERF_RECORD_MISC_SWITCH_OUT             (1 << 13)
+/*
+ * Indicates that the content of PERF_SAMPLE_IP points to
+ * the actual instruction that triggered the event. See also
+ * perf_event_attr::precise_ip.
+ */
+#define PERF_RECORD_MISC_EXACT_IP               (1 << 14)
+/*
+ * Reserve the last bit to indicate some extended misc field
+ */
+#define PERF_RECORD_MISC_EXT_RESERVED           (1 << 15)
+
+struct perf_event_header {
+        __u32   type;
+        __u16   misc;
+        __u16   size;
+};
+
+enum perf_event_type {
+
+        /*
+         * If perf_event_attr.sample_id_all is set then all event types will
+         * have the sample_type selected fields related to where/when
+         * (identity) an event took place (TID, TIME, ID, STREAM_ID, CPU,
+         * IDENTIFIER) described in PERF_RECORD_SAMPLE below, it will be stashed
+         * just after the perf_event_header and the fields already present for
+         * the existing fields, i.e. at the end of the payload. That way a newer
+         * perf.data file will be supported by older perf tools, with these new
+         * optional fields being ignored.
+         *
+         * struct sample_id {
+         *      { u32                   pid, tid; } && PERF_SAMPLE_TID
+         *      { u64                   time;     } && PERF_SAMPLE_TIME
+         *      { u64                   id;       } && PERF_SAMPLE_ID
+         *      { u64                   stream_id;} && PERF_SAMPLE_STREAM_ID
+         *      { u32                   cpu, res; } && PERF_SAMPLE_CPU
+         *      { u64                   id;       } && PERF_SAMPLE_IDENTIFIER
+         * } && perf_event_attr::sample_id_all
+         *
+         * Note that PERF_SAMPLE_IDENTIFIER duplicates PERF_SAMPLE_ID.  The
+         * advantage of PERF_SAMPLE_IDENTIFIER is that its position is fixed
+         * relative to header.size.
+         */
+
+        /*
+         * The MMAP events record the PROT_EXEC mappings so that we can
+         * correlate userspace IPs to code. They have the following structure:
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      u64                             addr;
+         *      u64                             len;
+         *      u64                             pgoff;
+         *      char                            filename[];
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_MMAP                        = 1,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u64                             id;
+         *      u64                             lost;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_LOST                        = 2,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      char                            comm[];
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_COMM                        = 3,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, ppid;
+         *      u32                             tid, ptid;
+         *      u64                             time;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_EXIT                        = 4,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u64                             time;
+         *      u64                             id;
+         *      u64                             stream_id;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_THROTTLE                    = 5,
+        PERF_RECORD_UNTHROTTLE                  = 6,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, ppid;
+         *      u32                             tid, ptid;
+         *      u64                             time;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_FORK                        = 7,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid, tid;
+         *
+         *      struct read_format              values;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_READ                        = 8,
+
+        /*
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      #
+         *      # Note that PERF_SAMPLE_IDENTIFIER duplicates PERF_SAMPLE_ID.
+         *      # The advantage of PERF_SAMPLE_IDENTIFIER is that its position
+         *      # is fixed relative to header.
+         *      #
+         *
+         *      { u64                   id;       } && PERF_SAMPLE_IDENTIFIER
+         *      { u64                   ip;       } && PERF_SAMPLE_IP
+         *      { u32                   pid, tid; } && PERF_SAMPLE_TID
+         *      { u64                   time;     } && PERF_SAMPLE_TIME
+         *      { u64                   addr;     } && PERF_SAMPLE_ADDR
+         *      { u64                   id;       } && PERF_SAMPLE_ID
+         *      { u64                   stream_id;} && PERF_SAMPLE_STREAM_ID
+         *      { u32                   cpu, res; } && PERF_SAMPLE_CPU
+         *      { u64                   period;   } && PERF_SAMPLE_PERIOD
+         *
+         *      { struct read_format    values;   } && PERF_SAMPLE_READ
+         *
+         *      { u64                   nr,
+         *        u64                   ips[nr];  } && PERF_SAMPLE_CALLCHAIN
+         *
+         *      #
+         *      # The RAW record below is opaque data wrt the ABI
+         *      #
+         *      # That is, the ABI doesn't make any promises wrt to
+         *      # the stability of its content, it may vary depending
+         *      # on event, hardware, kernel version and phase of
+         *      # the moon.
+         *      #
+         *      # In other words, PERF_SAMPLE_RAW contents are not an ABI.
+         *      #
+         *
+         *      { u32                   size;
+         *        char                  data[size];}&& PERF_SAMPLE_RAW
+         *
+         *      { u64                   nr;
+         *        { u64 from, to, flags } lbr[nr];} && PERF_SAMPLE_BRANCH_STACK
+         *
+         *      { u64                   abi; # enum perf_sample_regs_abi
+         *        u64                   regs[weight(mask)]; } && PERF_SAMPLE_REGS_USER
+         *
+         *      { u64                   size;
+         *        char                  data[size];
+         *        u64                   dyn_size; } && PERF_SAMPLE_STACK_USER
+         *
+         *      { u64                   weight;   } && PERF_SAMPLE_WEIGHT
+         *      { u64                   data_src; } && PERF_SAMPLE_DATA_SRC
+         *      { u64                   transaction; } && PERF_SAMPLE_TRANSACTION
+         *      { u64                   abi; # enum perf_sample_regs_abi
+         *        u64                   regs[weight(mask)]; } && PERF_SAMPLE_REGS_INTR
+         * };
+         */
+        PERF_RECORD_SAMPLE                      = 9,
+
+        /*
+         * The MMAP2 records are an augmented version of MMAP, they add
+         * maj, min, ino numbers to be used to uniquely identify each mapping
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u32                             pid, tid;
+         *      u64                             addr;
+         *      u64                             len;
+         *      u64                             pgoff;
+         *      u32                             maj;
+         *      u32                             min;
+         *      u64                             ino;
+         *      u64                             ino_generation;
+         *      u32                             prot, flags;
+         *      char                            filename[];
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_MMAP2                       = 10,
+
+        /*
+         * Records that new data landed in the AUX buffer part.
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u64                             aux_offset;
+         *      u64                             aux_size;
+         *      u64                             flags;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_AUX                         = 11,
+
+        /*
+         * Indicates that instruction trace has started
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             pid;
+         *      u32                             tid;
+         * };
+         */
+        PERF_RECORD_ITRACE_START                = 12,
+
+        /*
+         * Records the dropped/lost sample number.
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *
+         *      u64                             lost;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_LOST_SAMPLES                = 13,
+
+        /*
+         * Records a context switch in or out (flagged by
+         * PERF_RECORD_MISC_SWITCH_OUT). See also
+         * PERF_RECORD_SWITCH_CPU_WIDE.
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_SWITCH                      = 14,
+
+        /*
+         * CPU-wide version of PERF_RECORD_SWITCH with next_prev_pid and
+         * next_prev_tid that are the next (switching out) or previous
+         * (switching in) pid/tid.
+         *
+         * struct {
+         *      struct perf_event_header        header;
+         *      u32                             next_prev_pid;
+         *      u32                             next_prev_tid;
+         *      struct sample_id                sample_id;
+         * };
+         */
+        PERF_RECORD_SWITCH_CPU_WIDE             = 15,
+
+        PERF_RECORD_MAX,                        /* non-ABI */
+};
+
+#define PERF_MAX_STACK_DEPTH            127
+#define PERF_MAX_CONTEXTS_PER_STACK       8
+
+enum perf_callchain_context {
+        PERF_CONTEXT_HV                 = (__u64)-32,
+        PERF_CONTEXT_KERNEL             = (__u64)-128,
+        PERF_CONTEXT_USER               = (__u64)-512,
+
+        PERF_CONTEXT_GUEST              = (__u64)-2048,
+        PERF_CONTEXT_GUEST_KERNEL       = (__u64)-2176,
+        PERF_CONTEXT_GUEST_USER         = (__u64)-2560,
+
+        PERF_CONTEXT_MAX                = (__u64)-4095,
+};
+
+/**
+ * PERF_RECORD_AUX::flags bits
+ */
+#define PERF_AUX_FLAG_TRUNCATED         0x01    /* record was truncated to fit */
+#define PERF_AUX_FLAG_OVERWRITE         0x02    /* snapshot from overwrite mode */
+
+#define PERF_FLAG_FD_NO_GROUP           (1UL << 0)
+#define PERF_FLAG_FD_OUTPUT             (1UL << 1)
+#define PERF_FLAG_PID_CGROUP            (1UL << 2) /* pid=cgroup id, per-cpu mode only */
+#define PERF_FLAG_FD_CLOEXEC            (1UL << 3) /* O_CLOEXEC */
+
+union perf_mem_data_src {
+        __u64 val;
+        struct {
+                __u64   mem_op:5,       /* type of opcode */
+                        mem_lvl:14,     /* memory hierarchy level */
+                        mem_snoop:5,    /* snoop mode */
+                        mem_lock:2,     /* lock instr */
+                        mem_dtlb:7,     /* tlb access */
+                        mem_rsvd:31;
+        };
+};
+
+/* type of opcode (load/store/prefetch,code) */
+#define PERF_MEM_OP_NA          0x01 /* not available */
+#define PERF_MEM_OP_LOAD        0x02 /* load instruction */
+#define PERF_MEM_OP_STORE       0x04 /* store instruction */
+#define PERF_MEM_OP_PFETCH      0x08 /* prefetch */
+#define PERF_MEM_OP_EXEC        0x10 /* code (execution) */
+#define PERF_MEM_OP_SHIFT       0
+
+/* memory hierarchy (memory level, hit or miss) */
+#define PERF_MEM_LVL_NA         0x01  /* not available */
+#define PERF_MEM_LVL_HIT        0x02  /* hit level */
+#define PERF_MEM_LVL_MISS       0x04  /* miss level  */
+#define PERF_MEM_LVL_L1         0x08  /* L1 */
+#define PERF_MEM_LVL_LFB        0x10  /* Line Fill Buffer */
+#define PERF_MEM_LVL_L2         0x20  /* L2 */
+#define PERF_MEM_LVL_L3         0x40  /* L3 */
+#define PERF_MEM_LVL_LOC_RAM    0x80  /* Local DRAM */
+#define PERF_MEM_LVL_REM_RAM1   0x100 /* Remote DRAM (1 hop) */
+#define PERF_MEM_LVL_REM_RAM2   0x200 /* Remote DRAM (2 hops) */
+#define PERF_MEM_LVL_REM_CCE1   0x400 /* Remote Cache (1 hop) */
+#define PERF_MEM_LVL_REM_CCE2   0x800 /* Remote Cache (2 hops) */
+#define PERF_MEM_LVL_IO         0x1000 /* I/O memory */
+#define PERF_MEM_LVL_UNC        0x2000 /* Uncached memory */
+#define PERF_MEM_LVL_SHIFT      5
+
+/* snoop mode */
+#define PERF_MEM_SNOOP_NA       0x01 /* not available */
+#define PERF_MEM_SNOOP_NONE     0x02 /* no snoop */
+#define PERF_MEM_SNOOP_HIT      0x04 /* snoop hit */
+#define PERF_MEM_SNOOP_MISS     0x08 /* snoop miss */
+#define PERF_MEM_SNOOP_HITM     0x10 /* snoop hit modified */
+#define PERF_MEM_SNOOP_SHIFT    19
+
+/* locked instruction */
+#define PERF_MEM_LOCK_NA        0x01 /* not available */
+#define PERF_MEM_LOCK_LOCKED    0x02 /* locked transaction */
+#define PERF_MEM_LOCK_SHIFT     24
+
+/* TLB access */
+#define PERF_MEM_TLB_NA         0x01 /* not available */
+#define PERF_MEM_TLB_HIT        0x02 /* hit level */
+#define PERF_MEM_TLB_MISS       0x04 /* miss level */
+#define PERF_MEM_TLB_L1         0x08 /* L1 */
+#define PERF_MEM_TLB_L2         0x10 /* L2 */
+#define PERF_MEM_TLB_WK         0x20 /* Hardware Walker*/
+#define PERF_MEM_TLB_OS         0x40 /* OS fault handler */
+#define PERF_MEM_TLB_SHIFT      26
+
+#define PERF_MEM_S(a, s) \
+        (((__u64)PERF_MEM_##a##_##s) << PERF_MEM_##a##_SHIFT)
+
+/*
+ * single taken branch record layout:
+ *
+ *      from: source instruction (may not always be a branch insn)
+ *        to: branch target
+ *   mispred: branch target was mispredicted
+ * predicted: branch target was predicted
+ *
+ * support for mispred, predicted is optional. In case it
+ * is not supported mispred = predicted = 0.
+ *
+ *     in_tx: running in a hardware transaction
+ *     abort: aborting a hardware transaction
+ *    cycles: cycles from last branch (or 0 if not supported)
+ */
+struct perf_branch_entry {
+        __u64   from;
+        __u64   to;
+        __u64   mispred:1,  /* target mispredicted */
+                predicted:1,/* target predicted */
+                in_tx:1,    /* in transaction */
+                abort:1,    /* transaction abort */
+                cycles:16,  /* cycle count to last branch */
+                reserved:44;
+};
+
+#endif /* _UAPI_LINUX_PERF_EVENT_H */
diff --git a/tools/laptop/dslm/.gitignore b/tools/laptop/dslm/.gitignore
new file mode 100644
index 000000000000..9fc984e64386
--- /dev/null
+++ b/tools/laptop/dslm/.gitignore
@@ -0,0 +1 @@
+dslm
diff --git a/tools/laptop/dslm/Makefile b/tools/laptop/dslm/Makefile
new file mode 100644
index 000000000000..ff613b31730b
--- /dev/null
+++ b/tools/laptop/dslm/Makefile
@@ -0,0 +1,9 @@
+CC := $(CROSS_COMPILE)gcc
+CFLAGS := -I../../usr/include
+
+PROGS := dslm
+
+all: $(PROGS)
+
+clean:
+        rm -fr $(PROGS)
diff --git a/tools/laptop/dslm/dslm.c b/tools/laptop/dslm/dslm.c
new file mode 100644
index 000000000000..d5dd2d4b04d8
--- /dev/null
+++ b/tools/laptop/dslm/dslm.c
@@ -0,0 +1,166 @@
+/*
+ * dslm.c
+ * Simple Disk Sleep Monitor
+ *  by Bartek Kania
+ * Licensed under the GPL
+ */
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <time.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <linux/hdreg.h>
+
+#ifdef DEBUG
+#define D(x) x
+#else
+#define D(x)
+#endif
+
+int endit = 0;
+
+/* Check if the disk is in powersave-mode
+ * Most of the code is stolen from hdparm.
+ * 1 = active, 0 = standby/sleep, -1 = unknown */
+static int check_powermode(int fd)
+{
+    unsigned char args[4] = {WIN_CHECKPOWERMODE1,0,0,0};
+    int state;
+
+    if (ioctl(fd, HDIO_DRIVE_CMD, &args)
+        && (args[0] = WIN_CHECKPOWERMODE2) /* try again with 0x98 */
+        && ioctl(fd, HDIO_DRIVE_CMD, &args)) {
+        if (errno != EIO || args[0] != 0 || args[1] != 0) {
+            state = -1; /* "unknown"; */
+        } else
+            state = 0; /* "sleeping"; */
+    } else {
+        state = (args[2] == 255) ? 1 : 0;
+    }
+    D(printf(" drive state is:  %d\n", state));
+
+    return state;
+}
+
+static char *state_name(int i)
+{
+    if (i == -1) return "unknown";
+    if (i == 0) return "sleeping";
+    if (i == 1) return "active";
+
+    return "internal error";
+}
+
+static char *myctime(time_t time)
+{
+    char *ts = ctime(&time);
+    ts[strlen(ts) - 1] = 0;
+
+    return ts;
+}
+
+static void measure(int fd)
+{
+    time_t start_time;
+    int last_state;
+    time_t last_time;
+    int curr_state;
+    time_t curr_time = 0;
+    time_t time_diff;
+    time_t active_time = 0;
+    time_t sleep_time = 0;
+    time_t unknown_time = 0;
+    time_t total_time = 0;
+    int changes = 0;
+    float tmp;
+
+    printf("Starting measurements\n");
+
+    last_state = check_powermode(fd);
+    start_time = last_time = time(0);
+    printf("  System is in state %s\n\n", state_name(last_state));
+
+    while(!endit) {
+        sleep(1);
+        curr_state = check_powermode(fd);
+
+        if (curr_state != last_state || endit) {
+            changes++;
+            curr_time = time(0);
+            time_diff = curr_time - last_time;
+
+            if (last_state == 1) active_time += time_diff;
+            else if (last_state == 0) sleep_time += time_diff;
+            else unknown_time += time_diff;
+
+            last_state = curr_state;
+            last_time = curr_time;
+
+            printf("%s: State-change to %s\n", myctime(curr_time),
+                   state_name(curr_state));
+        }
+    }
+    changes--; /* Compensate for SIGINT */
+
+    total_time = time(0) - start_time;
+    printf("\nTotal running time:  %lus\n", curr_time - start_time);
+    printf(" State changed %d times\n", changes);
+
+    tmp = (float)sleep_time / (float)total_time * 100;
+    printf(" Time in sleep state:   %lus (%.2f%%)\n", sleep_time, tmp);
+    tmp = (float)active_time / (float)total_time * 100;
+    printf(" Time in active state:  %lus (%.2f%%)\n", active_time, tmp);
+    tmp = (float)unknown_time / (float)total_time * 100;
+    printf(" Time in unknown state: %lus (%.2f%%)\n", unknown_time, tmp);
+}
+
+static void ender(int s)
+{
+    endit = 1;
+}
+
+static void usage(void)
+{
+    puts("usage: dslm [-w <time>] <disk>");
+    exit(0);
+}
+
+int main(int argc, char **argv)
+{
+    int fd;
+    char *disk = 0;
+    int settle_time = 60;
+
+    /* Parse the simple command-line */
+    if (argc == 2)
+        disk = argv[1];
+    else if (argc == 4) {
+        settle_time = atoi(argv[2]);
+        disk = argv[3];
+    } else
+        usage();
+
+    if (!(fd = open(disk, O_RDONLY|O_NONBLOCK))) {
+        printf("Can't open %s, because: %s\n", disk, strerror(errno));
+        exit(-1);
+    }
+
+    if (settle_time) {
+        printf("Waiting %d seconds for the system to settle down to "
+               "'normal'\n", settle_time);
+        sleep(settle_time);
+    } else
+        puts("Not waiting for system to settle down");
+
+    signal(SIGINT, ender);
+
+    measure(fd);
+
+    close(fd);
+
+    return 0;
+}
diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
index d9836c5eb694..11c8d9bc762e 100644
--- a/tools/lguest/lguest.c
+++ b/tools/lguest/lguest.c
@@ -3266,6 +3266,9 @@ int main(int argc, char *argv[])
                 }
         }
 
+        /* If we exit via err(), this kills all the threads, restores tty. */
+        atexit(cleanup_devices);
+
         /* We always have a console device, and it's always device 1. */
         setup_console();
 
@@ -3369,9 +3372,6 @@ int main(int argc, char *argv[])
         /* Ensure that we terminate if a device-servicing child dies. */
         signal(SIGCHLD, kill_launcher);
 
-        /* If we exit via err(), this kills all the threads, restores tty. */
-        atexit(cleanup_devices);
-
         /* If requested, chroot to a directory */
         if (chroot_path) {
                 if (chroot(chroot_path) != 0)
diff --git a/tools/lib/api/Build b/tools/lib/api/Build
index 954c644f7ad9..6e2373db5598 100644
--- a/tools/lib/api/Build
+++ b/tools/lib/api/Build
@@ -2,3 +2,8 @@ libapi-y += fd/
 libapi-y += fs/
 libapi-y += cpu.o
 libapi-y += debug.o
+libapi-y += str_error_r.o
+
+$(OUTPUT)str_error_r.o: ../str_error_r.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
diff --git a/tools/lib/api/Makefile b/tools/lib/api/Makefile
index 316f308a63ea..0a6fda9837f7 100644
--- a/tools/lib/api/Makefile
+++ b/tools/lib/api/Makefile
@@ -10,15 +10,23 @@ endif
 
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
+LD = $(CROSS_COMPILE)ld
 
 MAKEFLAGS += --no-print-directory
 
 LIBFILE = $(OUTPUT)libapi.a
 
 CFLAGS := $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
-CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC
+CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -O6 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC
+
+# Treat warnings as errors unless directed not to
+ifneq ($(WERROR),0)
+  CFLAGS += -Werror
+endif
+
 CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 CFLAGS += -I$(srctree)/tools/lib/api
+CFLAGS += -I$(srctree)/tools/include
 
 RM = rm -f
 
diff --git a/tools/lib/api/fd/array.c b/tools/lib/api/fd/array.c
index 0e636c4339b8..b0a035fc87b3 100644
--- a/tools/lib/api/fd/array.c
+++ b/tools/lib/api/fd/array.c
@@ -85,7 +85,8 @@ int fdarray__add(struct fdarray *fda, int fd, short revents)
 }
 
 int fdarray__filter(struct fdarray *fda, short revents,
-                    void (*entry_destructor)(struct fdarray *fda, int fd))
+                    void (*entry_destructor)(struct fdarray *fda, int fd, void *arg),
+                    void *arg)
 {
         int fd, nr = 0;
 
@@ -95,7 +96,7 @@ int fdarray__filter(struct fdarray *fda, short revents,
         for (fd = 0; fd < fda->nr; ++fd) {
                 if (fda->entries[fd].revents & revents) {
                         if (entry_destructor)
-                                entry_destructor(fda, fd);
+                                entry_destructor(fda, fd, arg);
 
                         continue;
                 }
diff --git a/tools/lib/api/fd/array.h b/tools/lib/api/fd/array.h
index 45db01818f45..71287dddc05f 100644
--- a/tools/lib/api/fd/array.h
+++ b/tools/lib/api/fd/array.h
@@ -22,6 +22,7 @@ struct fdarray {
         struct pollfd *entries;
         union {
                 int    idx;
+                void   *ptr;
         } *priv;
 };
 
@@ -34,7 +35,8 @@ void fdarray__delete(struct fdarray *fda);
 int fdarray__add(struct fdarray *fda, int fd, short revents);
 int fdarray__poll(struct fdarray *fda, int timeout);
 int fdarray__filter(struct fdarray *fda, short revents,
-                    void (*entry_destructor)(struct fdarray *fda, int fd));
+                    void (*entry_destructor)(struct fdarray *fda, int fd, void *arg),
+                    void *arg);
 int fdarray__grow(struct fdarray *fda, int extra);
 int fdarray__fprintf(struct fdarray *fda, FILE *fp);
 
diff --git a/tools/lib/api/fs/fs.c b/tools/lib/api/fs/fs.c
index 08556cf2c70d..f99f49e4a31e 100644
--- a/tools/lib/api/fs/fs.c
+++ b/tools/lib/api/fs/fs.c
@@ -34,6 +34,10 @@
 #define TRACEFS_MAGIC          0x74726163
 #endif
 
+#ifndef HUGETLBFS_MAGIC
+#define HUGETLBFS_MAGIC        0x958458f6
+#endif
+
 static const char * const sysfs__fs_known_mountpoints[] = {
         "/sys",
         0,
@@ -67,6 +71,10 @@ static const char * const tracefs__known_mountpoints[] = {
         0,
 };
 
+static const char * const hugetlbfs__known_mountpoints[] = {
+        0,
+};
+
 struct fs {
         const char              *name;
         const char * const      *mounts;
@@ -80,6 +88,7 @@ enum {
         FS__PROCFS  = 1,
         FS__DEBUGFS = 2,
         FS__TRACEFS = 3,
+        FS__HUGETLBFS = 4,
 };
 
 #ifndef TRACEFS_MAGIC
@@ -107,6 +116,11 @@ static struct fs fs__entries[] = {
                 .mounts = tracefs__known_mountpoints,
                 .magic  = TRACEFS_MAGIC,
         },
+        [FS__HUGETLBFS] = {
+                .name   = "hugetlbfs",
+                .mounts = hugetlbfs__known_mountpoints,
+                .magic  = HUGETLBFS_MAGIC,
+        },
 };
 
 static bool fs__read_mounts(struct fs *fs)
@@ -265,6 +279,7 @@ FS(sysfs,   FS__SYSFS);
 FS(procfs,  FS__PROCFS);
 FS(debugfs, FS__DEBUGFS);
 FS(tracefs, FS__TRACEFS);
+FS(hugetlbfs, FS__HUGETLBFS);
 
 int filename__read_int(const char *filename, int *value)
 {
@@ -283,6 +298,11 @@ int filename__read_int(const char *filename, int *value)
         return err;
 }
 
+/*
+ * Parses @value out of @filename with strtoull.
+ * By using 0 for base, the strtoull detects the
+ * base automatically (see man strtoull).
+ */
 int filename__read_ull(const char *filename, unsigned long long *value)
 {
         char line[64];
@@ -292,7 +312,7 @@ int filename__read_ull(const char *filename, unsigned long long *value)
                 return -1;
 
         if (read(fd, line, sizeof(line)) > 0) {
-                *value = strtoull(line, NULL, 10);
+                *value = strtoull(line, NULL, 0);
                 if (*value != ULLONG_MAX)
                         err = 0;
         }
diff --git a/tools/lib/api/fs/fs.h b/tools/lib/api/fs/fs.h
index 16c9c2ed7c5b..a63269f5d20c 100644
--- a/tools/lib/api/fs/fs.h
+++ b/tools/lib/api/fs/fs.h
@@ -21,6 +21,7 @@ FS(sysfs)
 FS(procfs)
 FS(debugfs)
 FS(tracefs)
+FS(hugetlbfs)
 
 #undef FS
 
diff --git a/tools/lib/api/fs/tracing_path.c b/tools/lib/api/fs/tracing_path.c
index a26bb5ea8283..251b7c342a87 100644
--- a/tools/lib/api/fs/tracing_path.c
+++ b/tools/lib/api/fs/tracing_path.c
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <linux/string.h>
 #include <errno.h>
 #include <unistd.h>
 #include "fs.h"
@@ -118,7 +119,7 @@ static int strerror_open(int err, char *buf, size_t size, const char *filename)
         }
                 break;
         default:
-                snprintf(buf, size, "%s", strerror_r(err, sbuf, sizeof(sbuf)));
+                snprintf(buf, size, "%s", str_error_r(err, sbuf, sizeof(sbuf)));
                 break;
         }
 
diff --git a/tools/lib/bitmap.c b/tools/lib/bitmap.c
index 0a1adc1111fd..38748b0e342f 100644
--- a/tools/lib/bitmap.c
+++ b/tools/lib/bitmap.c
@@ -29,3 +29,47 @@ void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
         for (k = 0; k < nr; k++)
                 dst[k] = bitmap1[k] | bitmap2[k];
 }
+
+size_t bitmap_scnprintf(unsigned long *bitmap, int nbits,
+                        char *buf, size_t size)
+{
+        /* current bit is 'cur', most recently seen range is [rbot, rtop] */
+        int cur, rbot, rtop;
+        bool first = true;
+        size_t ret = 0;
+
+        rbot = cur = find_first_bit(bitmap, nbits);
+        while (cur < nbits) {
+                rtop = cur;
+                cur = find_next_bit(bitmap, nbits, cur + 1);
+                if (cur < nbits && cur <= rtop + 1)
+                        continue;
+
+                if (!first)
+                        ret += scnprintf(buf + ret, size - ret, ",");
+
+                first = false;
+
+                ret += scnprintf(buf + ret, size - ret, "%d", rbot);
+                if (rbot < rtop)
+                        ret += scnprintf(buf + ret, size - ret, "-%d", rtop);
+
+                rbot = cur;
+        }
+        return ret;
+}
+
+int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
+                 const unsigned long *bitmap2, unsigned int bits)
+{
+        unsigned int k;
+        unsigned int lim = bits/BITS_PER_LONG;
+        unsigned long result = 0;
+
+        for (k = 0; k < lim; k++)
+                result |= (dst[k] = bitmap1[k] & bitmap2[k]);
+        if (bits % BITS_PER_LONG)
+                result |= (dst[k] = bitmap1[k] & bitmap2[k] &
+                           BITMAP_LAST_WORD_MASK(bits));
+        return result != 0;
+}
diff --git a/tools/lib/bpf/Makefile b/tools/lib/bpf/Makefile
index fc1bc75ae56d..62d89d50fcbd 100644
--- a/tools/lib/bpf/Makefile
+++ b/tools/lib/bpf/Makefile
@@ -68,7 +68,7 @@ FEATURE_USER = .libbpf
 FEATURE_TESTS = libelf libelf-getphdrnum libelf-mmap bpf
 FEATURE_DISPLAY = libelf bpf
 
-INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/arch/$(ARCH)/include/uapi -I$(srctree)/include/uapi
+INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi
 FEATURE_CHECK_CFLAGS-bpf = $(INCLUDES)
 
 check_feat := 1
@@ -154,6 +154,12 @@ all: fixdep $(VERSION_FILES) all_cmd
 all_cmd: $(CMD_TARGETS)
 
 $(BPF_IN): force elfdep bpfdep
+        @(test -f ../../../include/uapi/linux/bpf.h -a -f ../../../include/uapi/linux/bpf.h && ( \
+        (diff -B ../../include/uapi/linux/bpf.h ../../../include/uapi/linux/bpf.h >/dev/null) || \
+        echo "Warning: tools/include/uapi/linux/bpf.h differs from kernel" >&2 )) || true
+        @(test -f ../../../include/uapi/linux/bpf_common.h -a -f ../../../include/uapi/linux/bpf_common.h && ( \
+        (diff -B ../../include/uapi/linux/bpf_common.h ../../../include/uapi/linux/bpf_common.h >/dev/null) || \
+        echo "Warning: tools/include/uapi/linux/bpf_common.h differs from kernel" >&2 )) || true
         $(Q)$(MAKE) $(build)=libbpf
 
 $(OUTPUT)libbpf.so: $(BPF_IN)
diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 1f91cc941b7c..4212ed62235b 100644
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -4,6 +4,19 @@
  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
  * Copyright (C) 2015 Huawei Inc.
+ *
+ * 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,  see <http://www.gnu.org/licenses>
  */
 
 #include <stdlib.h>
diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index a76465541292..e8ba54087497 100644
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -4,6 +4,19 @@
  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
  * Copyright (C) 2015 Huawei Inc.
+ *
+ * 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,  see <http://www.gnu.org/licenses>
  */
 #ifndef __BPF_BPF_H
 #define __BPF_BPF_H
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 7e543c3102d4..b699aea9a025 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -4,6 +4,19 @@
  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
  * Copyright (C) 2015 Huawei Inc.
+ *
+ * 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,  see <http://www.gnu.org/licenses>
  */
 
 #include <stdlib.h>
@@ -24,6 +37,10 @@
 #include "libbpf.h"
 #include "bpf.h"
 
+#ifndef EM_BPF
+#define EM_BPF 247
+#endif
+
 #define __printf(a, b)  __attribute__((format(printf, a, b)))
 
 __printf(1, 2)
@@ -71,12 +88,13 @@ static const char *libbpf_strerror_table[NR_ERRNO] = {
         [ERRCODE_OFFSET(LIBELF)]        = "Something wrong in libelf",
         [ERRCODE_OFFSET(FORMAT)]        = "BPF object format invalid",
         [ERRCODE_OFFSET(KVERSION)]      = "'version' section incorrect or lost",
-        [ERRCODE_OFFSET(ENDIAN)]        = "Endian missmatch",
+        [ERRCODE_OFFSET(ENDIAN)]        = "Endian mismatch",
         [ERRCODE_OFFSET(INTERNAL)]      = "Internal error in libbpf",
         [ERRCODE_OFFSET(RELOC)]         = "Relocation failed",
         [ERRCODE_OFFSET(VERIFY)]        = "Kernel verifier blocks program loading",
         [ERRCODE_OFFSET(PROG2BIG)]      = "Program too big",
         [ERRCODE_OFFSET(KVER)]          = "Incorrect kernel version",
+        [ERRCODE_OFFSET(PROGTYPE)]      = "Kernel doesn't support this program type",
 };
 
 int libbpf_strerror(int err, char *buf, size_t size)
@@ -145,6 +163,7 @@ struct bpf_program {
         char *section_name;
         struct bpf_insn *insns;
         size_t insns_cnt;
+        enum bpf_prog_type type;
 
         struct {
                 int insn_idx;
@@ -286,6 +305,7 @@ bpf_program__init(void *data, size_t size, char *name, int idx,
         prog->idx = idx;
         prog->instances.fds = NULL;
         prog->instances.nr = -1;
+        prog->type = BPF_PROG_TYPE_KPROBE;
 
         return 0;
 errout:
@@ -423,7 +443,8 @@ static int bpf_object__elf_init(struct bpf_object *obj)
         }
         ep = &obj->efile.ehdr;
 
-        if ((ep->e_type != ET_REL) || (ep->e_machine != 0)) {
+        /* Old LLVM set e_machine to EM_NONE */
+        if ((ep->e_type != ET_REL) || (ep->e_machine && (ep->e_machine != EM_BPF))) {
                 pr_warning("%s is not an eBPF object file\n",
                         obj->path);
                 err = -LIBBPF_ERRNO__FORMAT;
@@ -881,8 +902,8 @@ static int bpf_object__collect_reloc(struct bpf_object *obj)
 }
 
 static int
-load_program(struct bpf_insn *insns, int insns_cnt,
-             char *license, u32 kern_version, int *pfd)
+load_program(enum bpf_prog_type type, struct bpf_insn *insns,
+             int insns_cnt, char *license, u32 kern_version, int *pfd)
 {
         int ret;
         char *log_buf;
@@ -894,9 +915,8 @@ load_program(struct bpf_insn *insns, int insns_cnt,
         if (!log_buf)
                 pr_warning("Alloc log buffer for bpf loader error, continue without log\n");
 
-        ret = bpf_load_program(BPF_PROG_TYPE_KPROBE, insns,
-                               insns_cnt, license, kern_version,
-                               log_buf, BPF_LOG_BUF_SIZE);
+        ret = bpf_load_program(type, insns, insns_cnt, license,
+                               kern_version, log_buf, BPF_LOG_BUF_SIZE);
 
         if (ret >= 0) {
                 *pfd = ret;
@@ -912,15 +932,27 @@ load_program(struct bpf_insn *insns, int insns_cnt,
                 pr_warning("-- BEGIN DUMP LOG ---\n");
                 pr_warning("\n%s\n", log_buf);
                 pr_warning("-- END LOG --\n");
+        } else if (insns_cnt >= BPF_MAXINSNS) {
+                pr_warning("Program too large (%d insns), at most %d insns\n",
+                           insns_cnt, BPF_MAXINSNS);
+                ret = -LIBBPF_ERRNO__PROG2BIG;
         } else {
-                if (insns_cnt >= BPF_MAXINSNS) {
-                        pr_warning("Program too large (%d insns), at most %d insns\n",
-                                   insns_cnt, BPF_MAXINSNS);
-                        ret = -LIBBPF_ERRNO__PROG2BIG;
-                } else if (log_buf) {
-                        pr_warning("log buffer is empty\n");
-                        ret = -LIBBPF_ERRNO__KVER;
+                /* Wrong program type? */
+                if (type != BPF_PROG_TYPE_KPROBE) {
+                        int fd;
+
+                        fd = bpf_load_program(BPF_PROG_TYPE_KPROBE, insns,
+                                              insns_cnt, license, kern_version,
+                                              NULL, 0);
+                        if (fd >= 0) {
+                                close(fd);
+                                ret = -LIBBPF_ERRNO__PROGTYPE;
+                                goto out;
+                        }
                 }
+
+                if (log_buf)
+                        ret = -LIBBPF_ERRNO__KVER;
         }
 
 out:
@@ -955,7 +987,7 @@ bpf_program__load(struct bpf_program *prog,
                         pr_warning("Program '%s' is inconsistent: nr(%d) != 1\n",
                                    prog->section_name, prog->instances.nr);
                 }
-                err = load_program(prog->insns, prog->insns_cnt,
+                err = load_program(prog->type, prog->insns, prog->insns_cnt,
                                    license, kern_version, &fd);
                 if (!err)
                         prog->instances.fds[0] = fd;
@@ -984,7 +1016,7 @@ bpf_program__load(struct bpf_program *prog,
                         continue;
                 }
 
-                err = load_program(result.new_insn_ptr,
+                err = load_program(prog->type, result.new_insn_ptr,
                                    result.new_insn_cnt,
                                    license, kern_version, &fd);
 
@@ -1186,20 +1218,14 @@ bpf_object__next(struct bpf_object *prev)
         return next;
 }
 
-const char *
-bpf_object__get_name(struct bpf_object *obj)
+const char *bpf_object__name(struct bpf_object *obj)
 {
-        if (!obj)
-                return ERR_PTR(-EINVAL);
-        return obj->path;
+        return obj ? obj->path : ERR_PTR(-EINVAL);
 }
 
-unsigned int
-bpf_object__get_kversion(struct bpf_object *obj)
+unsigned int bpf_object__kversion(struct bpf_object *obj)
 {
-        if (!obj)
-                return 0;
-        return obj->kern_version;
+        return obj ? obj->kern_version : 0;
 }
 
 struct bpf_program *
@@ -1224,9 +1250,8 @@ bpf_program__next(struct bpf_program *prev, struct bpf_object *obj)
         return &obj->programs[idx];
 }
 
-int bpf_program__set_private(struct bpf_program *prog,
-                             void *priv,
-                             bpf_program_clear_priv_t clear_priv)
+int bpf_program__set_priv(struct bpf_program *prog, void *priv,
+                          bpf_program_clear_priv_t clear_priv)
 {
         if (prog->priv && prog->clear_priv)
                 prog->clear_priv(prog, prog->priv);
@@ -1236,10 +1261,9 @@ int bpf_program__set_private(struct bpf_program *prog,
         return 0;
 }
 
-int bpf_program__get_private(struct bpf_program *prog, void **ppriv)
+void *bpf_program__priv(struct bpf_program *prog)
 {
-        *ppriv = prog->priv;
-        return 0;
+        return prog ? prog->priv : ERR_PTR(-EINVAL);
 }
 
 const char *bpf_program__title(struct bpf_program *prog, bool needs_copy)
@@ -1311,32 +1335,61 @@ int bpf_program__nth_fd(struct bpf_program *prog, int n)
         return fd;
 }
 
-int bpf_map__get_fd(struct bpf_map *map)
+static void bpf_program__set_type(struct bpf_program *prog,
+                                  enum bpf_prog_type type)
 {
-        if (!map)
-                return -EINVAL;
-
-        return map->fd;
+        prog->type = type;
 }
 
-int bpf_map__get_def(struct bpf_map *map, struct bpf_map_def *pdef)
+int bpf_program__set_tracepoint(struct bpf_program *prog)
 {
-        if (!map || !pdef)
+        if (!prog)
                 return -EINVAL;
+        bpf_program__set_type(prog, BPF_PROG_TYPE_TRACEPOINT);
+        return 0;
+}
 
-        *pdef = map->def;
+int bpf_program__set_kprobe(struct bpf_program *prog)
+{
+        if (!prog)
+                return -EINVAL;
+        bpf_program__set_type(prog, BPF_PROG_TYPE_KPROBE);
         return 0;
 }
 
-const char *bpf_map__get_name(struct bpf_map *map)
+static bool bpf_program__is_type(struct bpf_program *prog,
+                                 enum bpf_prog_type type)
 {
-        if (!map)
-                return NULL;
-        return map->name;
+        return prog ? (prog->type == type) : false;
+}
+
+bool bpf_program__is_tracepoint(struct bpf_program *prog)
+{
+        return bpf_program__is_type(prog, BPF_PROG_TYPE_TRACEPOINT);
+}
+
+bool bpf_program__is_kprobe(struct bpf_program *prog)
+{
+        return bpf_program__is_type(prog, BPF_PROG_TYPE_KPROBE);
+}
+
+int bpf_map__fd(struct bpf_map *map)
+{
+        return map ? map->fd : -EINVAL;
 }
 
-int bpf_map__set_private(struct bpf_map *map, void *priv,
-                         bpf_map_clear_priv_t clear_priv)
+const struct bpf_map_def *bpf_map__def(struct bpf_map *map)
+{
+        return map ? &map->def : ERR_PTR(-EINVAL);
+}
+
+const char *bpf_map__name(struct bpf_map *map)
+{
+        return map ? map->name : NULL;
+}
+
+int bpf_map__set_priv(struct bpf_map *map, void *priv,
+                     bpf_map_clear_priv_t clear_priv)
 {
         if (!map)
                 return -EINVAL;
@@ -1351,14 +1404,9 @@ int bpf_map__set_private(struct bpf_map *map, void *priv,
         return 0;
 }
 
-int bpf_map__get_private(struct bpf_map *map, void **ppriv)
+void *bpf_map__priv(struct bpf_map *map)
 {
-        if (!map)
-                return -EINVAL;
-
-        if (ppriv)
-                *ppriv = map->priv;
-        return 0;
+        return map ? map->priv : ERR_PTR(-EINVAL);
 }
 
 struct bpf_map *
@@ -1389,7 +1437,7 @@ bpf_map__next(struct bpf_map *prev, struct bpf_object *obj)
 }
 
 struct bpf_map *
-bpf_object__get_map_by_name(struct bpf_object *obj, const char *name)
+bpf_object__find_map_by_name(struct bpf_object *obj, const char *name)
 {
         struct bpf_map *pos;
 
diff --git a/tools/lib/bpf/libbpf.h b/tools/lib/bpf/libbpf.h
index a51594c7b518..dd7a513efb10 100644
--- a/tools/lib/bpf/libbpf.h
+++ b/tools/lib/bpf/libbpf.h
@@ -4,6 +4,19 @@
  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
  * Copyright (C) 2015 Huawei Inc.
+ *
+ * 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,  see <http://www.gnu.org/licenses>
  */
 #ifndef __BPF_LIBBPF_H
 #define __BPF_LIBBPF_H
@@ -19,13 +32,14 @@ enum libbpf_errno {
         LIBBPF_ERRNO__LIBELF = __LIBBPF_ERRNO__START,
         LIBBPF_ERRNO__FORMAT,   /* BPF object format invalid */
         LIBBPF_ERRNO__KVERSION, /* Incorrect or no 'version' section */
-        LIBBPF_ERRNO__ENDIAN,   /* Endian missmatch */
+        LIBBPF_ERRNO__ENDIAN,   /* Endian mismatch */
         LIBBPF_ERRNO__INTERNAL, /* Internal error in libbpf */
         LIBBPF_ERRNO__RELOC,    /* Relocation failed */
         LIBBPF_ERRNO__LOAD,     /* Load program failure for unknown reason */
         LIBBPF_ERRNO__VERIFY,   /* Kernel verifier blocks program loading */
         LIBBPF_ERRNO__PROG2BIG, /* Program too big */
         LIBBPF_ERRNO__KVER,     /* Incorrect kernel version */
+        LIBBPF_ERRNO__PROGTYPE, /* Kernel doesn't support this program type */
         __LIBBPF_ERRNO__END,
 };
 
@@ -55,8 +69,8 @@ void bpf_object__close(struct bpf_object *object);
 /* Load/unload object into/from kernel */
 int bpf_object__load(struct bpf_object *obj);
 int bpf_object__unload(struct bpf_object *obj);
-const char *bpf_object__get_name(struct bpf_object *obj);
-unsigned int bpf_object__get_kversion(struct bpf_object *obj);
+const char *bpf_object__name(struct bpf_object *obj);
+unsigned int bpf_object__kversion(struct bpf_object *obj);
 
 struct bpf_object *bpf_object__next(struct bpf_object *prev);
 #define bpf_object__for_each_safe(pos, tmp)                     \
@@ -78,11 +92,10 @@ struct bpf_program *bpf_program__next(struct bpf_program *prog,
 typedef void (*bpf_program_clear_priv_t)(struct bpf_program *,
                                          void *);
 
-int bpf_program__set_private(struct bpf_program *prog, void *priv,
-                             bpf_program_clear_priv_t clear_priv);
+int bpf_program__set_priv(struct bpf_program *prog, void *priv,
+                          bpf_program_clear_priv_t clear_priv);
 
-int bpf_program__get_private(struct bpf_program *prog,
-                             void **ppriv);
+void *bpf_program__priv(struct bpf_program *prog);
 
 const char *bpf_program__title(struct bpf_program *prog, bool needs_copy);
 
@@ -153,6 +166,15 @@ int bpf_program__set_prep(struct bpf_program *prog, int nr_instance,
 int bpf_program__nth_fd(struct bpf_program *prog, int n);
 
 /*
+ * Adjust type of bpf program. Default is kprobe.
+ */
+int bpf_program__set_tracepoint(struct bpf_program *prog);
+int bpf_program__set_kprobe(struct bpf_program *prog);
+
+bool bpf_program__is_tracepoint(struct bpf_program *prog);
+bool bpf_program__is_kprobe(struct bpf_program *prog);
+
+/*
  * We don't need __attribute__((packed)) now since it is
  * unnecessary for 'bpf_map_def' because they are all aligned.
  * In addition, using it will trigger -Wpacked warning message,
@@ -171,7 +193,7 @@ struct bpf_map_def {
  */
 struct bpf_map;
 struct bpf_map *
-bpf_object__get_map_by_name(struct bpf_object *obj, const char *name);
+bpf_object__find_map_by_name(struct bpf_object *obj, const char *name);
 
 struct bpf_map *
 bpf_map__next(struct bpf_map *map, struct bpf_object *obj);
@@ -180,13 +202,13 @@ bpf_map__next(struct bpf_map *map, struct bpf_object *obj);
              (pos) != NULL;                             \
              (pos) = bpf_map__next((pos), (obj)))
 
-int bpf_map__get_fd(struct bpf_map *map);
-int bpf_map__get_def(struct bpf_map *map, struct bpf_map_def *pdef);
-const char *bpf_map__get_name(struct bpf_map *map);
+int bpf_map__fd(struct bpf_map *map);
+const struct bpf_map_def *bpf_map__def(struct bpf_map *map);
+const char *bpf_map__name(struct bpf_map *map);
 
 typedef void (*bpf_map_clear_priv_t)(struct bpf_map *, void *);
-int bpf_map__set_private(struct bpf_map *map, void *priv,
-                         bpf_map_clear_priv_t clear_priv);
-int bpf_map__get_private(struct bpf_map *map, void **ppriv);
+int bpf_map__set_priv(struct bpf_map *map, void *priv,
+                      bpf_map_clear_priv_t clear_priv);
+void *bpf_map__priv(struct bpf_map *map);
 
 #endif
diff --git a/tools/lib/str_error_r.c b/tools/lib/str_error_r.c
new file mode 100644
index 000000000000..503ae072244c
--- /dev/null
+++ b/tools/lib/str_error_r.c
@@ -0,0 +1,26 @@
+#undef _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+#include <linux/string.h>
+
+/*
+ * The tools so far have been using the strerror_r() GNU variant, that returns
+ * a string, be it the buffer passed or something else.
+ *
+ * But that, besides being tricky in cases where we expect that the function
+ * using strerror_r() returns the error formatted in a provided buffer (we have
+ * to check if it returned something else and copy that instead), breaks the
+ * build on systems not using glibc, like Alpine Linux, where musl libc is
+ * used.
+ *
+ * So, introduce yet another wrapper, str_error_r(), that has the GNU
+ * interface, but uses the portable XSI variant of strerror_r(), so that users
+ * rest asured that the provided buffer is used and it is what is returned.
+ */
+char *str_error_r(int errnum, char *buf, size_t buflen)
+{
+        int err = strerror_r(errnum, buf, buflen);
+        if (err)
+                snprintf(buf, buflen, "INTERNAL ERROR: strerror_r(%d, %p, %zd)=%d", errnum, buf, buflen, err);
+        return buf;
+}
diff --git a/tools/lib/subcmd/Makefile b/tools/lib/subcmd/Makefile
index a8103700c172..ce4b7e527566 100644
--- a/tools/lib/subcmd/Makefile
+++ b/tools/lib/subcmd/Makefile
@@ -19,7 +19,13 @@ MAKEFLAGS += --no-print-directory
 LIBFILE = $(OUTPUT)libsubcmd.a
 
 CFLAGS := $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
-CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC
+CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -O6 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fPIC
+
+# Treat warnings as errors unless directed not to
+ifneq ($(WERROR),0)
+  CFLAGS += -Werror
+endif
+
 CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 
 CFLAGS += -I$(srctree)/tools/include/
diff --git a/tools/lib/subcmd/pager.c b/tools/lib/subcmd/pager.c
index d50f3b58606b..6518bea926d6 100644
--- a/tools/lib/subcmd/pager.c
+++ b/tools/lib/subcmd/pager.c
@@ -3,6 +3,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <signal.h>
+#include <sys/ioctl.h>
 #include "pager.h"
 #include "run-command.h"
 #include "sigchain.h"
@@ -14,6 +15,7 @@
  */
 
 static int spawned_pager;
+static int pager_columns;
 
 void pager_init(const char *pager_env)
 {
@@ -58,9 +60,12 @@ static void wait_for_pager_signal(int signo)
 void setup_pager(void)
 {
         const char *pager = getenv(subcmd_config.pager_env);
+        struct winsize sz;
 
         if (!isatty(1))
                 return;
+        if (ioctl(1, TIOCGWINSZ, &sz) == 0)
+                pager_columns = sz.ws_col;
         if (!pager)
                 pager = getenv("PAGER");
         if (!(pager || access("/usr/bin/pager", X_OK)))
@@ -98,3 +103,14 @@ int pager_in_use(void)
 {
         return spawned_pager;
 }
+
+int pager_get_columns(void)
+{
+        char *s;
+
+        s = getenv("COLUMNS");
+        if (s)
+                return atoi(s);
+
+        return (pager_columns ? pager_columns : 80) - 2;
+}
diff --git a/tools/lib/subcmd/pager.h b/tools/lib/subcmd/pager.h
index 8b83714ecf73..623f5542d05d 100644
--- a/tools/lib/subcmd/pager.h
+++ b/tools/lib/subcmd/pager.h
@@ -5,5 +5,6 @@ extern void pager_init(const char *pager_env);
 
 extern void setup_pager(void);
 extern int pager_in_use(void);
+extern int pager_get_columns(void);
 
 #endif /* __SUBCMD_PAGER_H */
diff --git a/tools/lib/subcmd/run-command.c b/tools/lib/subcmd/run-command.c
index f4f6c9eb8e59..911f83942723 100644
--- a/tools/lib/subcmd/run-command.c
+++ b/tools/lib/subcmd/run-command.c
@@ -3,6 +3,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <string.h>
+#include <linux/string.h>
 #include <errno.h>
 #include <sys/wait.h>
 #include "subcmd-util.h"
@@ -109,7 +110,7 @@ int start_command(struct child_process *cmd)
 
                 if (cmd->dir && chdir(cmd->dir))
                         die("exec %s: cd to %s failed (%s)", cmd->argv[0],
-                            cmd->dir, strerror_r(errno, sbuf, sizeof(sbuf)));
+                            cmd->dir, str_error_r(errno, sbuf, sizeof(sbuf)));
                 if (cmd->env) {
                         for (; *cmd->env; cmd->env++) {
                                 if (strchr(*cmd->env, '='))
@@ -173,7 +174,7 @@ static int wait_or_whine(pid_t pid)
                         if (errno == EINTR)
                                 continue;
                         fprintf(stderr, " Error: waitpid failed (%s)",
-                                strerror_r(errno, sbuf, sizeof(sbuf)));
+                                str_error_r(errno, sbuf, sizeof(sbuf)));
                         return -ERR_RUN_COMMAND_WAITPID;
                 }
                 if (waiting != pid)
diff --git a/tools/lib/traceevent/.gitignore b/tools/lib/traceevent/.gitignore
index 3c60335fe7be..9e9f25fb1922 100644
--- a/tools/lib/traceevent/.gitignore
+++ b/tools/lib/traceevent/.gitignore
@@ -1,2 +1,3 @@
 TRACEEVENT-CFLAGS
 libtraceevent-dynamic-list
+libtraceevent.so.*
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index a8b6357d1ffe..664c90c8e22b 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -23,6 +23,7 @@
  *  Frederic Weisbecker gave his permission to relicense the code to
  *  the Lesser General Public License.
  */
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -31,8 +32,9 @@
 #include <errno.h>
 #include <stdint.h>
 #include <limits.h>
+#include <linux/string.h>
 
-#include <netinet/ip6.h>
+#include <netinet/in.h>
 #include "event-parse.h"
 #include "event-utils.h"
 
@@ -6131,12 +6133,7 @@ int pevent_strerror(struct pevent *pevent __maybe_unused,
         const char *msg;
 
         if (errnum >= 0) {
-                msg = strerror_r(errnum, buf, buflen);
-                if (msg != buf) {
-                        size_t len = strlen(msg);
-                        memcpy(buf, msg, min(buflen - 1, len));
-                        *(buf + min(buflen - 1, len)) = '\0';
-                }
+                str_error_r(errnum, buf, buflen);
                 return 0;
         }
 
diff --git a/tools/lib/traceevent/kbuffer-parse.c b/tools/lib/traceevent/kbuffer-parse.c
index 3bcada3ae05a..65984f1c2974 100644
--- a/tools/lib/traceevent/kbuffer-parse.c
+++ b/tools/lib/traceevent/kbuffer-parse.c
@@ -622,6 +622,7 @@ void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset,
 
         /* Reset the buffer */
         kbuffer_load_subbuffer(kbuf, kbuf->subbuffer);
+        data = kbuffer_read_event(kbuf, ts);
 
         while (kbuf->curr < offset) {
                 data = kbuffer_next_event(kbuf, ts);
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index 88cccea3ca99..7c214ceb9386 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -28,11 +28,16 @@
 #include "event-utils.h"
 
 #define COMM "COMM"
+#define CPU "CPU"
 
 static struct format_field comm = {
         .name = "COMM",
 };
 
+static struct format_field cpu = {
+        .name = "CPU",
+};
+
 struct event_list {
         struct event_list       *next;
         struct event_format     *event;
@@ -382,14 +387,17 @@ create_arg_item(struct event_format *event, const char *token,
                 /* Consider this a field */
                 field = pevent_find_any_field(event, token);
                 if (!field) {
-                        if (strcmp(token, COMM) != 0) {
+                        /* If token is 'COMM' or 'CPU' then it is special */
+                        if (strcmp(token, COMM) == 0) {
+                                field = &comm;
+                        } else if (strcmp(token, CPU) == 0) {
+                                field = &cpu;
+                        } else {
                                 /* not a field, Make it false */
                                 arg->type = FILTER_ARG_BOOLEAN;
                                 arg->boolean.value = FILTER_FALSE;
                                 break;
                         }
-                        /* If token is 'COMM' then it is special */
-                        field = &comm;
                 }
                 arg->type = FILTER_ARG_FIELD;
                 arg->field.field = field;
@@ -1718,6 +1726,10 @@ get_value(struct event_format *event,
                 return (unsigned long)name;
         }
 
+        /* Handle our dummy "cpu" field */
+        if (field == &cpu)
+                return record->cpu;
+
         pevent_read_number_field(field, record->data, &val);
 
         if (!(field->flags & FIELD_IS_SIGNED))
diff --git a/tools/lib/vsprintf.c b/tools/lib/vsprintf.c
new file mode 100644
index 000000000000..45f9a06daa56
--- /dev/null
+++ b/tools/lib/vsprintf.c
@@ -0,0 +1,24 @@
+#include <sys/types.h>
+#include <linux/kernel.h>
+#include <stdio.h>
+
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+       int i = vsnprintf(buf, size, fmt, args);
+       ssize_t ssize = size;
+
+       return (i >= ssize) ? (ssize - 1) : i;
+}
+
+int scnprintf(char * buf, size_t size, const char * fmt, ...)
+{
+       ssize_t ssize = size;
+       va_list args;
+       int i;
+
+       va_start(args, fmt);
+       i = vsnprintf(buf, size, fmt, args);
+       va_end(args);
+
+       return (i >= ssize) ? (ssize - 1) : i;
+}
diff --git a/tools/objtool/.gitignore b/tools/objtool/.gitignore
index a0b3128bb31f..d3102c865a95 100644
--- a/tools/objtool/.gitignore
+++ b/tools/objtool/.gitignore
@@ -1,2 +1,3 @@
 arch/x86/insn/inat-tables.c
 objtool
+fixdep
diff --git a/tools/objtool/Build b/tools/objtool/Build
index 0e89258a3541..d6cdece5e58b 100644
--- a/tools/objtool/Build
+++ b/tools/objtool/Build
@@ -1,13 +1,18 @@
-objtool-y += arch/$(ARCH)/
+objtool-y += arch/$(SRCARCH)/
 objtool-y += builtin-check.o
 objtool-y += elf.o
 objtool-y += special.o
 objtool-y += objtool.o
 
 objtool-y += libstring.o
+objtool-y += str_error_r.o
 
 CFLAGS += -I$(srctree)/tools/lib
 
 $(OUTPUT)libstring.o: ../lib/string.c FORCE
         $(call rule_mkdir)
         $(call if_changed_dep,cc_o_c)
+
+$(OUTPUT)str_error_r.o: ../lib/str_error_r.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
diff --git a/tools/objtool/Makefile b/tools/objtool/Makefile
index f094f3c4ed84..041b493ad3ab 100644
--- a/tools/objtool/Makefile
+++ b/tools/objtool/Makefile
@@ -1,11 +1,9 @@
 include ../scripts/Makefile.include
+include ../scripts/Makefile.arch
 
-ifndef ($(ARCH))
-ARCH ?= $(shell uname -m)
 ifeq ($(ARCH),x86_64)
 ARCH := x86
 endif
-endif
 
 # always use the host compiler
 CC = gcc
@@ -26,7 +24,7 @@ OBJTOOL_IN := $(OBJTOOL)-in.o
 
 all: $(OBJTOOL)
 
-INCLUDES := -I$(srctree)/tools/include
+INCLUDES := -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(HOSTARCH)/include/uapi
 CFLAGS   += -Wall -Werror $(EXTRA_WARNINGS) -fomit-frame-pointer -O2 -g $(INCLUDES)
 LDFLAGS  += -lelf $(LIBSUBCMD)
 
@@ -35,14 +33,17 @@ elfshdr := $(shell echo '\#include <libelf.h>' | $(CC) $(CFLAGS) -x c -E - | gre
 CFLAGS += $(if $(elfshdr),,-DLIBELF_USE_DEPRECATED)
 
 AWK = awk
-export srctree OUTPUT CFLAGS ARCH AWK
+export srctree OUTPUT CFLAGS SRCARCH AWK
 include $(srctree)/tools/build/Makefile.include
 
 $(OBJTOOL_IN): fixdep FORCE
         @$(MAKE) $(build)=objtool
 
+# Busybox's diff doesn't have -I, avoid warning in that case
+#
 $(OBJTOOL): $(LIBSUBCMD) $(OBJTOOL_IN)
-        @(test -d ../../kernel -a -d ../../tools -a -d ../objtool && (( \
+        @(diff -I 2>&1 | grep -q 'option requires an argument' && \
+        test -d ../../kernel -a -d ../../tools -a -d ../objtool && (( \
         diff -I'^#include' arch/x86/insn/insn.c ../../arch/x86/lib/insn.c >/dev/null && \
         diff -I'^#include' arch/x86/insn/inat.c ../../arch/x86/lib/inat.c >/dev/null && \
         diff arch/x86/insn/x86-opcode-map.txt ../../arch/x86/lib/x86-opcode-map.txt >/dev/null && \
@@ -50,7 +51,7 @@ $(OBJTOOL): $(LIBSUBCMD) $(OBJTOOL_IN)
         diff -I'^#include' arch/x86/insn/insn.h ../../arch/x86/include/asm/insn.h >/dev/null && \
         diff -I'^#include' arch/x86/insn/inat.h ../../arch/x86/include/asm/inat.h >/dev/null && \
         diff -I'^#include' arch/x86/insn/inat_types.h ../../arch/x86/include/asm/inat_types.h >/dev/null) \
-        || echo "Warning: objtool: x86 instruction decoder differs from kernel" >&2 )) || true
+        || echo "warning: objtool: x86 instruction decoder differs from kernel" >&2 )) || true
         $(QUIET_LINK)$(CC) $(OBJTOOL_IN) $(LDFLAGS) -o $@
 
 
diff --git a/tools/objtool/arch/x86/insn/gen-insn-attr-x86.awk b/tools/objtool/arch/x86/insn/gen-insn-attr-x86.awk
index 093a892026f9..a3d2c62fd805 100644
--- a/tools/objtool/arch/x86/insn/gen-insn-attr-x86.awk
+++ b/tools/objtool/arch/x86/insn/gen-insn-attr-x86.awk
@@ -72,12 +72,14 @@ BEGIN {
         lprefix_expr = "\\((66|F2|F3)\\)"
         max_lprefix = 4
 
-        # All opcodes starting with lower-case 'v' or with (v1) superscript
+        # All opcodes starting with lower-case 'v', 'k' or with (v1) superscript
         # accepts VEX prefix
-        vexok_opcode_expr = "^v.*"
+        vexok_opcode_expr = "^[vk].*"
         vexok_expr = "\\(v1\\)"
         # All opcodes with (v) superscript supports *only* VEX prefix
         vexonly_expr = "\\(v\\)"
+        # All opcodes with (ev) superscript supports *only* EVEX prefix
+        evexonly_expr = "\\(ev\\)"
 
         prefix_expr = "\\(Prefix\\)"
         prefix_num["Operand-Size"] = "INAT_PFX_OPNDSZ"
@@ -95,6 +97,7 @@ BEGIN {
         prefix_num["Address-Size"] = "INAT_PFX_ADDRSZ"
         prefix_num["VEX+1byte"] = "INAT_PFX_VEX2"
         prefix_num["VEX+2byte"] = "INAT_PFX_VEX3"
+        prefix_num["EVEX"] = "INAT_PFX_EVEX"
 
         clear_vars()
 }
@@ -319,7 +322,9 @@ function convert_operands(count,opnd,       i,j,imm,mod)
                         flags = add_flags(flags, "INAT_MODRM")
 
                 # check VEX codes
-                if (match(ext, vexonly_expr))
+                if (match(ext, evexonly_expr))
+                        flags = add_flags(flags, "INAT_VEXOK | INAT_EVEXONLY")
+                else if (match(ext, vexonly_expr))
                         flags = add_flags(flags, "INAT_VEXOK | INAT_VEXONLY")
                 else if (match(ext, vexok_expr) || match(opcode, vexok_opcode_expr))
                         flags = add_flags(flags, "INAT_VEXOK")
diff --git a/tools/objtool/arch/x86/insn/inat.h b/tools/objtool/arch/x86/insn/inat.h
index 611645e903a8..125ecd2a300d 100644
--- a/tools/objtool/arch/x86/insn/inat.h
+++ b/tools/objtool/arch/x86/insn/inat.h
@@ -48,6 +48,7 @@
 /* AVX VEX prefixes */
 #define INAT_PFX_VEX2   13      /* 2-bytes VEX prefix */
 #define INAT_PFX_VEX3   14      /* 3-bytes VEX prefix */
+#define INAT_PFX_EVEX   15      /* EVEX prefix */
 
 #define INAT_LSTPFX_MAX 3
 #define INAT_LGCPFX_MAX 11
@@ -89,6 +90,7 @@
 #define INAT_VARIANT    (1 << (INAT_FLAG_OFFS + 4))
 #define INAT_VEXOK      (1 << (INAT_FLAG_OFFS + 5))
 #define INAT_VEXONLY    (1 << (INAT_FLAG_OFFS + 6))
+#define INAT_EVEXONLY   (1 << (INAT_FLAG_OFFS + 7))
 /* Attribute making macros for attribute tables */
 #define INAT_MAKE_PREFIX(pfx)   (pfx << INAT_PFX_OFFS)
 #define INAT_MAKE_ESCAPE(esc)   (esc << INAT_ESC_OFFS)
@@ -141,7 +143,13 @@ static inline int inat_last_prefix_id(insn_attr_t attr)
 static inline int inat_is_vex_prefix(insn_attr_t attr)
 {
         attr &= INAT_PFX_MASK;
-        return attr == INAT_PFX_VEX2 || attr == INAT_PFX_VEX3;
+        return attr == INAT_PFX_VEX2 || attr == INAT_PFX_VEX3 ||
+               attr == INAT_PFX_EVEX;
+}
+
+static inline int inat_is_evex_prefix(insn_attr_t attr)
+{
+        return (attr & INAT_PFX_MASK) == INAT_PFX_EVEX;
 }
 
 static inline int inat_is_vex3_prefix(insn_attr_t attr)
@@ -216,6 +224,11 @@ static inline int inat_accept_vex(insn_attr_t attr)
 
 static inline int inat_must_vex(insn_attr_t attr)
 {
-        return attr & INAT_VEXONLY;
+        return attr & (INAT_VEXONLY | INAT_EVEXONLY);
+}
+
+static inline int inat_must_evex(insn_attr_t attr)
+{
+        return attr & INAT_EVEXONLY;
 }
 #endif
diff --git a/tools/objtool/arch/x86/insn/insn.c b/tools/objtool/arch/x86/insn/insn.c
index 9f26eae6c9f0..ca983e2bea8b 100644
--- a/tools/objtool/arch/x86/insn/insn.c
+++ b/tools/objtool/arch/x86/insn/insn.c
@@ -155,14 +155,24 @@ found:
                         /*
                          * In 32-bits mode, if the [7:6] bits (mod bits of
                          * ModRM) on the second byte are not 11b, it is
-                         * LDS or LES.
+                         * LDS or LES or BOUND.
                          */
                         if (X86_MODRM_MOD(b2) != 3)
                                 goto vex_end;
                 }
                 insn->vex_prefix.bytes[0] = b;
                 insn->vex_prefix.bytes[1] = b2;
-                if (inat_is_vex3_prefix(attr)) {
+                if (inat_is_evex_prefix(attr)) {
+                        b2 = peek_nbyte_next(insn_byte_t, insn, 2);
+                        insn->vex_prefix.bytes[2] = b2;
+                        b2 = peek_nbyte_next(insn_byte_t, insn, 3);
+                        insn->vex_prefix.bytes[3] = b2;
+                        insn->vex_prefix.nbytes = 4;
+                        insn->next_byte += 4;
+                        if (insn->x86_64 && X86_VEX_W(b2))
+                                /* VEX.W overrides opnd_size */
+                                insn->opnd_bytes = 8;
+                } else if (inat_is_vex3_prefix(attr)) {
                         b2 = peek_nbyte_next(insn_byte_t, insn, 2);
                         insn->vex_prefix.bytes[2] = b2;
                         insn->vex_prefix.nbytes = 3;
@@ -221,7 +231,9 @@ void insn_get_opcode(struct insn *insn)
                 m = insn_vex_m_bits(insn);
                 p = insn_vex_p_bits(insn);
                 insn->attr = inat_get_avx_attribute(op, m, p);
-                if (!inat_accept_vex(insn->attr) && !inat_is_group(insn->attr))
+                if ((inat_must_evex(insn->attr) && !insn_is_evex(insn)) ||
+                    (!inat_accept_vex(insn->attr) &&
+                     !inat_is_group(insn->attr)))
                         insn->attr = 0; /* This instruction is bad */
                 goto end;       /* VEX has only 1 byte for opcode */
         }
diff --git a/tools/objtool/arch/x86/insn/insn.h b/tools/objtool/arch/x86/insn/insn.h
index dd12da0f4593..e23578c7b1be 100644
--- a/tools/objtool/arch/x86/insn/insn.h
+++ b/tools/objtool/arch/x86/insn/insn.h
@@ -91,6 +91,7 @@ struct insn {
 #define X86_VEX_B(vex)  ((vex) & 0x20)  /* VEX3 Byte1 */
 #define X86_VEX_L(vex)  ((vex) & 0x04)  /* VEX3 Byte2, VEX2 Byte1 */
 /* VEX bit fields */
+#define X86_EVEX_M(vex) ((vex) & 0x03)          /* EVEX Byte1 */
 #define X86_VEX3_M(vex) ((vex) & 0x1f)          /* VEX3 Byte1 */
 #define X86_VEX2_M      1                       /* VEX2.M always 1 */
 #define X86_VEX_V(vex)  (((vex) & 0x78) >> 3)   /* VEX3 Byte2, VEX2 Byte1 */
@@ -133,6 +134,13 @@ static inline int insn_is_avx(struct insn *insn)
         return (insn->vex_prefix.value != 0);
 }
 
+static inline int insn_is_evex(struct insn *insn)
+{
+        if (!insn->prefixes.got)
+                insn_get_prefixes(insn);
+        return (insn->vex_prefix.nbytes == 4);
+}
+
 /* Ensure this instruction is decoded completely */
 static inline int insn_complete(struct insn *insn)
 {
@@ -144,8 +152,10 @@ static inline insn_byte_t insn_vex_m_bits(struct insn *insn)
 {
         if (insn->vex_prefix.nbytes == 2)       /* 2 bytes VEX */
                 return X86_VEX2_M;
-        else
+        else if (insn->vex_prefix.nbytes == 3)  /* 3 bytes VEX */
                 return X86_VEX3_M(insn->vex_prefix.bytes[1]);
+        else                                    /* EVEX */
+                return X86_EVEX_M(insn->vex_prefix.bytes[1]);
 }
 
 static inline insn_byte_t insn_vex_p_bits(struct insn *insn)
diff --git a/tools/objtool/arch/x86/insn/x86-opcode-map.txt b/tools/objtool/arch/x86/insn/x86-opcode-map.txt
index d388de72eaca..767be7c76034 100644
--- a/tools/objtool/arch/x86/insn/x86-opcode-map.txt
+++ b/tools/objtool/arch/x86/insn/x86-opcode-map.txt
@@ -13,12 +13,17 @@
 # opcode: escape # escaped-name
 # EndTable
 #
+# mnemonics that begin with lowercase 'v' accept a VEX or EVEX prefix
+# mnemonics that begin with lowercase 'k' accept a VEX prefix
+#
 #<group maps>
 # GrpTable: GrpXXX
 # reg:  mnemonic [operand1[,operand2...]] [(extra1)[,(extra2)...] [| 2nd-mnemonic ...]
 # EndTable
 #
 # AVX Superscripts
+#  (ev): this opcode requires EVEX prefix.
+#  (evo): this opcode is changed by EVEX prefix (EVEX opcode)
 #  (v): this opcode requires VEX prefix.
 #  (v1): this opcode only supports 128bit VEX.
 #
@@ -137,7 +142,7 @@ AVXcode:
 # 0x60 - 0x6f
 60: PUSHA/PUSHAD (i64)
 61: POPA/POPAD (i64)
-62: BOUND Gv,Ma (i64)
+62: BOUND Gv,Ma (i64) | EVEX (Prefix)
 63: ARPL Ew,Gw (i64) | MOVSXD Gv,Ev (o64)
 64: SEG=FS (Prefix)
 65: SEG=GS (Prefix)
@@ -399,17 +404,17 @@ AVXcode: 1
 3f:
 # 0x0f 0x40-0x4f
 40: CMOVO Gv,Ev
-41: CMOVNO Gv,Ev
-42: CMOVB/C/NAE Gv,Ev
+41: CMOVNO Gv,Ev | kandw/q Vk,Hk,Uk | kandb/d Vk,Hk,Uk (66)
+42: CMOVB/C/NAE Gv,Ev | kandnw/q Vk,Hk,Uk | kandnb/d Vk,Hk,Uk (66)
 43: CMOVAE/NB/NC Gv,Ev
-44: CMOVE/Z Gv,Ev
-45: CMOVNE/NZ Gv,Ev
-46: CMOVBE/NA Gv,Ev
-47: CMOVA/NBE Gv,Ev
+44: CMOVE/Z Gv,Ev | knotw/q Vk,Uk | knotb/d Vk,Uk (66)
+45: CMOVNE/NZ Gv,Ev | korw/q Vk,Hk,Uk | korb/d Vk,Hk,Uk (66)
+46: CMOVBE/NA Gv,Ev | kxnorw/q Vk,Hk,Uk | kxnorb/d Vk,Hk,Uk (66)
+47: CMOVA/NBE Gv,Ev | kxorw/q Vk,Hk,Uk | kxorb/d Vk,Hk,Uk (66)
 48: CMOVS Gv,Ev
 49: CMOVNS Gv,Ev
-4a: CMOVP/PE Gv,Ev
-4b: CMOVNP/PO Gv,Ev
+4a: CMOVP/PE Gv,Ev | kaddw/q Vk,Hk,Uk | kaddb/d Vk,Hk,Uk (66)
+4b: CMOVNP/PO Gv,Ev | kunpckbw Vk,Hk,Uk (66) | kunpckwd/dq Vk,Hk,Uk
 4c: CMOVL/NGE Gv,Ev
 4d: CMOVNL/GE Gv,Ev
 4e: CMOVLE/NG Gv,Ev
@@ -426,7 +431,7 @@ AVXcode: 1
 58: vaddps Vps,Hps,Wps | vaddpd Vpd,Hpd,Wpd (66) | vaddss Vss,Hss,Wss (F3),(v1) | vaddsd Vsd,Hsd,Wsd (F2),(v1)
 59: vmulps Vps,Hps,Wps | vmulpd Vpd,Hpd,Wpd (66) | vmulss Vss,Hss,Wss (F3),(v1) | vmulsd Vsd,Hsd,Wsd (F2),(v1)
 5a: vcvtps2pd Vpd,Wps | vcvtpd2ps Vps,Wpd (66) | vcvtss2sd Vsd,Hx,Wss (F3),(v1) | vcvtsd2ss Vss,Hx,Wsd (F2),(v1)
-5b: vcvtdq2ps Vps,Wdq | vcvtps2dq Vdq,Wps (66) | vcvttps2dq Vdq,Wps (F3)
+5b: vcvtdq2ps Vps,Wdq | vcvtqq2ps Vps,Wqq (evo) | vcvtps2dq Vdq,Wps (66) | vcvttps2dq Vdq,Wps (F3)
 5c: vsubps Vps,Hps,Wps | vsubpd Vpd,Hpd,Wpd (66) | vsubss Vss,Hss,Wss (F3),(v1) | vsubsd Vsd,Hsd,Wsd (F2),(v1)
 5d: vminps Vps,Hps,Wps | vminpd Vpd,Hpd,Wpd (66) | vminss Vss,Hss,Wss (F3),(v1) | vminsd Vsd,Hsd,Wsd (F2),(v1)
 5e: vdivps Vps,Hps,Wps | vdivpd Vpd,Hpd,Wpd (66) | vdivss Vss,Hss,Wss (F3),(v1) | vdivsd Vsd,Hsd,Wsd (F2),(v1)
@@ -447,7 +452,7 @@ AVXcode: 1
 6c: vpunpcklqdq Vx,Hx,Wx (66),(v1)
 6d: vpunpckhqdq Vx,Hx,Wx (66),(v1)
 6e: movd/q Pd,Ey | vmovd/q Vy,Ey (66),(v1)
-6f: movq Pq,Qq | vmovdqa Vx,Wx (66) | vmovdqu Vx,Wx (F3)
+6f: movq Pq,Qq | vmovdqa Vx,Wx (66) | vmovdqa32/64 Vx,Wx (66),(evo) | vmovdqu Vx,Wx (F3) | vmovdqu32/64 Vx,Wx (F3),(evo) | vmovdqu8/16 Vx,Wx (F2),(ev)
 # 0x0f 0x70-0x7f
 70: pshufw Pq,Qq,Ib | vpshufd Vx,Wx,Ib (66),(v1) | vpshufhw Vx,Wx,Ib (F3),(v1) | vpshuflw Vx,Wx,Ib (F2),(v1)
 71: Grp12 (1A)
@@ -458,14 +463,14 @@ AVXcode: 1
 76: pcmpeqd Pq,Qq | vpcmpeqd Vx,Hx,Wx (66),(v1)
 # Note: Remove (v), because vzeroall and vzeroupper becomes emms without VEX.
 77: emms | vzeroupper | vzeroall
-78: VMREAD Ey,Gy
-79: VMWRITE Gy,Ey
-7a:
-7b:
+78: VMREAD Ey,Gy | vcvttps2udq/pd2udq Vx,Wpd (evo) | vcvttsd2usi Gv,Wx (F2),(ev) | vcvttss2usi Gv,Wx (F3),(ev) | vcvttps2uqq/pd2uqq Vx,Wx (66),(ev)
+79: VMWRITE Gy,Ey | vcvtps2udq/pd2udq Vx,Wpd (evo) | vcvtsd2usi Gv,Wx (F2),(ev) | vcvtss2usi Gv,Wx (F3),(ev) | vcvtps2uqq/pd2uqq Vx,Wx (66),(ev)
+7a: vcvtudq2pd/uqq2pd Vpd,Wx (F3),(ev) | vcvtudq2ps/uqq2ps Vpd,Wx (F2),(ev) | vcvttps2qq/pd2qq Vx,Wx (66),(ev)
+7b: vcvtusi2sd Vpd,Hpd,Ev (F2),(ev) | vcvtusi2ss Vps,Hps,Ev (F3),(ev) | vcvtps2qq/pd2qq Vx,Wx (66),(ev)
 7c: vhaddpd Vpd,Hpd,Wpd (66) | vhaddps Vps,Hps,Wps (F2)
 7d: vhsubpd Vpd,Hpd,Wpd (66) | vhsubps Vps,Hps,Wps (F2)
 7e: movd/q Ey,Pd | vmovd/q Ey,Vy (66),(v1) | vmovq Vq,Wq (F3),(v1)
-7f: movq Qq,Pq | vmovdqa Wx,Vx (66) | vmovdqu Wx,Vx (F3)
+7f: movq Qq,Pq | vmovdqa Wx,Vx (66) | vmovdqa32/64 Wx,Vx (66),(evo) | vmovdqu Wx,Vx (F3) | vmovdqu32/64 Wx,Vx (F3),(evo) | vmovdqu8/16 Wx,Vx (F2),(ev)
 # 0x0f 0x80-0x8f
 # Note: "forced64" is Intel CPU behavior (see comment about CALL insn).
 80: JO Jz (f64)
@@ -485,16 +490,16 @@ AVXcode: 1
 8e: JLE/JNG Jz (f64)
 8f: JNLE/JG Jz (f64)
 # 0x0f 0x90-0x9f
-90: SETO Eb
-91: SETNO Eb
-92: SETB/C/NAE Eb
-93: SETAE/NB/NC Eb
+90: SETO Eb | kmovw/q Vk,Wk | kmovb/d Vk,Wk (66)
+91: SETNO Eb | kmovw/q Mv,Vk | kmovb/d Mv,Vk (66)
+92: SETB/C/NAE Eb | kmovw Vk,Rv | kmovb Vk,Rv (66) | kmovq/d Vk,Rv (F2)
+93: SETAE/NB/NC Eb | kmovw Gv,Uk | kmovb Gv,Uk (66) | kmovq/d Gv,Uk (F2)
 94: SETE/Z Eb
 95: SETNE/NZ Eb
 96: SETBE/NA Eb
 97: SETA/NBE Eb
-98: SETS Eb
-99: SETNS Eb
+98: SETS Eb | kortestw/q Vk,Uk | kortestb/d Vk,Uk (66)
+99: SETNS Eb | ktestw/q Vk,Uk | ktestb/d Vk,Uk (66)
 9a: SETP/PE Eb
 9b: SETNP/PO Eb
 9c: SETL/NGE Eb
@@ -564,11 +569,11 @@ d7: pmovmskb Gd,Nq | vpmovmskb Gd,Ux (66),(v1)
 d8: psubusb Pq,Qq | vpsubusb Vx,Hx,Wx (66),(v1)
 d9: psubusw Pq,Qq | vpsubusw Vx,Hx,Wx (66),(v1)
 da: pminub Pq,Qq | vpminub Vx,Hx,Wx (66),(v1)
-db: pand Pq,Qq | vpand Vx,Hx,Wx (66),(v1)
+db: pand Pq,Qq | vpand Vx,Hx,Wx (66),(v1) | vpandd/q Vx,Hx,Wx (66),(evo)
 dc: paddusb Pq,Qq | vpaddusb Vx,Hx,Wx (66),(v1)
 dd: paddusw Pq,Qq | vpaddusw Vx,Hx,Wx (66),(v1)
 de: pmaxub Pq,Qq | vpmaxub Vx,Hx,Wx (66),(v1)
-df: pandn Pq,Qq | vpandn Vx,Hx,Wx (66),(v1)
+df: pandn Pq,Qq | vpandn Vx,Hx,Wx (66),(v1) | vpandnd/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0xe0-0xef
 e0: pavgb Pq,Qq | vpavgb Vx,Hx,Wx (66),(v1)
 e1: psraw Pq,Qq | vpsraw Vx,Hx,Wx (66),(v1)
@@ -576,16 +581,16 @@ e2: psrad Pq,Qq | vpsrad Vx,Hx,Wx (66),(v1)
 e3: pavgw Pq,Qq | vpavgw Vx,Hx,Wx (66),(v1)
 e4: pmulhuw Pq,Qq | vpmulhuw Vx,Hx,Wx (66),(v1)
 e5: pmulhw Pq,Qq | vpmulhw Vx,Hx,Wx (66),(v1)
-e6: vcvttpd2dq Vx,Wpd (66) | vcvtdq2pd Vx,Wdq (F3) | vcvtpd2dq Vx,Wpd (F2)
+e6: vcvttpd2dq Vx,Wpd (66) | vcvtdq2pd Vx,Wdq (F3) | vcvtdq2pd/qq2pd Vx,Wdq (F3),(evo) | vcvtpd2dq Vx,Wpd (F2)
 e7: movntq Mq,Pq | vmovntdq Mx,Vx (66)
 e8: psubsb Pq,Qq | vpsubsb Vx,Hx,Wx (66),(v1)
 e9: psubsw Pq,Qq | vpsubsw Vx,Hx,Wx (66),(v1)
 ea: pminsw Pq,Qq | vpminsw Vx,Hx,Wx (66),(v1)
-eb: por Pq,Qq | vpor Vx,Hx,Wx (66),(v1)
+eb: por Pq,Qq | vpor Vx,Hx,Wx (66),(v1) | vpord/q Vx,Hx,Wx (66),(evo)
 ec: paddsb Pq,Qq | vpaddsb Vx,Hx,Wx (66),(v1)
 ed: paddsw Pq,Qq | vpaddsw Vx,Hx,Wx (66),(v1)
 ee: pmaxsw Pq,Qq | vpmaxsw Vx,Hx,Wx (66),(v1)
-ef: pxor Pq,Qq | vpxor Vx,Hx,Wx (66),(v1)
+ef: pxor Pq,Qq | vpxor Vx,Hx,Wx (66),(v1) | vpxord/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0xf0-0xff
 f0: vlddqu Vx,Mx (F2)
 f1: psllw Pq,Qq | vpsllw Vx,Hx,Wx (66),(v1)
@@ -626,81 +631,105 @@ AVXcode: 2
 0e: vtestps Vx,Wx (66),(v)
 0f: vtestpd Vx,Wx (66),(v)
 # 0x0f 0x38 0x10-0x1f
-10: pblendvb Vdq,Wdq (66)
-11:
-12:
-13: vcvtph2ps Vx,Wx,Ib (66),(v)
-14: blendvps Vdq,Wdq (66)
-15: blendvpd Vdq,Wdq (66)
-16: vpermps Vqq,Hqq,Wqq (66),(v)
+10: pblendvb Vdq,Wdq (66) | vpsrlvw Vx,Hx,Wx (66),(evo) | vpmovuswb Wx,Vx (F3),(ev)
+11: vpmovusdb Wx,Vd (F3),(ev) | vpsravw Vx,Hx,Wx (66),(ev)
+12: vpmovusqb Wx,Vq (F3),(ev) | vpsllvw Vx,Hx,Wx (66),(ev)
+13: vcvtph2ps Vx,Wx (66),(v) | vpmovusdw Wx,Vd (F3),(ev)
+14: blendvps Vdq,Wdq (66) | vpmovusqw Wx,Vq (F3),(ev) | vprorvd/q Vx,Hx,Wx (66),(evo)
+15: blendvpd Vdq,Wdq (66) | vpmovusqd Wx,Vq (F3),(ev) | vprolvd/q Vx,Hx,Wx (66),(evo)
+16: vpermps Vqq,Hqq,Wqq (66),(v) | vpermps/d Vqq,Hqq,Wqq (66),(evo)
 17: vptest Vx,Wx (66)
 18: vbroadcastss Vx,Wd (66),(v)
-19: vbroadcastsd Vqq,Wq (66),(v)
-1a: vbroadcastf128 Vqq,Mdq (66),(v)
-1b:
+19: vbroadcastsd Vqq,Wq (66),(v) | vbroadcastf32x2 Vqq,Wq (66),(evo)
+1a: vbroadcastf128 Vqq,Mdq (66),(v) | vbroadcastf32x4/64x2 Vqq,Wq (66),(evo)
+1b: vbroadcastf32x8/64x4 Vqq,Mdq (66),(ev)
 1c: pabsb Pq,Qq | vpabsb Vx,Wx (66),(v1)
 1d: pabsw Pq,Qq | vpabsw Vx,Wx (66),(v1)
 1e: pabsd Pq,Qq | vpabsd Vx,Wx (66),(v1)
-1f:
+1f: vpabsq Vx,Wx (66),(ev)
 # 0x0f 0x38 0x20-0x2f
-20: vpmovsxbw Vx,Ux/Mq (66),(v1)
-21: vpmovsxbd Vx,Ux/Md (66),(v1)
-22: vpmovsxbq Vx,Ux/Mw (66),(v1)
-23: vpmovsxwd Vx,Ux/Mq (66),(v1)
-24: vpmovsxwq Vx,Ux/Md (66),(v1)
-25: vpmovsxdq Vx,Ux/Mq (66),(v1)
-26:
-27:
-28: vpmuldq Vx,Hx,Wx (66),(v1)
-29: vpcmpeqq Vx,Hx,Wx (66),(v1)
-2a: vmovntdqa Vx,Mx (66),(v1)
+20: vpmovsxbw Vx,Ux/Mq (66),(v1) | vpmovswb Wx,Vx (F3),(ev)
+21: vpmovsxbd Vx,Ux/Md (66),(v1) | vpmovsdb Wx,Vd (F3),(ev)
+22: vpmovsxbq Vx,Ux/Mw (66),(v1) | vpmovsqb Wx,Vq (F3),(ev)
+23: vpmovsxwd Vx,Ux/Mq (66),(v1) | vpmovsdw Wx,Vd (F3),(ev)
+24: vpmovsxwq Vx,Ux/Md (66),(v1) | vpmovsqw Wx,Vq (F3),(ev)
+25: vpmovsxdq Vx,Ux/Mq (66),(v1) | vpmovsqd Wx,Vq (F3),(ev)
+26: vptestmb/w Vk,Hx,Wx (66),(ev) | vptestnmb/w Vk,Hx,Wx (F3),(ev)
+27: vptestmd/q Vk,Hx,Wx (66),(ev) | vptestnmd/q Vk,Hx,Wx (F3),(ev)
+28: vpmuldq Vx,Hx,Wx (66),(v1) | vpmovm2b/w Vx,Uk (F3),(ev)
+29: vpcmpeqq Vx,Hx,Wx (66),(v1) | vpmovb2m/w2m Vk,Ux (F3),(ev)
+2a: vmovntdqa Vx,Mx (66),(v1) | vpbroadcastmb2q Vx,Uk (F3),(ev)
 2b: vpackusdw Vx,Hx,Wx (66),(v1)
-2c: vmaskmovps Vx,Hx,Mx (66),(v)
-2d: vmaskmovpd Vx,Hx,Mx (66),(v)
+2c: vmaskmovps Vx,Hx,Mx (66),(v) | vscalefps/d Vx,Hx,Wx (66),(evo)
+2d: vmaskmovpd Vx,Hx,Mx (66),(v) | vscalefss/d Vx,Hx,Wx (66),(evo)
 2e: vmaskmovps Mx,Hx,Vx (66),(v)
 2f: vmaskmovpd Mx,Hx,Vx (66),(v)
 # 0x0f 0x38 0x30-0x3f
-30: vpmovzxbw Vx,Ux/Mq (66),(v1)
-31: vpmovzxbd Vx,Ux/Md (66),(v1)
-32: vpmovzxbq Vx,Ux/Mw (66),(v1)
-33: vpmovzxwd Vx,Ux/Mq (66),(v1)
-34: vpmovzxwq Vx,Ux/Md (66),(v1)
-35: vpmovzxdq Vx,Ux/Mq (66),(v1)
-36: vpermd Vqq,Hqq,Wqq (66),(v)
+30: vpmovzxbw Vx,Ux/Mq (66),(v1) | vpmovwb Wx,Vx (F3),(ev)
+31: vpmovzxbd Vx,Ux/Md (66),(v1) | vpmovdb Wx,Vd (F3),(ev)
+32: vpmovzxbq Vx,Ux/Mw (66),(v1) | vpmovqb Wx,Vq (F3),(ev)
+33: vpmovzxwd Vx,Ux/Mq (66),(v1) | vpmovdw Wx,Vd (F3),(ev)
+34: vpmovzxwq Vx,Ux/Md (66),(v1) | vpmovqw Wx,Vq (F3),(ev)
+35: vpmovzxdq Vx,Ux/Mq (66),(v1) | vpmovqd Wx,Vq (F3),(ev)
+36: vpermd Vqq,Hqq,Wqq (66),(v) | vpermd/q Vqq,Hqq,Wqq (66),(evo)
 37: vpcmpgtq Vx,Hx,Wx (66),(v1)
-38: vpminsb Vx,Hx,Wx (66),(v1)
-39: vpminsd Vx,Hx,Wx (66),(v1)
-3a: vpminuw Vx,Hx,Wx (66),(v1)
-3b: vpminud Vx,Hx,Wx (66),(v1)
+38: vpminsb Vx,Hx,Wx (66),(v1) | vpmovm2d/q Vx,Uk (F3),(ev)
+39: vpminsd Vx,Hx,Wx (66),(v1) | vpminsd/q Vx,Hx,Wx (66),(evo) | vpmovd2m/q2m Vk,Ux (F3),(ev)
+3a: vpminuw Vx,Hx,Wx (66),(v1) | vpbroadcastmw2d Vx,Uk (F3),(ev)
+3b: vpminud Vx,Hx,Wx (66),(v1) | vpminud/q Vx,Hx,Wx (66),(evo)
 3c: vpmaxsb Vx,Hx,Wx (66),(v1)
-3d: vpmaxsd Vx,Hx,Wx (66),(v1)
+3d: vpmaxsd Vx,Hx,Wx (66),(v1) | vpmaxsd/q Vx,Hx,Wx (66),(evo)
 3e: vpmaxuw Vx,Hx,Wx (66),(v1)
-3f: vpmaxud Vx,Hx,Wx (66),(v1)
+3f: vpmaxud Vx,Hx,Wx (66),(v1) | vpmaxud/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0x38 0x40-0x8f
-40: vpmulld Vx,Hx,Wx (66),(v1)
+40: vpmulld Vx,Hx,Wx (66),(v1) | vpmulld/q Vx,Hx,Wx (66),(evo)
 41: vphminposuw Vdq,Wdq (66),(v1)
-42:
-43:
-44:
+42: vgetexpps/d Vx,Wx (66),(ev)
+43: vgetexpss/d Vx,Hx,Wx (66),(ev)
+44: vplzcntd/q Vx,Wx (66),(ev)
 45: vpsrlvd/q Vx,Hx,Wx (66),(v)
-46: vpsravd Vx,Hx,Wx (66),(v)
+46: vpsravd Vx,Hx,Wx (66),(v) | vpsravd/q Vx,Hx,Wx (66),(evo)
 47: vpsllvd/q Vx,Hx,Wx (66),(v)
-# Skip 0x48-0x57
+# Skip 0x48-0x4b
+4c: vrcp14ps/d Vpd,Wpd (66),(ev)
+4d: vrcp14ss/d Vsd,Hpd,Wsd (66),(ev)
+4e: vrsqrt14ps/d Vpd,Wpd (66),(ev)
+4f: vrsqrt14ss/d Vsd,Hsd,Wsd (66),(ev)
+# Skip 0x50-0x57
 58: vpbroadcastd Vx,Wx (66),(v)
-59: vpbroadcastq Vx,Wx (66),(v)
-5a: vbroadcasti128 Vqq,Mdq (66),(v)
-# Skip 0x5b-0x77
+59: vpbroadcastq Vx,Wx (66),(v) | vbroadcasti32x2 Vx,Wx (66),(evo)
+5a: vbroadcasti128 Vqq,Mdq (66),(v) | vbroadcasti32x4/64x2 Vx,Wx (66),(evo)
+5b: vbroadcasti32x8/64x4 Vqq,Mdq (66),(ev)
+# Skip 0x5c-0x63
+64: vpblendmd/q Vx,Hx,Wx (66),(ev)
+65: vblendmps/d Vx,Hx,Wx (66),(ev)
+66: vpblendmb/w Vx,Hx,Wx (66),(ev)
+# Skip 0x67-0x74
+75: vpermi2b/w Vx,Hx,Wx (66),(ev)
+76: vpermi2d/q Vx,Hx,Wx (66),(ev)
+77: vpermi2ps/d Vx,Hx,Wx (66),(ev)
 78: vpbroadcastb Vx,Wx (66),(v)
 79: vpbroadcastw Vx,Wx (66),(v)
-# Skip 0x7a-0x7f
+7a: vpbroadcastb Vx,Rv (66),(ev)
+7b: vpbroadcastw Vx,Rv (66),(ev)
+7c: vpbroadcastd/q Vx,Rv (66),(ev)
+7d: vpermt2b/w Vx,Hx,Wx (66),(ev)
+7e: vpermt2d/q Vx,Hx,Wx (66),(ev)
+7f: vpermt2ps/d Vx,Hx,Wx (66),(ev)
 80: INVEPT Gy,Mdq (66)
 81: INVPID Gy,Mdq (66)
 82: INVPCID Gy,Mdq (66)
+83: vpmultishiftqb Vx,Hx,Wx (66),(ev)
+88: vexpandps/d Vpd,Wpd (66),(ev)
+89: vpexpandd/q Vx,Wx (66),(ev)
+8a: vcompressps/d Wx,Vx (66),(ev)
+8b: vpcompressd/q Wx,Vx (66),(ev)
 8c: vpmaskmovd/q Vx,Hx,Mx (66),(v)
+8d: vpermb/w Vx,Hx,Wx (66),(ev)
 8e: vpmaskmovd/q Mx,Vx,Hx (66),(v)
 # 0x0f 0x38 0x90-0xbf (FMA)
-90: vgatherdd/q Vx,Hx,Wx (66),(v)
-91: vgatherqd/q Vx,Hx,Wx (66),(v)
+90: vgatherdd/q Vx,Hx,Wx (66),(v) | vpgatherdd/q Vx,Wx (66),(evo)
+91: vgatherqd/q Vx,Hx,Wx (66),(v) | vpgatherqd/q Vx,Wx (66),(evo)
 92: vgatherdps/d Vx,Hx,Wx (66),(v)
 93: vgatherqps/d Vx,Hx,Wx (66),(v)
 94:
@@ -715,6 +744,10 @@ AVXcode: 2
 9d: vfnmadd132ss/d Vx,Hx,Wx (66),(v),(v1)
 9e: vfnmsub132ps/d Vx,Hx,Wx (66),(v)
 9f: vfnmsub132ss/d Vx,Hx,Wx (66),(v),(v1)
+a0: vpscatterdd/q Wx,Vx (66),(ev)
+a1: vpscatterqd/q Wx,Vx (66),(ev)
+a2: vscatterdps/d Wx,Vx (66),(ev)
+a3: vscatterqps/d Wx,Vx (66),(ev)
 a6: vfmaddsub213ps/d Vx,Hx,Wx (66),(v)
 a7: vfmsubadd213ps/d Vx,Hx,Wx (66),(v)
 a8: vfmadd213ps/d Vx,Hx,Wx (66),(v)
@@ -725,6 +758,8 @@ ac: vfnmadd213ps/d Vx,Hx,Wx (66),(v)
 ad: vfnmadd213ss/d Vx,Hx,Wx (66),(v),(v1)
 ae: vfnmsub213ps/d Vx,Hx,Wx (66),(v)
 af: vfnmsub213ss/d Vx,Hx,Wx (66),(v),(v1)
+b4: vpmadd52luq Vx,Hx,Wx (66),(ev)
+b5: vpmadd52huq Vx,Hx,Wx (66),(ev)
 b6: vfmaddsub231ps/d Vx,Hx,Wx (66),(v)
 b7: vfmsubadd231ps/d Vx,Hx,Wx (66),(v)
 b8: vfmadd231ps/d Vx,Hx,Wx (66),(v)
@@ -736,12 +771,15 @@ bd: vfnmadd231ss/d Vx,Hx,Wx (66),(v),(v1)
 be: vfnmsub231ps/d Vx,Hx,Wx (66),(v)
 bf: vfnmsub231ss/d Vx,Hx,Wx (66),(v),(v1)
 # 0x0f 0x38 0xc0-0xff
-c8: sha1nexte Vdq,Wdq
+c4: vpconflictd/q Vx,Wx (66),(ev)
+c6: Grp18 (1A)
+c7: Grp19 (1A)
+c8: sha1nexte Vdq,Wdq | vexp2ps/d Vx,Wx (66),(ev)
 c9: sha1msg1 Vdq,Wdq
-ca: sha1msg2 Vdq,Wdq
-cb: sha256rnds2 Vdq,Wdq
-cc: sha256msg1 Vdq,Wdq
-cd: sha256msg2 Vdq,Wdq
+ca: sha1msg2 Vdq,Wdq | vrcp28ps/d Vx,Wx (66),(ev)
+cb: sha256rnds2 Vdq,Wdq | vrcp28ss/d Vx,Hx,Wx (66),(ev)
+cc: sha256msg1 Vdq,Wdq | vrsqrt28ps/d Vx,Wx (66),(ev)
+cd: sha256msg2 Vdq,Wdq | vrsqrt28ss/d Vx,Hx,Wx (66),(ev)
 db: VAESIMC Vdq,Wdq (66),(v1)
 dc: VAESENC Vdq,Hdq,Wdq (66),(v1)
 dd: VAESENCLAST Vdq,Hdq,Wdq (66),(v1)
@@ -763,15 +801,15 @@ AVXcode: 3
 00: vpermq Vqq,Wqq,Ib (66),(v)
 01: vpermpd Vqq,Wqq,Ib (66),(v)
 02: vpblendd Vx,Hx,Wx,Ib (66),(v)
-03:
+03: valignd/q Vx,Hx,Wx,Ib (66),(ev)
 04: vpermilps Vx,Wx,Ib (66),(v)
 05: vpermilpd Vx,Wx,Ib (66),(v)
 06: vperm2f128 Vqq,Hqq,Wqq,Ib (66),(v)
 07:
-08: vroundps Vx,Wx,Ib (66)
-09: vroundpd Vx,Wx,Ib (66)
-0a: vroundss Vss,Wss,Ib (66),(v1)
-0b: vroundsd Vsd,Wsd,Ib (66),(v1)
+08: vroundps Vx,Wx,Ib (66) | vrndscaleps Vx,Wx,Ib (66),(evo)
+09: vroundpd Vx,Wx,Ib (66) | vrndscalepd Vx,Wx,Ib (66),(evo)
+0a: vroundss Vss,Wss,Ib (66),(v1) | vrndscaless Vx,Hx,Wx,Ib (66),(evo)
+0b: vroundsd Vsd,Wsd,Ib (66),(v1) | vrndscalesd Vx,Hx,Wx,Ib (66),(evo)
 0c: vblendps Vx,Hx,Wx,Ib (66)
 0d: vblendpd Vx,Hx,Wx,Ib (66)
 0e: vpblendw Vx,Hx,Wx,Ib (66),(v1)
@@ -780,26 +818,51 @@ AVXcode: 3
 15: vpextrw Rd/Mw,Vdq,Ib (66),(v1)
 16: vpextrd/q Ey,Vdq,Ib (66),(v1)
 17: vextractps Ed,Vdq,Ib (66),(v1)
-18: vinsertf128 Vqq,Hqq,Wqq,Ib (66),(v)
-19: vextractf128 Wdq,Vqq,Ib (66),(v)
+18: vinsertf128 Vqq,Hqq,Wqq,Ib (66),(v) | vinsertf32x4/64x2 Vqq,Hqq,Wqq,Ib (66),(evo)
+19: vextractf128 Wdq,Vqq,Ib (66),(v) | vextractf32x4/64x2 Wdq,Vqq,Ib (66),(evo)
+1a: vinsertf32x8/64x4 Vqq,Hqq,Wqq,Ib (66),(ev)
+1b: vextractf32x8/64x4 Wdq,Vqq,Ib (66),(ev)
 1d: vcvtps2ph Wx,Vx,Ib (66),(v)
+1e: vpcmpud/q Vk,Hd,Wd,Ib (66),(ev)
+1f: vpcmpd/q Vk,Hd,Wd,Ib (66),(ev)
 20: vpinsrb Vdq,Hdq,Ry/Mb,Ib (66),(v1)
 21: vinsertps Vdq,Hdq,Udq/Md,Ib (66),(v1)
 22: vpinsrd/q Vdq,Hdq,Ey,Ib (66),(v1)
-38: vinserti128 Vqq,Hqq,Wqq,Ib (66),(v)
-39: vextracti128 Wdq,Vqq,Ib (66),(v)
+23: vshuff32x4/64x2 Vx,Hx,Wx,Ib (66),(ev)
+25: vpternlogd/q Vx,Hx,Wx,Ib (66),(ev)
+26: vgetmantps/d Vx,Wx,Ib (66),(ev)
+27: vgetmantss/d Vx,Hx,Wx,Ib (66),(ev)
+30: kshiftrb/w Vk,Uk,Ib (66),(v)
+31: kshiftrd/q Vk,Uk,Ib (66),(v)
+32: kshiftlb/w Vk,Uk,Ib (66),(v)
+33: kshiftld/q Vk,Uk,Ib (66),(v)
+38: vinserti128 Vqq,Hqq,Wqq,Ib (66),(v) | vinserti32x4/64x2 Vqq,Hqq,Wqq,Ib (66),(evo)
+39: vextracti128 Wdq,Vqq,Ib (66),(v) | vextracti32x4/64x2 Wdq,Vqq,Ib (66),(evo)
+3a: vinserti32x8/64x4 Vqq,Hqq,Wqq,Ib (66),(ev)
+3b: vextracti32x8/64x4 Wdq,Vqq,Ib (66),(ev)
+3e: vpcmpub/w Vk,Hk,Wx,Ib (66),(ev)
+3f: vpcmpb/w Vk,Hk,Wx,Ib (66),(ev)
 40: vdpps Vx,Hx,Wx,Ib (66)
 41: vdppd Vdq,Hdq,Wdq,Ib (66),(v1)
-42: vmpsadbw Vx,Hx,Wx,Ib (66),(v1)
+42: vmpsadbw Vx,Hx,Wx,Ib (66),(v1) | vdbpsadbw Vx,Hx,Wx,Ib (66),(evo)
+43: vshufi32x4/64x2 Vx,Hx,Wx,Ib (66),(ev)
 44: vpclmulqdq Vdq,Hdq,Wdq,Ib (66),(v1)
 46: vperm2i128 Vqq,Hqq,Wqq,Ib (66),(v)
 4a: vblendvps Vx,Hx,Wx,Lx (66),(v)
 4b: vblendvpd Vx,Hx,Wx,Lx (66),(v)
 4c: vpblendvb Vx,Hx,Wx,Lx (66),(v1)
+50: vrangeps/d Vx,Hx,Wx,Ib (66),(ev)
+51: vrangess/d Vx,Hx,Wx,Ib (66),(ev)
+54: vfixupimmps/d Vx,Hx,Wx,Ib (66),(ev)
+55: vfixupimmss/d Vx,Hx,Wx,Ib (66),(ev)
+56: vreduceps/d Vx,Wx,Ib (66),(ev)
+57: vreducess/d Vx,Hx,Wx,Ib (66),(ev)
 60: vpcmpestrm Vdq,Wdq,Ib (66),(v1)
 61: vpcmpestri Vdq,Wdq,Ib (66),(v1)
 62: vpcmpistrm Vdq,Wdq,Ib (66),(v1)
 63: vpcmpistri Vdq,Wdq,Ib (66),(v1)
+66: vfpclassps/d Vk,Wx,Ib (66),(ev)
+67: vfpclassss/d Vk,Wx,Ib (66),(ev)
 cc: sha1rnds4 Vdq,Wdq,Ib
 df: VAESKEYGEN Vdq,Wdq,Ib (66),(v1)
 f0: RORX Gy,Ey,Ib (F2),(v)
@@ -927,8 +990,10 @@ GrpTable: Grp12
 EndTable
 
 GrpTable: Grp13
+0: vprord/q Hx,Wx,Ib (66),(ev)
+1: vprold/q Hx,Wx,Ib (66),(ev)
 2: psrld Nq,Ib (11B) | vpsrld Hx,Ux,Ib (66),(11B),(v1)
-4: psrad Nq,Ib (11B) | vpsrad Hx,Ux,Ib (66),(11B),(v1)
+4: psrad Nq,Ib (11B) | vpsrad Hx,Ux,Ib (66),(11B),(v1) | vpsrad/q Hx,Ux,Ib (66),(evo)
 6: pslld Nq,Ib (11B) | vpslld Hx,Ux,Ib (66),(11B),(v1)
 EndTable
 
@@ -947,7 +1012,7 @@ GrpTable: Grp15
 4: XSAVE
 5: XRSTOR | lfence (11B)
 6: XSAVEOPT | clwb (66) | mfence (11B)
-7: clflush | clflushopt (66) | sfence (11B) | pcommit (66),(11B)
+7: clflush | clflushopt (66) | sfence (11B)
 EndTable
 
 GrpTable: Grp16
@@ -963,6 +1028,20 @@ GrpTable: Grp17
 3: BLSI By,Ey (v)
 EndTable
 
+GrpTable: Grp18
+1: vgatherpf0dps/d Wx (66),(ev)
+2: vgatherpf1dps/d Wx (66),(ev)
+5: vscatterpf0dps/d Wx (66),(ev)
+6: vscatterpf1dps/d Wx (66),(ev)
+EndTable
+
+GrpTable: Grp19
+1: vgatherpf0qps/d Wx (66),(ev)
+2: vgatherpf1qps/d Wx (66),(ev)
+5: vscatterpf0qps/d Wx (66),(ev)
+6: vscatterpf1qps/d Wx (66),(ev)
+EndTable
+
 # AMD's Prefetch Group
 GrpTable: GrpP
 0: PREFETCH
diff --git a/tools/objtool/builtin-check.c b/tools/objtool/builtin-check.c
index e8a1e69eb92c..143b6cdd7f06 100644
--- a/tools/objtool/builtin-check.c
+++ b/tools/objtool/builtin-check.c
@@ -26,6 +26,7 @@
  */
 
 #include <string.h>
+#include <stdlib.h>
 #include <subcmd/parse-options.h>
 
 #include "builtin.h"
@@ -106,6 +107,12 @@ static struct instruction *next_insn_same_sec(struct objtool_file *file,
                 insn->offset < func->offset + func->len;                \
              insn = list_next_entry(insn, list))
 
+#define func_for_each_insn_continue_reverse(file, func, insn)           \
+        for (insn = list_prev_entry(insn, list);                        \
+             &insn->list != &file->insn_list &&                         \
+                insn->sec == func->sec && insn->offset >= func->offset; \
+             insn = list_prev_entry(insn, list))
+
 #define sec_for_each_insn_from(file, insn)                              \
         for (; insn; insn = next_insn_same_sec(file, insn))
 
@@ -122,10 +129,14 @@ static bool ignore_func(struct objtool_file *file, struct symbol *func)
 
         /* check for STACK_FRAME_NON_STANDARD */
         if (file->whitelist && file->whitelist->rela)
-                list_for_each_entry(rela, &file->whitelist->rela->rela_list, list)
-                        if (rela->sym->sec == func->sec &&
+                list_for_each_entry(rela, &file->whitelist->rela->rela_list, list) {
+                        if (rela->sym->type == STT_SECTION &&
+                            rela->sym->sec == func->sec &&
                             rela->addend == func->offset)
                                 return true;
+                        if (rela->sym->type == STT_FUNC && rela->sym == func)
+                                return true;
+                }
 
         /* check if it has a context switching instruction */
         func_for_each_insn(file, func, insn)
@@ -164,6 +175,7 @@ static int __dead_end_function(struct objtool_file *file, struct symbol *func,
                 "__stack_chk_fail",
                 "panic",
                 "do_exit",
+                "do_task_dead",
                 "__module_put_and_exit",
                 "complete_and_exit",
                 "kvm_spurious_fault",
@@ -659,65 +671,95 @@ static int add_switch_table(struct objtool_file *file, struct symbol *func,
         return 0;
 }
 
-static int add_func_switch_tables(struct objtool_file *file,
-                                  struct symbol *func)
+/*
+ * find_switch_table() - Given a dynamic jump, find the switch jump table in
+ * .rodata associated with it.
+ *
+ * There are 3 basic patterns:
+ *
+ * 1. jmpq *[rodata addr](,%reg,8)
+ *
+ *    This is the most common case by far.  It jumps to an address in a simple
+ *    jump table which is stored in .rodata.
+ *
+ * 2. jmpq *[rodata addr](%rip)
+ *
+ *    This is caused by a rare GCC quirk, currently only seen in three driver
+ *    functions in the kernel, only with certain obscure non-distro configs.
+ *
+ *    As part of an optimization, GCC makes a copy of an existing switch jump
+ *    table, modifies it, and then hard-codes the jump (albeit with an indirect
+ *    jump) to use a single entry in the table.  The rest of the jump table and
+ *    some of its jump targets remain as dead code.
+ *
+ *    In such a case we can just crudely ignore all unreachable instruction
+ *    warnings for the entire object file.  Ideally we would just ignore them
+ *    for the function, but that would require redesigning the code quite a
+ *    bit.  And honestly that's just not worth doing: unreachable instruction
+ *    warnings are of questionable value anyway, and this is such a rare issue.
+ *
+ * 3. mov [rodata addr],%reg1
+ *    ... some instructions ...
+ *    jmpq *(%reg1,%reg2,8)
+ *
+ *    This is a fairly uncommon pattern which is new for GCC 6.  As of this
+ *    writing, there are 11 occurrences of it in the allmodconfig kernel.
+ *
+ *    TODO: Once we have DWARF CFI and smarter instruction decoding logic,
+ *    ensure the same register is used in the mov and jump instructions.
+ */
+static struct rela *find_switch_table(struct objtool_file *file,
+                                      struct symbol *func,
+                                      struct instruction *insn)
 {
-        struct instruction *insn, *prev_jump;
-        struct rela *text_rela, *rodata_rela, *prev_rela;
-        int ret;
+        struct rela *text_rela, *rodata_rela;
 
-        prev_jump = NULL;
+        text_rela = find_rela_by_dest_range(insn->sec, insn->offset, insn->len);
+        if (text_rela && text_rela->sym == file->rodata->sym) {
+                /* case 1 */
+                rodata_rela = find_rela_by_dest(file->rodata,
+                                                text_rela->addend);
+                if (rodata_rela)
+                        return rodata_rela;
 
-        func_for_each_insn(file, func, insn) {
-                if (insn->type != INSN_JUMP_DYNAMIC)
-                        continue;
+                /* case 2 */
+                rodata_rela = find_rela_by_dest(file->rodata,
+                                                text_rela->addend + 4);
+                if (!rodata_rela)
+                        return NULL;
+                file->ignore_unreachables = true;
+                return rodata_rela;
+        }
+
+        /* case 3 */
+        func_for_each_insn_continue_reverse(file, func, insn) {
+                if (insn->type == INSN_JUMP_UNCONDITIONAL ||
+                    insn->type == INSN_JUMP_DYNAMIC)
+                        break;
 
                 text_rela = find_rela_by_dest_range(insn->sec, insn->offset,
                                                     insn->len);
-                if (!text_rela || text_rela->sym != file->rodata->sym)
-                        continue;
+                if (text_rela && text_rela->sym == file->rodata->sym)
+                        return find_rela_by_dest(file->rodata,
+                                                 text_rela->addend);
+        }
 
-                /* common case: jmpq *[addr](,%rax,8) */
-                rodata_rela = find_rela_by_dest(file->rodata,
-                                                text_rela->addend);
+        return NULL;
+}
 
-                /*
-                 * rare case:   jmpq *[addr](%rip)
-                 *
-                 * This check is for a rare gcc quirk, currently only seen in
-                 * three driver functions in the kernel, only with certain
-                 * obscure non-distro configs.
-                 *
-                 * As part of an optimization, gcc makes a copy of an existing
-                 * switch jump table, modifies it, and then hard-codes the jump
-                 * (albeit with an indirect jump) to use a single entry in the
-                 * table.  The rest of the jump table and some of its jump
-                 * targets remain as dead code.
-                 *
-                 * In such a case we can just crudely ignore all unreachable
-                 * instruction warnings for the entire object file.  Ideally we
-                 * would just ignore them for the function, but that would
-                 * require redesigning the code quite a bit.  And honestly
-                 * that's just not worth doing: unreachable instruction
-                 * warnings are of questionable value anyway, and this is such
-                 * a rare issue.
-                 *
-                 * kbuild reports:
-                 * - https://lkml.kernel.org/r/201603231906.LWcVUpxm%25fengguang.wu@intel.com
-                 * - https://lkml.kernel.org/r/201603271114.K9i45biy%25fengguang.wu@intel.com
-                 * - https://lkml.kernel.org/r/201603291058.zuJ6ben1%25fengguang.wu@intel.com
-                 *
-                 * gcc bug:
-                 * - https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70604
-                 */
-                if (!rodata_rela) {
-                        rodata_rela = find_rela_by_dest(file->rodata,
-                                                        text_rela->addend + 4);
-                        if (rodata_rela)
-                                file->ignore_unreachables = true;
-                }
+static int add_func_switch_tables(struct objtool_file *file,
+                                  struct symbol *func)
+{
+        struct instruction *insn, *prev_jump = NULL;
+        struct rela *rela, *prev_rela = NULL;
+        int ret;
 
-                if (!rodata_rela)
+        func_for_each_insn(file, func, insn) {
+                if (insn->type != INSN_JUMP_DYNAMIC)
+                        continue;
+
+                rela = find_switch_table(file, func, insn);
+                if (!rela)
                         continue;
 
                 /*
@@ -727,13 +769,13 @@ static int add_func_switch_tables(struct objtool_file *file,
                  */
                 if (prev_jump) {
                         ret = add_switch_table(file, func, prev_jump, prev_rela,
-                                               rodata_rela);
+                                               rela);
                         if (ret)
                                 return ret;
                 }
 
                 prev_jump = insn;
-                prev_rela = rodata_rela;
+                prev_rela = rela;
         }
 
         if (prev_jump) {
diff --git a/tools/objtool/elf.c b/tools/objtool/elf.c
index e11f6b69cce6..0d7983ac63ef 100644
--- a/tools/objtool/elf.c
+++ b/tools/objtool/elf.c
@@ -30,6 +30,13 @@
 #include "elf.h"
 #include "warn.h"
 
+/*
+ * Fallback for systems without this "read, mmaping if possible" cmd.
+ */
+#ifndef ELF_C_READ_MMAP
+#define ELF_C_READ_MMAP ELF_C_READ
+#endif
+
 struct section *find_section_by_name(struct elf *elf, const char *name)
 {
         struct section *sec;
diff --git a/tools/pcmcia/.gitignore b/tools/pcmcia/.gitignore
new file mode 100644
index 000000000000..53d081336757
--- /dev/null
+++ b/tools/pcmcia/.gitignore
@@ -0,0 +1 @@
+crc32hash
diff --git a/tools/pcmcia/Makefile b/tools/pcmcia/Makefile
new file mode 100644
index 000000000000..81a7498c5cd9
--- /dev/null
+++ b/tools/pcmcia/Makefile
@@ -0,0 +1,9 @@
+CC := $(CROSS_COMPILE)gcc
+CFLAGS := -I../../usr/include
+
+PROGS := crc32hash
+
+all: $(PROGS)
+
+clean:
+        rm -fr $(PROGS)
diff --git a/tools/pcmcia/crc32hash.c b/tools/pcmcia/crc32hash.c
new file mode 100644
index 000000000000..44f8beea7260
--- /dev/null
+++ b/tools/pcmcia/crc32hash.c
@@ -0,0 +1,32 @@
+/* crc32hash.c - derived from linux/lib/crc32.c, GNU GPL v2 */
+/* Usage example:
+$ ./crc32hash "Dual Speed"
+*/
+
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+
+static unsigned int crc32(unsigned char const *p, unsigned int len)
+{
+        int i;
+        unsigned int crc = 0;
+        while (len--) {
+                crc ^= *p++;
+                for (i = 0; i < 8; i++)
+                        crc = (crc >> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
+        }
+        return crc;
+}
+
+int main(int argc, char **argv) {
+        unsigned int result;
+        if (argc != 2) {
+                printf("no string passed as argument\n");
+                return -1;
+        }
+        result = crc32((unsigned char const *)argv[1], strlen(argv[1]));
+        printf("0x%x\n", result);
+        return 0;
+}
diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index 3d1bb802dbf4..3db3db9278be 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -30,3 +30,4 @@ config.mak.autogen
 *.pyo
 .config-detected
 util/intel-pt-decoder/inat-tables.c
+arch/*/include/generated/
diff --git a/tools/perf/Documentation/android.txt b/tools/perf/Documentation/android.txt
index 8484c3a04a6a..24a59998fc91 100644
--- a/tools/perf/Documentation/android.txt
+++ b/tools/perf/Documentation/android.txt
@@ -12,14 +12,14 @@ Set the NDK variable to point to the path where you installed the NDK:
 
 2. Set cross-compiling environment variables for NDK toolchain and sysroot.
 For arm:
-  export NDK_TOOLCHAIN=${NDK}/toolchains/arm-linux-androideabi-4.6/prebuilt/linux-x86/bin/arm-linux-androideabi-
-  export NDK_SYSROOT=${NDK}/platforms/android-9/arch-arm
+  export NDK_TOOLCHAIN=${NDK}/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-
+  export NDK_SYSROOT=${NDK}/platforms/android-24/arch-arm
 For x86:
-  export NDK_TOOLCHAIN=${NDK}/toolchains/x86-4.6/prebuilt/linux-x86/bin/i686-linux-android-
-  export NDK_SYSROOT=${NDK}/platforms/android-9/arch-x86
+  export NDK_TOOLCHAIN=${NDK}/toolchains/x86-4.9/prebuilt/linux-x86_64/bin/i686-linux-android-
+  export NDK_SYSROOT=${NDK}/platforms/android-24/arch-x86
 
-This method is not working for Android NDK versions up to Revision 8b.
-perf uses some bionic enhancements that are not included in these NDK versions.
+This method is only tested for Android NDK versions Revision 11b and later.
+perf uses some bionic enhancements that are not included in prior NDK versions.
 You can use method (b) described below instead.
 
 (b). Use the Android source tree
@@ -49,9 +49,9 @@ II. Compile perf for Android
 ------------------------------------------------
 You need to run make with the NDK toolchain and sysroot defined above:
 For arm:
-  make ARCH=arm CROSS_COMPILE=${NDK_TOOLCHAIN} CFLAGS="--sysroot=${NDK_SYSROOT}"
+  make WERROR=0 ARCH=arm CROSS_COMPILE=${NDK_TOOLCHAIN} EXTRA_CFLAGS="-pie --sysroot=${NDK_SYSROOT}"
 For x86:
-  make ARCH=x86 CROSS_COMPILE=${NDK_TOOLCHAIN} CFLAGS="--sysroot=${NDK_SYSROOT}"
+  make WERROR=0 ARCH=x86 CROSS_COMPILE=${NDK_TOOLCHAIN} EXTRA_CFLAGS="-pie --sysroot=${NDK_SYSROOT}"
 
 III. Install perf
 -----------------------------------------------
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
index 778f54d4d0bd..8ffbd272952d 100644
--- a/tools/perf/Documentation/perf-annotate.txt
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -61,6 +61,13 @@ OPTIONS
 
 --stdio:: Use the stdio interface.
 
+--stdio-color::
+        'always', 'never' or 'auto', allowing configuring color output
+        via the command line, in addition to via "color.ui" .perfconfig.
+        Use '--stdio-color always' to generate color even when redirecting
+        to a pipe or file. Using just '--stdio-color' is equivalent to
+        using 'always'.
+
 --tui:: Use the TUI interface. Use of --tui requires a tty, if one is not
         present, as when piping to other commands, the stdio interface is
         used. This interfaces starts by centering on the line with more
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
index dd07b55f58d8..058064db39d2 100644
--- a/tools/perf/Documentation/perf-buildid-cache.txt
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -15,6 +15,9 @@ DESCRIPTION
 This command manages the build-id cache. It can add, remove, update and purge
 files to/from the cache. In the future it should as well set upper limits for
 the space used by the cache, etc.
+This also scans the target binary for SDT (Statically Defined Tracing) and
+record it along with the buildid-cache, which will be used by perf-probe.
+For more details, see linkperf:perf-probe[1].
 
 OPTIONS
 -------
diff --git a/tools/perf/Documentation/perf-config.txt b/tools/perf/Documentation/perf-config.txt
index 15949e2a7805..cb081ac59fd1 100644
--- a/tools/perf/Documentation/perf-config.txt
+++ b/tools/perf/Documentation/perf-config.txt
@@ -110,6 +110,14 @@ Given a $HOME/.perfconfig like this:
                 order = caller
                 sort-key = function
 
+        [report]
+                # Defaults
+                sort-order = comm,dso,symbol
+                percent-limit = 0
+                queue-size = 0
+                children = true
+                group = true
+
 Variables
 ~~~~~~~~~
 
@@ -382,6 +390,10 @@ call-graph.*::
                 histogram entry. Default is 0 which means no limitation.
 
 report.*::
+        report.sort_order::
+                Allows changing the default sort order from "comm,dso,symbol" to
+                some other default, for instance "sym,dso" may be more fitting for
+                kernel developers.
         report.percent-limit::
                 This one is mostly the same as call-graph.threshold but works for
                 histogram entries. Entries having an overhead lower than this
diff --git a/tools/perf/Documentation/perf-data.txt b/tools/perf/Documentation/perf-data.txt
index be8fa1a0a97e..f0796a47dfa3 100644
--- a/tools/perf/Documentation/perf-data.txt
+++ b/tools/perf/Documentation/perf-data.txt
@@ -34,6 +34,10 @@ OPTIONS for 'convert'
 --verbose::
         Be more verbose (show counter open errors, etc).
 
+--all::
+        Convert all events, including non-sample events (comm, fork, ...), to output.
+        Default is off, only convert samples.
+
 SEE ALSO
 --------
 linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index a126e97a8114..41857cce5e86 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -8,13 +8,23 @@ perf-list - List all symbolic event types
 SYNOPSIS
 --------
 [verse]
-'perf list' [hw|sw|cache|tracepoint|pmu|event_glob]
+'perf list' [--no-desc] [--long-desc] [hw|sw|cache|tracepoint|pmu|event_glob]
 
 DESCRIPTION
 -----------
 This command displays the symbolic event types which can be selected in the
 various perf commands with the -e option.
 
+OPTIONS
+-------
+--no-desc::
+Don't print descriptions.
+
+-v::
+--long-desc::
+Print longer event descriptions.
+
+
 [[EVENT_MODIFIERS]]
 EVENT MODIFIERS
 ---------------
diff --git a/tools/perf/Documentation/perf-mem.txt b/tools/perf/Documentation/perf-mem.txt
index 1d6092c460dd..73496320fca3 100644
--- a/tools/perf/Documentation/perf-mem.txt
+++ b/tools/perf/Documentation/perf-mem.txt
@@ -56,6 +56,9 @@ OPTIONS
 --all-user::
         Configure all used events to run in user space.
 
+--ldload::
+        Specify desired latency for loads event.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 3a8a9ba2b041..e6c9902c6d82 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -21,6 +21,8 @@ or
 'perf probe' [options] --vars='PROBEPOINT'
 or
 'perf probe' [options] --funcs
+or
+'perf probe' [options] --definition='PROBE' [...]
 
 DESCRIPTION
 -----------
@@ -34,6 +36,8 @@ OPTIONS
 -k::
 --vmlinux=PATH::
         Specify vmlinux path which has debuginfo (Dwarf binary).
+        Only when using this with --definition, you can give an offline
+        vmlinux file.
 
 -m::
 --module=MODNAME|PATH::
@@ -67,7 +71,10 @@ OPTIONS
 
 -l::
 --list[=[GROUP:]EVENT]::
-        List up current probe events. This can also accept filtering patterns of event names.
+        List up current probe events. This can also accept filtering patterns of
+        event names.
+        When this is used with --cache, perf shows all cached probes instead of
+        the live probes.
 
 -L::
 --line=::
@@ -93,6 +100,11 @@ OPTIONS
         can also list functions in a user space executable / shared library.
         This also can accept a FILTER rule argument.
 
+-D::
+--definition=::
+        Show trace-event definition converted from given probe-event instead
+        of write it into tracing/[k,u]probe_events.
+
 --filter=FILTER::
         (Only for --vars and --funcs) Set filter. FILTER is a combination of glob
         pattern, see FILTER PATTERN for detail.
@@ -109,6 +121,12 @@ OPTIONS
         Dry run. With this option, --add and --del doesn't execute actual
         adding and removal operations.
 
+--cache::
+        (With --add) Cache the probes. Any events which successfully added
+        are also stored in the cache file.
+        (With --list) Show cached probes.
+        (With --del) Remove cached probes.
+
 --max-probes=NUM::
         Set the maximum number of probe points for an event. Default is 128.
 
@@ -134,19 +152,30 @@ PROBE SYNTAX
 Probe points are defined by following syntax.
 
     1) Define event based on function name
-     [EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...]
+     [[GROUP:]EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...]
 
     2) Define event based on source file with line number
-     [EVENT=]SRC:ALN [ARG ...]
+     [[GROUP:]EVENT=]SRC:ALN [ARG ...]
 
     3) Define event based on source file with lazy pattern
-     [EVENT=]SRC;PTN [ARG ...]
+     [[GROUP:]EVENT=]SRC;PTN [ARG ...]
 
+    4) Pre-defined SDT events or cached event with name
+     %[sdt_PROVIDER:]SDTEVENT
+     or,
+     sdt_PROVIDER:SDTEVENT
 
-'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'.
+'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. You can also specify a group name by 'GROUP', if omitted, set 'probe' is used for kprobe and 'probe_<bin>' is used for uprobe.
+Note that using existing group name can conflict with other events. Especially, using the group name reserved for kernel modules can hide embedded events in the
+modules.
 'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition.  In addition, '@SRC' specifies a source file which has that function.
 It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.
 'ARG' specifies the arguments of this probe point, (see PROBE ARGUMENT).
+'SDTEVENT' and 'PROVIDER' is the pre-defined event name which is defined by user SDT (Statically Defined Tracing) or the pre-cached probes with event name.
+Note that before using the SDT event, the target binary (on which SDT events are defined) must be scanned by linkperf:perf-buildid-cache[1] to make SDT events as cached events.
+
+For details of the SDT, see below.
+https://sourceware.org/gdb/onlinedocs/gdb/Static-Probe-Points.html
 
 PROBE ARGUMENT
 --------------
@@ -156,10 +185,17 @@ Each probe argument follows below syntax.
 
 'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)
 '$vars' and '$params' special arguments are also available for NAME, '$vars' is expanded to the local variables (including function parameters) which can access at given probe point. '$params' is expanded to only the function parameters.
-'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
-
+'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo (*). Currently, basic types (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal integers (x/x8/x16/x32/x64), signedness casting (u/s), "string" and bitfield are supported. (see TYPES for detail)
 On x86 systems %REG is always the short form of the register: for example %AX. %RAX or %EAX is not valid.
 
+TYPES
+-----
+Basic types (u8/u16/u32/u64/s8/s16/s32/s64) and hexadecimal integers (x8/x16/x32/x64) are integer types. Prefix 's' and 'u' means those types are signed and unsigned respectively, and 'x' means that is shown in hexadecimal format. Traced arguments are shown in decimal (sNN/uNN) or hex (xNN). You can also use 's' or 'u' to specify only signedness and leave its size auto-detected by perf probe. Moreover, you can use 'x' to explicitly specify to be shown in hexadecimal (the size is also auto-detected).
+String type is a special type, which fetches a "null-terminated" string from kernel space. This means it will fail and store NULL if the string container has been paged out. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
+Bitfield is another special type, which takes 3 parameters, bit-width, bit-offset, and container-size (usually 32). The syntax is;
+
+ b<bit-width>@<bit-offset>/<container-size>
+
 LINE SYNTAX
 -----------
 Line range is described by following syntax.
@@ -226,4 +262,4 @@ Add probes at malloc() function on libc
 
 SEE ALSO
 --------
-linkperf:perf-trace[1], linkperf:perf-record[1]
+linkperf:perf-trace[1], linkperf:perf-record[1], linkperf:perf-buildid-cache[1]
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 8dbee832abd9..92335193dc33 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -35,15 +35,15 @@ OPTIONS
 
         - a symbolically formed PMU event like 'pmu/param1=0x3,param2/' where
           'param1', 'param2', etc are defined as formats for the PMU in
-          /sys/bus/event_sources/devices/<pmu>/format/*.
+          /sys/bus/event_source/devices/<pmu>/format/*.
 
         - a symbolically formed event like 'pmu/config=M,config1=N,config3=K/'
 
           where M, N, K are numbers (in decimal, hex, octal format). Acceptable
           values for each of 'config', 'config1' and 'config2' are defined by
-          corresponding entries in /sys/bus/event_sources/devices/<pmu>/format/*
+          corresponding entries in /sys/bus/event_source/devices/<pmu>/format/*
           param1 and param2 are defined as formats for the PMU in:
-          /sys/bus/event_sources/devices/<pmu>/format/*
+          /sys/bus/event_source/devices/<pmu>/format/*
 
           There are also some params which are not defined in .../<pmu>/format/*.
           These params can be used to overload default config values per event.
@@ -60,6 +60,18 @@ OPTIONS
           Note: If user explicitly sets options which conflict with the params,
           the value set by the params will be overridden.
 
+          Also not defined in .../<pmu>/format/* are PMU driver specific
+          configuration parameters.  Any configuration parameter preceded by
+          the letter '@' is not interpreted in user space and sent down directly
+          to the PMU driver.  For example:
+
+          perf record -e some_event/@cfg1,@cfg2=config/ ...
+
+          will see 'cfg1' and 'cfg2=config' pushed to the PMU driver associated
+          with the event for further processing.  There is no restriction on
+          what the configuration parameters are, as long as their semantic is
+          understood and supported by the PMU driver.
+
         - a hardware breakpoint event in the form of '\mem:addr[/len][:access]'
           where addr is the address in memory you want to break in.
           Access is the memory access type (read, write, execute) it can
@@ -77,9 +89,62 @@ OPTIONS
 
 --filter=<filter>::
         Event filter. This option should follow a event selector (-e) which
-        selects tracepoint event(s). Multiple '--filter' options are combined
+        selects either tracepoint event(s) or a hardware trace PMU
+        (e.g. Intel PT or CoreSight).
+
+        - tracepoint filters
+
+        In the case of tracepoints, multiple '--filter' options are combined
         using '&&'.
 
+        - address filters
+
+        A hardware trace PMU advertises its ability to accept a number of
+        address filters by specifying a non-zero value in
+        /sys/bus/event_source/devices/<pmu>/nr_addr_filters.
+
+        Address filters have the format:
+
+        filter|start|stop|tracestop <start> [/ <size>] [@<file name>]
+
+        Where:
+        - 'filter': defines a region that will be traced.
+        - 'start': defines an address at which tracing will begin.
+        - 'stop': defines an address at which tracing will stop.
+        - 'tracestop': defines a region in which tracing will stop.
+
+        <file name> is the name of the object file, <start> is the offset to the
+        code to trace in that file, and <size> is the size of the region to
+        trace. 'start' and 'stop' filters need not specify a <size>.
+
+        If no object file is specified then the kernel is assumed, in which case
+        the start address must be a current kernel memory address.
+
+        <start> can also be specified by providing the name of a symbol. If the
+        symbol name is not unique, it can be disambiguated by inserting #n where
+        'n' selects the n'th symbol in address order. Alternately #0, #g or #G
+        select only a global symbol. <size> can also be specified by providing
+        the name of a symbol, in which case the size is calculated to the end
+        of that symbol. For 'filter' and 'tracestop' filters, if <size> is
+        omitted and <start> is a symbol, then the size is calculated to the end
+        of that symbol.
+
+        If <size> is omitted and <start> is '*', then the start and size will
+        be calculated from the first and last symbols, i.e. to trace the whole
+        file.
+
+        If symbol names (or '*') are provided, they must be surrounded by white
+        space.
+
+        The filter passed to the kernel is not necessarily the same as entered.
+        To see the filter that is passed, use the -v option.
+
+        The kernel may not be able to configure a trace region if it is not
+        within a single mapping.  MMAP events (or /proc/<pid>/maps) can be
+        examined to determine if that is a possibility.
+
+        Multiple filters can be separated with space or comma.
+
 --exclude-perf::
         Don't record events issued by perf itself. This option should follow
         a event selector (-e) which selects tracepoint event(s). It adds a
@@ -192,6 +257,9 @@ OPTIONS
 --period::
         Record the sample period.
 
+--sample-cpu::
+        Record the sample cpu.
+
 -n::
 --no-samples::
         Don't sample.
@@ -360,6 +428,35 @@ particular perf.data snapshot should be kept or not.
 
 Implies --timestamp-filename, --no-buildid and --no-buildid-cache.
 
+--dry-run::
+Parse options then exit. --dry-run can be used to detect errors in cmdline
+options.
+
+'perf record --dry-run -e' can act as a BPF script compiler if llvm.dump-obj
+in config file is set to true.
+
+--tail-synthesize::
+Instead of collecting non-sample events (for example, fork, comm, mmap) at
+the beginning of record, collect them during finalizing an output file.
+The collected non-sample events reflects the status of the system when
+record is finished.
+
+--overwrite::
+Makes all events use an overwritable ring buffer. An overwritable ring
+buffer works like a flight recorder: when it gets full, the kernel will
+overwrite the oldest records, that thus will never make it to the
+perf.data file.
+
+When '--overwrite' and '--switch-output' are used perf records and drops
+events until it receives a signal, meaning that something unusual was
+detected that warrants taking a snapshot of the most current events,
+those fitting in the ring buffer at that moment.
+
+'overwrite' attribute can also be set or canceled for an event using
+config terms. For example: 'cycles/overwrite/' and 'instructions/no-overwrite/'.
+
+Implies --tail-synthesize.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 9cbddc290aff..2d1746295abf 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -265,6 +265,13 @@ OPTIONS
 
 --stdio:: Use the stdio interface.
 
+--stdio-color::
+        'always', 'never' or 'auto', allowing configuring color output
+        via the command line, in addition to via "color.ui" .perfconfig.
+        Use '--stdio-color always' to generate color even when redirecting
+        to a pipe or file. Using just '--stdio-color' is equivalent to
+        using 'always'.
+
 --tui:: Use the TUI interface, that is integrated with annotate and allows
         zooming into DSOs or threads, among other features. Use of --tui
         requires a tty, if one is not present, as when piping to other
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index 4fc44c75263f..053bbbd84ece 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -116,16 +116,16 @@ OPTIONS
 --fields::
         Comma separated list of fields to print. Options are:
         comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr, symoff,
-        srcline, period, iregs, brstack, brstacksym, flags.
-        Field list can be prepended with the type, trace, sw or hw,
+        srcline, period, iregs, brstack, brstacksym, flags, bpf-output,
+        callindent. Field list can be prepended with the type, trace, sw or hw,
         to indicate to which event type the field list applies.
-        e.g., -f sw:comm,tid,time,ip,sym  and -f trace:time,cpu,trace
+        e.g., -F sw:comm,tid,time,ip,sym  and -F trace:time,cpu,trace
 
-                perf script -f <fields>
+                perf script -F <fields>
 
         is equivalent to:
 
-                perf script -f trace:<fields> -f sw:<fields> -f hw:<fields>
+                perf script -F trace:<fields> -F sw:<fields> -F hw:<fields>
 
         i.e., the specified fields apply to all event types if the type string
         is not given.
@@ -133,9 +133,9 @@ OPTIONS
         The arguments are processed in the order received. A later usage can
         reset a prior request. e.g.:
 
-                -f trace: -f comm,tid,time,ip,sym
+                -F trace: -F comm,tid,time,ip,sym
 
-        The first -f suppresses trace events (field list is ""), but then the
+        The first -F suppresses trace events (field list is ""), but then the
         second invocation sets the fields to comm,tid,time,ip,sym. In this case a
         warning is given to the user:
 
@@ -143,9 +143,9 @@ OPTIONS
 
         Alternatively, consider the order:
 
-                -f comm,tid,time,ip,sym -f trace:
+                -F comm,tid,time,ip,sym -F trace:
 
-        The first -f sets the fields for all events and the second -f
+        The first -F sets the fields for all events and the second -F
         suppresses trace events. The user is given a warning message about
         the override, and the result of the above is that only S/W and H/W
         events are displayed with the given fields.
@@ -154,14 +154,14 @@ OPTIONS
         event type, a message is displayed to the user that the option is
         ignored for that type. For example:
 
-                $ perf script -f comm,tid,trace
+                $ perf script -F comm,tid,trace
                 'trace' not valid for hardware events. Ignoring.
                 'trace' not valid for software events. Ignoring.
 
         Alternatively, if the type is given an invalid field is specified it
         is an error. For example:
 
-        perf script -v -f sw:comm,tid,trace
+        perf script -v -F sw:comm,tid,trace
         'trace' not valid for software events.
 
         At this point usage is displayed, and perf-script exits.
@@ -170,10 +170,19 @@ OPTIONS
         Trace decoding. The flags are "bcrosyiABEx" which stand for branch,
         call, return, conditional, system, asynchronous, interrupt,
         transaction abort, trace begin, trace end, and in transaction,
-        respectively.
+        respectively. Known combinations of flags are printed more nicely e.g.
+        "call" for "bc", "return" for "br", "jcc" for "bo", "jmp" for "b",
+        "int" for "bci", "iret" for "bri", "syscall" for "bcs", "sysret" for "brs",
+        "async" for "by", "hw int" for "bcyi", "tx abrt" for "bA", "tr strt" for "bB",
+        "tr end" for "bE". However the "x" flag will be display separately in those
+        cases e.g. "jcc     (x)" for a condition branch within a transaction.
+
+        The callindent field is synthesized and may have a value when
+        Instruction Trace decoding. For calls and returns, it will display the
+        name of the symbol indented with spaces to reflect the stack depth.
 
         Finally, a user may not set fields to none for all event types.
-        i.e., -f "" is not allowed.
+        i.e., -F "" is not allowed.
 
         The brstack output includes branch related information with raw addresses using the
         /v/v/v/v/ syntax in the following order:
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 04f23b404bbc..d96ccd4844df 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -204,6 +204,38 @@ Aggregate counts per physical processor for system-wide mode measurements.
 --no-aggr::
 Do not aggregate counts across all monitored CPUs.
 
+--topdown::
+Print top down level 1 metrics if supported by the CPU. This allows to
+determine bottle necks in the CPU pipeline for CPU bound workloads,
+by breaking the cycles consumed down into frontend bound, backend bound,
+bad speculation and retiring.
+
+Frontend bound means that the CPU cannot fetch and decode instructions fast
+enough. Backend bound means that computation or memory access is the bottle
+neck. Bad Speculation means that the CPU wasted cycles due to branch
+mispredictions and similar issues. Retiring means that the CPU computed without
+an apparently bottleneck. The bottleneck is only the real bottleneck
+if the workload is actually bound by the CPU and not by something else.
+
+For best results it is usually a good idea to use it with interval
+mode like -I 1000, as the bottleneck of workloads can change often.
+
+The top down metrics are collected per core instead of per
+CPU thread. Per core mode is automatically enabled
+and -a (global monitoring) is needed, requiring root rights or
+perf.perf_event_paranoid=-1.
+
+Topdown uses the full Performance Monitoring Unit, and needs
+disabling of the NMI watchdog (as root):
+echo 0 > /proc/sys/kernel/nmi_watchdog
+for best results. Otherwise the bottlenecks may be inconsistent
+on workload with changing phases.
+
+This enables --metric-only, unless overriden with --no-metric-only.
+
+To interpret the results it is usually needed to know on which
+CPUs the workload runs on. If needed the CPUs can be forced using
+taskset.
 
 EXAMPLES
 --------
diff --git a/tools/perf/Documentation/perf-test.txt b/tools/perf/Documentation/perf-test.txt
index 31a5c3ea7f74..b329c65d7f40 100644
--- a/tools/perf/Documentation/perf-test.txt
+++ b/tools/perf/Documentation/perf-test.txt
@@ -30,3 +30,7 @@ OPTIONS
 -v::
 --verbose::
         Be more verbose.
+
+-F::
+--dont-fork::
+        Do not fork child for each test, run all tests within single process.
diff --git a/tools/perf/Documentation/perf.data-file-format.txt b/tools/perf/Documentation/perf.data-file-format.txt
new file mode 100644
index 000000000000..b664b18d3991
--- /dev/null
+++ b/tools/perf/Documentation/perf.data-file-format.txt
@@ -0,0 +1,446 @@
+perf.data format
+
+Uptodate as of v4.7
+
+This document describes the on-disk perf.data format, generated by perf record
+or perf inject and consumed by the other perf tools.
+
+On a high level perf.data contains the events generated by the PMUs, plus metadata.
+
+All fields are in native-endian of the machine that generated the perf.data.
+
+When perf is writing to a pipe it uses a special version of the file
+format that does not rely on seeking to adjust data offsets.  This
+format is not described here. The pipe version can be converted to
+normal perf.data with perf inject.
+
+The file starts with a perf_header:
+
+struct perf_header {
+        char magic[8];          /* PERFILE2 */
+        uint64_t size;          /* size of the header */
+        uint64_t attr_size;     /* size of an attribute in attrs */
+        struct perf_file_section attrs;
+        struct perf_file_section data;
+        struct perf_file_section event_types;
+        uint64_t flags;
+        uint64_t flags1[3];
+};
+
+The magic number identifies the perf file and the version. Current perf versions
+use PERFILE2. Old perf versions generated a version 1 format (PERFFILE). Version 1
+is not described here. The magic number also identifies the endian. When the
+magic value is 64bit byte swapped compared the file is in non-native
+endian.
+
+A perf_file_section contains a pointer to another section of the perf file.
+The header contains three such pointers: for attributes, data and event types.
+
+struct perf_file_section {
+        uint64_t offset;        /* offset from start of file */
+        uint64_t size;          /* size of the section */
+};
+
+Flags section:
+
+The header is followed by different optional headers, described by the bits set
+in flags. Only headers for which the bit is set are included. Each header
+consists of a perf_file_section located after the initial header.
+The respective perf_file_section points to the data of the additional
+header and defines its size.
+
+Some headers consist of strings, which are defined like this:
+
+struct perf_header_string {
+       uint32_t len;
+       char string[len]; /* zero terminated */
+};
+
+Some headers consist of a sequence of strings, which start with a
+
+struct perf_header_string_list {
+     uint32_t nr;
+     struct perf_header_string strings[nr]; /* variable length records */
+};
+
+The bits are the flags bits in a 256 bit bitmap starting with
+flags. These define the valid bits:
+
+        HEADER_RESERVED         = 0,    /* always cleared */
+        HEADER_FIRST_FEATURE    = 1,
+        HEADER_TRACING_DATA     = 1,
+
+Describe me.
+
+        HEADER_BUILD_ID = 2,
+
+The header consists of an sequence of build_id_event. The size of each record
+is defined by header.size (see perf_event.h). Each event defines a ELF build id
+for a executable file name for a pid. An ELF build id is a unique identifier
+assigned by the linker to an executable.
+
+struct build_id_event {
+        struct perf_event_header header;
+        pid_t                    pid;
+        uint8_t                  build_id[24];
+        char                     filename[header.size - offsetof(struct build_id_event, filename)];
+};
+
+        HEADER_HOSTNAME = 3,
+
+A perf_header_string with the hostname where the data was collected
+(uname -n)
+
+        HEADER_OSRELEASE = 4,
+
+A perf_header_string with the os release where the data was collected
+(uname -r)
+
+        HEADER_VERSION = 5,
+
+A perf_header_string with the perf user tool version where the
+data was collected. This is the same as the version of the source tree
+the perf tool was built from.
+
+        HEADER_ARCH = 6,
+
+A perf_header_string with the CPU architecture (uname -m)
+
+        HEADER_NRCPUS = 7,
+
+A structure defining the number of CPUs.
+
+struct nr_cpus {
+       uint32_t nr_cpus_online;
+       uint32_t nr_cpus_available; /* CPUs not yet onlined */
+};
+
+        HEADER_CPUDESC = 8,
+
+A perf_header_string with description of the CPU. On x86 this is the model name
+in /proc/cpuinfo
+
+        HEADER_CPUID = 9,
+
+A perf_header_string with the exact CPU type. On x86 this is
+vendor,family,model,stepping. For example: GenuineIntel,6,69,1
+
+        HEADER_TOTAL_MEM = 10,
+
+An uint64_t with the total memory in bytes.
+
+        HEADER_CMDLINE = 11,
+
+A perf_header_string with the perf command line used to collect the data.
+
+        HEADER_EVENT_DESC = 12,
+
+Another description of the perf_event_attrs, more detailed than header.attrs
+including IDs and names. See perf_event.h or the man page for a description
+of a struct perf_event_attr.
+
+struct {
+       uint32_t nr; /* number of events */
+       uint32_t attr_size; /* size of each perf_event_attr */
+       struct {
+              struct perf_event_attr attr;  /* size of attr_size */
+              uint32_t nr_ids;
+              struct perf_header_string event_string;
+              uint64_t ids[nr_ids];
+       } events[nr]; /* Variable length records */
+};
+
+        HEADER_CPU_TOPOLOGY = 13,
+
+String lists defining the core and CPU threads topology.
+
+struct {
+       struct perf_header_string_list cores; /* Variable length */
+       struct perf_header_string_list threads; /* Variable length */
+};
+
+Example:
+        sibling cores   : 0-3
+        sibling threads : 0-1
+        sibling threads : 2-3
+
+        HEADER_NUMA_TOPOLOGY = 14,
+
+        A list of NUMA node descriptions
+
+struct {
+       uint32_t nr;
+       struct {
+              uint32_t nodenr;
+              uint64_t mem_total;
+              uint64_t mem_free;
+              struct perf_header_string cpus;
+       } nodes[nr]; /* Variable length records */
+};
+
+        HEADER_BRANCH_STACK = 15,
+
+Not implemented in perf.
+
+        HEADER_PMU_MAPPINGS = 16,
+
+        A list of PMU structures, defining the different PMUs supported by perf.
+
+struct {
+       uint32_t nr;
+       struct pmu {
+              uint32_t pmu_type;
+              struct perf_header_string pmu_name;
+       } [nr]; /* Variable length records */
+};
+
+        HEADER_GROUP_DESC = 17,
+
+        Description of counter groups ({...} in perf syntax)
+
+struct {
+         uint32_t nr;
+         struct {
+                struct perf_header_string string;
+                uint32_t leader_idx;
+                uint32_t nr_members;
+         } [nr]; /* Variable length records */
+};
+
+        HEADER_AUXTRACE = 18,
+
+Define additional auxtrace areas in the perf.data. auxtrace is used to store
+undecoded hardware tracing information, such as Intel Processor Trace data.
+
+/**
+ * struct auxtrace_index_entry - indexes a AUX area tracing event within a
+ *                               perf.data file.
+ * @file_offset: offset within the perf.data file
+ * @sz: size of the event
+ */
+struct auxtrace_index_entry {
+        u64                     file_offset;
+        u64                     sz;
+};
+
+#define PERF_AUXTRACE_INDEX_ENTRY_COUNT 256
+
+/**
+ * struct auxtrace_index - index of AUX area tracing events within a perf.data
+ *                         file.
+ * @list: linking a number of arrays of entries
+ * @nr: number of entries
+ * @entries: array of entries
+ */
+struct auxtrace_index {
+        struct list_head        list;
+        size_t                  nr;
+        struct auxtrace_index_entry entries[PERF_AUXTRACE_INDEX_ENTRY_COUNT];
+};
+
+        other bits are reserved and should ignored for now
+        HEADER_FEAT_BITS        = 256,
+
+Attributes
+
+This is an array of perf_event_attrs, each attr_size bytes long, which defines
+each event collected. See perf_event.h or the man page for a detailed
+description.
+
+Data
+
+This section is the bulk of the file. It consist of a stream of perf_events
+describing events. This matches the format generated by the kernel.
+See perf_event.h or the manpage for a detailed description.
+
+Some notes on parsing:
+
+Ordering
+
+The events are not necessarily in time stamp order, as they can be
+collected in parallel on different CPUs. If the events should be
+processed in time order they need to be sorted first. It is possible
+to only do a partial sort using the FINISHED_ROUND event header (see
+below). perf record guarantees that there is no reordering over a
+FINISHED_ROUND.
+
+ID vs IDENTIFIER
+
+When the event stream contains multiple events each event is identified
+by an ID. This can be either through the PERF_SAMPLE_ID or the
+PERF_SAMPLE_IDENTIFIER header. The PERF_SAMPLE_IDENTIFIER header is
+at a fixed offset from the event header, which allows reliable
+parsing of the header. Relying on ID may be ambigious.
+IDENTIFIER is only supported by newer Linux kernels.
+
+Perf record specific events:
+
+In addition to the kernel generated event types perf record adds its
+own event types (in addition it also synthesizes some kernel events,
+for example MMAP events)
+
+        PERF_RECORD_USER_TYPE_START             = 64,
+        PERF_RECORD_HEADER_ATTR                 = 64,
+
+struct attr_event {
+        struct perf_event_header header;
+        struct perf_event_attr attr;
+        uint64_t id[];
+};
+
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65, /* depreceated */
+
+#define MAX_EVENT_NAME 64
+
+struct perf_trace_event_type {
+        uint64_t        event_id;
+        char    name[MAX_EVENT_NAME];
+};
+
+struct event_type_event {
+        struct perf_event_header header;
+        struct perf_trace_event_type event_type;
+};
+
+
+        PERF_RECORD_HEADER_TRACING_DATA         = 66,
+
+Describe me
+
+struct tracing_data_event {
+        struct perf_event_header header;
+        uint32_t size;
+};
+
+        PERF_RECORD_HEADER_BUILD_ID             = 67,
+
+Define a ELF build ID for a referenced executable.
+
+       struct build_id_event;   /* See above */
+
+        PERF_RECORD_FINISHED_ROUND              = 68,
+
+No event reordering over this header. No payload.
+
+        PERF_RECORD_ID_INDEX                    = 69,
+
+Map event ids to CPUs and TIDs.
+
+struct id_index_entry {
+        uint64_t id;
+        uint64_t idx;
+        uint64_t cpu;
+        uint64_t tid;
+};
+
+struct id_index_event {
+        struct perf_event_header header;
+        uint64_t nr;
+        struct id_index_entry entries[nr];
+};
+
+        PERF_RECORD_AUXTRACE_INFO               = 70,
+
+Auxtrace type specific information. Describe me
+
+struct auxtrace_info_event {
+        struct perf_event_header header;
+        uint32_t type;
+        uint32_t reserved__; /* For alignment */
+        uint64_t priv[];
+};
+
+        PERF_RECORD_AUXTRACE                    = 71,
+
+Defines auxtrace data. Followed by the actual data. The contents of
+the auxtrace data is dependent on the event and the CPU. For example
+for Intel Processor Trace it contains Processor Trace data generated
+by the CPU.
+
+struct auxtrace_event {
+        struct perf_event_header header;
+        uint64_t size;
+        uint64_t offset;
+        uint64_t reference;
+        uint32_t idx;
+        uint32_t tid;
+        uint32_t cpu;
+        uint32_t reserved__; /* For alignment */
+};
+
+struct aux_event {
+        struct perf_event_header header;
+        uint64_t        aux_offset;
+        uint64_t        aux_size;
+        uint64_t        flags;
+};
+
+        PERF_RECORD_AUXTRACE_ERROR              = 72,
+
+Describes an error in hardware tracing
+
+enum auxtrace_error_type {
+        PERF_AUXTRACE_ERROR_ITRACE  = 1,
+        PERF_AUXTRACE_ERROR_MAX
+};
+
+#define MAX_AUXTRACE_ERROR_MSG 64
+
+struct auxtrace_error_event {
+        struct perf_event_header header;
+        uint32_t type;
+        uint32_t code;
+        uint32_t cpu;
+        uint32_t pid;
+        uint32_t tid;
+        uint32_t reserved__; /* For alignment */
+        uint64_t ip;
+        char msg[MAX_AUXTRACE_ERROR_MSG];
+};
+
+Event types
+
+Define the event attributes with their IDs.
+
+An array bound by the perf_file_section size.
+
+        struct {
+                struct perf_event_attr attr;   /* Size defined by header.attr_size */
+                struct perf_file_section ids;
+        }
+
+ids points to a array of uint64_t defining the ids for event attr attr.
+
+References:
+
+include/uapi/linux/perf_event.h
+
+This is the canonical description of the kernel generated perf_events
+and the perf_event_attrs.
+
+perf_events manpage
+
+A manpage describing perf_event and perf_event_attr is here:
+http://web.eece.maine.edu/~vweaver/projects/perf_events/programming.html
+This tends to be slightly behind the kernel include, but has better
+descriptions.  An (typically older) version of the man page may be
+included with the standard Linux man pages, available with "man
+perf_events"
+
+pmu-tools
+
+https://github.com/andikleen/pmu-tools/tree/master/parser
+
+A definition of the perf.data format in python "construct" format is available
+in pmu-tools parser. This allows to read perf.data from python and dump it.
+
+quipper
+
+The quipper C++ parser is available at
+https://chromium.googlesource.com/chromiumos/platform2
+
+It is under the chromiumos-wide-profiling/ subdirectory. This library can
+convert a perf data file to a protobuf and vice versa.
+
+Unfortunately this parser tends to be many versions behind and may not be able
+to parse data files generated by recent perf.
diff --git a/tools/perf/Documentation/perfconfig.example b/tools/perf/Documentation/perfconfig.example
index 1d8d5bc4cd2d..2b477c1d1efe 100644
--- a/tools/perf/Documentation/perfconfig.example
+++ b/tools/perf/Documentation/perfconfig.example
@@ -27,3 +27,12 @@
         use_offset = true
         jump_arrows = true
         show_nr_jumps = false
+
+[report]
+
+        # Defaults
+        sort-order = comm,dso,symbol
+        percent-limit = 0
+        queue-size = 0
+        children = true
+        group = true
diff --git a/tools/perf/Documentation/tips.txt b/tools/perf/Documentation/tips.txt
index 5950b5a24efd..8a6479c0eac9 100644
--- a/tools/perf/Documentation/tips.txt
+++ b/tools/perf/Documentation/tips.txt
@@ -28,3 +28,7 @@ To change sampling frequency to 100 Hz: perf record -F 100
 See assembly instructions with percentage: perf annotate <symbol>
 If you prefer Intel style assembly, try: perf annotate -M intel
 For hierarchical output, try: perf report --hierarchy
+Order by the overhead of source file name and line number: perf report -s srcline
+System-wide collection from all CPUs: perf record -a
+Show current config key-value pairs: perf config --list
+Show user configuration overrides: perf config --user --list
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index 8c8c6b9ce915..0bda2cca2b3a 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -12,13 +12,23 @@ tools/arch/sparc/include/asm/barrier_32.h
 tools/arch/sparc/include/asm/barrier_64.h
 tools/arch/tile/include/asm/barrier.h
 tools/arch/x86/include/asm/barrier.h
+tools/arch/x86/include/asm/cpufeatures.h
+tools/arch/x86/include/asm/disabled-features.h
+tools/arch/x86/include/asm/required-features.h
+tools/arch/x86/include/uapi/asm/svm.h
+tools/arch/x86/include/uapi/asm/vmx.h
+tools/arch/x86/include/uapi/asm/kvm.h
+tools/arch/x86/include/uapi/asm/kvm_perf.h
+tools/arch/x86/lib/memcpy_64.S
+tools/arch/x86/lib/memset_64.S
+tools/arch/s390/include/uapi/asm/kvm_perf.h
+tools/arch/s390/include/uapi/asm/sie.h
 tools/arch/xtensa/include/asm/barrier.h
 tools/scripts
 tools/build
 tools/arch/x86/include/asm/atomic.h
 tools/arch/x86/include/asm/rmwcc.h
 tools/lib/traceevent
-tools/lib/bpf
 tools/lib/api
 tools/lib/bpf
 tools/lib/subcmd
@@ -29,6 +39,9 @@ tools/lib/symbol/kallsyms.c
 tools/lib/symbol/kallsyms.h
 tools/lib/find_bit.c
 tools/lib/bitmap.c
+tools/lib/str_error_r.c
+tools/lib/vsprintf.c
+tools/include/asm/alternative-asm.h
 tools/include/asm/atomic.h
 tools/include/asm/barrier.h
 tools/include/asm/bug.h
@@ -47,48 +60,27 @@ tools/include/asm-generic/bitops.h
 tools/include/linux/atomic.h
 tools/include/linux/bitops.h
 tools/include/linux/compiler.h
+tools/include/linux/coresight-pmu.h
 tools/include/linux/filter.h
 tools/include/linux/hash.h
 tools/include/linux/kernel.h
 tools/include/linux/list.h
 tools/include/linux/log2.h
+tools/include/uapi/asm-generic/mman-common.h
+tools/include/uapi/asm-generic/mman.h
+tools/include/uapi/linux/bpf.h
+tools/include/uapi/linux/bpf_common.h
+tools/include/uapi/linux/hw_breakpoint.h
+tools/include/uapi/linux/mman.h
+tools/include/uapi/linux/perf_event.h
 tools/include/linux/poison.h
 tools/include/linux/rbtree.h
 tools/include/linux/rbtree_augmented.h
 tools/include/linux/string.h
+tools/include/linux/stringify.h
 tools/include/linux/types.h
 tools/include/linux/err.h
 tools/include/linux/bitmap.h
-include/asm-generic/bitops/arch_hweight.h
-include/asm-generic/bitops/const_hweight.h
-include/asm-generic/bitops/fls64.h
-include/asm-generic/bitops/__fls.h
-include/asm-generic/bitops/fls.h
-include/linux/perf_event.h
-include/linux/list.h
-include/linux/hash.h
-include/linux/stringify.h
-include/linux/swab.h
-arch/*/include/asm/unistd*.h
-arch/*/include/uapi/asm/unistd*.h
-arch/*/include/uapi/asm/perf_regs.h
-arch/*/lib/memcpy*.S
-arch/*/lib/memset*.S
-arch/*/include/asm/*features.h
-include/linux/poison.h
-include/linux/hw_breakpoint.h
-include/uapi/linux/perf_event.h
-include/uapi/linux/bpf.h
-include/uapi/linux/bpf_common.h
-include/uapi/linux/const.h
-include/uapi/linux/swab.h
-include/uapi/linux/hw_breakpoint.h
-arch/x86/include/asm/svm.h
-arch/x86/include/asm/vmx.h
-arch/x86/include/asm/kvm_host.h
-arch/x86/include/uapi/asm/svm.h
-arch/x86/include/uapi/asm/vmx.h
-arch/x86/include/uapi/asm/kvm.h
-arch/x86/include/uapi/asm/kvm_perf.h
-arch/s390/include/uapi/asm/sie.h
-arch/s390/include/uapi/asm/kvm_perf.h
+tools/include/linux/time64.h
+tools/arch/*/include/uapi/asm/mman.h
+tools/arch/*/include/uapi/asm/perf_regs.h
diff --git a/tools/perf/config/Makefile b/tools/perf/Makefile.config
index 5ad0255f8756..72edf83d76b7 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/Makefile.config
@@ -73,17 +73,25 @@ endif
 #
 #   make DEBUG=1 LIBUNWIND_DIR=/opt/libunwind/
 #
+
+libunwind_arch_set_flags = $(eval $(libunwind_arch_set_flags_code))
+define libunwind_arch_set_flags_code
+  FEATURE_CHECK_CFLAGS-libunwind-$(1)  = -I$(LIBUNWIND_DIR)/include
+  FEATURE_CHECK_LDFLAGS-libunwind-$(1) = -L$(LIBUNWIND_DIR)/lib
+endef
+
 ifdef LIBUNWIND_DIR
   LIBUNWIND_CFLAGS  = -I$(LIBUNWIND_DIR)/include
   LIBUNWIND_LDFLAGS = -L$(LIBUNWIND_DIR)/lib
+  LIBUNWIND_ARCHS = x86 x86_64 arm aarch64 debug-frame-arm debug-frame-aarch64
+  $(foreach libunwind_arch,$(LIBUNWIND_ARCHS),$(call libunwind_arch_set_flags,$(libunwind_arch)))
 endif
-LIBUNWIND_LDFLAGS += $(LIBUNWIND_LIBS)
 
 # Set per-feature check compilation flags
 FEATURE_CHECK_CFLAGS-libunwind = $(LIBUNWIND_CFLAGS)
-FEATURE_CHECK_LDFLAGS-libunwind = $(LIBUNWIND_LDFLAGS)
+FEATURE_CHECK_LDFLAGS-libunwind = $(LIBUNWIND_LDFLAGS) $(LIBUNWIND_LIBS)
 FEATURE_CHECK_CFLAGS-libunwind-debug-frame = $(LIBUNWIND_CFLAGS)
-FEATURE_CHECK_LDFLAGS-libunwind-debug-frame = $(LIBUNWIND_LDFLAGS)
+FEATURE_CHECK_LDFLAGS-libunwind-debug-frame = $(LIBUNWIND_LDFLAGS) $(LIBUNWIND_LIBS)
 
 ifeq ($(NO_PERF_REGS),0)
   CFLAGS += -DHAVE_PERF_REGS_SUPPORT
@@ -107,7 +115,7 @@ endif
 FEATURE_CHECK_CFLAGS-libbabeltrace := $(LIBBABELTRACE_CFLAGS)
 FEATURE_CHECK_LDFLAGS-libbabeltrace := $(LIBBABELTRACE_LDFLAGS) -lbabeltrace-ctf
 
-FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/arch/$(ARCH)/include/uapi -I$(srctree)/include/uapi
+FEATURE_CHECK_CFLAGS-bpf = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi
 # include ARCH specific config
 -include $(src-perf)/arch/$(ARCH)/Makefile
 
@@ -198,11 +206,11 @@ endif
 
 CFLAGS += -I$(src-perf)/util/include
 CFLAGS += -I$(src-perf)/arch/$(ARCH)/include
+CFLAGS += -I$(srctree)/tools/include/uapi
 CFLAGS += -I$(srctree)/tools/include/
-CFLAGS += -I$(srctree)/arch/$(ARCH)/include/uapi
-CFLAGS += -I$(srctree)/arch/$(ARCH)/include
-CFLAGS += -I$(srctree)/include/uapi
-CFLAGS += -I$(srctree)/include
+CFLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/uapi
+CFLAGS += -I$(srctree)/tools/arch/$(ARCH)/include/
+CFLAGS += -I$(srctree)/tools/arch/$(ARCH)/
 
 # $(obj-perf)      for generated common-cmds.h
 # $(obj-perf)/util for generated bison/flex headers
@@ -249,7 +257,7 @@ else
       LIBC_SUPPORT := 1
     endif
     ifeq ($(LIBC_SUPPORT),1)
-      msg := $(warning No libelf found, disables 'probe' tool and BPF support in 'perf record', please install elfutils-libelf-devel/libelf-dev);
+      msg := $(warning No libelf found, disables 'probe' tool and BPF support in 'perf record', please install libelf-dev, libelf-devel or elfutils-libelf-devel);
 
       NO_LIBELF := 1
       NO_DWARF := 1
@@ -301,6 +309,16 @@ ifndef NO_LIBELF
     CFLAGS += -DHAVE_ELF_GETPHDRNUM_SUPPORT
   endif
 
+  ifeq ($(feature-libelf-gelf_getnote), 1)
+    CFLAGS += -DHAVE_GELF_GETNOTE_SUPPORT
+  else
+    msg := $(warning gelf_getnote() not found on libelf, SDT support disabled);
+  endif
+
+  ifeq ($(feature-libelf-getshdrstrndx), 1)
+    CFLAGS += -DHAVE_ELF_GETSHDRSTRNDX_SUPPORT
+  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);
@@ -337,6 +355,16 @@ ifndef NO_LIBELF
   endif # NO_LIBBPF
 endif # NO_LIBELF
 
+ifndef NO_SDT
+  ifneq ($(feature-sdt), 1)
+    msg := $(warning No sys/sdt.h found, no SDT events are defined, please install systemtap-sdt-devel or systemtap-sdt-dev);
+    NO_SDT := 1;
+  else
+    CFLAGS += -DHAVE_SDT_EVENT
+    $(call detected,CONFIG_SDT_EVENT)
+  endif
+endif
+
 ifdef PERF_HAVE_JITDUMP
   ifndef NO_DWARF
     $(call detected,CONFIG_JITDUMP)
@@ -351,10 +379,42 @@ ifeq ($(ARCH),powerpc)
 endif
 
 ifndef NO_LIBUNWIND
+  have_libunwind :=
+
+  ifeq ($(feature-libunwind-x86), 1)
+    $(call detected,CONFIG_LIBUNWIND_X86)
+    CFLAGS += -DHAVE_LIBUNWIND_X86_SUPPORT
+    LDFLAGS += -lunwind-x86
+    EXTLIBS_LIBUNWIND += -lunwind-x86
+    have_libunwind = 1
+  endif
+
+  ifeq ($(feature-libunwind-aarch64), 1)
+    $(call detected,CONFIG_LIBUNWIND_AARCH64)
+    CFLAGS += -DHAVE_LIBUNWIND_AARCH64_SUPPORT
+    LDFLAGS += -lunwind-aarch64
+    EXTLIBS_LIBUNWIND += -lunwind-aarch64
+    have_libunwind = 1
+    $(call feature_check,libunwind-debug-frame-aarch64)
+    ifneq ($(feature-libunwind-debug-frame-aarch64), 1)
+      msg := $(warning No debug_frame support found in libunwind-aarch64);
+      CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME_AARCH64
+    endif
+  endif
+
   ifneq ($(feature-libunwind), 1)
     msg := $(warning No libunwind found. Please install libunwind-dev[el] >= 1.1 and/or set LIBUNWIND_DIR);
+    NO_LOCAL_LIBUNWIND := 1
+  else
+    have_libunwind := 1
+    $(call detected,CONFIG_LOCAL_LIBUNWIND)
+  endif
+
+  ifneq ($(have_libunwind), 1)
     NO_LIBUNWIND := 1
   endif
+else
+  NO_LOCAL_LIBUNWIND := 1
 endif
 
 ifndef NO_LIBBPF
@@ -392,7 +452,7 @@ else
   NO_DWARF_UNWIND := 1
 endif
 
-ifndef NO_LIBUNWIND
+ifndef NO_LOCAL_LIBUNWIND
   ifeq ($(ARCH),$(filter $(ARCH),arm arm64))
     $(call feature_check,libunwind-debug-frame)
     ifneq ($(feature-libunwind-debug-frame), 1)
@@ -403,10 +463,15 @@ ifndef NO_LIBUNWIND
     # non-ARM has no dwarf_find_debug_frame() function:
     CFLAGS += -DNO_LIBUNWIND_DEBUG_FRAME
   endif
-  CFLAGS  += -DHAVE_LIBUNWIND_SUPPORT
   EXTLIBS += $(LIBUNWIND_LIBS)
+  LDFLAGS += $(LIBUNWIND_LIBS)
+endif
+
+ifndef NO_LIBUNWIND
+  CFLAGS  += -DHAVE_LIBUNWIND_SUPPORT
   CFLAGS  += $(LIBUNWIND_CFLAGS)
   LDFLAGS += $(LIBUNWIND_LDFLAGS)
+  EXTLIBS += $(EXTLIBS_LIBUNWIND)
 endif
 
 ifndef NO_LIBAUDIT
@@ -437,7 +502,7 @@ endif
 
 ifndef NO_SLANG
   ifneq ($(feature-libslang), 1)
-    msg := $(warning slang not found, disables TUI support. Please install slang-devel or libslang-dev);
+    msg := $(warning slang not found, disables TUI support. Please install slang-devel, libslang-dev or libslang2-dev);
     NO_SLANG := 1
   else
     # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
@@ -681,10 +746,13 @@ ifdef LIBBABELTRACE
 endif
 
 ifndef NO_AUXTRACE
-  ifeq ($(feature-get_cpuid), 0)
-    msg := $(warning Your gcc lacks the __get_cpuid() builtin, disables support for auxtrace/Intel PT, please install a newer gcc);
-    NO_AUXTRACE := 1
-  else
+  ifeq ($(ARCH),x86)
+    ifeq ($(feature-get_cpuid), 0)
+      msg := $(warning Your gcc lacks the __get_cpuid() builtin, disables support for auxtrace/Intel PT, please install a newer gcc);
+      NO_AUXTRACE := 1
+    endif
+  endif
+  ifndef NO_AUXTRACE
     $(call detected,CONFIG_AUXTRACE)
     CFLAGS += -DHAVE_AUXTRACE_SUPPORT
   endif
diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf
index bde8cbae7dd9..982d6439bb07 100644
--- a/tools/perf/Makefile.perf
+++ b/tools/perf/Makefile.perf
@@ -81,6 +81,9 @@ include ../scripts/utilities.mak
 #
 # Define NO_LIBBPF if you do not want BPF support
 #
+# Define NO_SDT if you do not want to define SDT event in perf tools,
+# note that it doesn't disable SDT scanning support.
+#
 # Define FEATURES_DUMP to provide features detection dump file
 # and bypass the feature detection
 
@@ -141,6 +144,10 @@ $(call allow-override,LD,$(CROSS_COMPILE)ld)
 
 LD += $(EXTRA_LDFLAGS)
 
+HOSTCC  ?= gcc
+HOSTLD  ?= ld
+HOSTAR  ?= ar
+
 PKG_CONFIG = $(CROSS_COMPILE)pkg-config
 
 RM      = rm -f
@@ -158,11 +165,11 @@ TRACE_EVENT_DIR = $(srctree)/tools/lib/traceevent/
 BPF_DIR         = $(srctree)/tools/lib/bpf/
 SUBCMD_DIR      = $(srctree)/tools/lib/subcmd/
 
-# include config/Makefile by default and rule out
+# include Makefile.config by default and rule out
 # non-config cases
 config := 1
 
-NON_CONFIG_TARGETS := clean TAGS tags cscope help
+NON_CONFIG_TARGETS := clean TAGS tags cscope help install-doc
 
 ifdef MAKECMDGOALS
 ifeq ($(filter-out $(NON_CONFIG_TARGETS),$(MAKECMDGOALS)),)
@@ -180,7 +187,7 @@ ifeq ($(filter feature-dump,$(MAKECMDGOALS)),feature-dump)
 FEATURE_TESTS := all
 endif
 endif
-include config/Makefile
+include Makefile.config
 endif
 
 ifeq ($(config),0)
@@ -254,7 +261,8 @@ PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
 PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py $(LIBTRACEEVENT) $(LIBAPI)
 
 $(OUTPUT)python/perf.so: $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS) $(LIBTRACEEVENT_DYNAMIC_LIST)
-        $(QUIET_GEN)CFLAGS='$(CFLAGS)' LDFLAGS='$(LDFLAGS) $(LIBTRACEEVENT_DYNAMIC_LIST_LDFLAGS)' \
+        $(QUIET_GEN)LDSHARED="$(CC) -pthread -shared" \
+        CFLAGS='$(CFLAGS)' LDFLAGS='$(LDFLAGS) $(LIBTRACEEVENT_DYNAMIC_LIST_LDFLAGS)' \
           $(PYTHON_WORD) util/setup.py \
           --quiet build_ext; \
         mkdir -p $(OUTPUT)python && \
@@ -341,14 +349,126 @@ strip: $(PROGRAMS) $(OUTPUT)perf
 PERF_IN := $(OUTPUT)perf-in.o
 
 export srctree OUTPUT RM CC LD AR CFLAGS V BISON FLEX AWK
+export HOSTCC HOSTLD HOSTAR
 include $(srctree)/tools/build/Makefile.include
 
+JEVENTS       := $(OUTPUT)pmu-events/jevents
+JEVENTS_IN    := $(OUTPUT)pmu-events/jevents-in.o
+
+PMU_EVENTS_IN := $(OUTPUT)pmu-events/pmu-events-in.o
+
+export JEVENTS
+
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
+
 $(PERF_IN): prepare FORCE
+        @(test -f ../../include/uapi/linux/perf_event.h && ( \
+        (diff -B ../include/uapi/linux/perf_event.h ../../include/uapi/linux/perf_event.h >/dev/null) \
+        || echo "Warning: tools/include/uapi/linux/perf_event.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/linux/hash.h && ( \
+        (diff -B ../include/linux/hash.h ../../include/linux/hash.h >/dev/null) \
+        || echo "Warning: tools/include/linux/hash.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/uapi/linux/hw_breakpoint.h && ( \
+        (diff -B ../include/uapi/linux/hw_breakpoint.h ../../include/uapi/linux/hw_breakpoint.h >/dev/null) \
+        || echo "Warning: tools/include/uapi/linux/hw_breakpoint.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/asm/disabled-features.h && ( \
+        (diff -B ../arch/x86/include/asm/disabled-features.h ../../arch/x86/include/asm/disabled-features.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/asm/disabled-features.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/asm/required-features.h && ( \
+        (diff -B ../arch/x86/include/asm/required-features.h ../../arch/x86/include/asm/required-features.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/asm/required-features.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/asm/cpufeatures.h && ( \
+        (diff -B ../arch/x86/include/asm/cpufeatures.h ../../arch/x86/include/asm/cpufeatures.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/asm/cpufeatures.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/lib/memcpy_64.S && ( \
+        (diff -B ../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memcpy_64.S >/dev/null) \
+        || echo "Warning: tools/arch/x86/lib/memcpy_64.S differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/lib/memset_64.S && ( \
+        (diff -B ../arch/x86/lib/memset_64.S ../../arch/x86/lib/memset_64.S >/dev/null) \
+        || echo "Warning: tools/arch/x86/lib/memset_64.S differs from kernel" >&2 )) || true
+        @(test -f ../../arch/arm/include/uapi/asm/perf_regs.h && ( \
+        (diff -B ../arch/arm/include/uapi/asm/perf_regs.h ../../arch/arm/include/uapi/asm/perf_regs.h >/dev/null) \
+        || echo "Warning: tools/arch/arm/include/uapi/asm/perf_regs.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/arm64/include/uapi/asm/perf_regs.h && ( \
+        (diff -B ../arch/arm64/include/uapi/asm/perf_regs.h ../../arch/arm64/include/uapi/asm/perf_regs.h >/dev/null) \
+        || echo "Warning: tools/arch/arm64/include/uapi/asm/perf_regs.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/powerpc/include/uapi/asm/perf_regs.h && ( \
+        (diff -B ../arch/powerpc/include/uapi/asm/perf_regs.h ../../arch/powerpc/include/uapi/asm/perf_regs.h >/dev/null) \
+        || echo "Warning: tools/arch/powerpc/include/uapi/asm/perf_regs.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/uapi/asm/perf_regs.h && ( \
+        (diff -B ../arch/x86/include/uapi/asm/perf_regs.h ../../arch/x86/include/uapi/asm/perf_regs.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/uapi/asm/perf_regs.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/uapi/asm/kvm.h && ( \
+        (diff -B ../arch/x86/include/uapi/asm/kvm.h ../../arch/x86/include/uapi/asm/kvm.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/uapi/asm/kvm.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/uapi/asm/kvm_perf.h && ( \
+        (diff -B ../arch/x86/include/uapi/asm/kvm_perf.h ../../arch/x86/include/uapi/asm/kvm_perf.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/uapi/asm/kvm_perf.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/uapi/asm/svm.h && ( \
+        (diff -B ../arch/x86/include/uapi/asm/svm.h ../../arch/x86/include/uapi/asm/svm.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/uapi/asm/svm.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/x86/include/uapi/asm/vmx.h && ( \
+        (diff -B ../arch/x86/include/uapi/asm/vmx.h ../../arch/x86/include/uapi/asm/vmx.h >/dev/null) \
+        || echo "Warning: tools/arch/x86/include/uapi/asm/vmx.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/powerpc/include/uapi/asm/kvm.h && ( \
+        (diff -B ../arch/powerpc/include/uapi/asm/kvm.h ../../arch/powerpc/include/uapi/asm/kvm.h >/dev/null) \
+        || echo "Warning: tools/arch/powerpc/include/uapi/asm/kvm.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/s390/include/uapi/asm/kvm.h && ( \
+        (diff -B ../arch/s390/include/uapi/asm/kvm.h ../../arch/s390/include/uapi/asm/kvm.h >/dev/null) \
+        || echo "Warning: tools/arch/s390/include/uapi/asm/kvm.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/s390/include/uapi/asm/kvm_perf.h && ( \
+        (diff -B ../arch/s390/include/uapi/asm/kvm_perf.h ../../arch/s390/include/uapi/asm/kvm_perf.h >/dev/null) \
+        || echo "Warning: tools/arch/s390/include/uapi/asm/kvm_perf.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/s390/include/uapi/asm/sie.h && ( \
+        (diff -B ../arch/s390/include/uapi/asm/sie.h ../../arch/s390/include/uapi/asm/sie.h >/dev/null) \
+        || echo "Warning: tools/arch/s390/include/uapi/asm/sie.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/arm/include/uapi/asm/kvm.h && ( \
+        (diff -B ../arch/arm/include/uapi/asm/kvm.h ../../arch/arm/include/uapi/asm/kvm.h >/dev/null) \
+        || echo "Warning: tools/arch/arm/include/uapi/asm/kvm.h differs from kernel" >&2 )) || true
+        @(test -f ../../arch/arm64/include/uapi/asm/kvm.h && ( \
+        (diff -B ../arch/arm64/include/uapi/asm/kvm.h ../../arch/arm64/include/uapi/asm/kvm.h >/dev/null) \
+        || echo "Warning: tools/arch/arm64/include/uapi/asm/kvm.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/asm-generic/bitops/arch_hweight.h && ( \
+        (diff -B ../include/asm-generic/bitops/arch_hweight.h ../../include/asm-generic/bitops/arch_hweight.h >/dev/null) \
+        || echo "Warning: tools/include/asm-generic/bitops/arch_hweight.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/asm-generic/bitops/const_hweight.h && ( \
+        (diff -B ../include/asm-generic/bitops/const_hweight.h ../../include/asm-generic/bitops/const_hweight.h >/dev/null) \
+        || echo "Warning: tools/include/asm-generic/bitops/const_hweight.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/asm-generic/bitops/__fls.h && ( \
+        (diff -B ../include/asm-generic/bitops/__fls.h ../../include/asm-generic/bitops/__fls.h >/dev/null) \
+        || echo "Warning: tools/include/asm-generic/bitops/__fls.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/asm-generic/bitops/fls.h && ( \
+        (diff -B ../include/asm-generic/bitops/fls.h ../../include/asm-generic/bitops/fls.h >/dev/null) \
+        || echo "Warning: tools/include/asm-generic/bitops/fls.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/asm-generic/bitops/fls64.h && ( \
+        (diff -B ../include/asm-generic/bitops/fls64.h ../../include/asm-generic/bitops/fls64.h >/dev/null) \
+        || echo "Warning: tools/include/asm-generic/bitops/fls64.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/linux/coresight-pmu.h && ( \
+        (diff -B ../include/linux/coresight-pmu.h ../../include/linux/coresight-pmu.h >/dev/null) \
+        || echo "Warning: tools/include/linux/coresight-pmu.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/uapi/asm-generic/mman-common.h && ( \
+        (diff -B ../include/uapi/asm-generic/mman-common.h ../../include/uapi/asm-generic/mman-common.h >/dev/null) \
+        || echo "Warning: tools/include/uapi/asm-generic/mman-common.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/uapi/asm-generic/mman.h && ( \
+        (diff -B -I "^#include <\(uapi/\)*asm-generic/mman-common.h>$$" ../include/uapi/asm-generic/mman.h ../../include/uapi/asm-generic/mman.h >/dev/null) \
+        || echo "Warning: tools/include/uapi/asm-generic/mman.h differs from kernel" >&2 )) || true
+        @(test -f ../../include/uapi/linux/mman.h && ( \
+        (diff -B -I "^#include <\(uapi/\)*asm/mman.h>$$" ../include/uapi/linux/mman.h ../../include/uapi/linux/mman.h >/dev/null) \
+        || echo "Warning: tools/include/uapi/linux/mman.h differs from kernel" >&2 )) || true
         $(Q)$(MAKE) $(build)=perf
 
-$(OUTPUT)perf: $(PERFLIBS) $(PERF_IN) $(LIBTRACEEVENT_DYNAMIC_LIST)
+$(JEVENTS_IN): FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=pmu-events obj=jevents
+
+$(JEVENTS): $(JEVENTS_IN)
+        $(QUIET_LINK)$(HOSTCC) $(JEVENTS_IN) -o $@
+
+$(PMU_EVENTS_IN): $(JEVENTS) FORCE
+        $(Q)$(MAKE) -f $(srctree)/tools/build/Makefile.build dir=pmu-events obj=pmu-events
+
+$(OUTPUT)perf: $(PERFLIBS) $(PERF_IN) $(PMU_EVENTS_IN) $(LIBTRACEEVENT_DYNAMIC_LIST)
         $(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(LIBTRACEEVENT_DYNAMIC_LIST_LDFLAGS) \
-                $(PERF_IN) $(LIBS) -o $@
+                $(PERF_IN) $(PMU_EVENTS_IN) $(LIBS) -o $@
 
 $(GTK_IN): fixdep FORCE
         $(Q)$(MAKE) $(build)=gtk
@@ -377,6 +497,8 @@ perf.spec $(SCRIPTS) \
 ifneq ($(OUTPUT),)
 %.o: $(OUTPUT)%.o
         @echo "    # Redirected target $@ => $(OUTPUT)$@"
+pmu-events/%.o: $(OUTPUT)pmu-events/%.o
+        @echo "    # Redirected target $@ => $(OUTPUT)$@"
 util/%.o: $(OUTPUT)util/%.o
         @echo "    # Redirected target $@ => $(OUTPUT)$@"
 bench/%.o: $(OUTPUT)bench/%.o
@@ -621,7 +743,7 @@ $(INSTALL_DOC_TARGETS):
 ### Cleaning rules
 
 #
-# This is here, not in config/Makefile, because config/Makefile does
+# This is here, not in Makefile.config, because Makefile.config does
 # not get included for the clean target:
 #
 config-clean:
@@ -632,10 +754,11 @@ clean:: $(LIBTRACEEVENT)-clean $(LIBAPI)-clean $(LIBBPF)-clean $(LIBSUBCMD)-clea
         $(call QUIET_CLEAN, core-objs)  $(RM) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf-with-kcore $(LANG_BINDINGS)
         $(Q)find $(if $(OUTPUT),$(OUTPUT),.) -name '*.o' -delete -o -name '\.*.cmd' -delete -o -name '\.*.d' -delete
         $(Q)$(RM) $(OUTPUT).config-detected
-        $(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32
+        $(call QUIET_CLEAN, core-progs) $(RM) $(ALL_PROGRAMS) perf perf-read-vdso32 perf-read-vdsox32 $(OUTPUT)pmu-events/jevents
         $(call QUIET_CLEAN, core-gen)   $(RM)  *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope* $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)FEATURE-DUMP $(OUTPUT)util/*-bison* $(OUTPUT)util/*-flex* \
                 $(OUTPUT)util/intel-pt-decoder/inat-tables.c $(OUTPUT)fixdep \
-                $(OUTPUT)tests/llvm-src-{base,kbuild,prologue,relocation}.c
+                $(OUTPUT)tests/llvm-src-{base,kbuild,prologue,relocation}.c \
+                $(OUTPUT)pmu-events/pmu-events.c
         $(QUIET_SUBDIR0)Documentation $(QUIET_SUBDIR1) clean
         $(python-clean)
 
diff --git a/tools/perf/arch/arm/include/dwarf-regs-table.h b/tools/perf/arch/arm/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..f298d034c37b
--- /dev/null
+++ b/tools/perf/arch/arm/include/dwarf-regs-table.h
@@ -0,0 +1,9 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const arm_regstr_tbl[] = {
+        "%r0", "%r1", "%r2", "%r3", "%r4",
+        "%r5", "%r6", "%r7", "%r8", "%r9", "%r10",
+        "%fp", "%ip", "%sp", "%lr", "%pc",
+};
+#endif
diff --git a/tools/perf/arch/arm/util/Build b/tools/perf/arch/arm/util/Build
index d22e3d07de3d..e64c5f216448 100644
--- a/tools/perf/arch/arm/util/Build
+++ b/tools/perf/arch/arm/util/Build
@@ -1,4 +1,6 @@
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
 
-libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LOCAL_LIBUNWIND)    += unwind-libunwind.o
 libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
+
+libperf-$(CONFIG_AUXTRACE) += pmu.o auxtrace.o cs-etm.o
diff --git a/tools/perf/arch/arm/util/auxtrace.c b/tools/perf/arch/arm/util/auxtrace.c
new file mode 100644
index 000000000000..8edf2cb71564
--- /dev/null
+++ b/tools/perf/arch/arm/util/auxtrace.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdbool.h>
+#include <linux/coresight-pmu.h>
+
+#include "../../util/auxtrace.h"
+#include "../../util/evlist.h"
+#include "../../util/pmu.h"
+#include "cs-etm.h"
+
+struct auxtrace_record
+*auxtrace_record__init(struct perf_evlist *evlist, int *err)
+{
+        struct perf_pmu *cs_etm_pmu;
+        struct perf_evsel *evsel;
+        bool found_etm = false;
+
+        cs_etm_pmu = perf_pmu__find(CORESIGHT_ETM_PMU_NAME);
+
+        if (evlist) {
+                evlist__for_each_entry(evlist, evsel) {
+                        if (cs_etm_pmu &&
+                            evsel->attr.type == cs_etm_pmu->type)
+                                found_etm = true;
+                }
+        }
+
+        if (found_etm)
+                return cs_etm_record_init(err);
+
+        /*
+         * Clear 'err' even if we haven't found a cs_etm event - that way perf
+         * record can still be used even if tracers aren't present.  The NULL
+         * return value will take care of telling the infrastructure HW tracing
+         * isn't available.
+         */
+        *err = 0;
+        return NULL;
+}
diff --git a/tools/perf/arch/arm/util/cs-etm.c b/tools/perf/arch/arm/util/cs-etm.c
new file mode 100644
index 000000000000..47d584da5819
--- /dev/null
+++ b/tools/perf/arch/arm/util/cs-etm.c
@@ -0,0 +1,617 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <api/fs/fs.h>
+#include <linux/bitops.h>
+#include <linux/coresight-pmu.h>
+#include <linux/kernel.h>
+#include <linux/log2.h>
+#include <linux/types.h>
+
+#include "cs-etm.h"
+#include "../../perf.h"
+#include "../../util/auxtrace.h"
+#include "../../util/cpumap.h"
+#include "../../util/evlist.h"
+#include "../../util/evsel.h"
+#include "../../util/pmu.h"
+#include "../../util/thread_map.h"
+#include "../../util/cs-etm.h"
+
+#include <stdlib.h>
+
+#define ENABLE_SINK_MAX 128
+#define CS_BUS_DEVICE_PATH "/bus/coresight/devices/"
+
+struct cs_etm_recording {
+        struct auxtrace_record  itr;
+        struct perf_pmu         *cs_etm_pmu;
+        struct perf_evlist      *evlist;
+        bool                    snapshot_mode;
+        size_t                  snapshot_size;
+};
+
+static bool cs_etm_is_etmv4(struct auxtrace_record *itr, int cpu);
+
+static int cs_etm_parse_snapshot_options(struct auxtrace_record *itr,
+                                         struct record_opts *opts,
+                                         const char *str)
+{
+        struct cs_etm_recording *ptr =
+                                container_of(itr, struct cs_etm_recording, itr);
+        unsigned long long snapshot_size = 0;
+        char *endptr;
+
+        if (str) {
+                snapshot_size = strtoull(str, &endptr, 0);
+                if (*endptr || snapshot_size > SIZE_MAX)
+                        return -1;
+        }
+
+        opts->auxtrace_snapshot_mode = true;
+        opts->auxtrace_snapshot_size = snapshot_size;
+        ptr->snapshot_size = snapshot_size;
+
+        return 0;
+}
+
+static int cs_etm_recording_options(struct auxtrace_record *itr,
+                                    struct perf_evlist *evlist,
+                                    struct record_opts *opts)
+{
+        struct cs_etm_recording *ptr =
+                                container_of(itr, struct cs_etm_recording, itr);
+        struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
+        struct perf_evsel *evsel, *cs_etm_evsel = NULL;
+        const struct cpu_map *cpus = evlist->cpus;
+        bool privileged = (geteuid() == 0 || perf_event_paranoid() < 0);
+
+        ptr->evlist = evlist;
+        ptr->snapshot_mode = opts->auxtrace_snapshot_mode;
+
+        evlist__for_each_entry(evlist, evsel) {
+                if (evsel->attr.type == cs_etm_pmu->type) {
+                        if (cs_etm_evsel) {
+                                pr_err("There may be only one %s event\n",
+                                       CORESIGHT_ETM_PMU_NAME);
+                                return -EINVAL;
+                        }
+                        evsel->attr.freq = 0;
+                        evsel->attr.sample_period = 1;
+                        cs_etm_evsel = evsel;
+                        opts->full_auxtrace = true;
+                }
+        }
+
+        /* no need to continue if at least one event of interest was found */
+        if (!cs_etm_evsel)
+                return 0;
+
+        if (opts->use_clockid) {
+                pr_err("Cannot use clockid (-k option) with %s\n",
+                       CORESIGHT_ETM_PMU_NAME);
+                return -EINVAL;
+        }
+
+        /* we are in snapshot mode */
+        if (opts->auxtrace_snapshot_mode) {
+                /*
+                 * No size were given to '-S' or '-m,', so go with
+                 * the default
+                 */
+                if (!opts->auxtrace_snapshot_size &&
+                    !opts->auxtrace_mmap_pages) {
+                        if (privileged) {
+                                opts->auxtrace_mmap_pages = MiB(4) / page_size;
+                        } else {
+                                opts->auxtrace_mmap_pages =
+                                                        KiB(128) / page_size;
+                                if (opts->mmap_pages == UINT_MAX)
+                                        opts->mmap_pages = KiB(256) / page_size;
+                        }
+                } else if (!opts->auxtrace_mmap_pages && !privileged &&
+                                                opts->mmap_pages == UINT_MAX) {
+                        opts->mmap_pages = KiB(256) / page_size;
+                }
+
+                /*
+                 * '-m,xyz' was specified but no snapshot size, so make the
+                 * snapshot size as big as the auxtrace mmap area.
+                 */
+                if (!opts->auxtrace_snapshot_size) {
+                        opts->auxtrace_snapshot_size =
+                                opts->auxtrace_mmap_pages * (size_t)page_size;
+                }
+
+                /*
+                 * -Sxyz was specified but no auxtrace mmap area, so make the
+                 * auxtrace mmap area big enough to fit the requested snapshot
+                 * size.
+                 */
+                if (!opts->auxtrace_mmap_pages) {
+                        size_t sz = opts->auxtrace_snapshot_size;
+
+                        sz = round_up(sz, page_size) / page_size;
+                        opts->auxtrace_mmap_pages = roundup_pow_of_two(sz);
+                }
+
+                /* Snapshost size can't be bigger than the auxtrace area */
+                if (opts->auxtrace_snapshot_size >
+                                opts->auxtrace_mmap_pages * (size_t)page_size) {
+                        pr_err("Snapshot size %zu must not be greater than AUX area tracing mmap size %zu\n",
+                               opts->auxtrace_snapshot_size,
+                               opts->auxtrace_mmap_pages * (size_t)page_size);
+                        return -EINVAL;
+                }
+
+                /* Something went wrong somewhere - this shouldn't happen */
+                if (!opts->auxtrace_snapshot_size ||
+                    !opts->auxtrace_mmap_pages) {
+                        pr_err("Failed to calculate default snapshot size and/or AUX area tracing mmap pages\n");
+                        return -EINVAL;
+                }
+        }
+
+        /* We are in full trace mode but '-m,xyz' wasn't specified */
+        if (opts->full_auxtrace && !opts->auxtrace_mmap_pages) {
+                if (privileged) {
+                        opts->auxtrace_mmap_pages = MiB(4) / page_size;
+                } else {
+                        opts->auxtrace_mmap_pages = KiB(128) / page_size;
+                        if (opts->mmap_pages == UINT_MAX)
+                                opts->mmap_pages = KiB(256) / page_size;
+                }
+
+        }
+
+        /* Validate auxtrace_mmap_pages provided by user */
+        if (opts->auxtrace_mmap_pages) {
+                unsigned int max_page = (KiB(128) / page_size);
+                size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;
+
+                if (!privileged &&
+                    opts->auxtrace_mmap_pages > max_page) {
+                        opts->auxtrace_mmap_pages = max_page;
+                        pr_err("auxtrace too big, truncating to %d\n",
+                               max_page);
+                }
+
+                if (!is_power_of_2(sz)) {
+                        pr_err("Invalid mmap size for %s: must be a power of 2\n",
+                               CORESIGHT_ETM_PMU_NAME);
+                        return -EINVAL;
+                }
+        }
+
+        if (opts->auxtrace_snapshot_mode)
+                pr_debug2("%s snapshot size: %zu\n", CORESIGHT_ETM_PMU_NAME,
+                          opts->auxtrace_snapshot_size);
+
+        if (cs_etm_evsel) {
+                /*
+                 * To obtain the auxtrace buffer file descriptor, the auxtrace
+                 * event must come first.
+                 */
+                perf_evlist__to_front(evlist, cs_etm_evsel);
+                /*
+                 * In the case of per-cpu mmaps, we need the CPU on the
+                 * AUX event.
+                 */
+                if (!cpu_map__empty(cpus))
+                        perf_evsel__set_sample_bit(cs_etm_evsel, CPU);
+        }
+
+        /* Add dummy event to keep tracking */
+        if (opts->full_auxtrace) {
+                struct perf_evsel *tracking_evsel;
+                int err;
+
+                err = parse_events(evlist, "dummy:u", NULL);
+                if (err)
+                        return err;
+
+                tracking_evsel = perf_evlist__last(evlist);
+                perf_evlist__set_tracking_event(evlist, tracking_evsel);
+
+                tracking_evsel->attr.freq = 0;
+                tracking_evsel->attr.sample_period = 1;
+
+                /* In per-cpu case, always need the time of mmap events etc */
+                if (!cpu_map__empty(cpus))
+                        perf_evsel__set_sample_bit(tracking_evsel, TIME);
+        }
+
+        return 0;
+}
+
+static u64 cs_etm_get_config(struct auxtrace_record *itr)
+{
+        u64 config = 0;
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
+        struct perf_evlist *evlist = ptr->evlist;
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(evlist, evsel) {
+                if (evsel->attr.type == cs_etm_pmu->type) {
+                        /*
+                         * Variable perf_event_attr::config is assigned to
+                         * ETMv3/PTM.  The bit fields have been made to match
+                         * the ETMv3.5 ETRMCR register specification.  See the
+                         * PMU_FORMAT_ATTR() declarations in
+                         * drivers/hwtracing/coresight/coresight-perf.c for
+                         * details.
+                         */
+                        config = evsel->attr.config;
+                        break;
+                }
+        }
+
+        return config;
+}
+
+static size_t
+cs_etm_info_priv_size(struct auxtrace_record *itr __maybe_unused,
+                      struct perf_evlist *evlist __maybe_unused)
+{
+        int i;
+        int etmv3 = 0, etmv4 = 0;
+        const struct cpu_map *cpus = evlist->cpus;
+
+        /* cpu map is not empty, we have specific CPUs to work with */
+        if (!cpu_map__empty(cpus)) {
+                for (i = 0; i < cpu_map__nr(cpus); i++) {
+                        if (cs_etm_is_etmv4(itr, cpus->map[i]))
+                                etmv4++;
+                        else
+                                etmv3++;
+                }
+        } else {
+                /* get configuration for all CPUs in the system */
+                for (i = 0; i < cpu__max_cpu(); i++) {
+                        if (cs_etm_is_etmv4(itr, i))
+                                etmv4++;
+                        else
+                                etmv3++;
+                }
+        }
+
+        return (CS_ETM_HEADER_SIZE +
+               (etmv4 * CS_ETMV4_PRIV_SIZE) +
+               (etmv3 * CS_ETMV3_PRIV_SIZE));
+}
+
+static const char *metadata_etmv3_ro[CS_ETM_PRIV_MAX] = {
+        [CS_ETM_ETMCCER]        = "mgmt/etmccer",
+        [CS_ETM_ETMIDR]         = "mgmt/etmidr",
+};
+
+static const char *metadata_etmv4_ro[CS_ETMV4_PRIV_MAX] = {
+        [CS_ETMV4_TRCIDR0]              = "trcidr/trcidr0",
+        [CS_ETMV4_TRCIDR1]              = "trcidr/trcidr1",
+        [CS_ETMV4_TRCIDR2]              = "trcidr/trcidr2",
+        [CS_ETMV4_TRCIDR8]              = "trcidr/trcidr8",
+        [CS_ETMV4_TRCAUTHSTATUS]        = "mgmt/trcauthstatus",
+};
+
+static bool cs_etm_is_etmv4(struct auxtrace_record *itr, int cpu)
+{
+        bool ret = false;
+        char path[PATH_MAX];
+        int scan;
+        unsigned int val;
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
+
+        /* Take any of the RO files for ETMv4 and see if it present */
+        snprintf(path, PATH_MAX, "cpu%d/%s",
+                 cpu, metadata_etmv4_ro[CS_ETMV4_TRCIDR0]);
+        scan = perf_pmu__scan_file(cs_etm_pmu, path, "%x", &val);
+
+        /* The file was read successfully, we have a winner */
+        if (scan == 1)
+                ret = true;
+
+        return ret;
+}
+
+static int cs_etm_get_ro(struct perf_pmu *pmu, int cpu, const char *path)
+{
+        char pmu_path[PATH_MAX];
+        int scan;
+        unsigned int val = 0;
+
+        /* Get RO metadata from sysfs */
+        snprintf(pmu_path, PATH_MAX, "cpu%d/%s", cpu, path);
+
+        scan = perf_pmu__scan_file(pmu, pmu_path, "%x", &val);
+        if (scan != 1)
+                pr_err("%s: error reading: %s\n", __func__, pmu_path);
+
+        return val;
+}
+
+static void cs_etm_get_metadata(int cpu, u32 *offset,
+                                struct auxtrace_record *itr,
+                                struct auxtrace_info_event *info)
+{
+        u32 increment;
+        u64 magic;
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
+
+        /* first see what kind of tracer this cpu is affined to */
+        if (cs_etm_is_etmv4(itr, cpu)) {
+                magic = __perf_cs_etmv4_magic;
+                /* Get trace configuration register */
+                info->priv[*offset + CS_ETMV4_TRCCONFIGR] =
+                                                cs_etm_get_config(itr);
+                /* Get traceID from the framework */
+                info->priv[*offset + CS_ETMV4_TRCTRACEIDR] =
+                                                coresight_get_trace_id(cpu);
+                /* Get read-only information from sysFS */
+                info->priv[*offset + CS_ETMV4_TRCIDR0] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv4_ro[CS_ETMV4_TRCIDR0]);
+                info->priv[*offset + CS_ETMV4_TRCIDR1] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv4_ro[CS_ETMV4_TRCIDR1]);
+                info->priv[*offset + CS_ETMV4_TRCIDR2] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv4_ro[CS_ETMV4_TRCIDR2]);
+                info->priv[*offset + CS_ETMV4_TRCIDR8] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv4_ro[CS_ETMV4_TRCIDR8]);
+                info->priv[*offset + CS_ETMV4_TRCAUTHSTATUS] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv4_ro
+                                      [CS_ETMV4_TRCAUTHSTATUS]);
+
+                /* How much space was used */
+                increment = CS_ETMV4_PRIV_MAX;
+        } else {
+                magic = __perf_cs_etmv3_magic;
+                /* Get configuration register */
+                info->priv[*offset + CS_ETM_ETMCR] = cs_etm_get_config(itr);
+                /* Get traceID from the framework */
+                info->priv[*offset + CS_ETM_ETMTRACEIDR] =
+                                                coresight_get_trace_id(cpu);
+                /* Get read-only information from sysFS */
+                info->priv[*offset + CS_ETM_ETMCCER] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv3_ro[CS_ETM_ETMCCER]);
+                info->priv[*offset + CS_ETM_ETMIDR] =
+                        cs_etm_get_ro(cs_etm_pmu, cpu,
+                                      metadata_etmv3_ro[CS_ETM_ETMIDR]);
+
+                /* How much space was used */
+                increment = CS_ETM_PRIV_MAX;
+        }
+
+        /* Build generic header portion */
+        info->priv[*offset + CS_ETM_MAGIC] = magic;
+        info->priv[*offset + CS_ETM_CPU] = cpu;
+        /* Where the next CPU entry should start from */
+        *offset += increment;
+}
+
+static int cs_etm_info_fill(struct auxtrace_record *itr,
+                            struct perf_session *session,
+                            struct auxtrace_info_event *info,
+                            size_t priv_size)
+{
+        int i;
+        u32 offset;
+        u64 nr_cpu, type;
+        const struct cpu_map *cpus = session->evlist->cpus;
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_pmu *cs_etm_pmu = ptr->cs_etm_pmu;
+
+        if (priv_size != cs_etm_info_priv_size(itr, session->evlist))
+                return -EINVAL;
+
+        if (!session->evlist->nr_mmaps)
+                return -EINVAL;
+
+        /* If the cpu_map is empty all CPUs are involved */
+        nr_cpu = cpu_map__empty(cpus) ? cpu__max_cpu() : cpu_map__nr(cpus);
+        /* Get PMU type as dynamically assigned by the core */
+        type = cs_etm_pmu->type;
+
+        /* First fill out the session header */
+        info->type = PERF_AUXTRACE_CS_ETM;
+        info->priv[CS_HEADER_VERSION_0] = 0;
+        info->priv[CS_PMU_TYPE_CPUS] = type << 32;
+        info->priv[CS_PMU_TYPE_CPUS] |= nr_cpu;
+        info->priv[CS_ETM_SNAPSHOT] = ptr->snapshot_mode;
+
+        offset = CS_ETM_SNAPSHOT + 1;
+
+        /* cpu map is not empty, we have specific CPUs to work with */
+        if (!cpu_map__empty(cpus)) {
+                for (i = 0; i < cpu_map__nr(cpus) && offset < priv_size; i++)
+                        cs_etm_get_metadata(cpus->map[i], &offset, itr, info);
+        } else {
+                /* get configuration for all CPUs in the system */
+                for (i = 0; i < cpu__max_cpu(); i++)
+                        cs_etm_get_metadata(i, &offset, itr, info);
+        }
+
+        return 0;
+}
+
+static int cs_etm_find_snapshot(struct auxtrace_record *itr __maybe_unused,
+                                int idx, struct auxtrace_mmap *mm,
+                                unsigned char *data __maybe_unused,
+                                u64 *head, u64 *old)
+{
+        pr_debug3("%s: mmap index %d old head %zu new head %zu size %zu\n",
+                  __func__, idx, (size_t)*old, (size_t)*head, mm->len);
+
+        *old = *head;
+        *head += mm->len;
+
+        return 0;
+}
+
+static int cs_etm_snapshot_start(struct auxtrace_record *itr)
+{
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(ptr->evlist, evsel) {
+                if (evsel->attr.type == ptr->cs_etm_pmu->type)
+                        return perf_evsel__disable(evsel);
+        }
+        return -EINVAL;
+}
+
+static int cs_etm_snapshot_finish(struct auxtrace_record *itr)
+{
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(ptr->evlist, evsel) {
+                if (evsel->attr.type == ptr->cs_etm_pmu->type)
+                        return perf_evsel__enable(evsel);
+        }
+        return -EINVAL;
+}
+
+static u64 cs_etm_reference(struct auxtrace_record *itr __maybe_unused)
+{
+        return (((u64) rand() <<  0) & 0x00000000FFFFFFFFull) |
+                (((u64) rand() << 32) & 0xFFFFFFFF00000000ull);
+}
+
+static void cs_etm_recording_free(struct auxtrace_record *itr)
+{
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        free(ptr);
+}
+
+static int cs_etm_read_finish(struct auxtrace_record *itr, int idx)
+{
+        struct cs_etm_recording *ptr =
+                        container_of(itr, struct cs_etm_recording, itr);
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(ptr->evlist, evsel) {
+                if (evsel->attr.type == ptr->cs_etm_pmu->type)
+                        return perf_evlist__enable_event_idx(ptr->evlist,
+                                                             evsel, idx);
+        }
+
+        return -EINVAL;
+}
+
+struct auxtrace_record *cs_etm_record_init(int *err)
+{
+        struct perf_pmu *cs_etm_pmu;
+        struct cs_etm_recording *ptr;
+
+        cs_etm_pmu = perf_pmu__find(CORESIGHT_ETM_PMU_NAME);
+
+        if (!cs_etm_pmu) {
+                *err = -EINVAL;
+                goto out;
+        }
+
+        ptr = zalloc(sizeof(struct cs_etm_recording));
+        if (!ptr) {
+                *err = -ENOMEM;
+                goto out;
+        }
+
+        ptr->cs_etm_pmu                 = cs_etm_pmu;
+        ptr->itr.parse_snapshot_options = cs_etm_parse_snapshot_options;
+        ptr->itr.recording_options      = cs_etm_recording_options;
+        ptr->itr.info_priv_size         = cs_etm_info_priv_size;
+        ptr->itr.info_fill              = cs_etm_info_fill;
+        ptr->itr.find_snapshot          = cs_etm_find_snapshot;
+        ptr->itr.snapshot_start         = cs_etm_snapshot_start;
+        ptr->itr.snapshot_finish        = cs_etm_snapshot_finish;
+        ptr->itr.reference              = cs_etm_reference;
+        ptr->itr.free                   = cs_etm_recording_free;
+        ptr->itr.read_finish            = cs_etm_read_finish;
+
+        *err = 0;
+        return &ptr->itr;
+out:
+        return NULL;
+}
+
+static FILE *cs_device__open_file(const char *name)
+{
+        struct stat st;
+        char path[PATH_MAX];
+        const char *sysfs;
+
+        sysfs = sysfs__mountpoint();
+        if (!sysfs)
+                return NULL;
+
+        snprintf(path, PATH_MAX,
+                 "%s" CS_BUS_DEVICE_PATH "%s", sysfs, name);
+
+        printf("path: %s\n", path);
+
+        if (stat(path, &st) < 0)
+                return NULL;
+
+        return fopen(path, "w");
+
+}
+
+static __attribute__((format(printf, 2, 3)))
+int cs_device__print_file(const char *name, const char *fmt, ...)
+{
+        va_list args;
+        FILE *file;
+        int ret = -EINVAL;
+
+        va_start(args, fmt);
+        file = cs_device__open_file(name);
+        if (file) {
+                ret = vfprintf(file, fmt, args);
+                fclose(file);
+        }
+        va_end(args);
+        return ret;
+}
+
+int cs_etm_set_drv_config(struct perf_evsel_config_term *term)
+{
+        int ret;
+        char enable_sink[ENABLE_SINK_MAX];
+
+        snprintf(enable_sink, ENABLE_SINK_MAX, "%s/%s",
+                 term->val.drv_cfg, "enable_sink");
+
+        ret = cs_device__print_file(enable_sink, "%d", 1);
+        if (ret < 0)
+                return ret;
+
+        return 0;
+}
diff --git a/tools/perf/arch/arm/util/cs-etm.h b/tools/perf/arch/arm/util/cs-etm.h
new file mode 100644
index 000000000000..5256741be549
--- /dev/null
+++ b/tools/perf/arch/arm/util/cs-etm.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDE__PERF_CS_ETM_H__
+#define INCLUDE__PERF_CS_ETM_H__
+
+#include "../../util/evsel.h"
+
+struct auxtrace_record *cs_etm_record_init(int *err);
+int cs_etm_set_drv_config(struct perf_evsel_config_term *term);
+
+#endif
diff --git a/tools/perf/arch/arm/util/pmu.c b/tools/perf/arch/arm/util/pmu.c
new file mode 100644
index 000000000000..98d67399a0d6
--- /dev/null
+++ b/tools/perf/arch/arm/util/pmu.c
@@ -0,0 +1,36 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+#include <linux/coresight-pmu.h>
+#include <linux/perf_event.h>
+
+#include "cs-etm.h"
+#include "../../util/pmu.h"
+
+struct perf_event_attr
+*perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
+{
+#ifdef HAVE_AUXTRACE_SUPPORT
+        if (!strcmp(pmu->name, CORESIGHT_ETM_PMU_NAME)) {
+                /* add ETM default config here */
+                pmu->selectable = true;
+                pmu->set_drv_config = cs_etm_set_drv_config;
+        }
+#endif
+        return NULL;
+}
diff --git a/tools/perf/arch/arm64/include/dwarf-regs-table.h b/tools/perf/arch/arm64/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..26759363f921
--- /dev/null
+++ b/tools/perf/arch/arm64/include/dwarf-regs-table.h
@@ -0,0 +1,13 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const aarch64_regstr_tbl[] = {
+        "%r0", "%r1", "%r2", "%r3", "%r4",
+        "%r5", "%r6", "%r7", "%r8", "%r9",
+        "%r10", "%r11", "%r12", "%r13", "%r14",
+        "%r15", "%r16", "%r17", "%r18", "%r19",
+        "%r20", "%r21", "%r22", "%r23", "%r24",
+        "%r25", "%r26", "%r27", "%r28", "%r29",
+        "%lr", "%sp",
+};
+#endif
diff --git a/tools/perf/arch/arm64/util/Build b/tools/perf/arch/arm64/util/Build
index e58123a8912b..cef6fb38d17e 100644
--- a/tools/perf/arch/arm64/util/Build
+++ b/tools/perf/arch/arm64/util/Build
@@ -1,2 +1,6 @@
 libperf-$(CONFIG_DWARF)     += dwarf-regs.o
-libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
+libperf-$(CONFIG_LOCAL_LIBUNWIND) += unwind-libunwind.o
+
+libperf-$(CONFIG_AUXTRACE) += ../../arm/util/pmu.o \
+                              ../../arm/util/auxtrace.o \
+                              ../../arm/util/cs-etm.o
diff --git a/tools/perf/arch/arm64/util/unwind-libunwind.c b/tools/perf/arch/arm64/util/unwind-libunwind.c
index a87afa91a99e..c116b713f7f7 100644
--- a/tools/perf/arch/arm64/util/unwind-libunwind.c
+++ b/tools/perf/arch/arm64/util/unwind-libunwind.c
@@ -1,11 +1,13 @@
 
+#ifndef REMOTE_UNWIND_LIBUNWIND
 #include <errno.h>
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
 #include "../../util/debug.h"
+#endif
 
-int libunwind__arch_reg_id(int regnum)
+int LIBUNWIND__ARCH_REG_ID(int regnum)
 {
         switch (regnum) {
         case UNW_AARCH64_X0:
diff --git a/tools/perf/arch/common.c b/tools/perf/arch/common.c
index e83c8ce24303..886dd2aaff0d 100644
--- a/tools/perf/arch/common.c
+++ b/tools/perf/arch/common.c
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <sys/utsname.h>
 #include "common.h"
+#include "../util/util.h"
 #include "../util/debug.h"
 
 const char *const arm_triplets[] = {
@@ -9,34 +10,44 @@ const char *const arm_triplets[] = {
         "arm-unknown-linux-",
         "arm-unknown-linux-gnu-",
         "arm-unknown-linux-gnueabi-",
+        "arm-linux-gnu-",
+        "arm-linux-gnueabihf-",
+        "arm-none-eabi-",
         NULL
 };
 
 const char *const arm64_triplets[] = {
         "aarch64-linux-android-",
+        "aarch64-linux-gnu-",
         NULL
 };
 
 const char *const powerpc_triplets[] = {
         "powerpc-unknown-linux-gnu-",
         "powerpc64-unknown-linux-gnu-",
+        "powerpc64-linux-gnu-",
+        "powerpc64le-linux-gnu-",
         NULL
 };
 
 const char *const s390_triplets[] = {
         "s390-ibm-linux-",
+        "s390x-linux-gnu-",
         NULL
 };
 
 const char *const sh_triplets[] = {
         "sh-unknown-linux-gnu-",
         "sh64-unknown-linux-gnu-",
+        "sh-linux-gnu-",
+        "sh64-linux-gnu-",
         NULL
 };
 
 const char *const sparc_triplets[] = {
         "sparc-unknown-linux-gnu-",
         "sparc64-unknown-linux-gnu-",
+        "sparc64-linux-gnu-",
         NULL
 };
 
@@ -49,12 +60,19 @@ const char *const x86_triplets[] = {
         "i386-pc-linux-gnu-",
         "i686-linux-android-",
         "i686-android-linux-",
+        "x86_64-linux-gnu-",
+        "i586-linux-gnu-",
         NULL
 };
 
 const char *const mips_triplets[] = {
         "mips-unknown-linux-gnu-",
         "mipsel-linux-android-",
+        "mips-linux-gnu-",
+        "mips64-linux-gnu-",
+        "mips64el-linux-gnuabi64-",
+        "mips64-linux-gnuabi64-",
+        "mipsel-linux-gnu-",
         NULL
 };
 
@@ -102,7 +120,7 @@ static int lookup_triplets(const char *const *triplets, const char *name)
  * Return architecture name in a normalized form.
  * The conversion logic comes from the Makefile.
  */
-static const char *normalize_arch(char *arch)
+const char *normalize_arch(char *arch)
 {
         if (!strcmp(arch, "x86_64"))
                 return "x86";
diff --git a/tools/perf/arch/common.h b/tools/perf/arch/common.h
index 7529cfb143ce..6b01c736b7d9 100644
--- a/tools/perf/arch/common.h
+++ b/tools/perf/arch/common.h
@@ -6,5 +6,6 @@
 extern const char *objdump_path;
 
 int perf_env__lookup_objdump(struct perf_env *env);
+const char *normalize_arch(char *arch);
 
 #endif /* ARCH_PERF_COMMON_H */
diff --git a/tools/perf/arch/powerpc/Build b/tools/perf/arch/powerpc/Build
index 54afe4a467e7..db52fa22d3a1 100644
--- a/tools/perf/arch/powerpc/Build
+++ b/tools/perf/arch/powerpc/Build
@@ -1 +1,2 @@
 libperf-y += util/
+libperf-y += tests/
diff --git a/tools/perf/arch/powerpc/include/arch-tests.h b/tools/perf/arch/powerpc/include/arch-tests.h
new file mode 100644
index 000000000000..84d8dedef2ed
--- /dev/null
+++ b/tools/perf/arch/powerpc/include/arch-tests.h
@@ -0,0 +1,13 @@
+#ifndef ARCH_TESTS_H
+#define ARCH_TESTS_H
+
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+struct thread;
+struct perf_sample;
+int test__arch_unwind_sample(struct perf_sample *sample,
+                             struct thread *thread);
+#endif
+
+extern struct test arch_tests[];
+
+#endif
diff --git a/tools/perf/arch/powerpc/include/dwarf-regs-table.h b/tools/perf/arch/powerpc/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..db4730f5585c
--- /dev/null
+++ b/tools/perf/arch/powerpc/include/dwarf-regs-table.h
@@ -0,0 +1,27 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+/*
+ * Reference:
+ * http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.html
+ * http://refspecs.linux-foundation.org/elf/elfspec_ppc.pdf
+ */
+#define REG_DWARFNUM_NAME(reg, idx)     [idx] = "%" #reg
+
+static const char * const powerpc_regstr_tbl[] = {
+        "%gpr0", "%gpr1", "%gpr2", "%gpr3", "%gpr4",
+        "%gpr5", "%gpr6", "%gpr7", "%gpr8", "%gpr9",
+        "%gpr10", "%gpr11", "%gpr12", "%gpr13", "%gpr14",
+        "%gpr15", "%gpr16", "%gpr17", "%gpr18", "%gpr19",
+        "%gpr20", "%gpr21", "%gpr22", "%gpr23", "%gpr24",
+        "%gpr25", "%gpr26", "%gpr27", "%gpr28", "%gpr29",
+        "%gpr30", "%gpr31",
+        REG_DWARFNUM_NAME(msr,   66),
+        REG_DWARFNUM_NAME(ctr,   109),
+        REG_DWARFNUM_NAME(link,  108),
+        REG_DWARFNUM_NAME(xer,   101),
+        REG_DWARFNUM_NAME(dar,   119),
+        REG_DWARFNUM_NAME(dsisr, 118),
+};
+
+#endif
diff --git a/tools/perf/arch/powerpc/include/perf_regs.h b/tools/perf/arch/powerpc/include/perf_regs.h
index 75de0e92e71e..c12f4e804f66 100644
--- a/tools/perf/arch/powerpc/include/perf_regs.h
+++ b/tools/perf/arch/powerpc/include/perf_regs.h
@@ -5,6 +5,8 @@
 #include <linux/types.h>
 #include <asm/perf_regs.h>
 
+void perf_regs_load(u64 *regs);
+
 #define PERF_REGS_MASK  ((1ULL << PERF_REG_POWERPC_MAX) - 1)
 #define PERF_REGS_MAX   PERF_REG_POWERPC_MAX
 #ifdef __powerpc64__
diff --git a/tools/perf/arch/powerpc/tests/Build b/tools/perf/arch/powerpc/tests/Build
new file mode 100644
index 000000000000..d827ef384b33
--- /dev/null
+++ b/tools/perf/arch/powerpc/tests/Build
@@ -0,0 +1,4 @@
+libperf-$(CONFIG_DWARF_UNWIND) += regs_load.o
+libperf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
+
+libperf-y += arch-tests.o
diff --git a/tools/perf/arch/powerpc/tests/arch-tests.c b/tools/perf/arch/powerpc/tests/arch-tests.c
new file mode 100644
index 000000000000..e24f46241f40
--- /dev/null
+++ b/tools/perf/arch/powerpc/tests/arch-tests.c
@@ -0,0 +1,15 @@
+#include <string.h>
+#include "tests/tests.h"
+#include "arch-tests.h"
+
+struct test arch_tests[] = {
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+        {
+                .desc = "Test dwarf unwind",
+                .func = test__dwarf_unwind,
+        },
+#endif
+        {
+                .func = NULL,
+        },
+};
diff --git a/tools/perf/arch/powerpc/tests/dwarf-unwind.c b/tools/perf/arch/powerpc/tests/dwarf-unwind.c
new file mode 100644
index 000000000000..0bac3137ccbd
--- /dev/null
+++ b/tools/perf/arch/powerpc/tests/dwarf-unwind.c
@@ -0,0 +1,62 @@
+#include <string.h>
+#include "perf_regs.h"
+#include "thread.h"
+#include "map.h"
+#include "event.h"
+#include "debug.h"
+#include "tests/tests.h"
+#include "arch-tests.h"
+
+#define STACK_SIZE 8192
+
+static int sample_ustack(struct perf_sample *sample,
+                         struct thread *thread, u64 *regs)
+{
+        struct stack_dump *stack = &sample->user_stack;
+        struct map *map;
+        unsigned long sp;
+        u64 stack_size, *buf;
+
+        buf = malloc(STACK_SIZE);
+        if (!buf) {
+                pr_debug("failed to allocate sample uregs data\n");
+                return -1;
+        }
+
+        sp = (unsigned long) regs[PERF_REG_POWERPC_R1];
+
+        map = map_groups__find(thread->mg, MAP__VARIABLE, (u64) sp);
+        if (!map) {
+                pr_debug("failed to get stack map\n");
+                free(buf);
+                return -1;
+        }
+
+        stack_size = map->end - sp;
+        stack_size = stack_size > STACK_SIZE ? STACK_SIZE : stack_size;
+
+        memcpy(buf, (void *) sp, stack_size);
+        stack->data = (char *) buf;
+        stack->size = stack_size;
+        return 0;
+}
+
+int test__arch_unwind_sample(struct perf_sample *sample,
+                             struct thread *thread)
+{
+        struct regs_dump *regs = &sample->user_regs;
+        u64 *buf;
+
+        buf = calloc(1, sizeof(u64) * PERF_REGS_MAX);
+        if (!buf) {
+                pr_debug("failed to allocate sample uregs data\n");
+                return -1;
+        }
+
+        perf_regs_load(buf);
+        regs->abi  = PERF_SAMPLE_REGS_ABI;
+        regs->regs = buf;
+        regs->mask = PERF_REGS_MASK;
+
+        return sample_ustack(sample, thread, buf);
+}
diff --git a/tools/perf/arch/powerpc/tests/regs_load.S b/tools/perf/arch/powerpc/tests/regs_load.S
new file mode 100644
index 000000000000..d76c9a32f327
--- /dev/null
+++ b/tools/perf/arch/powerpc/tests/regs_load.S
@@ -0,0 +1,94 @@
+#include <linux/linkage.h>
+
+/* Offset is based on macros from arch/powerpc/include/uapi/asm/ptrace.h. */
+#define R0       0
+#define R1       1 * 8
+#define R2       2 * 8
+#define R3       3 * 8
+#define R4       4 * 8
+#define R5       5 * 8
+#define R6       6 * 8
+#define R7       7 * 8
+#define R8       8 * 8
+#define R9       9 * 8
+#define R10     10 * 8
+#define R11     11 * 8
+#define R12     12 * 8
+#define R13     13 * 8
+#define R14     14 * 8
+#define R15     15 * 8
+#define R16     16 * 8
+#define R17     17 * 8
+#define R18     18 * 8
+#define R19     19 * 8
+#define R20     20 * 8
+#define R21     21 * 8
+#define R22     22 * 8
+#define R23     23 * 8
+#define R24     24 * 8
+#define R25     25 * 8
+#define R26     26 * 8
+#define R27     27 * 8
+#define R28     28 * 8
+#define R29     29 * 8
+#define R30     30 * 8
+#define R31     31 * 8
+#define NIP     32 * 8
+#define CTR     35 * 8
+#define LINK    36 * 8
+#define XER     37 * 8
+
+.globl perf_regs_load
+perf_regs_load:
+        std 0, R0(3)
+        std 1, R1(3)
+        std 2, R2(3)
+        std 3, R3(3)
+        std 4, R4(3)
+        std 5, R5(3)
+        std 6, R6(3)
+        std 7, R7(3)
+        std 8, R8(3)
+        std 9, R9(3)
+        std 10, R10(3)
+        std 11, R11(3)
+        std 12, R12(3)
+        std 13, R13(3)
+        std 14, R14(3)
+        std 15, R15(3)
+        std 16, R16(3)
+        std 17, R17(3)
+        std 18, R18(3)
+        std 19, R19(3)
+        std 20, R20(3)
+        std 21, R21(3)
+        std 22, R22(3)
+        std 23, R23(3)
+        std 24, R24(3)
+        std 25, R25(3)
+        std 26, R26(3)
+        std 27, R27(3)
+        std 28, R28(3)
+        std 29, R29(3)
+        std 30, R30(3)
+        std 31, R31(3)
+
+        /* store NIP */
+        mflr 4
+        std 4, NIP(3)
+
+        /* Store LR */
+        std 4, LINK(3)
+
+        /* Store XER */
+        mfxer 4
+        std 4, XER(3)
+
+        /* Store CTR */
+        mfctr 4
+        std 4, CTR(3)
+
+        /* Restore original value of r4 */
+        ld 4, R4(3)
+
+        blr
diff --git a/tools/perf/arch/powerpc/util/header.c b/tools/perf/arch/powerpc/util/header.c
index f8ccee132867..9aaa6f5a9347 100644
--- a/tools/perf/arch/powerpc/util/header.c
+++ b/tools/perf/arch/powerpc/util/header.c
@@ -32,3 +32,14 @@ get_cpuid(char *buffer, size_t sz)
         }
         return -1;
 }
+
+char *
+get_cpuid_str(void)
+{
+        char *bufp;
+
+        if (asprintf(&bufp, "%.8lx", mfspr(SPRN_PVR)) < 0)
+                bufp = NULL;
+
+        return bufp;
+}
diff --git a/tools/perf/arch/powerpc/util/sym-handling.c b/tools/perf/arch/powerpc/util/sym-handling.c
index c6d0f91731a1..1030a6e504bb 100644
--- a/tools/perf/arch/powerpc/util/sym-handling.c
+++ b/tools/perf/arch/powerpc/util/sym-handling.c
@@ -54,10 +54,6 @@ int arch__compare_symbol_names(const char *namea, const char *nameb)
 #endif
 
 #if defined(_CALL_ELF) && _CALL_ELF == 2
-bool arch__prefers_symtab(void)
-{
-        return true;
-}
 
 #ifdef HAVE_LIBELF_SUPPORT
 void arch__sym_update(struct symbol *s, GElf_Sym *sym)
@@ -86,7 +82,8 @@ void arch__fix_tev_from_maps(struct perf_probe_event *pev,
          *
          * In addition, we shouldn't specify an offset for kretprobes.
          */
-        if (pev->point.offset || pev->point.retprobe || !map || !sym)
+        if (pev->point.offset || (!pev->uprobes && pev->point.retprobe) ||
+            !map || !sym)
                 return;
 
         lep_offset = PPC64_LOCAL_ENTRY_OFFSET(sym->arch_sym);
@@ -100,4 +97,29 @@ void arch__fix_tev_from_maps(struct perf_probe_event *pev,
                         tev->point.offset += lep_offset;
         }
 }
+
+#ifdef HAVE_LIBELF_SUPPORT
+void arch__post_process_probe_trace_events(struct perf_probe_event *pev,
+                                           int ntevs)
+{
+        struct probe_trace_event *tev;
+        struct map *map;
+        struct symbol *sym = NULL;
+        struct rb_node *tmp;
+        int i = 0;
+
+        map = get_target_map(pev->target, pev->uprobes);
+        if (!map || map__load(map) < 0)
+                return;
+
+        for (i = 0; i < ntevs; i++) {
+                tev = &pev->tevs[i];
+                map__for_each_symbol(map, sym, tmp) {
+                        if (map->unmap_ip(map, sym->start) == tev->point.address)
+                                arch__fix_tev_from_maps(pev, tev, map, sym);
+                }
+        }
+}
+#endif /* HAVE_LIBELF_SUPPORT */
+
 #endif
diff --git a/tools/perf/arch/s390/include/dwarf-regs-table.h b/tools/perf/arch/s390/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..9da74a933bd6
--- /dev/null
+++ b/tools/perf/arch/s390/include/dwarf-regs-table.h
@@ -0,0 +1,8 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const s390_regstr_tbl[] = {
+        "%r0", "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
+        "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
+};
+#endif
diff --git a/tools/perf/arch/s390/util/Build b/tools/perf/arch/s390/util/Build
index 8a61372bb47a..5bd7b9260cc0 100644
--- a/tools/perf/arch/s390/util/Build
+++ b/tools/perf/arch/s390/util/Build
@@ -2,3 +2,5 @@ libperf-y += header.o
 libperf-y += kvm-stat.o
 
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
+
+libperf-y += machine.o
diff --git a/tools/perf/arch/s390/util/machine.c b/tools/perf/arch/s390/util/machine.c
new file mode 100644
index 000000000000..b9a95a1a8e69
--- /dev/null
+++ b/tools/perf/arch/s390/util/machine.c
@@ -0,0 +1,19 @@
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include "util.h"
+#include "machine.h"
+#include "api/fs/fs.h"
+
+int arch__fix_module_text_start(u64 *start, const char *name)
+{
+        char path[PATH_MAX];
+
+        snprintf(path, PATH_MAX, "module/%.*s/sections/.text",
+                                (int)strlen(name) - 2, name + 1);
+
+        if (sysfs__read_ull(path, (unsigned long long *)start) < 0)
+                return -1;
+
+        return 0;
+}
diff --git a/tools/perf/arch/sh/include/dwarf-regs-table.h b/tools/perf/arch/sh/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..3a2deaf3dab4
--- /dev/null
+++ b/tools/perf/arch/sh/include/dwarf-regs-table.h
@@ -0,0 +1,25 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+const char * const sh_regstr_tbl[] = {
+        "r0",
+        "r1",
+        "r2",
+        "r3",
+        "r4",
+        "r5",
+        "r6",
+        "r7",
+        "r8",
+        "r9",
+        "r10",
+        "r11",
+        "r12",
+        "r13",
+        "r14",
+        "r15",
+        "pc",
+        "pr",
+};
+
+#endif
diff --git a/tools/perf/arch/sparc/include/dwarf-regs-table.h b/tools/perf/arch/sparc/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..12c07619002c
--- /dev/null
+++ b/tools/perf/arch/sparc/include/dwarf-regs-table.h
@@ -0,0 +1,18 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const sparc_regstr_tbl[] = {
+        "%g0", "%g1", "%g2", "%g3", "%g4", "%g5", "%g6", "%g7",
+        "%o0", "%o1", "%o2", "%o3", "%o4", "%o5", "%sp", "%o7",
+        "%l0", "%l1", "%l2", "%l3", "%l4", "%l5", "%l6", "%l7",
+        "%i0", "%i1", "%i2", "%i3", "%i4", "%i5", "%fp", "%i7",
+        "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
+        "%f8", "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
+        "%f16", "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
+        "%f24", "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
+        "%f32", "%f33", "%f34", "%f35", "%f36", "%f37", "%f38", "%f39",
+        "%f40", "%f41", "%f42", "%f43", "%f44", "%f45", "%f46", "%f47",
+        "%f48", "%f49", "%f50", "%f51", "%f52", "%f53", "%f54", "%f55",
+        "%f56", "%f57", "%f58", "%f59", "%f60", "%f61", "%f62", "%f63",
+};
+#endif
diff --git a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
index cac6d17ce5db..555263e385c9 100644
--- a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
@@ -374,3 +374,5 @@
 543     x32     io_setup                compat_sys_io_setup
 544     x32     io_submit               compat_sys_io_submit
 545     x32     execveat                compat_sys_execveat/ptregs
+534     x32     preadv2                 compat_sys_preadv2
+535     x32     pwritev2                compat_sys_pwritev2
diff --git a/tools/perf/arch/x86/include/dwarf-regs-table.h b/tools/perf/arch/x86/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..9b5e5cbb4209
--- /dev/null
+++ b/tools/perf/arch/x86/include/dwarf-regs-table.h
@@ -0,0 +1,14 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const x86_32_regstr_tbl[] = {
+        "%ax", "%cx", "%dx", "%bx", "$stack",/* Stack address instead of %sp */
+        "%bp", "%si", "%di",
+};
+
+static const char * const x86_64_regstr_tbl[] = {
+        "%ax", "%dx", "%cx", "%bx", "%si", "%di",
+        "%bp", "%sp", "%r8", "%r9", "%r10", "%r11",
+        "%r12", "%r13", "%r14", "%r15",
+};
+#endif
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-32.c b/tools/perf/arch/x86/tests/insn-x86-dat-32.c
index 3b491cfe204e..0f196eec9f48 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-32.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-32.c
@@ -6,6 +6,1016 @@
 
 {{0x0f, 0x31, }, 2, 0, "", "",
 "0f 31                \trdtsc  ",},
+{{0xc4, 0xe2, 0x7d, 0x13, 0xeb, }, 5, 0, "", "",
+"c4 e2 7d 13 eb       \tvcvtph2ps %xmm3,%ymm5",},
+{{0x62, 0x81, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 81 78 56 34 12    \tbound  %eax,0x12345678(%ecx)",},
+{{0x62, 0x88, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 88 78 56 34 12    \tbound  %ecx,0x12345678(%eax)",},
+{{0x62, 0x90, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 90 78 56 34 12    \tbound  %edx,0x12345678(%eax)",},
+{{0x62, 0x98, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 98 78 56 34 12    \tbound  %ebx,0x12345678(%eax)",},
+{{0x62, 0xa0, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 a0 78 56 34 12    \tbound  %esp,0x12345678(%eax)",},
+{{0x62, 0xa8, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 a8 78 56 34 12    \tbound  %ebp,0x12345678(%eax)",},
+{{0x62, 0xb0, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 b0 78 56 34 12    \tbound  %esi,0x12345678(%eax)",},
+{{0x62, 0xb8, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 b8 78 56 34 12    \tbound  %edi,0x12345678(%eax)",},
+{{0x62, 0x08, }, 2, 0, "", "",
+"62 08                \tbound  %ecx,(%eax)",},
+{{0x62, 0x05, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 05 78 56 34 12    \tbound  %eax,0x12345678",},
+{{0x62, 0x14, 0x01, }, 3, 0, "", "",
+"62 14 01             \tbound  %edx,(%ecx,%eax,1)",},
+{{0x62, 0x14, 0x05, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"62 14 05 78 56 34 12 \tbound  %edx,0x12345678(,%eax,1)",},
+{{0x62, 0x14, 0x08, }, 3, 0, "", "",
+"62 14 08             \tbound  %edx,(%eax,%ecx,1)",},
+{{0x62, 0x14, 0xc8, }, 3, 0, "", "",
+"62 14 c8             \tbound  %edx,(%eax,%ecx,8)",},
+{{0x62, 0x50, 0x12, }, 3, 0, "", "",
+"62 50 12             \tbound  %edx,0x12(%eax)",},
+{{0x62, 0x55, 0x12, }, 3, 0, "", "",
+"62 55 12             \tbound  %edx,0x12(%ebp)",},
+{{0x62, 0x54, 0x01, 0x12, }, 4, 0, "", "",
+"62 54 01 12          \tbound  %edx,0x12(%ecx,%eax,1)",},
+{{0x62, 0x54, 0x05, 0x12, }, 4, 0, "", "",
+"62 54 05 12          \tbound  %edx,0x12(%ebp,%eax,1)",},
+{{0x62, 0x54, 0x08, 0x12, }, 4, 0, "", "",
+"62 54 08 12          \tbound  %edx,0x12(%eax,%ecx,1)",},
+{{0x62, 0x54, 0xc8, 0x12, }, 4, 0, "", "",
+"62 54 c8 12          \tbound  %edx,0x12(%eax,%ecx,8)",},
+{{0x62, 0x90, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 90 78 56 34 12    \tbound  %edx,0x12345678(%eax)",},
+{{0x62, 0x95, 0x78, 0x56, 0x34, 0x12, }, 6, 0, "", "",
+"62 95 78 56 34 12    \tbound  %edx,0x12345678(%ebp)",},
+{{0x62, 0x94, 0x01, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"62 94 01 78 56 34 12 \tbound  %edx,0x12345678(%ecx,%eax,1)",},
+{{0x62, 0x94, 0x05, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"62 94 05 78 56 34 12 \tbound  %edx,0x12345678(%ebp,%eax,1)",},
+{{0x62, 0x94, 0x08, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"62 94 08 78 56 34 12 \tbound  %edx,0x12345678(%eax,%ecx,1)",},
+{{0x62, 0x94, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"62 94 c8 78 56 34 12 \tbound  %edx,0x12345678(%eax,%ecx,8)",},
+{{0x66, 0x62, 0x81, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 81 78 56 34 12 \tbound  %ax,0x12345678(%ecx)",},
+{{0x66, 0x62, 0x88, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 88 78 56 34 12 \tbound  %cx,0x12345678(%eax)",},
+{{0x66, 0x62, 0x90, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 90 78 56 34 12 \tbound  %dx,0x12345678(%eax)",},
+{{0x66, 0x62, 0x98, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 98 78 56 34 12 \tbound  %bx,0x12345678(%eax)",},
+{{0x66, 0x62, 0xa0, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 a0 78 56 34 12 \tbound  %sp,0x12345678(%eax)",},
+{{0x66, 0x62, 0xa8, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 a8 78 56 34 12 \tbound  %bp,0x12345678(%eax)",},
+{{0x66, 0x62, 0xb0, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 b0 78 56 34 12 \tbound  %si,0x12345678(%eax)",},
+{{0x66, 0x62, 0xb8, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 b8 78 56 34 12 \tbound  %di,0x12345678(%eax)",},
+{{0x66, 0x62, 0x08, }, 3, 0, "", "",
+"66 62 08             \tbound  %cx,(%eax)",},
+{{0x66, 0x62, 0x05, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 05 78 56 34 12 \tbound  %ax,0x12345678",},
+{{0x66, 0x62, 0x14, 0x01, }, 4, 0, "", "",
+"66 62 14 01          \tbound  %dx,(%ecx,%eax,1)",},
+{{0x66, 0x62, 0x14, 0x05, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 62 14 05 78 56 34 12 \tbound  %dx,0x12345678(,%eax,1)",},
+{{0x66, 0x62, 0x14, 0x08, }, 4, 0, "", "",
+"66 62 14 08          \tbound  %dx,(%eax,%ecx,1)",},
+{{0x66, 0x62, 0x14, 0xc8, }, 4, 0, "", "",
+"66 62 14 c8          \tbound  %dx,(%eax,%ecx,8)",},
+{{0x66, 0x62, 0x50, 0x12, }, 4, 0, "", "",
+"66 62 50 12          \tbound  %dx,0x12(%eax)",},
+{{0x66, 0x62, 0x55, 0x12, }, 4, 0, "", "",
+"66 62 55 12          \tbound  %dx,0x12(%ebp)",},
+{{0x66, 0x62, 0x54, 0x01, 0x12, }, 5, 0, "", "",
+"66 62 54 01 12       \tbound  %dx,0x12(%ecx,%eax,1)",},
+{{0x66, 0x62, 0x54, 0x05, 0x12, }, 5, 0, "", "",
+"66 62 54 05 12       \tbound  %dx,0x12(%ebp,%eax,1)",},
+{{0x66, 0x62, 0x54, 0x08, 0x12, }, 5, 0, "", "",
+"66 62 54 08 12       \tbound  %dx,0x12(%eax,%ecx,1)",},
+{{0x66, 0x62, 0x54, 0xc8, 0x12, }, 5, 0, "", "",
+"66 62 54 c8 12       \tbound  %dx,0x12(%eax,%ecx,8)",},
+{{0x66, 0x62, 0x90, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 90 78 56 34 12 \tbound  %dx,0x12345678(%eax)",},
+{{0x66, 0x62, 0x95, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"66 62 95 78 56 34 12 \tbound  %dx,0x12345678(%ebp)",},
+{{0x66, 0x62, 0x94, 0x01, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 62 94 01 78 56 34 12 \tbound  %dx,0x12345678(%ecx,%eax,1)",},
+{{0x66, 0x62, 0x94, 0x05, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 62 94 05 78 56 34 12 \tbound  %dx,0x12345678(%ebp,%eax,1)",},
+{{0x66, 0x62, 0x94, 0x08, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 62 94 08 78 56 34 12 \tbound  %dx,0x12345678(%eax,%ecx,1)",},
+{{0x66, 0x62, 0x94, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 62 94 c8 78 56 34 12 \tbound  %dx,0x12345678(%eax,%ecx,8)",},
+{{0x0f, 0x41, 0xd8, }, 3, 0, "", "",
+"0f 41 d8             \tcmovno %eax,%ebx",},
+{{0x0f, 0x41, 0x88, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 41 88 78 56 34 12 \tcmovno 0x12345678(%eax),%ecx",},
+{{0x66, 0x0f, 0x41, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 0f 41 88 78 56 34 12 \tcmovno 0x12345678(%eax),%cx",},
+{{0x0f, 0x44, 0xd8, }, 3, 0, "", "",
+"0f 44 d8             \tcmove  %eax,%ebx",},
+{{0x0f, 0x44, 0x88, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 44 88 78 56 34 12 \tcmove  0x12345678(%eax),%ecx",},
+{{0x66, 0x0f, 0x44, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 0f 44 88 78 56 34 12 \tcmove  0x12345678(%eax),%cx",},
+{{0x0f, 0x90, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 90 80 78 56 34 12 \tseto   0x12345678(%eax)",},
+{{0x0f, 0x91, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 91 80 78 56 34 12 \tsetno  0x12345678(%eax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%eax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%eax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%eax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%eax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%eax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%eax)",},
+{{0x0f, 0x98, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 98 80 78 56 34 12 \tsets   0x12345678(%eax)",},
+{{0x0f, 0x99, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 99 80 78 56 34 12 \tsetns  0x12345678(%eax)",},
+{{0xc5, 0xcc, 0x41, 0xef, }, 4, 0, "", "",
+"c5 cc 41 ef          \tkandw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x41, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 41 ef       \tkandq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x41, 0xef, }, 4, 0, "", "",
+"c5 cd 41 ef          \tkandb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x41, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 41 ef       \tkandd  %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x42, 0xef, }, 4, 0, "", "",
+"c5 cc 42 ef          \tkandnw %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x42, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 42 ef       \tkandnq %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x42, 0xef, }, 4, 0, "", "",
+"c5 cd 42 ef          \tkandnb %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x42, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 42 ef       \tkandnd %k7,%k6,%k5",},
+{{0xc5, 0xf8, 0x44, 0xf7, }, 4, 0, "", "",
+"c5 f8 44 f7          \tknotw  %k7,%k6",},
+{{0xc4, 0xe1, 0xf8, 0x44, 0xf7, }, 5, 0, "", "",
+"c4 e1 f8 44 f7       \tknotq  %k7,%k6",},
+{{0xc5, 0xf9, 0x44, 0xf7, }, 4, 0, "", "",
+"c5 f9 44 f7          \tknotb  %k7,%k6",},
+{{0xc4, 0xe1, 0xf9, 0x44, 0xf7, }, 5, 0, "", "",
+"c4 e1 f9 44 f7       \tknotd  %k7,%k6",},
+{{0xc5, 0xcc, 0x45, 0xef, }, 4, 0, "", "",
+"c5 cc 45 ef          \tkorw   %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x45, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 45 ef       \tkorq   %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x45, 0xef, }, 4, 0, "", "",
+"c5 cd 45 ef          \tkorb   %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x45, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 45 ef       \tkord   %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x46, 0xef, }, 4, 0, "", "",
+"c5 cc 46 ef          \tkxnorw %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x46, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 46 ef       \tkxnorq %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x46, 0xef, }, 4, 0, "", "",
+"c5 cd 46 ef          \tkxnorb %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x46, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 46 ef       \tkxnord %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x47, 0xef, }, 4, 0, "", "",
+"c5 cc 47 ef          \tkxorw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x47, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 47 ef       \tkxorq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x47, 0xef, }, 4, 0, "", "",
+"c5 cd 47 ef          \tkxorb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x47, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 47 ef       \tkxord  %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x4a, 0xef, }, 4, 0, "", "",
+"c5 cc 4a ef          \tkaddw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x4a, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 4a ef       \tkaddq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x4a, 0xef, }, 4, 0, "", "",
+"c5 cd 4a ef          \tkaddb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x4a, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 4a ef       \tkaddd  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x4b, 0xef, }, 4, 0, "", "",
+"c5 cd 4b ef          \tkunpckbw %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x4b, 0xef, }, 4, 0, "", "",
+"c5 cc 4b ef          \tkunpckwd %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x4b, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 4b ef       \tkunpckdq %k7,%k6,%k5",},
+{{0xc5, 0xf8, 0x90, 0xee, }, 4, 0, "", "",
+"c5 f8 90 ee          \tkmovw  %k6,%k5",},
+{{0xc5, 0xf8, 0x90, 0x29, }, 4, 0, "", "",
+"c5 f8 90 29          \tkmovw  (%ecx),%k5",},
+{{0xc5, 0xf8, 0x90, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 9, 0, "", "",
+"c5 f8 90 ac c8 23 01 00 00 \tkmovw  0x123(%eax,%ecx,8),%k5",},
+{{0xc5, 0xf8, 0x91, 0x29, }, 4, 0, "", "",
+"c5 f8 91 29          \tkmovw  %k5,(%ecx)",},
+{{0xc5, 0xf8, 0x91, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 9, 0, "", "",
+"c5 f8 91 ac c8 23 01 00 00 \tkmovw  %k5,0x123(%eax,%ecx,8)",},
+{{0xc5, 0xf8, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 f8 92 e8          \tkmovw  %eax,%k5",},
+{{0xc5, 0xf8, 0x92, 0xed, }, 4, 0, "", "",
+"c5 f8 92 ed          \tkmovw  %ebp,%k5",},
+{{0xc5, 0xf8, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 f8 93 c5          \tkmovw  %k5,%eax",},
+{{0xc5, 0xf8, 0x93, 0xed, }, 4, 0, "", "",
+"c5 f8 93 ed          \tkmovw  %k5,%ebp",},
+{{0xc4, 0xe1, 0xf8, 0x90, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 90 ee       \tkmovq  %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x90, 0x29, }, 5, 0, "", "",
+"c4 e1 f8 90 29       \tkmovq  (%ecx),%k5",},
+{{0xc4, 0xe1, 0xf8, 0x90, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 e1 f8 90 ac c8 23 01 00 00 \tkmovq  0x123(%eax,%ecx,8),%k5",},
+{{0xc4, 0xe1, 0xf8, 0x91, 0x29, }, 5, 0, "", "",
+"c4 e1 f8 91 29       \tkmovq  %k5,(%ecx)",},
+{{0xc4, 0xe1, 0xf8, 0x91, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 e1 f8 91 ac c8 23 01 00 00 \tkmovq  %k5,0x123(%eax,%ecx,8)",},
+{{0xc5, 0xf9, 0x90, 0xee, }, 4, 0, "", "",
+"c5 f9 90 ee          \tkmovb  %k6,%k5",},
+{{0xc5, 0xf9, 0x90, 0x29, }, 4, 0, "", "",
+"c5 f9 90 29          \tkmovb  (%ecx),%k5",},
+{{0xc5, 0xf9, 0x90, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 9, 0, "", "",
+"c5 f9 90 ac c8 23 01 00 00 \tkmovb  0x123(%eax,%ecx,8),%k5",},
+{{0xc5, 0xf9, 0x91, 0x29, }, 4, 0, "", "",
+"c5 f9 91 29          \tkmovb  %k5,(%ecx)",},
+{{0xc5, 0xf9, 0x91, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 9, 0, "", "",
+"c5 f9 91 ac c8 23 01 00 00 \tkmovb  %k5,0x123(%eax,%ecx,8)",},
+{{0xc5, 0xf9, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 f9 92 e8          \tkmovb  %eax,%k5",},
+{{0xc5, 0xf9, 0x92, 0xed, }, 4, 0, "", "",
+"c5 f9 92 ed          \tkmovb  %ebp,%k5",},
+{{0xc5, 0xf9, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 f9 93 c5          \tkmovb  %k5,%eax",},
+{{0xc5, 0xf9, 0x93, 0xed, }, 4, 0, "", "",
+"c5 f9 93 ed          \tkmovb  %k5,%ebp",},
+{{0xc4, 0xe1, 0xf9, 0x90, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 90 ee       \tkmovd  %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x90, 0x29, }, 5, 0, "", "",
+"c4 e1 f9 90 29       \tkmovd  (%ecx),%k5",},
+{{0xc4, 0xe1, 0xf9, 0x90, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 e1 f9 90 ac c8 23 01 00 00 \tkmovd  0x123(%eax,%ecx,8),%k5",},
+{{0xc4, 0xe1, 0xf9, 0x91, 0x29, }, 5, 0, "", "",
+"c4 e1 f9 91 29       \tkmovd  %k5,(%ecx)",},
+{{0xc4, 0xe1, 0xf9, 0x91, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 e1 f9 91 ac c8 23 01 00 00 \tkmovd  %k5,0x123(%eax,%ecx,8)",},
+{{0xc5, 0xfb, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 fb 92 e8          \tkmovd  %eax,%k5",},
+{{0xc5, 0xfb, 0x92, 0xed, }, 4, 0, "", "",
+"c5 fb 92 ed          \tkmovd  %ebp,%k5",},
+{{0xc5, 0xfb, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 fb 93 c5          \tkmovd  %k5,%eax",},
+{{0xc5, 0xfb, 0x93, 0xed, }, 4, 0, "", "",
+"c5 fb 93 ed          \tkmovd  %k5,%ebp",},
+{{0xc5, 0xf8, 0x98, 0xee, }, 4, 0, "", "",
+"c5 f8 98 ee          \tkortestw %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x98, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 98 ee       \tkortestq %k6,%k5",},
+{{0xc5, 0xf9, 0x98, 0xee, }, 4, 0, "", "",
+"c5 f9 98 ee          \tkortestb %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x98, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 98 ee       \tkortestd %k6,%k5",},
+{{0xc5, 0xf8, 0x99, 0xee, }, 4, 0, "", "",
+"c5 f8 99 ee          \tktestw %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x99, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 99 ee       \tktestq %k6,%k5",},
+{{0xc5, 0xf9, 0x99, 0xee, }, 4, 0, "", "",
+"c5 f9 99 ee          \tktestb %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x99, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 99 ee       \tktestd %k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x30, 0xee, 0x12, }, 6, 0, "", "",
+"c4 e3 f9 30 ee 12    \tkshiftrw $0x12,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x31, 0xee, 0x5b, }, 6, 0, "", "",
+"c4 e3 f9 31 ee 5b    \tkshiftrq $0x5b,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x32, 0xee, 0x12, }, 6, 0, "", "",
+"c4 e3 f9 32 ee 12    \tkshiftlw $0x12,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x33, 0xee, 0x5b, }, 6, 0, "", "",
+"c4 e3 f9 33 ee 5b    \tkshiftlq $0x5b,%k6,%k5",},
+{{0xc5, 0xf8, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 f8 5b f5          \tvcvtdq2ps %xmm5,%xmm6",},
+{{0x62, 0xf1, 0xfc, 0x4f, 0x5b, 0xf5, }, 6, 0, "", "",
+"62 f1 fc 4f 5b f5    \tvcvtqq2ps %zmm5,%ymm6{%k7}",},
+{{0xc5, 0xf9, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 f9 5b f5          \tvcvtps2dq %xmm5,%xmm6",},
+{{0xc5, 0xfa, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 fa 5b f5          \tvcvttps2dq %xmm5,%xmm6",},
+{{0x0f, 0x6f, 0xe0, }, 3, 0, "", "",
+"0f 6f e0             \tmovq   %mm0,%mm4",},
+{{0xc5, 0xfd, 0x6f, 0xf4, }, 4, 0, "", "",
+"c5 fd 6f f4          \tvmovdqa %ymm4,%ymm6",},
+{{0x62, 0xf1, 0x7d, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 7d 48 6f f5    \tvmovdqa32 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 fd 48 6f f5    \tvmovdqa64 %zmm5,%zmm6",},
+{{0xc5, 0xfe, 0x6f, 0xf4, }, 4, 0, "", "",
+"c5 fe 6f f4          \tvmovdqu %ymm4,%ymm6",},
+{{0x62, 0xf1, 0x7e, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 7e 48 6f f5    \tvmovdqu32 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfe, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 fe 48 6f f5    \tvmovdqu64 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0x7f, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 7f 48 6f f5    \tvmovdqu8 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xff, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 f1 ff 48 6f f5    \tvmovdqu16 %zmm5,%zmm6",},
+{{0x0f, 0x78, 0xc3, }, 3, 0, "", "",
+"0f 78 c3             \tvmread %eax,%ebx",},
+{{0x62, 0xf1, 0x7c, 0x48, 0x78, 0xf5, }, 6, 0, "", "",
+"62 f1 7c 48 78 f5    \tvcvttps2udq %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfc, 0x4f, 0x78, 0xf5, }, 6, 0, "", "",
+"62 f1 fc 4f 78 f5    \tvcvttpd2udq %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf1, 0x7f, 0x08, 0x78, 0xc6, }, 6, 0, "", "",
+"62 f1 7f 08 78 c6    \tvcvttsd2usi %xmm6,%eax",},
+{{0x62, 0xf1, 0x7e, 0x08, 0x78, 0xc6, }, 6, 0, "", "",
+"62 f1 7e 08 78 c6    \tvcvttss2usi %xmm6,%eax",},
+{{0x62, 0xf1, 0x7d, 0x4f, 0x78, 0xf5, }, 6, 0, "", "",
+"62 f1 7d 4f 78 f5    \tvcvttps2uqq %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x78, 0xf5, }, 6, 0, "", "",
+"62 f1 fd 48 78 f5    \tvcvttpd2uqq %zmm5,%zmm6",},
+{{0x0f, 0x79, 0xd8, }, 3, 0, "", "",
+"0f 79 d8             \tvmwrite %eax,%ebx",},
+{{0x62, 0xf1, 0x7c, 0x48, 0x79, 0xf5, }, 6, 0, "", "",
+"62 f1 7c 48 79 f5    \tvcvtps2udq %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfc, 0x4f, 0x79, 0xf5, }, 6, 0, "", "",
+"62 f1 fc 4f 79 f5    \tvcvtpd2udq %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf1, 0x7f, 0x08, 0x79, 0xc6, }, 6, 0, "", "",
+"62 f1 7f 08 79 c6    \tvcvtsd2usi %xmm6,%eax",},
+{{0x62, 0xf1, 0x7e, 0x08, 0x79, 0xc6, }, 6, 0, "", "",
+"62 f1 7e 08 79 c6    \tvcvtss2usi %xmm6,%eax",},
+{{0x62, 0xf1, 0x7d, 0x4f, 0x79, 0xf5, }, 6, 0, "", "",
+"62 f1 7d 4f 79 f5    \tvcvtps2uqq %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x79, 0xf5, }, 6, 0, "", "",
+"62 f1 fd 48 79 f5    \tvcvtpd2uqq %zmm5,%zmm6",},
+{{0x62, 0xf1, 0x7e, 0x4f, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 7e 4f 7a f5    \tvcvtudq2pd %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfe, 0x48, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 fe 48 7a f5    \tvcvtuqq2pd %zmm5,%zmm6",},
+{{0x62, 0xf1, 0x7f, 0x48, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 7f 48 7a f5    \tvcvtudq2ps %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xff, 0x4f, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 ff 4f 7a f5    \tvcvtuqq2ps %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf1, 0x7d, 0x4f, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 7d 4f 7a f5    \tvcvttps2qq %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 f1 fd 48 7a f5    \tvcvttpd2qq %zmm5,%zmm6",},
+{{0x62, 0xf1, 0x57, 0x08, 0x7b, 0xf0, }, 6, 0, "", "",
+"62 f1 57 08 7b f0    \tvcvtusi2sd %eax,%xmm5,%xmm6",},
+{{0x62, 0xf1, 0x56, 0x08, 0x7b, 0xf0, }, 6, 0, "", "",
+"62 f1 56 08 7b f0    \tvcvtusi2ss %eax,%xmm5,%xmm6",},
+{{0x62, 0xf1, 0x7d, 0x4f, 0x7b, 0xf5, }, 6, 0, "", "",
+"62 f1 7d 4f 7b f5    \tvcvtps2qq %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x7b, 0xf5, }, 6, 0, "", "",
+"62 f1 fd 48 7b f5    \tvcvtpd2qq %zmm5,%zmm6",},
+{{0x0f, 0x7f, 0xc4, }, 3, 0, "", "",
+"0f 7f c4             \tmovq   %mm0,%mm4",},
+{{0xc5, 0xfd, 0x7f, 0xee, }, 4, 0, "", "",
+"c5 fd 7f ee          \tvmovdqa %ymm5,%ymm6",},
+{{0x62, 0xf1, 0x7d, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 7d 48 7f ee    \tvmovdqa32 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfd, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 fd 48 7f ee    \tvmovdqa64 %zmm5,%zmm6",},
+{{0xc5, 0xfe, 0x7f, 0xee, }, 4, 0, "", "",
+"c5 fe 7f ee          \tvmovdqu %ymm5,%ymm6",},
+{{0x62, 0xf1, 0x7e, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 7e 48 7f ee    \tvmovdqu32 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xfe, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 fe 48 7f ee    \tvmovdqu64 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0x7f, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 7f 48 7f ee    \tvmovdqu8 %zmm5,%zmm6",},
+{{0x62, 0xf1, 0xff, 0x48, 0x7f, 0xee, }, 6, 0, "", "",
+"62 f1 ff 48 7f ee    \tvmovdqu16 %zmm5,%zmm6",},
+{{0x0f, 0xdb, 0xd1, }, 3, 0, "", "",
+"0f db d1             \tpand   %mm1,%mm2",},
+{{0x66, 0x0f, 0xdb, 0xd1, }, 4, 0, "", "",
+"66 0f db d1          \tpand   %xmm1,%xmm2",},
+{{0xc5, 0xcd, 0xdb, 0xd4, }, 4, 0, "", "",
+"c5 cd db d4          \tvpand  %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf1, 0x55, 0x48, 0xdb, 0xf4, }, 6, 0, "", "",
+"62 f1 55 48 db f4    \tvpandd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0xdb, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 48 db f4    \tvpandq %zmm4,%zmm5,%zmm6",},
+{{0x0f, 0xdf, 0xd1, }, 3, 0, "", "",
+"0f df d1             \tpandn  %mm1,%mm2",},
+{{0x66, 0x0f, 0xdf, 0xd1, }, 4, 0, "", "",
+"66 0f df d1          \tpandn  %xmm1,%xmm2",},
+{{0xc5, 0xcd, 0xdf, 0xd4, }, 4, 0, "", "",
+"c5 cd df d4          \tvpandn %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf1, 0x55, 0x48, 0xdf, 0xf4, }, 6, 0, "", "",
+"62 f1 55 48 df f4    \tvpandnd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0xdf, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 48 df f4    \tvpandnq %zmm4,%zmm5,%zmm6",},
+{{0xc5, 0xf9, 0xe6, 0xd1, }, 4, 0, "", "",
+"c5 f9 e6 d1          \tvcvttpd2dq %xmm1,%xmm2",},
+{{0xc5, 0xfa, 0xe6, 0xf5, }, 4, 0, "", "",
+"c5 fa e6 f5          \tvcvtdq2pd %xmm5,%xmm6",},
+{{0x62, 0xf1, 0x7e, 0x4f, 0xe6, 0xf5, }, 6, 0, "", "",
+"62 f1 7e 4f e6 f5    \tvcvtdq2pd %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xfe, 0x48, 0xe6, 0xf5, }, 6, 0, "", "",
+"62 f1 fe 48 e6 f5    \tvcvtqq2pd %zmm5,%zmm6",},
+{{0xc5, 0xfb, 0xe6, 0xd1, }, 4, 0, "", "",
+"c5 fb e6 d1          \tvcvtpd2dq %xmm1,%xmm2",},
+{{0x0f, 0xeb, 0xf4, }, 3, 0, "", "",
+"0f eb f4             \tpor    %mm4,%mm6",},
+{{0xc5, 0xcd, 0xeb, 0xd4, }, 4, 0, "", "",
+"c5 cd eb d4          \tvpor   %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf1, 0x55, 0x48, 0xeb, 0xf4, }, 6, 0, "", "",
+"62 f1 55 48 eb f4    \tvpord  %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0xeb, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 48 eb f4    \tvporq  %zmm4,%zmm5,%zmm6",},
+{{0x0f, 0xef, 0xf4, }, 3, 0, "", "",
+"0f ef f4             \tpxor   %mm4,%mm6",},
+{{0xc5, 0xcd, 0xef, 0xd4, }, 4, 0, "", "",
+"c5 cd ef d4          \tvpxor  %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf1, 0x55, 0x48, 0xef, 0xf4, }, 6, 0, "", "",
+"62 f1 55 48 ef f4    \tvpxord %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0xef, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 48 ef f4    \tvpxorq %zmm4,%zmm5,%zmm6",},
+{{0x66, 0x0f, 0x38, 0x10, 0xc1, }, 5, 0, "", "",
+"66 0f 38 10 c1       \tpblendvb %xmm0,%xmm1,%xmm0",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x10, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 10 f4    \tvpsrlvw %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x10, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 10 ee    \tvpmovuswb %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x11, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 11 ee    \tvpmovusdb %zmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x11, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 11 f4    \tvpsravw %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x12, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 12 ee    \tvpmovusqb %zmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x12, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 12 f4    \tvpsllvw %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x7d, 0x13, 0xeb, }, 5, 0, "", "",
+"c4 e2 7d 13 eb       \tvcvtph2ps %xmm3,%ymm5",},
+{{0x62, 0xf2, 0x7d, 0x4f, 0x13, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 4f 13 f5    \tvcvtph2ps %ymm5,%zmm6{%k7}",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x13, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 13 ee    \tvpmovusdw %zmm5,%ymm6{%k7}",},
+{{0x66, 0x0f, 0x38, 0x14, 0xc1, }, 5, 0, "", "",
+"66 0f 38 14 c1       \tblendvps %xmm0,%xmm1,%xmm0",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x14, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 14 ee    \tvpmovusqw %zmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0x55, 0x48, 0x14, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 14 f4    \tvprorvd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x14, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 14 f4    \tvprorvq %zmm4,%zmm5,%zmm6",},
+{{0x66, 0x0f, 0x38, 0x15, 0xc1, }, 5, 0, "", "",
+"66 0f 38 15 c1       \tblendvpd %xmm0,%xmm1,%xmm0",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x15, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 15 ee    \tvpmovusqd %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf2, 0x55, 0x48, 0x15, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 15 f4    \tvprolvd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x15, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 15 f4    \tvprolvq %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x16, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 16 d4       \tvpermps %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x4d, 0x2f, 0x16, 0xd4, }, 6, 0, "", "",
+"62 f2 4d 2f 16 d4    \tvpermps %ymm4,%ymm6,%ymm2{%k7}",},
+{{0x62, 0xf2, 0xcd, 0x2f, 0x16, 0xd4, }, 6, 0, "", "",
+"62 f2 cd 2f 16 d4    \tvpermpd %ymm4,%ymm6,%ymm2{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x19, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 19 f4       \tvbroadcastsd %xmm4,%ymm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x19, 0xf7, }, 6, 0, "", "",
+"62 f2 7d 48 19 f7    \tvbroadcastf32x2 %xmm7,%zmm6",},
+{{0xc4, 0xe2, 0x7d, 0x1a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 1a 21       \tvbroadcastf128 (%ecx),%ymm4",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x1a, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 1a 31    \tvbroadcastf32x4 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x1a, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 1a 31    \tvbroadcastf64x2 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x1b, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 1b 31    \tvbroadcastf32x8 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x1b, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 1b 31    \tvbroadcastf64x4 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x1f, 0xf4, }, 6, 0, "", "",
+"62 f2 fd 48 1f f4    \tvpabsq %zmm4,%zmm6",},
+{{0xc4, 0xe2, 0x79, 0x20, 0xec, }, 5, 0, "", "",
+"c4 e2 79 20 ec       \tvpmovsxbw %xmm4,%xmm5",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x20, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 20 ee    \tvpmovswb %zmm5,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x21, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 21 f4       \tvpmovsxbd %xmm4,%ymm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x21, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 21 ee    \tvpmovsdb %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x22, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 22 e4       \tvpmovsxbq %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x22, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 22 ee    \tvpmovsqb %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x23, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 23 e4       \tvpmovsxwd %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x23, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 23 ee    \tvpmovsdw %zmm5,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x24, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 24 f4       \tvpmovsxwq %xmm4,%ymm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x24, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 24 ee    \tvpmovsqw %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x25, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 25 e4       \tvpmovsxdq %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x25, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 25 ee    \tvpmovsqd %zmm5,%ymm6{%k7}",},
+{{0x62, 0xf2, 0x4d, 0x48, 0x26, 0xed, }, 6, 0, "", "",
+"62 f2 4d 48 26 ed    \tvptestmb %zmm5,%zmm6,%k5",},
+{{0x62, 0xf2, 0xcd, 0x48, 0x26, 0xed, }, 6, 0, "", "",
+"62 f2 cd 48 26 ed    \tvptestmw %zmm5,%zmm6,%k5",},
+{{0x62, 0xf2, 0x56, 0x48, 0x26, 0xec, }, 6, 0, "", "",
+"62 f2 56 48 26 ec    \tvptestnmb %zmm4,%zmm5,%k5",},
+{{0x62, 0xf2, 0xd6, 0x48, 0x26, 0xec, }, 6, 0, "", "",
+"62 f2 d6 48 26 ec    \tvptestnmw %zmm4,%zmm5,%k5",},
+{{0x62, 0xf2, 0x4d, 0x48, 0x27, 0xed, }, 6, 0, "", "",
+"62 f2 4d 48 27 ed    \tvptestmd %zmm5,%zmm6,%k5",},
+{{0x62, 0xf2, 0xcd, 0x48, 0x27, 0xed, }, 6, 0, "", "",
+"62 f2 cd 48 27 ed    \tvptestmq %zmm5,%zmm6,%k5",},
+{{0x62, 0xf2, 0x56, 0x48, 0x27, 0xec, }, 6, 0, "", "",
+"62 f2 56 48 27 ec    \tvptestnmd %zmm4,%zmm5,%k5",},
+{{0x62, 0xf2, 0xd6, 0x48, 0x27, 0xec, }, 6, 0, "", "",
+"62 f2 d6 48 27 ec    \tvptestnmq %zmm4,%zmm5,%k5",},
+{{0xc4, 0xe2, 0x4d, 0x28, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 28 d4       \tvpmuldq %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x7e, 0x48, 0x28, 0xf5, }, 6, 0, "", "",
+"62 f2 7e 48 28 f5    \tvpmovm2b %k5,%zmm6",},
+{{0x62, 0xf2, 0xfe, 0x48, 0x28, 0xf5, }, 6, 0, "", "",
+"62 f2 fe 48 28 f5    \tvpmovm2w %k5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x29, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 29 d4       \tvpcmpeqq %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x7e, 0x48, 0x29, 0xee, }, 6, 0, "", "",
+"62 f2 7e 48 29 ee    \tvpmovb2m %zmm6,%k5",},
+{{0x62, 0xf2, 0xfe, 0x48, 0x29, 0xee, }, 6, 0, "", "",
+"62 f2 fe 48 29 ee    \tvpmovw2m %zmm6,%k5",},
+{{0xc4, 0xe2, 0x7d, 0x2a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 2a 21       \tvmovntdqa (%ecx),%ymm4",},
+{{0x62, 0xf2, 0xfe, 0x48, 0x2a, 0xce, }, 6, 0, "", "",
+"62 f2 fe 48 2a ce    \tvpbroadcastmb2q %k6,%zmm1",},
+{{0xc4, 0xe2, 0x5d, 0x2c, 0x31, }, 5, 0, "", "",
+"c4 e2 5d 2c 31       \tvmaskmovps (%ecx),%ymm4,%ymm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x2c, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 2c f4    \tvscalefps %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x2c, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 2c f4    \tvscalefpd %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x5d, 0x2d, 0x31, }, 5, 0, "", "",
+"c4 e2 5d 2d 31       \tvmaskmovpd (%ecx),%ymm4,%ymm6",},
+{{0x62, 0xf2, 0x55, 0x0f, 0x2d, 0xf4, }, 6, 0, "", "",
+"62 f2 55 0f 2d f4    \tvscalefss %xmm4,%xmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xd5, 0x0f, 0x2d, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 0f 2d f4    \tvscalefsd %xmm4,%xmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x30, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 30 e4       \tvpmovzxbw %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x30, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 30 ee    \tvpmovwb %zmm5,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x31, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 31 f4       \tvpmovzxbd %xmm4,%ymm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x31, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 31 ee    \tvpmovdb %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x32, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 32 e4       \tvpmovzxbq %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x32, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 32 ee    \tvpmovqb %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x33, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 33 e4       \tvpmovzxwd %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x33, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 33 ee    \tvpmovdw %zmm5,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x34, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 34 f4       \tvpmovzxwq %xmm4,%ymm6",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x34, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 34 ee    \tvpmovqw %zmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x35, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 35 e4       \tvpmovzxdq %xmm4,%ymm4",},
+{{0x62, 0xf2, 0x7e, 0x4f, 0x35, 0xee, }, 6, 0, "", "",
+"62 f2 7e 4f 35 ee    \tvpmovqd %zmm5,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x4d, 0x36, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 36 d4       \tvpermd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x4d, 0x2f, 0x36, 0xd4, }, 6, 0, "", "",
+"62 f2 4d 2f 36 d4    \tvpermd %ymm4,%ymm6,%ymm2{%k7}",},
+{{0x62, 0xf2, 0xcd, 0x2f, 0x36, 0xd4, }, 6, 0, "", "",
+"62 f2 cd 2f 36 d4    \tvpermq %ymm4,%ymm6,%ymm2{%k7}",},
+{{0xc4, 0xe2, 0x4d, 0x38, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 38 d4       \tvpminsb %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x7e, 0x48, 0x38, 0xf5, }, 6, 0, "", "",
+"62 f2 7e 48 38 f5    \tvpmovm2d %k5,%zmm6",},
+{{0x62, 0xf2, 0xfe, 0x48, 0x38, 0xf5, }, 6, 0, "", "",
+"62 f2 fe 48 38 f5    \tvpmovm2q %k5,%zmm6",},
+{{0xc4, 0xe2, 0x69, 0x39, 0xd9, }, 5, 0, "", "",
+"c4 e2 69 39 d9       \tvpminsd %xmm1,%xmm2,%xmm3",},
+{{0x62, 0xf2, 0x55, 0x48, 0x39, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 39 f4    \tvpminsd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x39, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 39 f4    \tvpminsq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7e, 0x48, 0x39, 0xee, }, 6, 0, "", "",
+"62 f2 7e 48 39 ee    \tvpmovd2m %zmm6,%k5",},
+{{0x62, 0xf2, 0xfe, 0x48, 0x39, 0xee, }, 6, 0, "", "",
+"62 f2 fe 48 39 ee    \tvpmovq2m %zmm6,%k5",},
+{{0xc4, 0xe2, 0x4d, 0x3a, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3a d4       \tvpminuw %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x7e, 0x48, 0x3a, 0xf6, }, 6, 0, "", "",
+"62 f2 7e 48 3a f6    \tvpbroadcastmw2d %k6,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x3b, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3b d4       \tvpminud %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x55, 0x48, 0x3b, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 3b f4    \tvpminud %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x3b, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 3b f4    \tvpminuq %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x3d, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3d d4       \tvpmaxsd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x55, 0x48, 0x3d, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 3d f4    \tvpmaxsd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x3d, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 3d f4    \tvpmaxsq %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x3f, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3f d4       \tvpmaxud %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x55, 0x48, 0x3f, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 3f f4    \tvpmaxud %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x3f, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 3f f4    \tvpmaxuq %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x40, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 40 d4       \tvpmulld %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x55, 0x48, 0x40, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 40 f4    \tvpmulld %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x40, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 40 f4    \tvpmullq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x42, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 48 42 f5    \tvgetexpps %zmm5,%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x42, 0xf5, }, 6, 0, "", "",
+"62 f2 fd 48 42 f5    \tvgetexppd %zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x0f, 0x43, 0xf4, }, 6, 0, "", "",
+"62 f2 55 0f 43 f4    \tvgetexpss %xmm4,%xmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xe5, 0x0f, 0x43, 0xe2, }, 6, 0, "", "",
+"62 f2 e5 0f 43 e2    \tvgetexpsd %xmm2,%xmm3,%xmm4{%k7}",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x44, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 48 44 f5    \tvplzcntd %zmm5,%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x44, 0xf5, }, 6, 0, "", "",
+"62 f2 fd 48 44 f5    \tvplzcntq %zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x4d, 0x46, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 46 d4       \tvpsravd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf2, 0x55, 0x48, 0x46, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 46 f4    \tvpsravd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x46, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 46 f4    \tvpsravq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x4c, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 48 4c f5    \tvrcp14ps %zmm5,%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x4c, 0xf5, }, 6, 0, "", "",
+"62 f2 fd 48 4c f5    \tvrcp14pd %zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x0f, 0x4d, 0xf4, }, 6, 0, "", "",
+"62 f2 55 0f 4d f4    \tvrcp14ss %xmm4,%xmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xd5, 0x0f, 0x4d, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 0f 4d f4    \tvrcp14sd %xmm4,%xmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x4e, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 48 4e f5    \tvrsqrt14ps %zmm5,%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x4e, 0xf5, }, 6, 0, "", "",
+"62 f2 fd 48 4e f5    \tvrsqrt14pd %zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x0f, 0x4f, 0xf4, }, 6, 0, "", "",
+"62 f2 55 0f 4f f4    \tvrsqrt14ss %xmm4,%xmm5,%xmm6{%k7}",},
+{{0x62, 0xf2, 0xd5, 0x0f, 0x4f, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 0f 4f f4    \tvrsqrt14sd %xmm4,%xmm5,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x79, 0x59, 0xf4, }, 5, 0, "", "",
+"c4 e2 79 59 f4       \tvpbroadcastq %xmm4,%xmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x59, 0xf7, }, 6, 0, "", "",
+"62 f2 7d 48 59 f7    \tvbroadcasti32x2 %xmm7,%zmm6",},
+{{0xc4, 0xe2, 0x7d, 0x5a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 5a 21       \tvbroadcasti128 (%ecx),%ymm4",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x5a, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 5a 31    \tvbroadcasti32x4 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x5a, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 5a 31    \tvbroadcasti64x2 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x5b, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 5b 31    \tvbroadcasti32x8 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x5b, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 5b 31    \tvbroadcasti64x4 (%ecx),%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x64, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 64 f4    \tvpblendmd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x64, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 64 f4    \tvpblendmq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x65, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 65 f4    \tvblendmps %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x65, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 65 f4    \tvblendmpd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x66, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 66 f4    \tvpblendmb %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x66, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 66 f4    \tvpblendmw %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x75, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 75 f4    \tvpermi2b %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x75, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 75 f4    \tvpermi2w %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x76, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 76 f4    \tvpermi2d %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x76, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 76 f4    \tvpermi2q %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x77, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 77 f4    \tvpermi2ps %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x77, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 77 f4    \tvpermi2pd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x08, 0x7a, 0xd8, }, 6, 0, "", "",
+"62 f2 7d 08 7a d8    \tvpbroadcastb %eax,%xmm3",},
+{{0x62, 0xf2, 0x7d, 0x08, 0x7b, 0xd8, }, 6, 0, "", "",
+"62 f2 7d 08 7b d8    \tvpbroadcastw %eax,%xmm3",},
+{{0x62, 0xf2, 0x7d, 0x08, 0x7c, 0xd8, }, 6, 0, "", "",
+"62 f2 7d 08 7c d8    \tvpbroadcastd %eax,%xmm3",},
+{{0x62, 0xf2, 0x55, 0x48, 0x7d, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 7d f4    \tvpermt2b %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x7d, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 7d f4    \tvpermt2w %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x7e, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 7e f4    \tvpermt2d %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x7e, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 7e f4    \tvpermt2q %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x55, 0x48, 0x7f, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 7f f4    \tvpermt2ps %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x7f, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 7f f4    \tvpermt2pd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x83, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 83 f4    \tvpmultishiftqb %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x88, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 88 31    \tvexpandps (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x88, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 88 31    \tvexpandpd (%ecx),%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x89, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 89 31    \tvpexpandd (%ecx),%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x89, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 89 31    \tvpexpandq (%ecx),%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x8a, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 8a 31    \tvcompressps %zmm6,(%ecx)",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x8a, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 8a 31    \tvcompresspd %zmm6,(%ecx)",},
+{{0x62, 0xf2, 0x7d, 0x48, 0x8b, 0x31, }, 6, 0, "", "",
+"62 f2 7d 48 8b 31    \tvpcompressd %zmm6,(%ecx)",},
+{{0x62, 0xf2, 0xfd, 0x48, 0x8b, 0x31, }, 6, 0, "", "",
+"62 f2 fd 48 8b 31    \tvpcompressq %zmm6,(%ecx)",},
+{{0x62, 0xf2, 0x55, 0x48, 0x8d, 0xf4, }, 6, 0, "", "",
+"62 f2 55 48 8d f4    \tvpermb %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0x8d, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 8d f4    \tvpermw %zmm4,%zmm5,%zmm6",},
+{{0xc4, 0xe2, 0x69, 0x90, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 69 90 4c 7d 02 \tvpgatherdd %xmm2,0x2(%ebp,%xmm7,2),%xmm1",},
+{{0xc4, 0xe2, 0xe9, 0x90, 0x4c, 0x7d, 0x04, }, 7, 0, "", "",
+"c4 e2 e9 90 4c 7d 04 \tvpgatherdq %xmm2,0x4(%ebp,%xmm7,2),%xmm1",},
+{{0x62, 0xf2, 0x7d, 0x49, 0x90, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 90 b4 fd 7b 00 00 00 \tvpgatherdd 0x7b(%ebp,%zmm7,8),%zmm6{%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0x90, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 90 b4 fd 7b 00 00 00 \tvpgatherdq 0x7b(%ebp,%ymm7,8),%zmm6{%k1}",},
+{{0xc4, 0xe2, 0x69, 0x91, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 69 91 4c 7d 02 \tvpgatherqd %xmm2,0x2(%ebp,%xmm7,2),%xmm1",},
+{{0xc4, 0xe2, 0xe9, 0x91, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 e9 91 4c 7d 02 \tvpgatherqq %xmm2,0x2(%ebp,%xmm7,2),%xmm1",},
+{{0x62, 0xf2, 0x7d, 0x49, 0x91, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 91 b4 fd 7b 00 00 00 \tvpgatherqd 0x7b(%ebp,%zmm7,8),%ymm6{%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0x91, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 91 b4 fd 7b 00 00 00 \tvpgatherqq 0x7b(%ebp,%zmm7,8),%zmm6{%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xa0, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 a0 b4 fd 7b 00 00 00 \tvpscatterdd %zmm6,0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xa0, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 a0 b4 fd 7b 00 00 00 \tvpscatterdq %zmm6,0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xa1, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 a1 b4 fd 7b 00 00 00 \tvpscatterqd %ymm6,0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x29, 0xa1, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 29 a1 b4 fd 7b 00 00 00 \tvpscatterqq %ymm6,0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xa2, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 a2 b4 fd 7b 00 00 00 \tvscatterdps %zmm6,0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xa2, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 a2 b4 fd 7b 00 00 00 \tvscatterdpd %zmm6,0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xa3, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 a3 b4 fd 7b 00 00 00 \tvscatterqps %ymm6,0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xa3, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 a3 b4 fd 7b 00 00 00 \tvscatterqpd %zmm6,0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xd5, 0x48, 0xb4, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 b4 f4    \tvpmadd52luq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0xd5, 0x48, 0xb5, 0xf4, }, 6, 0, "", "",
+"62 f2 d5 48 b5 f4    \tvpmadd52huq %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0xc4, 0xf5, }, 6, 0, "", "",
+"62 f2 7d 48 c4 f5    \tvpconflictd %zmm5,%zmm6",},
+{{0x62, 0xf2, 0xfd, 0x48, 0xc4, 0xf5, }, 6, 0, "", "",
+"62 f2 fd 48 c4 f5    \tvpconflictq %zmm5,%zmm6",},
+{{0x62, 0xf2, 0x7d, 0x48, 0xc8, 0xfe, }, 6, 0, "", "",
+"62 f2 7d 48 c8 fe    \tvexp2ps %zmm6,%zmm7",},
+{{0x62, 0xf2, 0xfd, 0x48, 0xc8, 0xfe, }, 6, 0, "", "",
+"62 f2 fd 48 c8 fe    \tvexp2pd %zmm6,%zmm7",},
+{{0x62, 0xf2, 0x7d, 0x48, 0xca, 0xfe, }, 6, 0, "", "",
+"62 f2 7d 48 ca fe    \tvrcp28ps %zmm6,%zmm7",},
+{{0x62, 0xf2, 0xfd, 0x48, 0xca, 0xfe, }, 6, 0, "", "",
+"62 f2 fd 48 ca fe    \tvrcp28pd %zmm6,%zmm7",},
+{{0x62, 0xf2, 0x4d, 0x0f, 0xcb, 0xfd, }, 6, 0, "", "",
+"62 f2 4d 0f cb fd    \tvrcp28ss %xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf2, 0xcd, 0x0f, 0xcb, 0xfd, }, 6, 0, "", "",
+"62 f2 cd 0f cb fd    \tvrcp28sd %xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf2, 0x7d, 0x48, 0xcc, 0xfe, }, 6, 0, "", "",
+"62 f2 7d 48 cc fe    \tvrsqrt28ps %zmm6,%zmm7",},
+{{0x62, 0xf2, 0xfd, 0x48, 0xcc, 0xfe, }, 6, 0, "", "",
+"62 f2 fd 48 cc fe    \tvrsqrt28pd %zmm6,%zmm7",},
+{{0x62, 0xf2, 0x4d, 0x0f, 0xcd, 0xfd, }, 6, 0, "", "",
+"62 f2 4d 0f cd fd    \tvrsqrt28ss %xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf2, 0xcd, 0x0f, 0xcd, 0xfd, }, 6, 0, "", "",
+"62 f2 cd 0f cd fd    \tvrsqrt28sd %xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x03, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 03 fd 12 \tvalignd $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x03, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 03 fd 12 \tvalignq $0x12,%zmm5,%zmm6,%zmm7",},
+{{0xc4, 0xe3, 0x7d, 0x08, 0xd6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 08 d6 05    \tvroundps $0x5,%ymm6,%ymm2",},
+{{0x62, 0xf3, 0x7d, 0x48, 0x08, 0xf5, 0x12, }, 7, 0, "", "",
+"62 f3 7d 48 08 f5 12 \tvrndscaleps $0x12,%zmm5,%zmm6",},
+{{0xc4, 0xe3, 0x7d, 0x09, 0xd6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 09 d6 05    \tvroundpd $0x5,%ymm6,%ymm2",},
+{{0x62, 0xf3, 0xfd, 0x48, 0x09, 0xf5, 0x12, }, 7, 0, "", "",
+"62 f3 fd 48 09 f5 12 \tvrndscalepd $0x12,%zmm5,%zmm6",},
+{{0xc4, 0xe3, 0x49, 0x0a, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 49 0a d4 05    \tvroundss $0x5,%xmm4,%xmm6,%xmm2",},
+{{0x62, 0xf3, 0x55, 0x0f, 0x0a, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 55 0f 0a f4 12 \tvrndscaless $0x12,%xmm4,%xmm5,%xmm6{%k7}",},
+{{0xc4, 0xe3, 0x49, 0x0b, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 49 0b d4 05    \tvroundsd $0x5,%xmm4,%xmm6,%xmm2",},
+{{0x62, 0xf3, 0xd5, 0x0f, 0x0b, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 d5 0f 0b f4 12 \tvrndscalesd $0x12,%xmm4,%xmm5,%xmm6{%k7}",},
+{{0xc4, 0xe3, 0x5d, 0x18, 0xf4, 0x05, }, 6, 0, "", "",
+"c4 e3 5d 18 f4 05    \tvinsertf128 $0x5,%xmm4,%ymm4,%ymm6",},
+{{0x62, 0xf3, 0x55, 0x4f, 0x18, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 55 4f 18 f4 12 \tvinsertf32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}",},
+{{0x62, 0xf3, 0xd5, 0x4f, 0x18, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 d5 4f 18 f4 12 \tvinsertf64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}",},
+{{0xc4, 0xe3, 0x7d, 0x19, 0xe4, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 19 e4 05    \tvextractf128 $0x5,%ymm4,%xmm4",},
+{{0x62, 0xf3, 0x7d, 0x4f, 0x19, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 7d 4f 19 ee 12 \tvextractf32x4 $0x12,%zmm5,%xmm6{%k7}",},
+{{0x62, 0xf3, 0xfd, 0x4f, 0x19, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 fd 4f 19 ee 12 \tvextractf64x2 $0x12,%zmm5,%xmm6{%k7}",},
+{{0x62, 0xf3, 0x4d, 0x4f, 0x1a, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 4f 1a fd 12 \tvinsertf32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}",},
+{{0x62, 0xf3, 0xcd, 0x4f, 0x1a, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 4f 1a fd 12 \tvinsertf64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}",},
+{{0x62, 0xf3, 0x7d, 0x4f, 0x1b, 0xf7, 0x12, }, 7, 0, "", "",
+"62 f3 7d 4f 1b f7 12 \tvextractf32x8 $0x12,%zmm6,%ymm7{%k7}",},
+{{0x62, 0xf3, 0xfd, 0x4f, 0x1b, 0xf7, 0x12, }, 7, 0, "", "",
+"62 f3 fd 4f 1b f7 12 \tvextractf64x4 $0x12,%zmm6,%ymm7{%k7}",},
+{{0x62, 0xf3, 0x45, 0x48, 0x1e, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 45 48 1e ee 12 \tvpcmpud $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0xc5, 0x48, 0x1e, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 c5 48 1e ee 12 \tvpcmpuq $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0x45, 0x48, 0x1f, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 45 48 1f ee 12 \tvpcmpd $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0xc5, 0x48, 0x1f, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 c5 48 1f ee 12 \tvpcmpq $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x23, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 23 fd 12 \tvshuff32x4 $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x23, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 23 fd 12 \tvshuff64x2 $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x25, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 25 fd 12 \tvpternlogd $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x25, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 25 fd 12 \tvpternlogq $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x7d, 0x48, 0x26, 0xfe, 0x12, }, 7, 0, "", "",
+"62 f3 7d 48 26 fe 12 \tvgetmantps $0x12,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xfd, 0x48, 0x26, 0xfe, 0x12, }, 7, 0, "", "",
+"62 f3 fd 48 26 fe 12 \tvgetmantpd $0x12,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x0f, 0x27, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 0f 27 fd 12 \tvgetmantss $0x12,%xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf3, 0xcd, 0x0f, 0x27, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 0f 27 fd 12 \tvgetmantsd $0x12,%xmm5,%xmm6,%xmm7{%k7}",},
+{{0xc4, 0xe3, 0x5d, 0x38, 0xf4, 0x05, }, 6, 0, "", "",
+"c4 e3 5d 38 f4 05    \tvinserti128 $0x5,%xmm4,%ymm4,%ymm6",},
+{{0x62, 0xf3, 0x55, 0x4f, 0x38, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 55 4f 38 f4 12 \tvinserti32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}",},
+{{0x62, 0xf3, 0xd5, 0x4f, 0x38, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 d5 4f 38 f4 12 \tvinserti64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}",},
+{{0xc4, 0xe3, 0x7d, 0x39, 0xe6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 39 e6 05    \tvextracti128 $0x5,%ymm4,%xmm6",},
+{{0x62, 0xf3, 0x7d, 0x4f, 0x39, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 7d 4f 39 ee 12 \tvextracti32x4 $0x12,%zmm5,%xmm6{%k7}",},
+{{0x62, 0xf3, 0xfd, 0x4f, 0x39, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 fd 4f 39 ee 12 \tvextracti64x2 $0x12,%zmm5,%xmm6{%k7}",},
+{{0x62, 0xf3, 0x4d, 0x4f, 0x3a, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 4f 3a fd 12 \tvinserti32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}",},
+{{0x62, 0xf3, 0xcd, 0x4f, 0x3a, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 4f 3a fd 12 \tvinserti64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}",},
+{{0x62, 0xf3, 0x7d, 0x4f, 0x3b, 0xf7, 0x12, }, 7, 0, "", "",
+"62 f3 7d 4f 3b f7 12 \tvextracti32x8 $0x12,%zmm6,%ymm7{%k7}",},
+{{0x62, 0xf3, 0xfd, 0x4f, 0x3b, 0xf7, 0x12, }, 7, 0, "", "",
+"62 f3 fd 4f 3b f7 12 \tvextracti64x4 $0x12,%zmm6,%ymm7{%k7}",},
+{{0x62, 0xf3, 0x45, 0x48, 0x3e, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 45 48 3e ee 12 \tvpcmpub $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0xc5, 0x48, 0x3e, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 c5 48 3e ee 12 \tvpcmpuw $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0x45, 0x48, 0x3f, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 45 48 3f ee 12 \tvpcmpb $0x12,%zmm6,%zmm7,%k5",},
+{{0x62, 0xf3, 0xc5, 0x48, 0x3f, 0xee, 0x12, }, 7, 0, "", "",
+"62 f3 c5 48 3f ee 12 \tvpcmpw $0x12,%zmm6,%zmm7,%k5",},
+{{0xc4, 0xe3, 0x4d, 0x42, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 4d 42 d4 05    \tvmpsadbw $0x5,%ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf3, 0x55, 0x48, 0x42, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 55 48 42 f4 12 \tvdbpsadbw $0x12,%zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x43, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 43 fd 12 \tvshufi32x4 $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x43, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 43 fd 12 \tvshufi64x2 $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x50, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 50 fd 12 \tvrangeps $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x50, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 50 fd 12 \tvrangepd $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x08, 0x51, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 08 51 fd 12 \tvrangess $0x12,%xmm5,%xmm6,%xmm7",},
+{{0x62, 0xf3, 0xcd, 0x08, 0x51, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 08 51 fd 12 \tvrangesd $0x12,%xmm5,%xmm6,%xmm7",},
+{{0x62, 0xf3, 0x4d, 0x48, 0x54, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 48 54 fd 12 \tvfixupimmps $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xcd, 0x48, 0x54, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 48 54 fd 12 \tvfixupimmpd $0x12,%zmm5,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x0f, 0x55, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 0f 55 fd 12 \tvfixupimmss $0x12,%xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf3, 0xcd, 0x0f, 0x55, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 0f 55 fd 12 \tvfixupimmsd $0x12,%xmm5,%xmm6,%xmm7{%k7}",},
+{{0x62, 0xf3, 0x7d, 0x48, 0x56, 0xfe, 0x12, }, 7, 0, "", "",
+"62 f3 7d 48 56 fe 12 \tvreduceps $0x12,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0xfd, 0x48, 0x56, 0xfe, 0x12, }, 7, 0, "", "",
+"62 f3 fd 48 56 fe 12 \tvreducepd $0x12,%zmm6,%zmm7",},
+{{0x62, 0xf3, 0x4d, 0x08, 0x57, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 4d 08 57 fd 12 \tvreducess $0x12,%xmm5,%xmm6,%xmm7",},
+{{0x62, 0xf3, 0xcd, 0x08, 0x57, 0xfd, 0x12, }, 7, 0, "", "",
+"62 f3 cd 08 57 fd 12 \tvreducesd $0x12,%xmm5,%xmm6,%xmm7",},
+{{0x62, 0xf3, 0x7d, 0x48, 0x66, 0xef, 0x12, }, 7, 0, "", "",
+"62 f3 7d 48 66 ef 12 \tvfpclassps $0x12,%zmm7,%k5",},
+{{0x62, 0xf3, 0xfd, 0x48, 0x66, 0xef, 0x12, }, 7, 0, "", "",
+"62 f3 fd 48 66 ef 12 \tvfpclasspd $0x12,%zmm7,%k5",},
+{{0x62, 0xf3, 0x7d, 0x08, 0x67, 0xef, 0x12, }, 7, 0, "", "",
+"62 f3 7d 08 67 ef 12 \tvfpclassss $0x12,%xmm7,%k5",},
+{{0x62, 0xf3, 0xfd, 0x08, 0x67, 0xef, 0x12, }, 7, 0, "", "",
+"62 f3 fd 08 67 ef 12 \tvfpclasssd $0x12,%xmm7,%k5",},
+{{0x62, 0xf1, 0x4d, 0x48, 0x72, 0xc5, 0x12, }, 7, 0, "", "",
+"62 f1 4d 48 72 c5 12 \tvprord $0x12,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xcd, 0x48, 0x72, 0xc5, 0x12, }, 7, 0, "", "",
+"62 f1 cd 48 72 c5 12 \tvprorq $0x12,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0x4d, 0x48, 0x72, 0xcd, 0x12, }, 7, 0, "", "",
+"62 f1 4d 48 72 cd 12 \tvprold $0x12,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xcd, 0x48, 0x72, 0xcd, 0x12, }, 7, 0, "", "",
+"62 f1 cd 48 72 cd 12 \tvprolq $0x12,%zmm5,%zmm6",},
+{{0x0f, 0x72, 0xe6, 0x02, }, 4, 0, "", "",
+"0f 72 e6 02          \tpsrad  $0x2,%mm6",},
+{{0xc5, 0xed, 0x72, 0xe6, 0x05, }, 5, 0, "", "",
+"c5 ed 72 e6 05       \tvpsrad $0x5,%ymm6,%ymm2",},
+{{0x62, 0xf1, 0x6d, 0x48, 0x72, 0xe6, 0x05, }, 7, 0, "", "",
+"62 f1 6d 48 72 e6 05 \tvpsrad $0x5,%zmm6,%zmm2",},
+{{0x62, 0xf1, 0xed, 0x48, 0x72, 0xe6, 0x05, }, 7, 0, "", "",
+"62 f1 ed 48 72 e6 05 \tvpsraq $0x5,%zmm6,%zmm2",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc6, 0x8c, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c6 8c fd 7b 00 00 00 \tvgatherpf0dps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc6, 0x8c, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c6 8c fd 7b 00 00 00 \tvgatherpf0dpd 0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc6, 0x94, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c6 94 fd 7b 00 00 00 \tvgatherpf1dps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc6, 0x94, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c6 94 fd 7b 00 00 00 \tvgatherpf1dpd 0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc6, 0xac, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c6 ac fd 7b 00 00 00 \tvscatterpf0dps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc6, 0xac, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c6 ac fd 7b 00 00 00 \tvscatterpf0dpd 0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc6, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c6 b4 fd 7b 00 00 00 \tvscatterpf1dps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc6, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c6 b4 fd 7b 00 00 00 \tvscatterpf1dpd 0x7b(%ebp,%ymm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc7, 0x8c, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c7 8c fd 7b 00 00 00 \tvgatherpf0qps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc7, 0x8c, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c7 8c fd 7b 00 00 00 \tvgatherpf0qpd 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc7, 0x94, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c7 94 fd 7b 00 00 00 \tvgatherpf1qps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc7, 0x94, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c7 94 fd 7b 00 00 00 \tvgatherpf1qpd 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc7, 0xac, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c7 ac fd 7b 00 00 00 \tvscatterpf0qps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc7, 0xac, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c7 ac fd 7b 00 00 00 \tvscatterpf0qpd 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0x7d, 0x49, 0xc7, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 7d 49 c7 b4 fd 7b 00 00 00 \tvscatterpf1qps 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf2, 0xfd, 0x49, 0xc7, 0xb4, 0xfd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 f2 fd 49 c7 b4 fd 7b 00 00 00 \tvscatterpf1qpd 0x7b(%ebp,%zmm7,8){%k1}",},
+{{0x62, 0xf1, 0xd5, 0x48, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 48 58 f4    \tvaddpd %zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x4f, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 4f 58 f4    \tvaddpd %zmm4,%zmm5,%zmm6{%k7}",},
+{{0x62, 0xf1, 0xd5, 0xcf, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 cf 58 f4    \tvaddpd %zmm4,%zmm5,%zmm6{%k7}{z}",},
+{{0x62, 0xf1, 0xd5, 0x18, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 18 58 f4    \tvaddpd {rn-sae},%zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x58, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 58 58 f4    \tvaddpd {ru-sae},%zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x38, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 38 58 f4    \tvaddpd {rd-sae},%zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x78, 0x58, 0xf4, }, 6, 0, "", "",
+"62 f1 d5 78 58 f4    \tvaddpd {rz-sae},%zmm4,%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0x58, 0x31, }, 6, 0, "", "",
+"62 f1 d5 48 58 31    \tvaddpd (%ecx),%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0x58, 0xb4, 0xc8, 0x23, 0x01, 0x00, 0x00, }, 11, 0, "", "",
+"62 f1 d5 48 58 b4 c8 23 01 00 00 \tvaddpd 0x123(%eax,%ecx,8),%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x58, 0x58, 0x31, }, 6, 0, "", "",
+"62 f1 d5 58 58 31    \tvaddpd (%ecx){1to8},%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x48, 0x58, 0x72, 0x7f, }, 7, 0, "", "",
+"62 f1 d5 48 58 72 7f \tvaddpd 0x1fc0(%edx),%zmm5,%zmm6",},
+{{0x62, 0xf1, 0xd5, 0x58, 0x58, 0x72, 0x7f, }, 7, 0, "", "",
+"62 f1 d5 58 58 72 7f \tvaddpd 0x3f8(%edx){1to8},%zmm5,%zmm6",},
+{{0x62, 0xf1, 0x4c, 0x58, 0xc2, 0x6a, 0x7f, 0x08, }, 8, 0, "", "",
+"62 f1 4c 58 c2 6a 7f 08 \tvcmpeq_uqps 0x1fc(%edx){1to16},%zmm6,%k5",},
+{{0x62, 0xf1, 0xe7, 0x0f, 0xc2, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, 0x01, }, 12, 0, "", "",
+"62 f1 e7 0f c2 ac c8 23 01 00 00 01 \tvcmpltsd 0x123(%eax,%ecx,8),%xmm3,%k5{%k7}",},
+{{0x62, 0xf1, 0xd7, 0x1f, 0xc2, 0xec, 0x02, }, 7, 0, "", "",
+"62 f1 d7 1f c2 ec 02 \tvcmplesd {sae},%xmm4,%xmm5,%k5{%k7}",},
+{{0x62, 0xf3, 0x5d, 0x0f, 0x27, 0xac, 0xc8, 0x23, 0x01, 0x00, 0x00, 0x5b, }, 12, 0, "", "",
+"62 f3 5d 0f 27 ac c8 23 01 00 00 5b \tvgetmantss $0x5b,0x123(%eax,%ecx,8),%xmm4,%xmm5{%k7}",},
 {{0xf3, 0x0f, 0x1b, 0x00, }, 4, 0, "", "",
 "f3 0f 1b 00          \tbndmk  (%eax),%bnd0",},
 {{0xf3, 0x0f, 0x1b, 0x05, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
@@ -309,19 +1319,19 @@
 {{0x0f, 0x1b, 0x84, 0x08, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
 "0f 1b 84 08 78 56 34 12 \tbndstx %bnd0,0x12345678(%eax,%ecx,1)",},
 {{0xf2, 0xe8, 0xfc, 0xff, 0xff, 0xff, }, 6, 0xfffffffc, "call", "unconditional",
-"f2 e8 fc ff ff ff    \tbnd call 3c3 <main+0x3c3>",},
+"f2 e8 fc ff ff ff    \tbnd call fce <main+0xfce>",},
 {{0xf2, 0xff, 0x10, }, 3, 0, "call", "indirect",
 "f2 ff 10             \tbnd call *(%eax)",},
 {{0xf2, 0xc3, }, 2, 0, "ret", "indirect",
 "f2 c3                \tbnd ret ",},
 {{0xf2, 0xe9, 0xfc, 0xff, 0xff, 0xff, }, 6, 0xfffffffc, "jmp", "unconditional",
-"f2 e9 fc ff ff ff    \tbnd jmp 3ce <main+0x3ce>",},
+"f2 e9 fc ff ff ff    \tbnd jmp fd9 <main+0xfd9>",},
 {{0xf2, 0xe9, 0xfc, 0xff, 0xff, 0xff, }, 6, 0xfffffffc, "jmp", "unconditional",
-"f2 e9 fc ff ff ff    \tbnd jmp 3d4 <main+0x3d4>",},
+"f2 e9 fc ff ff ff    \tbnd jmp fdf <main+0xfdf>",},
 {{0xf2, 0xff, 0x21, }, 3, 0, "jmp", "indirect",
 "f2 ff 21             \tbnd jmp *(%ecx)",},
 {{0xf2, 0x0f, 0x85, 0xfc, 0xff, 0xff, 0xff, }, 7, 0xfffffffc, "jcc", "conditional",
-"f2 0f 85 fc ff ff ff \tbnd jne 3de <main+0x3de>",},
+"f2 0f 85 fc ff ff ff \tbnd jne fe9 <main+0xfe9>",},
 {{0x0f, 0x3a, 0xcc, 0xc1, 0x00, }, 5, 0, "", "",
 "0f 3a cc c1 00       \tsha1rnds4 $0x0,%xmm1,%xmm0",},
 {{0x0f, 0x3a, 0xcc, 0xd7, 0x91, }, 5, 0, "", "",
@@ -654,5 +1664,3 @@
 "0f c7 1d 78 56 34 12 \txrstors 0x12345678",},
 {{0x0f, 0xc7, 0x9c, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
 "0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%eax,%ecx,8)",},
-{{0x66, 0x0f, 0xae, 0xf8, }, 4, 0, "", "",
-"66 0f ae f8          \tpcommit ",},
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-64.c b/tools/perf/arch/x86/tests/insn-x86-dat-64.c
index 4fe7cce179c4..af25bc8240d0 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-64.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-64.c
@@ -6,6 +6,938 @@
 
 {{0x0f, 0x31, }, 2, 0, "", "",
 "0f 31                \trdtsc  ",},
+{{0xc4, 0xe2, 0x7d, 0x13, 0xeb, }, 5, 0, "", "",
+"c4 e2 7d 13 eb       \tvcvtph2ps %xmm3,%ymm5",},
+{{0x48, 0x0f, 0x41, 0xd8, }, 4, 0, "", "",
+"48 0f 41 d8          \tcmovno %rax,%rbx",},
+{{0x48, 0x0f, 0x41, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"48 0f 41 88 78 56 34 12 \tcmovno 0x12345678(%rax),%rcx",},
+{{0x66, 0x0f, 0x41, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 0f 41 88 78 56 34 12 \tcmovno 0x12345678(%rax),%cx",},
+{{0x48, 0x0f, 0x44, 0xd8, }, 4, 0, "", "",
+"48 0f 44 d8          \tcmove  %rax,%rbx",},
+{{0x48, 0x0f, 0x44, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"48 0f 44 88 78 56 34 12 \tcmove  0x12345678(%rax),%rcx",},
+{{0x66, 0x0f, 0x44, 0x88, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
+"66 0f 44 88 78 56 34 12 \tcmove  0x12345678(%rax),%cx",},
+{{0x0f, 0x90, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 90 80 78 56 34 12 \tseto   0x12345678(%rax)",},
+{{0x0f, 0x91, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 91 80 78 56 34 12 \tsetno  0x12345678(%rax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%rax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%rax)",},
+{{0x0f, 0x92, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 92 80 78 56 34 12 \tsetb   0x12345678(%rax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%rax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%rax)",},
+{{0x0f, 0x93, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 93 80 78 56 34 12 \tsetae  0x12345678(%rax)",},
+{{0x0f, 0x98, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 98 80 78 56 34 12 \tsets   0x12345678(%rax)",},
+{{0x0f, 0x99, 0x80, 0x78, 0x56, 0x34, 0x12, }, 7, 0, "", "",
+"0f 99 80 78 56 34 12 \tsetns  0x12345678(%rax)",},
+{{0xc5, 0xcc, 0x41, 0xef, }, 4, 0, "", "",
+"c5 cc 41 ef          \tkandw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x41, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 41 ef       \tkandq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x41, 0xef, }, 4, 0, "", "",
+"c5 cd 41 ef          \tkandb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x41, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 41 ef       \tkandd  %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x42, 0xef, }, 4, 0, "", "",
+"c5 cc 42 ef          \tkandnw %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x42, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 42 ef       \tkandnq %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x42, 0xef, }, 4, 0, "", "",
+"c5 cd 42 ef          \tkandnb %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x42, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 42 ef       \tkandnd %k7,%k6,%k5",},
+{{0xc5, 0xf8, 0x44, 0xf7, }, 4, 0, "", "",
+"c5 f8 44 f7          \tknotw  %k7,%k6",},
+{{0xc4, 0xe1, 0xf8, 0x44, 0xf7, }, 5, 0, "", "",
+"c4 e1 f8 44 f7       \tknotq  %k7,%k6",},
+{{0xc5, 0xf9, 0x44, 0xf7, }, 4, 0, "", "",
+"c5 f9 44 f7          \tknotb  %k7,%k6",},
+{{0xc4, 0xe1, 0xf9, 0x44, 0xf7, }, 5, 0, "", "",
+"c4 e1 f9 44 f7       \tknotd  %k7,%k6",},
+{{0xc5, 0xcc, 0x45, 0xef, }, 4, 0, "", "",
+"c5 cc 45 ef          \tkorw   %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x45, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 45 ef       \tkorq   %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x45, 0xef, }, 4, 0, "", "",
+"c5 cd 45 ef          \tkorb   %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x45, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 45 ef       \tkord   %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x46, 0xef, }, 4, 0, "", "",
+"c5 cc 46 ef          \tkxnorw %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x46, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 46 ef       \tkxnorq %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x46, 0xef, }, 4, 0, "", "",
+"c5 cd 46 ef          \tkxnorb %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x46, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 46 ef       \tkxnord %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x47, 0xef, }, 4, 0, "", "",
+"c5 cc 47 ef          \tkxorw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x47, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 47 ef       \tkxorq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x47, 0xef, }, 4, 0, "", "",
+"c5 cd 47 ef          \tkxorb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x47, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 47 ef       \tkxord  %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x4a, 0xef, }, 4, 0, "", "",
+"c5 cc 4a ef          \tkaddw  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x4a, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 4a ef       \tkaddq  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x4a, 0xef, }, 4, 0, "", "",
+"c5 cd 4a ef          \tkaddb  %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcd, 0x4a, 0xef, }, 5, 0, "", "",
+"c4 e1 cd 4a ef       \tkaddd  %k7,%k6,%k5",},
+{{0xc5, 0xcd, 0x4b, 0xef, }, 4, 0, "", "",
+"c5 cd 4b ef          \tkunpckbw %k7,%k6,%k5",},
+{{0xc5, 0xcc, 0x4b, 0xef, }, 4, 0, "", "",
+"c5 cc 4b ef          \tkunpckwd %k7,%k6,%k5",},
+{{0xc4, 0xe1, 0xcc, 0x4b, 0xef, }, 5, 0, "", "",
+"c4 e1 cc 4b ef       \tkunpckdq %k7,%k6,%k5",},
+{{0xc5, 0xf8, 0x90, 0xee, }, 4, 0, "", "",
+"c5 f8 90 ee          \tkmovw  %k6,%k5",},
+{{0xc5, 0xf8, 0x90, 0x29, }, 4, 0, "", "",
+"c5 f8 90 29          \tkmovw  (%rcx),%k5",},
+{{0xc4, 0xa1, 0x78, 0x90, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 78 90 ac f0 23 01 00 00 \tkmovw  0x123(%rax,%r14,8),%k5",},
+{{0xc5, 0xf8, 0x91, 0x29, }, 4, 0, "", "",
+"c5 f8 91 29          \tkmovw  %k5,(%rcx)",},
+{{0xc4, 0xa1, 0x78, 0x91, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 78 91 ac f0 23 01 00 00 \tkmovw  %k5,0x123(%rax,%r14,8)",},
+{{0xc5, 0xf8, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 f8 92 e8          \tkmovw  %eax,%k5",},
+{{0xc5, 0xf8, 0x92, 0xed, }, 4, 0, "", "",
+"c5 f8 92 ed          \tkmovw  %ebp,%k5",},
+{{0xc4, 0xc1, 0x78, 0x92, 0xed, }, 5, 0, "", "",
+"c4 c1 78 92 ed       \tkmovw  %r13d,%k5",},
+{{0xc5, 0xf8, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 f8 93 c5          \tkmovw  %k5,%eax",},
+{{0xc5, 0xf8, 0x93, 0xed, }, 4, 0, "", "",
+"c5 f8 93 ed          \tkmovw  %k5,%ebp",},
+{{0xc5, 0x78, 0x93, 0xed, }, 4, 0, "", "",
+"c5 78 93 ed          \tkmovw  %k5,%r13d",},
+{{0xc4, 0xe1, 0xf8, 0x90, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 90 ee       \tkmovq  %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x90, 0x29, }, 5, 0, "", "",
+"c4 e1 f8 90 29       \tkmovq  (%rcx),%k5",},
+{{0xc4, 0xa1, 0xf8, 0x90, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 f8 90 ac f0 23 01 00 00 \tkmovq  0x123(%rax,%r14,8),%k5",},
+{{0xc4, 0xe1, 0xf8, 0x91, 0x29, }, 5, 0, "", "",
+"c4 e1 f8 91 29       \tkmovq  %k5,(%rcx)",},
+{{0xc4, 0xa1, 0xf8, 0x91, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 f8 91 ac f0 23 01 00 00 \tkmovq  %k5,0x123(%rax,%r14,8)",},
+{{0xc4, 0xe1, 0xfb, 0x92, 0xe8, }, 5, 0, "", "",
+"c4 e1 fb 92 e8       \tkmovq  %rax,%k5",},
+{{0xc4, 0xe1, 0xfb, 0x92, 0xed, }, 5, 0, "", "",
+"c4 e1 fb 92 ed       \tkmovq  %rbp,%k5",},
+{{0xc4, 0xc1, 0xfb, 0x92, 0xed, }, 5, 0, "", "",
+"c4 c1 fb 92 ed       \tkmovq  %r13,%k5",},
+{{0xc4, 0xe1, 0xfb, 0x93, 0xc5, }, 5, 0, "", "",
+"c4 e1 fb 93 c5       \tkmovq  %k5,%rax",},
+{{0xc4, 0xe1, 0xfb, 0x93, 0xed, }, 5, 0, "", "",
+"c4 e1 fb 93 ed       \tkmovq  %k5,%rbp",},
+{{0xc4, 0x61, 0xfb, 0x93, 0xed, }, 5, 0, "", "",
+"c4 61 fb 93 ed       \tkmovq  %k5,%r13",},
+{{0xc5, 0xf9, 0x90, 0xee, }, 4, 0, "", "",
+"c5 f9 90 ee          \tkmovb  %k6,%k5",},
+{{0xc5, 0xf9, 0x90, 0x29, }, 4, 0, "", "",
+"c5 f9 90 29          \tkmovb  (%rcx),%k5",},
+{{0xc4, 0xa1, 0x79, 0x90, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 79 90 ac f0 23 01 00 00 \tkmovb  0x123(%rax,%r14,8),%k5",},
+{{0xc5, 0xf9, 0x91, 0x29, }, 4, 0, "", "",
+"c5 f9 91 29          \tkmovb  %k5,(%rcx)",},
+{{0xc4, 0xa1, 0x79, 0x91, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 79 91 ac f0 23 01 00 00 \tkmovb  %k5,0x123(%rax,%r14,8)",},
+{{0xc5, 0xf9, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 f9 92 e8          \tkmovb  %eax,%k5",},
+{{0xc5, 0xf9, 0x92, 0xed, }, 4, 0, "", "",
+"c5 f9 92 ed          \tkmovb  %ebp,%k5",},
+{{0xc4, 0xc1, 0x79, 0x92, 0xed, }, 5, 0, "", "",
+"c4 c1 79 92 ed       \tkmovb  %r13d,%k5",},
+{{0xc5, 0xf9, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 f9 93 c5          \tkmovb  %k5,%eax",},
+{{0xc5, 0xf9, 0x93, 0xed, }, 4, 0, "", "",
+"c5 f9 93 ed          \tkmovb  %k5,%ebp",},
+{{0xc5, 0x79, 0x93, 0xed, }, 4, 0, "", "",
+"c5 79 93 ed          \tkmovb  %k5,%r13d",},
+{{0xc4, 0xe1, 0xf9, 0x90, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 90 ee       \tkmovd  %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x90, 0x29, }, 5, 0, "", "",
+"c4 e1 f9 90 29       \tkmovd  (%rcx),%k5",},
+{{0xc4, 0xa1, 0xf9, 0x90, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 f9 90 ac f0 23 01 00 00 \tkmovd  0x123(%rax,%r14,8),%k5",},
+{{0xc4, 0xe1, 0xf9, 0x91, 0x29, }, 5, 0, "", "",
+"c4 e1 f9 91 29       \tkmovd  %k5,(%rcx)",},
+{{0xc4, 0xa1, 0xf9, 0x91, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 10, 0, "", "",
+"c4 a1 f9 91 ac f0 23 01 00 00 \tkmovd  %k5,0x123(%rax,%r14,8)",},
+{{0xc5, 0xfb, 0x92, 0xe8, }, 4, 0, "", "",
+"c5 fb 92 e8          \tkmovd  %eax,%k5",},
+{{0xc5, 0xfb, 0x92, 0xed, }, 4, 0, "", "",
+"c5 fb 92 ed          \tkmovd  %ebp,%k5",},
+{{0xc4, 0xc1, 0x7b, 0x92, 0xed, }, 5, 0, "", "",
+"c4 c1 7b 92 ed       \tkmovd  %r13d,%k5",},
+{{0xc5, 0xfb, 0x93, 0xc5, }, 4, 0, "", "",
+"c5 fb 93 c5          \tkmovd  %k5,%eax",},
+{{0xc5, 0xfb, 0x93, 0xed, }, 4, 0, "", "",
+"c5 fb 93 ed          \tkmovd  %k5,%ebp",},
+{{0xc5, 0x7b, 0x93, 0xed, }, 4, 0, "", "",
+"c5 7b 93 ed          \tkmovd  %k5,%r13d",},
+{{0xc5, 0xf8, 0x98, 0xee, }, 4, 0, "", "",
+"c5 f8 98 ee          \tkortestw %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x98, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 98 ee       \tkortestq %k6,%k5",},
+{{0xc5, 0xf9, 0x98, 0xee, }, 4, 0, "", "",
+"c5 f9 98 ee          \tkortestb %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x98, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 98 ee       \tkortestd %k6,%k5",},
+{{0xc5, 0xf8, 0x99, 0xee, }, 4, 0, "", "",
+"c5 f8 99 ee          \tktestw %k6,%k5",},
+{{0xc4, 0xe1, 0xf8, 0x99, 0xee, }, 5, 0, "", "",
+"c4 e1 f8 99 ee       \tktestq %k6,%k5",},
+{{0xc5, 0xf9, 0x99, 0xee, }, 4, 0, "", "",
+"c5 f9 99 ee          \tktestb %k6,%k5",},
+{{0xc4, 0xe1, 0xf9, 0x99, 0xee, }, 5, 0, "", "",
+"c4 e1 f9 99 ee       \tktestd %k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x30, 0xee, 0x12, }, 6, 0, "", "",
+"c4 e3 f9 30 ee 12    \tkshiftrw $0x12,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x31, 0xee, 0x5b, }, 6, 0, "", "",
+"c4 e3 f9 31 ee 5b    \tkshiftrq $0x5b,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x32, 0xee, 0x12, }, 6, 0, "", "",
+"c4 e3 f9 32 ee 12    \tkshiftlw $0x12,%k6,%k5",},
+{{0xc4, 0xe3, 0xf9, 0x33, 0xee, 0x5b, }, 6, 0, "", "",
+"c4 e3 f9 33 ee 5b    \tkshiftlq $0x5b,%k6,%k5",},
+{{0xc5, 0xf8, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 f8 5b f5          \tvcvtdq2ps %xmm5,%xmm6",},
+{{0x62, 0x91, 0xfc, 0x4f, 0x5b, 0xf5, }, 6, 0, "", "",
+"62 91 fc 4f 5b f5    \tvcvtqq2ps %zmm29,%ymm6{%k7}",},
+{{0xc5, 0xf9, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 f9 5b f5          \tvcvtps2dq %xmm5,%xmm6",},
+{{0xc5, 0xfa, 0x5b, 0xf5, }, 4, 0, "", "",
+"c5 fa 5b f5          \tvcvttps2dq %xmm5,%xmm6",},
+{{0x0f, 0x6f, 0xe0, }, 3, 0, "", "",
+"0f 6f e0             \tmovq   %mm0,%mm4",},
+{{0xc5, 0xfd, 0x6f, 0xf4, }, 4, 0, "", "",
+"c5 fd 6f f4          \tvmovdqa %ymm4,%ymm6",},
+{{0x62, 0x01, 0x7d, 0x48, 0x6f, 0xd1, }, 6, 0, "", "",
+"62 01 7d 48 6f d1    \tvmovdqa32 %zmm25,%zmm26",},
+{{0x62, 0x01, 0xfd, 0x48, 0x6f, 0xd1, }, 6, 0, "", "",
+"62 01 fd 48 6f d1    \tvmovdqa64 %zmm25,%zmm26",},
+{{0xc5, 0xfe, 0x6f, 0xf4, }, 4, 0, "", "",
+"c5 fe 6f f4          \tvmovdqu %ymm4,%ymm6",},
+{{0x62, 0x01, 0x7e, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 01 7e 48 6f f5    \tvmovdqu32 %zmm29,%zmm30",},
+{{0x62, 0x01, 0xfe, 0x48, 0x6f, 0xd1, }, 6, 0, "", "",
+"62 01 fe 48 6f d1    \tvmovdqu64 %zmm25,%zmm26",},
+{{0x62, 0x01, 0x7f, 0x48, 0x6f, 0xf5, }, 6, 0, "", "",
+"62 01 7f 48 6f f5    \tvmovdqu8 %zmm29,%zmm30",},
+{{0x62, 0x01, 0xff, 0x48, 0x6f, 0xd1, }, 6, 0, "", "",
+"62 01 ff 48 6f d1    \tvmovdqu16 %zmm25,%zmm26",},
+{{0x0f, 0x78, 0xc3, }, 3, 0, "", "",
+"0f 78 c3             \tvmread %rax,%rbx",},
+{{0x62, 0x01, 0x7c, 0x48, 0x78, 0xd1, }, 6, 0, "", "",
+"62 01 7c 48 78 d1    \tvcvttps2udq %zmm25,%zmm26",},
+{{0x62, 0x91, 0xfc, 0x4f, 0x78, 0xf5, }, 6, 0, "", "",
+"62 91 fc 4f 78 f5    \tvcvttpd2udq %zmm29,%ymm6{%k7}",},
+{{0x62, 0xf1, 0xff, 0x08, 0x78, 0xc6, }, 6, 0, "", "",
+"62 f1 ff 08 78 c6    \tvcvttsd2usi %xmm6,%rax",},
+{{0x62, 0xf1, 0xfe, 0x08, 0x78, 0xc6, }, 6, 0, "", "",
+"62 f1 fe 08 78 c6    \tvcvttss2usi %xmm6,%rax",},
+{{0x62, 0x61, 0x7d, 0x4f, 0x78, 0xd5, }, 6, 0, "", "",
+"62 61 7d 4f 78 d5    \tvcvttps2uqq %ymm5,%zmm26{%k7}",},
+{{0x62, 0x01, 0xfd, 0x48, 0x78, 0xf5, }, 6, 0, "", "",
+"62 01 fd 48 78 f5    \tvcvttpd2uqq %zmm29,%zmm30",},
+{{0x0f, 0x79, 0xd8, }, 3, 0, "", "",
+"0f 79 d8             \tvmwrite %rax,%rbx",},
+{{0x62, 0x01, 0x7c, 0x48, 0x79, 0xd1, }, 6, 0, "", "",
+"62 01 7c 48 79 d1    \tvcvtps2udq %zmm25,%zmm26",},
+{{0x62, 0x91, 0xfc, 0x4f, 0x79, 0xf5, }, 6, 0, "", "",
+"62 91 fc 4f 79 f5    \tvcvtpd2udq %zmm29,%ymm6{%k7}",},
+{{0x62, 0xf1, 0xff, 0x08, 0x79, 0xc6, }, 6, 0, "", "",
+"62 f1 ff 08 79 c6    \tvcvtsd2usi %xmm6,%rax",},
+{{0x62, 0xf1, 0xfe, 0x08, 0x79, 0xc6, }, 6, 0, "", "",
+"62 f1 fe 08 79 c6    \tvcvtss2usi %xmm6,%rax",},
+{{0x62, 0x61, 0x7d, 0x4f, 0x79, 0xd5, }, 6, 0, "", "",
+"62 61 7d 4f 79 d5    \tvcvtps2uqq %ymm5,%zmm26{%k7}",},
+{{0x62, 0x01, 0xfd, 0x48, 0x79, 0xf5, }, 6, 0, "", "",
+"62 01 fd 48 79 f5    \tvcvtpd2uqq %zmm29,%zmm30",},
+{{0x62, 0x61, 0x7e, 0x4f, 0x7a, 0xed, }, 6, 0, "", "",
+"62 61 7e 4f 7a ed    \tvcvtudq2pd %ymm5,%zmm29{%k7}",},
+{{0x62, 0x01, 0xfe, 0x48, 0x7a, 0xd1, }, 6, 0, "", "",
+"62 01 fe 48 7a d1    \tvcvtuqq2pd %zmm25,%zmm26",},
+{{0x62, 0x01, 0x7f, 0x48, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 01 7f 48 7a f5    \tvcvtudq2ps %zmm29,%zmm30",},
+{{0x62, 0x01, 0xff, 0x4f, 0x7a, 0xd1, }, 6, 0, "", "",
+"62 01 ff 4f 7a d1    \tvcvtuqq2ps %zmm25,%ymm26{%k7}",},
+{{0x62, 0x01, 0x7d, 0x4f, 0x7a, 0xd1, }, 6, 0, "", "",
+"62 01 7d 4f 7a d1    \tvcvttps2qq %ymm25,%zmm26{%k7}",},
+{{0x62, 0x01, 0xfd, 0x48, 0x7a, 0xf5, }, 6, 0, "", "",
+"62 01 fd 48 7a f5    \tvcvttpd2qq %zmm29,%zmm30",},
+{{0x62, 0xf1, 0x57, 0x08, 0x7b, 0xf0, }, 6, 0, "", "",
+"62 f1 57 08 7b f0    \tvcvtusi2sd %eax,%xmm5,%xmm6",},
+{{0x62, 0xf1, 0x56, 0x08, 0x7b, 0xf0, }, 6, 0, "", "",
+"62 f1 56 08 7b f0    \tvcvtusi2ss %eax,%xmm5,%xmm6",},
+{{0x62, 0x61, 0x7d, 0x4f, 0x7b, 0xd5, }, 6, 0, "", "",
+"62 61 7d 4f 7b d5    \tvcvtps2qq %ymm5,%zmm26{%k7}",},
+{{0x62, 0x01, 0xfd, 0x48, 0x7b, 0xf5, }, 6, 0, "", "",
+"62 01 fd 48 7b f5    \tvcvtpd2qq %zmm29,%zmm30",},
+{{0x0f, 0x7f, 0xc4, }, 3, 0, "", "",
+"0f 7f c4             \tmovq   %mm0,%mm4",},
+{{0xc5, 0x7d, 0x7f, 0xc6, }, 4, 0, "", "",
+"c5 7d 7f c6          \tvmovdqa %ymm8,%ymm6",},
+{{0x62, 0x01, 0x7d, 0x48, 0x7f, 0xca, }, 6, 0, "", "",
+"62 01 7d 48 7f ca    \tvmovdqa32 %zmm25,%zmm26",},
+{{0x62, 0x01, 0xfd, 0x48, 0x7f, 0xca, }, 6, 0, "", "",
+"62 01 fd 48 7f ca    \tvmovdqa64 %zmm25,%zmm26",},
+{{0xc5, 0x7e, 0x7f, 0xc6, }, 4, 0, "", "",
+"c5 7e 7f c6          \tvmovdqu %ymm8,%ymm6",},
+{{0x62, 0x01, 0x7e, 0x48, 0x7f, 0xca, }, 6, 0, "", "",
+"62 01 7e 48 7f ca    \tvmovdqu32 %zmm25,%zmm26",},
+{{0x62, 0x01, 0xfe, 0x48, 0x7f, 0xca, }, 6, 0, "", "",
+"62 01 fe 48 7f ca    \tvmovdqu64 %zmm25,%zmm26",},
+{{0x62, 0x61, 0x7f, 0x48, 0x7f, 0x31, }, 6, 0, "", "",
+"62 61 7f 48 7f 31    \tvmovdqu8 %zmm30,(%rcx)",},
+{{0x62, 0x01, 0xff, 0x48, 0x7f, 0xca, }, 6, 0, "", "",
+"62 01 ff 48 7f ca    \tvmovdqu16 %zmm25,%zmm26",},
+{{0x0f, 0xdb, 0xd1, }, 3, 0, "", "",
+"0f db d1             \tpand   %mm1,%mm2",},
+{{0x66, 0x0f, 0xdb, 0xd1, }, 4, 0, "", "",
+"66 0f db d1          \tpand   %xmm1,%xmm2",},
+{{0xc5, 0xcd, 0xdb, 0xd4, }, 4, 0, "", "",
+"c5 cd db d4          \tvpand  %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x01, 0x35, 0x40, 0xdb, 0xd0, }, 6, 0, "", "",
+"62 01 35 40 db d0    \tvpandd %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x01, 0xb5, 0x40, 0xdb, 0xd0, }, 6, 0, "", "",
+"62 01 b5 40 db d0    \tvpandq %zmm24,%zmm25,%zmm26",},
+{{0x0f, 0xdf, 0xd1, }, 3, 0, "", "",
+"0f df d1             \tpandn  %mm1,%mm2",},
+{{0x66, 0x0f, 0xdf, 0xd1, }, 4, 0, "", "",
+"66 0f df d1          \tpandn  %xmm1,%xmm2",},
+{{0xc5, 0xcd, 0xdf, 0xd4, }, 4, 0, "", "",
+"c5 cd df d4          \tvpandn %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x01, 0x35, 0x40, 0xdf, 0xd0, }, 6, 0, "", "",
+"62 01 35 40 df d0    \tvpandnd %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x01, 0xb5, 0x40, 0xdf, 0xd0, }, 6, 0, "", "",
+"62 01 b5 40 df d0    \tvpandnq %zmm24,%zmm25,%zmm26",},
+{{0xc5, 0xf9, 0xe6, 0xd1, }, 4, 0, "", "",
+"c5 f9 e6 d1          \tvcvttpd2dq %xmm1,%xmm2",},
+{{0xc5, 0xfa, 0xe6, 0xf5, }, 4, 0, "", "",
+"c5 fa e6 f5          \tvcvtdq2pd %xmm5,%xmm6",},
+{{0x62, 0x61, 0x7e, 0x4f, 0xe6, 0xd5, }, 6, 0, "", "",
+"62 61 7e 4f e6 d5    \tvcvtdq2pd %ymm5,%zmm26{%k7}",},
+{{0x62, 0x01, 0xfe, 0x48, 0xe6, 0xd1, }, 6, 0, "", "",
+"62 01 fe 48 e6 d1    \tvcvtqq2pd %zmm25,%zmm26",},
+{{0xc5, 0xfb, 0xe6, 0xd1, }, 4, 0, "", "",
+"c5 fb e6 d1          \tvcvtpd2dq %xmm1,%xmm2",},
+{{0x0f, 0xeb, 0xf4, }, 3, 0, "", "",
+"0f eb f4             \tpor    %mm4,%mm6",},
+{{0xc5, 0xcd, 0xeb, 0xd4, }, 4, 0, "", "",
+"c5 cd eb d4          \tvpor   %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x01, 0x35, 0x40, 0xeb, 0xd0, }, 6, 0, "", "",
+"62 01 35 40 eb d0    \tvpord  %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x01, 0xb5, 0x40, 0xeb, 0xd0, }, 6, 0, "", "",
+"62 01 b5 40 eb d0    \tvporq  %zmm24,%zmm25,%zmm26",},
+{{0x0f, 0xef, 0xf4, }, 3, 0, "", "",
+"0f ef f4             \tpxor   %mm4,%mm6",},
+{{0xc5, 0xcd, 0xef, 0xd4, }, 4, 0, "", "",
+"c5 cd ef d4          \tvpxor  %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x01, 0x35, 0x40, 0xef, 0xd0, }, 6, 0, "", "",
+"62 01 35 40 ef d0    \tvpxord %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x01, 0xb5, 0x40, 0xef, 0xd0, }, 6, 0, "", "",
+"62 01 b5 40 ef d0    \tvpxorq %zmm24,%zmm25,%zmm26",},
+{{0x66, 0x0f, 0x38, 0x10, 0xc1, }, 5, 0, "", "",
+"66 0f 38 10 c1       \tpblendvb %xmm0,%xmm1,%xmm0",},
+{{0x62, 0x02, 0x9d, 0x40, 0x10, 0xeb, }, 6, 0, "", "",
+"62 02 9d 40 10 eb    \tvpsrlvw %zmm27,%zmm28,%zmm29",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x10, 0xe6, }, 6, 0, "", "",
+"62 62 7e 4f 10 e6    \tvpmovuswb %zmm28,%ymm6{%k7}",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x11, 0xe6, }, 6, 0, "", "",
+"62 62 7e 4f 11 e6    \tvpmovusdb %zmm28,%xmm6{%k7}",},
+{{0x62, 0x02, 0x9d, 0x40, 0x11, 0xeb, }, 6, 0, "", "",
+"62 02 9d 40 11 eb    \tvpsravw %zmm27,%zmm28,%zmm29",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x12, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 12 de    \tvpmovusqb %zmm27,%xmm6{%k7}",},
+{{0x62, 0x02, 0x9d, 0x40, 0x12, 0xeb, }, 6, 0, "", "",
+"62 02 9d 40 12 eb    \tvpsllvw %zmm27,%zmm28,%zmm29",},
+{{0xc4, 0xe2, 0x7d, 0x13, 0xeb, }, 5, 0, "", "",
+"c4 e2 7d 13 eb       \tvcvtph2ps %xmm3,%ymm5",},
+{{0x62, 0x62, 0x7d, 0x4f, 0x13, 0xdd, }, 6, 0, "", "",
+"62 62 7d 4f 13 dd    \tvcvtph2ps %ymm5,%zmm27{%k7}",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x13, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 13 de    \tvpmovusdw %zmm27,%ymm6{%k7}",},
+{{0x66, 0x0f, 0x38, 0x14, 0xc1, }, 5, 0, "", "",
+"66 0f 38 14 c1       \tblendvps %xmm0,%xmm1,%xmm0",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x14, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 14 de    \tvpmovusqw %zmm27,%xmm6{%k7}",},
+{{0x62, 0x02, 0x1d, 0x40, 0x14, 0xeb, }, 6, 0, "", "",
+"62 02 1d 40 14 eb    \tvprorvd %zmm27,%zmm28,%zmm29",},
+{{0x62, 0x02, 0x9d, 0x40, 0x14, 0xeb, }, 6, 0, "", "",
+"62 02 9d 40 14 eb    \tvprorvq %zmm27,%zmm28,%zmm29",},
+{{0x66, 0x0f, 0x38, 0x15, 0xc1, }, 5, 0, "", "",
+"66 0f 38 15 c1       \tblendvpd %xmm0,%xmm1,%xmm0",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x15, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 15 de    \tvpmovusqd %zmm27,%ymm6{%k7}",},
+{{0x62, 0x02, 0x1d, 0x40, 0x15, 0xeb, }, 6, 0, "", "",
+"62 02 1d 40 15 eb    \tvprolvd %zmm27,%zmm28,%zmm29",},
+{{0x62, 0x02, 0x9d, 0x40, 0x15, 0xeb, }, 6, 0, "", "",
+"62 02 9d 40 15 eb    \tvprolvq %zmm27,%zmm28,%zmm29",},
+{{0xc4, 0xe2, 0x4d, 0x16, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 16 d4       \tvpermps %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x82, 0x2d, 0x27, 0x16, 0xf0, }, 6, 0, "", "",
+"62 82 2d 27 16 f0    \tvpermps %ymm24,%ymm26,%ymm22{%k7}",},
+{{0x62, 0x82, 0xad, 0x27, 0x16, 0xf0, }, 6, 0, "", "",
+"62 82 ad 27 16 f0    \tvpermpd %ymm24,%ymm26,%ymm22{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x19, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 19 f4       \tvbroadcastsd %xmm4,%ymm6",},
+{{0x62, 0x02, 0x7d, 0x48, 0x19, 0xd3, }, 6, 0, "", "",
+"62 02 7d 48 19 d3    \tvbroadcastf32x2 %xmm27,%zmm26",},
+{{0xc4, 0xe2, 0x7d, 0x1a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 1a 21       \tvbroadcastf128 (%rcx),%ymm4",},
+{{0x62, 0x62, 0x7d, 0x48, 0x1a, 0x11, }, 6, 0, "", "",
+"62 62 7d 48 1a 11    \tvbroadcastf32x4 (%rcx),%zmm26",},
+{{0x62, 0x62, 0xfd, 0x48, 0x1a, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 1a 11    \tvbroadcastf64x2 (%rcx),%zmm26",},
+{{0x62, 0x62, 0x7d, 0x48, 0x1b, 0x19, }, 6, 0, "", "",
+"62 62 7d 48 1b 19    \tvbroadcastf32x8 (%rcx),%zmm27",},
+{{0x62, 0x62, 0xfd, 0x48, 0x1b, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 1b 11    \tvbroadcastf64x4 (%rcx),%zmm26",},
+{{0x62, 0x02, 0xfd, 0x48, 0x1f, 0xe3, }, 6, 0, "", "",
+"62 02 fd 48 1f e3    \tvpabsq %zmm27,%zmm28",},
+{{0xc4, 0xe2, 0x79, 0x20, 0xec, }, 5, 0, "", "",
+"c4 e2 79 20 ec       \tvpmovsxbw %xmm4,%xmm5",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x20, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 20 de    \tvpmovswb %zmm27,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x21, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 21 f4       \tvpmovsxbd %xmm4,%ymm6",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x21, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 21 de    \tvpmovsdb %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x22, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 22 e4       \tvpmovsxbq %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x22, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 22 de    \tvpmovsqb %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x23, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 23 e4       \tvpmovsxwd %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x23, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 23 de    \tvpmovsdw %zmm27,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x24, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 24 f4       \tvpmovsxwq %xmm4,%ymm6",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x24, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 24 de    \tvpmovsqw %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x25, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 25 e4       \tvpmovsxdq %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x25, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 25 de    \tvpmovsqd %zmm27,%ymm6{%k7}",},
+{{0x62, 0x92, 0x1d, 0x40, 0x26, 0xeb, }, 6, 0, "", "",
+"62 92 1d 40 26 eb    \tvptestmb %zmm27,%zmm28,%k5",},
+{{0x62, 0x92, 0x9d, 0x40, 0x26, 0xeb, }, 6, 0, "", "",
+"62 92 9d 40 26 eb    \tvptestmw %zmm27,%zmm28,%k5",},
+{{0x62, 0x92, 0x26, 0x40, 0x26, 0xea, }, 6, 0, "", "",
+"62 92 26 40 26 ea    \tvptestnmb %zmm26,%zmm27,%k5",},
+{{0x62, 0x92, 0xa6, 0x40, 0x26, 0xea, }, 6, 0, "", "",
+"62 92 a6 40 26 ea    \tvptestnmw %zmm26,%zmm27,%k5",},
+{{0x62, 0x92, 0x1d, 0x40, 0x27, 0xeb, }, 6, 0, "", "",
+"62 92 1d 40 27 eb    \tvptestmd %zmm27,%zmm28,%k5",},
+{{0x62, 0x92, 0x9d, 0x40, 0x27, 0xeb, }, 6, 0, "", "",
+"62 92 9d 40 27 eb    \tvptestmq %zmm27,%zmm28,%k5",},
+{{0x62, 0x92, 0x26, 0x40, 0x27, 0xea, }, 6, 0, "", "",
+"62 92 26 40 27 ea    \tvptestnmd %zmm26,%zmm27,%k5",},
+{{0x62, 0x92, 0xa6, 0x40, 0x27, 0xea, }, 6, 0, "", "",
+"62 92 a6 40 27 ea    \tvptestnmq %zmm26,%zmm27,%k5",},
+{{0xc4, 0xe2, 0x4d, 0x28, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 28 d4       \tvpmuldq %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x62, 0x7e, 0x48, 0x28, 0xe5, }, 6, 0, "", "",
+"62 62 7e 48 28 e5    \tvpmovm2b %k5,%zmm28",},
+{{0x62, 0x62, 0xfe, 0x48, 0x28, 0xe5, }, 6, 0, "", "",
+"62 62 fe 48 28 e5    \tvpmovm2w %k5,%zmm28",},
+{{0xc4, 0xe2, 0x4d, 0x29, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 29 d4       \tvpcmpeqq %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x92, 0x7e, 0x48, 0x29, 0xec, }, 6, 0, "", "",
+"62 92 7e 48 29 ec    \tvpmovb2m %zmm28,%k5",},
+{{0x62, 0x92, 0xfe, 0x48, 0x29, 0xec, }, 6, 0, "", "",
+"62 92 fe 48 29 ec    \tvpmovw2m %zmm28,%k5",},
+{{0xc4, 0xe2, 0x7d, 0x2a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 2a 21       \tvmovntdqa (%rcx),%ymm4",},
+{{0x62, 0x62, 0xfe, 0x48, 0x2a, 0xf6, }, 6, 0, "", "",
+"62 62 fe 48 2a f6    \tvpbroadcastmb2q %k6,%zmm30",},
+{{0xc4, 0xe2, 0x5d, 0x2c, 0x31, }, 5, 0, "", "",
+"c4 e2 5d 2c 31       \tvmaskmovps (%rcx),%ymm4,%ymm6",},
+{{0x62, 0x02, 0x35, 0x40, 0x2c, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 2c d0    \tvscalefps %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x2c, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 2c d0    \tvscalefpd %zmm24,%zmm25,%zmm26",},
+{{0xc4, 0xe2, 0x5d, 0x2d, 0x31, }, 5, 0, "", "",
+"c4 e2 5d 2d 31       \tvmaskmovpd (%rcx),%ymm4,%ymm6",},
+{{0x62, 0x02, 0x35, 0x07, 0x2d, 0xd0, }, 6, 0, "", "",
+"62 02 35 07 2d d0    \tvscalefss %xmm24,%xmm25,%xmm26{%k7}",},
+{{0x62, 0x02, 0xb5, 0x07, 0x2d, 0xd0, }, 6, 0, "", "",
+"62 02 b5 07 2d d0    \tvscalefsd %xmm24,%xmm25,%xmm26{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x30, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 30 e4       \tvpmovzxbw %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x30, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 30 de    \tvpmovwb %zmm27,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x31, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 31 f4       \tvpmovzxbd %xmm4,%ymm6",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x31, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 31 de    \tvpmovdb %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x32, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 32 e4       \tvpmovzxbq %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x32, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 32 de    \tvpmovqb %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x33, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 33 e4       \tvpmovzxwd %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x33, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 33 de    \tvpmovdw %zmm27,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x34, 0xf4, }, 5, 0, "", "",
+"c4 e2 7d 34 f4       \tvpmovzxwq %xmm4,%ymm6",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x34, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 34 de    \tvpmovqw %zmm27,%xmm6{%k7}",},
+{{0xc4, 0xe2, 0x7d, 0x35, 0xe4, }, 5, 0, "", "",
+"c4 e2 7d 35 e4       \tvpmovzxdq %xmm4,%ymm4",},
+{{0x62, 0x62, 0x7e, 0x4f, 0x35, 0xde, }, 6, 0, "", "",
+"62 62 7e 4f 35 de    \tvpmovqd %zmm27,%ymm6{%k7}",},
+{{0xc4, 0xe2, 0x4d, 0x36, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 36 d4       \tvpermd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x82, 0x2d, 0x27, 0x36, 0xf0, }, 6, 0, "", "",
+"62 82 2d 27 36 f0    \tvpermd %ymm24,%ymm26,%ymm22{%k7}",},
+{{0x62, 0x82, 0xad, 0x27, 0x36, 0xf0, }, 6, 0, "", "",
+"62 82 ad 27 36 f0    \tvpermq %ymm24,%ymm26,%ymm22{%k7}",},
+{{0xc4, 0xe2, 0x4d, 0x38, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 38 d4       \tvpminsb %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x62, 0x7e, 0x48, 0x38, 0xe5, }, 6, 0, "", "",
+"62 62 7e 48 38 e5    \tvpmovm2d %k5,%zmm28",},
+{{0x62, 0x62, 0xfe, 0x48, 0x38, 0xe5, }, 6, 0, "", "",
+"62 62 fe 48 38 e5    \tvpmovm2q %k5,%zmm28",},
+{{0xc4, 0xe2, 0x69, 0x39, 0xd9, }, 5, 0, "", "",
+"c4 e2 69 39 d9       \tvpminsd %xmm1,%xmm2,%xmm3",},
+{{0x62, 0x02, 0x35, 0x40, 0x39, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 39 d0    \tvpminsd %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x39, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 39 d0    \tvpminsq %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x92, 0x7e, 0x48, 0x39, 0xec, }, 6, 0, "", "",
+"62 92 7e 48 39 ec    \tvpmovd2m %zmm28,%k5",},
+{{0x62, 0x92, 0xfe, 0x48, 0x39, 0xec, }, 6, 0, "", "",
+"62 92 fe 48 39 ec    \tvpmovq2m %zmm28,%k5",},
+{{0xc4, 0xe2, 0x4d, 0x3a, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3a d4       \tvpminuw %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x62, 0x7e, 0x48, 0x3a, 0xe6, }, 6, 0, "", "",
+"62 62 7e 48 3a e6    \tvpbroadcastmw2d %k6,%zmm28",},
+{{0xc4, 0xe2, 0x4d, 0x3b, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3b d4       \tvpminud %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x02, 0x35, 0x40, 0x3b, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 3b d0    \tvpminud %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x3b, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 3b d0    \tvpminuq %zmm24,%zmm25,%zmm26",},
+{{0xc4, 0xe2, 0x4d, 0x3d, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3d d4       \tvpmaxsd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x02, 0x35, 0x40, 0x3d, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 3d d0    \tvpmaxsd %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x3d, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 3d d0    \tvpmaxsq %zmm24,%zmm25,%zmm26",},
+{{0xc4, 0xe2, 0x4d, 0x3f, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 3f d4       \tvpmaxud %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x02, 0x35, 0x40, 0x3f, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 3f d0    \tvpmaxud %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x3f, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 3f d0    \tvpmaxuq %zmm24,%zmm25,%zmm26",},
+{{0xc4, 0xe2, 0x4d, 0x40, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 40 d4       \tvpmulld %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x02, 0x35, 0x40, 0x40, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 40 d0    \tvpmulld %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x40, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 40 d0    \tvpmullq %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0x7d, 0x48, 0x42, 0xd1, }, 6, 0, "", "",
+"62 02 7d 48 42 d1    \tvgetexpps %zmm25,%zmm26",},
+{{0x62, 0x02, 0xfd, 0x48, 0x42, 0xe3, }, 6, 0, "", "",
+"62 02 fd 48 42 e3    \tvgetexppd %zmm27,%zmm28",},
+{{0x62, 0x02, 0x35, 0x07, 0x43, 0xd0, }, 6, 0, "", "",
+"62 02 35 07 43 d0    \tvgetexpss %xmm24,%xmm25,%xmm26{%k7}",},
+{{0x62, 0x02, 0x95, 0x07, 0x43, 0xf4, }, 6, 0, "", "",
+"62 02 95 07 43 f4    \tvgetexpsd %xmm28,%xmm29,%xmm30{%k7}",},
+{{0x62, 0x02, 0x7d, 0x48, 0x44, 0xe3, }, 6, 0, "", "",
+"62 02 7d 48 44 e3    \tvplzcntd %zmm27,%zmm28",},
+{{0x62, 0x02, 0xfd, 0x48, 0x44, 0xe3, }, 6, 0, "", "",
+"62 02 fd 48 44 e3    \tvplzcntq %zmm27,%zmm28",},
+{{0xc4, 0xe2, 0x4d, 0x46, 0xd4, }, 5, 0, "", "",
+"c4 e2 4d 46 d4       \tvpsravd %ymm4,%ymm6,%ymm2",},
+{{0x62, 0x02, 0x35, 0x40, 0x46, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 46 d0    \tvpsravd %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xb5, 0x40, 0x46, 0xd0, }, 6, 0, "", "",
+"62 02 b5 40 46 d0    \tvpsravq %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0x7d, 0x48, 0x4c, 0xd1, }, 6, 0, "", "",
+"62 02 7d 48 4c d1    \tvrcp14ps %zmm25,%zmm26",},
+{{0x62, 0x02, 0xfd, 0x48, 0x4c, 0xe3, }, 6, 0, "", "",
+"62 02 fd 48 4c e3    \tvrcp14pd %zmm27,%zmm28",},
+{{0x62, 0x02, 0x35, 0x07, 0x4d, 0xd0, }, 6, 0, "", "",
+"62 02 35 07 4d d0    \tvrcp14ss %xmm24,%xmm25,%xmm26{%k7}",},
+{{0x62, 0x02, 0xb5, 0x07, 0x4d, 0xd0, }, 6, 0, "", "",
+"62 02 b5 07 4d d0    \tvrcp14sd %xmm24,%xmm25,%xmm26{%k7}",},
+{{0x62, 0x02, 0x7d, 0x48, 0x4e, 0xd1, }, 6, 0, "", "",
+"62 02 7d 48 4e d1    \tvrsqrt14ps %zmm25,%zmm26",},
+{{0x62, 0x02, 0xfd, 0x48, 0x4e, 0xe3, }, 6, 0, "", "",
+"62 02 fd 48 4e e3    \tvrsqrt14pd %zmm27,%zmm28",},
+{{0x62, 0x02, 0x35, 0x07, 0x4f, 0xd0, }, 6, 0, "", "",
+"62 02 35 07 4f d0    \tvrsqrt14ss %xmm24,%xmm25,%xmm26{%k7}",},
+{{0x62, 0x02, 0xb5, 0x07, 0x4f, 0xd0, }, 6, 0, "", "",
+"62 02 b5 07 4f d0    \tvrsqrt14sd %xmm24,%xmm25,%xmm26{%k7}",},
+{{0xc4, 0xe2, 0x79, 0x59, 0xf4, }, 5, 0, "", "",
+"c4 e2 79 59 f4       \tvpbroadcastq %xmm4,%xmm6",},
+{{0x62, 0x02, 0x7d, 0x48, 0x59, 0xd3, }, 6, 0, "", "",
+"62 02 7d 48 59 d3    \tvbroadcasti32x2 %xmm27,%zmm26",},
+{{0xc4, 0xe2, 0x7d, 0x5a, 0x21, }, 5, 0, "", "",
+"c4 e2 7d 5a 21       \tvbroadcasti128 (%rcx),%ymm4",},
+{{0x62, 0x62, 0x7d, 0x48, 0x5a, 0x11, }, 6, 0, "", "",
+"62 62 7d 48 5a 11    \tvbroadcasti32x4 (%rcx),%zmm26",},
+{{0x62, 0x62, 0xfd, 0x48, 0x5a, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 5a 11    \tvbroadcasti64x2 (%rcx),%zmm26",},
+{{0x62, 0x62, 0x7d, 0x48, 0x5b, 0x21, }, 6, 0, "", "",
+"62 62 7d 48 5b 21    \tvbroadcasti32x8 (%rcx),%zmm28",},
+{{0x62, 0x62, 0xfd, 0x48, 0x5b, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 5b 11    \tvbroadcasti64x4 (%rcx),%zmm26",},
+{{0x62, 0x02, 0x25, 0x40, 0x64, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 64 e2    \tvpblendmd %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x64, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 64 e2    \tvpblendmq %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x35, 0x40, 0x65, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 65 d0    \tvblendmps %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xa5, 0x40, 0x65, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 65 e2    \tvblendmpd %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x25, 0x40, 0x66, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 66 e2    \tvpblendmb %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x66, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 66 e2    \tvpblendmw %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x35, 0x40, 0x75, 0xd0, }, 6, 0, "", "",
+"62 02 35 40 75 d0    \tvpermi2b %zmm24,%zmm25,%zmm26",},
+{{0x62, 0x02, 0xa5, 0x40, 0x75, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 75 e2    \tvpermi2w %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x25, 0x40, 0x76, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 76 e2    \tvpermi2d %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x76, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 76 e2    \tvpermi2q %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x25, 0x40, 0x77, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 77 e2    \tvpermi2ps %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x77, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 77 e2    \tvpermi2pd %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x62, 0x7d, 0x08, 0x7a, 0xf0, }, 6, 0, "", "",
+"62 62 7d 08 7a f0    \tvpbroadcastb %eax,%xmm30",},
+{{0x62, 0x62, 0x7d, 0x08, 0x7b, 0xf0, }, 6, 0, "", "",
+"62 62 7d 08 7b f0    \tvpbroadcastw %eax,%xmm30",},
+{{0x62, 0x62, 0x7d, 0x08, 0x7c, 0xf0, }, 6, 0, "", "",
+"62 62 7d 08 7c f0    \tvpbroadcastd %eax,%xmm30",},
+{{0x62, 0x62, 0xfd, 0x48, 0x7c, 0xf0, }, 6, 0, "", "",
+"62 62 fd 48 7c f0    \tvpbroadcastq %rax,%zmm30",},
+{{0x62, 0x02, 0x25, 0x40, 0x7d, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 7d e2    \tvpermt2b %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x7d, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 7d e2    \tvpermt2w %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x25, 0x40, 0x7e, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 7e e2    \tvpermt2d %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x7e, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 7e e2    \tvpermt2q %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x25, 0x40, 0x7f, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 7f e2    \tvpermt2ps %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x7f, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 7f e2    \tvpermt2pd %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x83, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 83 e2    \tvpmultishiftqb %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x62, 0x7d, 0x48, 0x88, 0x11, }, 6, 0, "", "",
+"62 62 7d 48 88 11    \tvexpandps (%rcx),%zmm26",},
+{{0x62, 0x62, 0xfd, 0x48, 0x88, 0x21, }, 6, 0, "", "",
+"62 62 fd 48 88 21    \tvexpandpd (%rcx),%zmm28",},
+{{0x62, 0x62, 0x7d, 0x48, 0x89, 0x21, }, 6, 0, "", "",
+"62 62 7d 48 89 21    \tvpexpandd (%rcx),%zmm28",},
+{{0x62, 0x62, 0xfd, 0x48, 0x89, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 89 11    \tvpexpandq (%rcx),%zmm26",},
+{{0x62, 0x62, 0x7d, 0x48, 0x8a, 0x21, }, 6, 0, "", "",
+"62 62 7d 48 8a 21    \tvcompressps %zmm28,(%rcx)",},
+{{0x62, 0x62, 0xfd, 0x48, 0x8a, 0x21, }, 6, 0, "", "",
+"62 62 fd 48 8a 21    \tvcompresspd %zmm28,(%rcx)",},
+{{0x62, 0x62, 0x7d, 0x48, 0x8b, 0x21, }, 6, 0, "", "",
+"62 62 7d 48 8b 21    \tvpcompressd %zmm28,(%rcx)",},
+{{0x62, 0x62, 0xfd, 0x48, 0x8b, 0x11, }, 6, 0, "", "",
+"62 62 fd 48 8b 11    \tvpcompressq %zmm26,(%rcx)",},
+{{0x62, 0x02, 0x25, 0x40, 0x8d, 0xe2, }, 6, 0, "", "",
+"62 02 25 40 8d e2    \tvpermb %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0x8d, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 8d e2    \tvpermw %zmm26,%zmm27,%zmm28",},
+{{0xc4, 0xe2, 0x69, 0x90, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 69 90 4c 7d 02 \tvpgatherdd %xmm2,0x2(%rbp,%xmm7,2),%xmm1",},
+{{0xc4, 0xe2, 0xe9, 0x90, 0x4c, 0x7d, 0x04, }, 7, 0, "", "",
+"c4 e2 e9 90 4c 7d 04 \tvpgatherdq %xmm2,0x4(%rbp,%xmm7,2),%xmm1",},
+{{0x62, 0x22, 0x7d, 0x41, 0x90, 0x94, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 7d 41 90 94 dd 7b 00 00 00 \tvpgatherdd 0x7b(%rbp,%zmm27,8),%zmm26{%k1}",},
+{{0x62, 0x22, 0xfd, 0x41, 0x90, 0x94, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 fd 41 90 94 dd 7b 00 00 00 \tvpgatherdq 0x7b(%rbp,%ymm27,8),%zmm26{%k1}",},
+{{0xc4, 0xe2, 0x69, 0x91, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 69 91 4c 7d 02 \tvpgatherqd %xmm2,0x2(%rbp,%xmm7,2),%xmm1",},
+{{0xc4, 0xe2, 0xe9, 0x91, 0x4c, 0x7d, 0x02, }, 7, 0, "", "",
+"c4 e2 e9 91 4c 7d 02 \tvpgatherqq %xmm2,0x2(%rbp,%xmm7,2),%xmm1",},
+{{0x62, 0x22, 0x7d, 0x41, 0x91, 0x94, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 7d 41 91 94 dd 7b 00 00 00 \tvpgatherqd 0x7b(%rbp,%zmm27,8),%ymm26{%k1}",},
+{{0x62, 0x22, 0xfd, 0x41, 0x91, 0x94, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 fd 41 91 94 dd 7b 00 00 00 \tvpgatherqq 0x7b(%rbp,%zmm27,8),%zmm26{%k1}",},
+{{0x62, 0x22, 0x7d, 0x41, 0xa0, 0xa4, 0xed, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 7d 41 a0 a4 ed 7b 00 00 00 \tvpscatterdd %zmm28,0x7b(%rbp,%zmm29,8){%k1}",},
+{{0x62, 0x22, 0xfd, 0x41, 0xa0, 0x94, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 fd 41 a0 94 dd 7b 00 00 00 \tvpscatterdq %zmm26,0x7b(%rbp,%ymm27,8){%k1}",},
+{{0x62, 0xb2, 0x7d, 0x41, 0xa1, 0xb4, 0xed, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 b2 7d 41 a1 b4 ed 7b 00 00 00 \tvpscatterqd %ymm6,0x7b(%rbp,%zmm29,8){%k1}",},
+{{0x62, 0xb2, 0xfd, 0x21, 0xa1, 0xb4, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 b2 fd 21 a1 b4 dd 7b 00 00 00 \tvpscatterqq %ymm6,0x7b(%rbp,%ymm27,8){%k1}",},
+{{0x62, 0x22, 0x7d, 0x41, 0xa2, 0xa4, 0xed, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 7d 41 a2 a4 ed 7b 00 00 00 \tvscatterdps %zmm28,0x7b(%rbp,%zmm29,8){%k1}",},
+{{0x62, 0x22, 0xfd, 0x41, 0xa2, 0xa4, 0xdd, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 fd 41 a2 a4 dd 7b 00 00 00 \tvscatterdpd %zmm28,0x7b(%rbp,%ymm27,8){%k1}",},
+{{0x62, 0xb2, 0x7d, 0x41, 0xa3, 0xb4, 0xed, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 b2 7d 41 a3 b4 ed 7b 00 00 00 \tvscatterqps %ymm6,0x7b(%rbp,%zmm29,8){%k1}",},
+{{0x62, 0x22, 0xfd, 0x41, 0xa3, 0xa4, 0xed, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 22 fd 41 a3 a4 ed 7b 00 00 00 \tvscatterqpd %zmm28,0x7b(%rbp,%zmm29,8){%k1}",},
+{{0x62, 0x02, 0xa5, 0x40, 0xb4, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 b4 e2    \tvpmadd52luq %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0xa5, 0x40, 0xb5, 0xe2, }, 6, 0, "", "",
+"62 02 a5 40 b5 e2    \tvpmadd52huq %zmm26,%zmm27,%zmm28",},
+{{0x62, 0x02, 0x7d, 0x48, 0xc4, 0xda, }, 6, 0, "", "",
+"62 02 7d 48 c4 da    \tvpconflictd %zmm26,%zmm27",},
+{{0x62, 0x02, 0xfd, 0x48, 0xc4, 0xda, }, 6, 0, "", "",
+"62 02 fd 48 c4 da    \tvpconflictq %zmm26,%zmm27",},
+{{0x62, 0x02, 0x7d, 0x48, 0xc8, 0xf5, }, 6, 0, "", "",
+"62 02 7d 48 c8 f5    \tvexp2ps %zmm29,%zmm30",},
+{{0x62, 0x02, 0xfd, 0x48, 0xc8, 0xda, }, 6, 0, "", "",
+"62 02 fd 48 c8 da    \tvexp2pd %zmm26,%zmm27",},
+{{0x62, 0x02, 0x7d, 0x48, 0xca, 0xf5, }, 6, 0, "", "",
+"62 02 7d 48 ca f5    \tvrcp28ps %zmm29,%zmm30",},
+{{0x62, 0x02, 0xfd, 0x48, 0xca, 0xda, }, 6, 0, "", "",
+"62 02 fd 48 ca da    \tvrcp28pd %zmm26,%zmm27",},
+{{0x62, 0x02, 0x15, 0x07, 0xcb, 0xf4, }, 6, 0, "", "",
+"62 02 15 07 cb f4    \tvrcp28ss %xmm28,%xmm29,%xmm30{%k7}",},
+{{0x62, 0x02, 0xad, 0x07, 0xcb, 0xd9, }, 6, 0, "", "",
+"62 02 ad 07 cb d9    \tvrcp28sd %xmm25,%xmm26,%xmm27{%k7}",},
+{{0x62, 0x02, 0x7d, 0x48, 0xcc, 0xf5, }, 6, 0, "", "",
+"62 02 7d 48 cc f5    \tvrsqrt28ps %zmm29,%zmm30",},
+{{0x62, 0x02, 0xfd, 0x48, 0xcc, 0xda, }, 6, 0, "", "",
+"62 02 fd 48 cc da    \tvrsqrt28pd %zmm26,%zmm27",},
+{{0x62, 0x02, 0x15, 0x07, 0xcd, 0xf4, }, 6, 0, "", "",
+"62 02 15 07 cd f4    \tvrsqrt28ss %xmm28,%xmm29,%xmm30{%k7}",},
+{{0x62, 0x02, 0xad, 0x07, 0xcd, 0xd9, }, 6, 0, "", "",
+"62 02 ad 07 cd d9    \tvrsqrt28sd %xmm25,%xmm26,%xmm27{%k7}",},
+{{0x62, 0x03, 0x15, 0x40, 0x03, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 40 03 f4 12 \tvalignd $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0xad, 0x40, 0x03, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 ad 40 03 d9 12 \tvalignq $0x12,%zmm25,%zmm26,%zmm27",},
+{{0xc4, 0xe3, 0x7d, 0x08, 0xd6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 08 d6 05    \tvroundps $0x5,%ymm6,%ymm2",},
+{{0x62, 0x03, 0x7d, 0x48, 0x08, 0xd1, 0x12, }, 7, 0, "", "",
+"62 03 7d 48 08 d1 12 \tvrndscaleps $0x12,%zmm25,%zmm26",},
+{{0xc4, 0xe3, 0x7d, 0x09, 0xd6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 09 d6 05    \tvroundpd $0x5,%ymm6,%ymm2",},
+{{0x62, 0x03, 0xfd, 0x48, 0x09, 0xd1, 0x12, }, 7, 0, "", "",
+"62 03 fd 48 09 d1 12 \tvrndscalepd $0x12,%zmm25,%zmm26",},
+{{0xc4, 0xe3, 0x49, 0x0a, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 49 0a d4 05    \tvroundss $0x5,%xmm4,%xmm6,%xmm2",},
+{{0x62, 0x03, 0x35, 0x07, 0x0a, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 35 07 0a d0 12 \tvrndscaless $0x12,%xmm24,%xmm25,%xmm26{%k7}",},
+{{0xc4, 0xe3, 0x49, 0x0b, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 49 0b d4 05    \tvroundsd $0x5,%xmm4,%xmm6,%xmm2",},
+{{0x62, 0x03, 0xb5, 0x07, 0x0b, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 b5 07 0b d0 12 \tvrndscalesd $0x12,%xmm24,%xmm25,%xmm26{%k7}",},
+{{0xc4, 0xe3, 0x5d, 0x18, 0xf4, 0x05, }, 6, 0, "", "",
+"c4 e3 5d 18 f4 05    \tvinsertf128 $0x5,%xmm4,%ymm4,%ymm6",},
+{{0x62, 0x03, 0x35, 0x47, 0x18, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 35 47 18 d0 12 \tvinsertf32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}",},
+{{0x62, 0x03, 0xb5, 0x47, 0x18, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 b5 47 18 d0 12 \tvinsertf64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}",},
+{{0xc4, 0xe3, 0x7d, 0x19, 0xe4, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 19 e4 05    \tvextractf128 $0x5,%ymm4,%xmm4",},
+{{0x62, 0x03, 0x7d, 0x4f, 0x19, 0xca, 0x12, }, 7, 0, "", "",
+"62 03 7d 4f 19 ca 12 \tvextractf32x4 $0x12,%zmm25,%xmm26{%k7}",},
+{{0x62, 0x03, 0xfd, 0x4f, 0x19, 0xca, 0x12, }, 7, 0, "", "",
+"62 03 fd 4f 19 ca 12 \tvextractf64x2 $0x12,%zmm25,%xmm26{%k7}",},
+{{0x62, 0x03, 0x2d, 0x47, 0x1a, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 47 1a d9 12 \tvinsertf32x8 $0x12,%ymm25,%zmm26,%zmm27{%k7}",},
+{{0x62, 0x03, 0x95, 0x47, 0x1a, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 47 1a f4 12 \tvinsertf64x4 $0x12,%ymm28,%zmm29,%zmm30{%k7}",},
+{{0x62, 0x03, 0x7d, 0x4f, 0x1b, 0xee, 0x12, }, 7, 0, "", "",
+"62 03 7d 4f 1b ee 12 \tvextractf32x8 $0x12,%zmm29,%ymm30{%k7}",},
+{{0x62, 0x03, 0xfd, 0x4f, 0x1b, 0xd3, 0x12, }, 7, 0, "", "",
+"62 03 fd 4f 1b d3 12 \tvextractf64x4 $0x12,%zmm26,%ymm27{%k7}",},
+{{0x62, 0x93, 0x0d, 0x40, 0x1e, 0xed, 0x12, }, 7, 0, "", "",
+"62 93 0d 40 1e ed 12 \tvpcmpud $0x12,%zmm29,%zmm30,%k5",},
+{{0x62, 0x93, 0xa5, 0x40, 0x1e, 0xea, 0x12, }, 7, 0, "", "",
+"62 93 a5 40 1e ea 12 \tvpcmpuq $0x12,%zmm26,%zmm27,%k5",},
+{{0x62, 0x93, 0x0d, 0x40, 0x1f, 0xed, 0x12, }, 7, 0, "", "",
+"62 93 0d 40 1f ed 12 \tvpcmpd $0x12,%zmm29,%zmm30,%k5",},
+{{0x62, 0x93, 0xa5, 0x40, 0x1f, 0xea, 0x12, }, 7, 0, "", "",
+"62 93 a5 40 1f ea 12 \tvpcmpq $0x12,%zmm26,%zmm27,%k5",},
+{{0x62, 0x03, 0x15, 0x40, 0x23, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 40 23 f4 12 \tvshuff32x4 $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0xad, 0x40, 0x23, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 ad 40 23 d9 12 \tvshuff64x2 $0x12,%zmm25,%zmm26,%zmm27",},
+{{0x62, 0x03, 0x15, 0x40, 0x25, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 40 25 f4 12 \tvpternlogd $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x95, 0x40, 0x25, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 40 25 f4 12 \tvpternlogq $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x7d, 0x48, 0x26, 0xda, 0x12, }, 7, 0, "", "",
+"62 03 7d 48 26 da 12 \tvgetmantps $0x12,%zmm26,%zmm27",},
+{{0x62, 0x03, 0xfd, 0x48, 0x26, 0xf5, 0x12, }, 7, 0, "", "",
+"62 03 fd 48 26 f5 12 \tvgetmantpd $0x12,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x2d, 0x07, 0x27, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 07 27 d9 12 \tvgetmantss $0x12,%xmm25,%xmm26,%xmm27{%k7}",},
+{{0x62, 0x03, 0x95, 0x07, 0x27, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 07 27 f4 12 \tvgetmantsd $0x12,%xmm28,%xmm29,%xmm30{%k7}",},
+{{0xc4, 0xe3, 0x5d, 0x38, 0xf4, 0x05, }, 6, 0, "", "",
+"c4 e3 5d 38 f4 05    \tvinserti128 $0x5,%xmm4,%ymm4,%ymm6",},
+{{0x62, 0x03, 0x35, 0x47, 0x38, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 35 47 38 d0 12 \tvinserti32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}",},
+{{0x62, 0x03, 0xb5, 0x47, 0x38, 0xd0, 0x12, }, 7, 0, "", "",
+"62 03 b5 47 38 d0 12 \tvinserti64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}",},
+{{0xc4, 0xe3, 0x7d, 0x39, 0xe6, 0x05, }, 6, 0, "", "",
+"c4 e3 7d 39 e6 05    \tvextracti128 $0x5,%ymm4,%xmm6",},
+{{0x62, 0x03, 0x7d, 0x4f, 0x39, 0xca, 0x12, }, 7, 0, "", "",
+"62 03 7d 4f 39 ca 12 \tvextracti32x4 $0x12,%zmm25,%xmm26{%k7}",},
+{{0x62, 0x03, 0xfd, 0x4f, 0x39, 0xca, 0x12, }, 7, 0, "", "",
+"62 03 fd 4f 39 ca 12 \tvextracti64x2 $0x12,%zmm25,%xmm26{%k7}",},
+{{0x62, 0x03, 0x15, 0x47, 0x3a, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 47 3a f4 12 \tvinserti32x8 $0x12,%ymm28,%zmm29,%zmm30{%k7}",},
+{{0x62, 0x03, 0xad, 0x47, 0x3a, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 ad 47 3a d9 12 \tvinserti64x4 $0x12,%ymm25,%zmm26,%zmm27{%k7}",},
+{{0x62, 0x03, 0x7d, 0x4f, 0x3b, 0xee, 0x12, }, 7, 0, "", "",
+"62 03 7d 4f 3b ee 12 \tvextracti32x8 $0x12,%zmm29,%ymm30{%k7}",},
+{{0x62, 0x03, 0xfd, 0x4f, 0x3b, 0xd3, 0x12, }, 7, 0, "", "",
+"62 03 fd 4f 3b d3 12 \tvextracti64x4 $0x12,%zmm26,%ymm27{%k7}",},
+{{0x62, 0x93, 0x0d, 0x40, 0x3e, 0xed, 0x12, }, 7, 0, "", "",
+"62 93 0d 40 3e ed 12 \tvpcmpub $0x12,%zmm29,%zmm30,%k5",},
+{{0x62, 0x93, 0xa5, 0x40, 0x3e, 0xea, 0x12, }, 7, 0, "", "",
+"62 93 a5 40 3e ea 12 \tvpcmpuw $0x12,%zmm26,%zmm27,%k5",},
+{{0x62, 0x93, 0x0d, 0x40, 0x3f, 0xed, 0x12, }, 7, 0, "", "",
+"62 93 0d 40 3f ed 12 \tvpcmpb $0x12,%zmm29,%zmm30,%k5",},
+{{0x62, 0x93, 0xa5, 0x40, 0x3f, 0xea, 0x12, }, 7, 0, "", "",
+"62 93 a5 40 3f ea 12 \tvpcmpw $0x12,%zmm26,%zmm27,%k5",},
+{{0xc4, 0xe3, 0x4d, 0x42, 0xd4, 0x05, }, 6, 0, "", "",
+"c4 e3 4d 42 d4 05    \tvmpsadbw $0x5,%ymm4,%ymm6,%ymm2",},
+{{0x62, 0xf3, 0x55, 0x48, 0x42, 0xf4, 0x12, }, 7, 0, "", "",
+"62 f3 55 48 42 f4 12 \tvdbpsadbw $0x12,%zmm4,%zmm5,%zmm6",},
+{{0x62, 0x03, 0x2d, 0x40, 0x43, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 40 43 d9 12 \tvshufi32x4 $0x12,%zmm25,%zmm26,%zmm27",},
+{{0x62, 0x03, 0x95, 0x40, 0x43, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 40 43 f4 12 \tvshufi64x2 $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x2d, 0x40, 0x50, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 40 50 d9 12 \tvrangeps $0x12,%zmm25,%zmm26,%zmm27",},
+{{0x62, 0x03, 0x95, 0x40, 0x50, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 40 50 f4 12 \tvrangepd $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x2d, 0x00, 0x51, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 00 51 d9 12 \tvrangess $0x12,%xmm25,%xmm26,%xmm27",},
+{{0x62, 0x03, 0x95, 0x00, 0x51, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 00 51 f4 12 \tvrangesd $0x12,%xmm28,%xmm29,%xmm30",},
+{{0x62, 0x03, 0x15, 0x40, 0x54, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 40 54 f4 12 \tvfixupimmps $0x12,%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x03, 0xad, 0x40, 0x54, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 ad 40 54 d9 12 \tvfixupimmpd $0x12,%zmm25,%zmm26,%zmm27",},
+{{0x62, 0x03, 0x15, 0x07, 0x55, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 15 07 55 f4 12 \tvfixupimmss $0x12,%xmm28,%xmm29,%xmm30{%k7}",},
+{{0x62, 0x03, 0xad, 0x07, 0x55, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 ad 07 55 d9 12 \tvfixupimmsd $0x12,%xmm25,%xmm26,%xmm27{%k7}",},
+{{0x62, 0x03, 0x7d, 0x48, 0x56, 0xda, 0x12, }, 7, 0, "", "",
+"62 03 7d 48 56 da 12 \tvreduceps $0x12,%zmm26,%zmm27",},
+{{0x62, 0x03, 0xfd, 0x48, 0x56, 0xf5, 0x12, }, 7, 0, "", "",
+"62 03 fd 48 56 f5 12 \tvreducepd $0x12,%zmm29,%zmm30",},
+{{0x62, 0x03, 0x2d, 0x00, 0x57, 0xd9, 0x12, }, 7, 0, "", "",
+"62 03 2d 00 57 d9 12 \tvreducess $0x12,%xmm25,%xmm26,%xmm27",},
+{{0x62, 0x03, 0x95, 0x00, 0x57, 0xf4, 0x12, }, 7, 0, "", "",
+"62 03 95 00 57 f4 12 \tvreducesd $0x12,%xmm28,%xmm29,%xmm30",},
+{{0x62, 0x93, 0x7d, 0x48, 0x66, 0xeb, 0x12, }, 7, 0, "", "",
+"62 93 7d 48 66 eb 12 \tvfpclassps $0x12,%zmm27,%k5",},
+{{0x62, 0x93, 0xfd, 0x48, 0x66, 0xee, 0x12, }, 7, 0, "", "",
+"62 93 fd 48 66 ee 12 \tvfpclasspd $0x12,%zmm30,%k5",},
+{{0x62, 0x93, 0x7d, 0x08, 0x67, 0xeb, 0x12, }, 7, 0, "", "",
+"62 93 7d 08 67 eb 12 \tvfpclassss $0x12,%xmm27,%k5",},
+{{0x62, 0x93, 0xfd, 0x08, 0x67, 0xee, 0x12, }, 7, 0, "", "",
+"62 93 fd 08 67 ee 12 \tvfpclasssd $0x12,%xmm30,%k5",},
+{{0x62, 0x91, 0x2d, 0x40, 0x72, 0xc1, 0x12, }, 7, 0, "", "",
+"62 91 2d 40 72 c1 12 \tvprord $0x12,%zmm25,%zmm26",},
+{{0x62, 0x91, 0xad, 0x40, 0x72, 0xc1, 0x12, }, 7, 0, "", "",
+"62 91 ad 40 72 c1 12 \tvprorq $0x12,%zmm25,%zmm26",},
+{{0x62, 0x91, 0x0d, 0x40, 0x72, 0xcd, 0x12, }, 7, 0, "", "",
+"62 91 0d 40 72 cd 12 \tvprold $0x12,%zmm29,%zmm30",},
+{{0x62, 0x91, 0x8d, 0x40, 0x72, 0xcd, 0x12, }, 7, 0, "", "",
+"62 91 8d 40 72 cd 12 \tvprolq $0x12,%zmm29,%zmm30",},
+{{0x0f, 0x72, 0xe6, 0x02, }, 4, 0, "", "",
+"0f 72 e6 02          \tpsrad  $0x2,%mm6",},
+{{0xc5, 0xed, 0x72, 0xe6, 0x05, }, 5, 0, "", "",
+"c5 ed 72 e6 05       \tvpsrad $0x5,%ymm6,%ymm2",},
+{{0x62, 0x91, 0x4d, 0x40, 0x72, 0xe2, 0x05, }, 7, 0, "", "",
+"62 91 4d 40 72 e2 05 \tvpsrad $0x5,%zmm26,%zmm22",},
+{{0x62, 0x91, 0xcd, 0x40, 0x72, 0xe2, 0x05, }, 7, 0, "", "",
+"62 91 cd 40 72 e2 05 \tvpsraq $0x5,%zmm26,%zmm22",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc6, 0x8c, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c6 8c fe 7b 00 00 00 \tvgatherpf0dps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc6, 0x8c, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c6 8c fe 7b 00 00 00 \tvgatherpf0dpd 0x7b(%r14,%ymm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc6, 0x94, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c6 94 fe 7b 00 00 00 \tvgatherpf1dps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc6, 0x94, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c6 94 fe 7b 00 00 00 \tvgatherpf1dpd 0x7b(%r14,%ymm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc6, 0xac, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c6 ac fe 7b 00 00 00 \tvscatterpf0dps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc6, 0xac, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c6 ac fe 7b 00 00 00 \tvscatterpf0dpd 0x7b(%r14,%ymm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc6, 0xb4, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c6 b4 fe 7b 00 00 00 \tvscatterpf1dps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc6, 0xb4, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c6 b4 fe 7b 00 00 00 \tvscatterpf1dpd 0x7b(%r14,%ymm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc7, 0x8c, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c7 8c fe 7b 00 00 00 \tvgatherpf0qps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc7, 0x8c, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c7 8c fe 7b 00 00 00 \tvgatherpf0qpd 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc7, 0x94, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c7 94 fe 7b 00 00 00 \tvgatherpf1qps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc7, 0x94, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c7 94 fe 7b 00 00 00 \tvgatherpf1qpd 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc7, 0xac, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c7 ac fe 7b 00 00 00 \tvscatterpf0qps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc7, 0xac, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c7 ac fe 7b 00 00 00 \tvscatterpf0qpd 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0x7d, 0x41, 0xc7, 0xb4, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 7d 41 c7 b4 fe 7b 00 00 00 \tvscatterpf1qps 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x92, 0xfd, 0x41, 0xc7, 0xb4, 0xfe, 0x7b, 0x00, 0x00, 0x00, }, 11, 0, "", "",
+"62 92 fd 41 c7 b4 fe 7b 00 00 00 \tvscatterpf1qpd 0x7b(%r14,%zmm31,8){%k1}",},
+{{0x62, 0x01, 0x95, 0x40, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 40 58 f4    \tvaddpd %zmm28,%zmm29,%zmm30",},
+{{0x62, 0x01, 0x95, 0x47, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 47 58 f4    \tvaddpd %zmm28,%zmm29,%zmm30{%k7}",},
+{{0x62, 0x01, 0x95, 0xc7, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 c7 58 f4    \tvaddpd %zmm28,%zmm29,%zmm30{%k7}{z}",},
+{{0x62, 0x01, 0x95, 0x10, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 10 58 f4    \tvaddpd {rn-sae},%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x01, 0x95, 0x50, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 50 58 f4    \tvaddpd {ru-sae},%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x01, 0x95, 0x30, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 30 58 f4    \tvaddpd {rd-sae},%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x01, 0x95, 0x70, 0x58, 0xf4, }, 6, 0, "", "",
+"62 01 95 70 58 f4    \tvaddpd {rz-sae},%zmm28,%zmm29,%zmm30",},
+{{0x62, 0x61, 0x95, 0x40, 0x58, 0x31, }, 6, 0, "", "",
+"62 61 95 40 58 31    \tvaddpd (%rcx),%zmm29,%zmm30",},
+{{0x62, 0x21, 0x95, 0x40, 0x58, 0xb4, 0xf0, 0x23, 0x01, 0x00, 0x00, }, 11, 0, "", "",
+"62 21 95 40 58 b4 f0 23 01 00 00 \tvaddpd 0x123(%rax,%r14,8),%zmm29,%zmm30",},
+{{0x62, 0x61, 0x95, 0x50, 0x58, 0x31, }, 6, 0, "", "",
+"62 61 95 50 58 31    \tvaddpd (%rcx){1to8},%zmm29,%zmm30",},
+{{0x62, 0x61, 0x95, 0x40, 0x58, 0x72, 0x7f, }, 7, 0, "", "",
+"62 61 95 40 58 72 7f \tvaddpd 0x1fc0(%rdx),%zmm29,%zmm30",},
+{{0x62, 0x61, 0x95, 0x50, 0x58, 0x72, 0x7f, }, 7, 0, "", "",
+"62 61 95 50 58 72 7f \tvaddpd 0x3f8(%rdx){1to8},%zmm29,%zmm30",},
+{{0x62, 0xf1, 0x0c, 0x50, 0xc2, 0x6a, 0x7f, 0x08, }, 8, 0, "", "",
+"62 f1 0c 50 c2 6a 7f 08 \tvcmpeq_uqps 0x1fc(%rdx){1to16},%zmm30,%k5",},
+{{0x62, 0xb1, 0x97, 0x07, 0xc2, 0xac, 0xf0, 0x23, 0x01, 0x00, 0x00, 0x01, }, 12, 0, "", "",
+"62 b1 97 07 c2 ac f0 23 01 00 00 01 \tvcmpltsd 0x123(%rax,%r14,8),%xmm29,%k5{%k7}",},
+{{0x62, 0x91, 0x97, 0x17, 0xc2, 0xec, 0x02, }, 7, 0, "", "",
+"62 91 97 17 c2 ec 02 \tvcmplesd {sae},%xmm28,%xmm29,%k5{%k7}",},
+{{0x62, 0x23, 0x15, 0x07, 0x27, 0xb4, 0xf0, 0x23, 0x01, 0x00, 0x00, 0x5b, }, 12, 0, "", "",
+"62 23 15 07 27 b4 f0 23 01 00 00 5b \tvgetmantss $0x5b,0x123(%rax,%r14,8),%xmm29,%xmm30{%k7}",},
 {{0xf3, 0x0f, 0x1b, 0x00, }, 4, 0, "", "",
 "f3 0f 1b 00          \tbndmk  (%rax),%bnd0",},
 {{0xf3, 0x41, 0x0f, 0x1b, 0x00, }, 5, 0, "", "",
@@ -325,19 +1257,19 @@
 {{0x0f, 0x1b, 0x84, 0x08, 0x78, 0x56, 0x34, 0x12, }, 8, 0, "", "",
 "0f 1b 84 08 78 56 34 12 \tbndstx %bnd0,0x12345678(%rax,%rcx,1)",},
 {{0xf2, 0xe8, 0x00, 0x00, 0x00, 0x00, }, 6, 0, "call", "unconditional",
-"f2 e8 00 00 00 00    \tbnd callq 3f6 <main+0x3f6>",},
+"f2 e8 00 00 00 00    \tbnd callq f22 <main+0xf22>",},
 {{0x67, 0xf2, 0xff, 0x10, }, 4, 0, "call", "indirect",
 "67 f2 ff 10          \tbnd callq *(%eax)",},
 {{0xf2, 0xc3, }, 2, 0, "ret", "indirect",
 "f2 c3                \tbnd retq ",},
 {{0xf2, 0xe9, 0x00, 0x00, 0x00, 0x00, }, 6, 0, "jmp", "unconditional",
-"f2 e9 00 00 00 00    \tbnd jmpq 402 <main+0x402>",},
+"f2 e9 00 00 00 00    \tbnd jmpq f2e <main+0xf2e>",},
 {{0xf2, 0xe9, 0x00, 0x00, 0x00, 0x00, }, 6, 0, "jmp", "unconditional",
-"f2 e9 00 00 00 00    \tbnd jmpq 408 <main+0x408>",},
+"f2 e9 00 00 00 00    \tbnd jmpq f34 <main+0xf34>",},
 {{0x67, 0xf2, 0xff, 0x21, }, 4, 0, "jmp", "indirect",
 "67 f2 ff 21          \tbnd jmpq *(%ecx)",},
 {{0xf2, 0x0f, 0x85, 0x00, 0x00, 0x00, 0x00, }, 7, 0, "jcc", "conditional",
-"f2 0f 85 00 00 00 00 \tbnd jne 413 <main+0x413>",},
+"f2 0f 85 00 00 00 00 \tbnd jne f3f <main+0xf3f>",},
 {{0x0f, 0x3a, 0xcc, 0xc1, 0x00, }, 5, 0, "", "",
 "0f 3a cc c1 00       \tsha1rnds4 $0x0,%xmm1,%xmm0",},
 {{0x0f, 0x3a, 0xcc, 0xd7, 0x91, }, 5, 0, "", "",
@@ -764,5 +1696,3 @@
 "0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%rax,%rcx,8)",},
 {{0x41, 0x0f, 0xc7, 0x9c, 0xc8, 0x78, 0x56, 0x34, 0x12, }, 9, 0, "", "",
 "41 0f c7 9c c8 78 56 34 12 \txrstors 0x12345678(%r8,%rcx,8)",},
-{{0x66, 0x0f, 0xae, 0xf8, }, 4, 0, "", "",
-"66 0f ae f8          \tpcommit ",},
diff --git a/tools/perf/arch/x86/tests/insn-x86-dat-src.c b/tools/perf/arch/x86/tests/insn-x86-dat-src.c
index 41b1b1c62660..979487dae8d4 100644
--- a/tools/perf/arch/x86/tests/insn-x86-dat-src.c
+++ b/tools/perf/arch/x86/tests/insn-x86-dat-src.c
@@ -19,8 +19,882 @@ int main(void)
         /* Following line is a marker for the awk script - do not change */
         asm volatile("rdtsc"); /* Start here */
 
+        /* Test fix for vcvtph2ps in x86-opcode-map.txt */
+
+        asm volatile("vcvtph2ps %xmm3,%ymm5");
+
 #ifdef __x86_64__
 
+        /* AVX-512: Instructions with the same op codes as Mask Instructions  */
+
+        asm volatile("cmovno %rax,%rbx");
+        asm volatile("cmovno 0x12345678(%rax),%rcx");
+        asm volatile("cmovno 0x12345678(%rax),%cx");
+
+        asm volatile("cmove  %rax,%rbx");
+        asm volatile("cmove 0x12345678(%rax),%rcx");
+        asm volatile("cmove 0x12345678(%rax),%cx");
+
+        asm volatile("seto    0x12345678(%rax)");
+        asm volatile("setno   0x12345678(%rax)");
+        asm volatile("setb    0x12345678(%rax)");
+        asm volatile("setc    0x12345678(%rax)");
+        asm volatile("setnae  0x12345678(%rax)");
+        asm volatile("setae   0x12345678(%rax)");
+        asm volatile("setnb   0x12345678(%rax)");
+        asm volatile("setnc   0x12345678(%rax)");
+        asm volatile("sets    0x12345678(%rax)");
+        asm volatile("setns   0x12345678(%rax)");
+
+        /* AVX-512: Mask Instructions */
+
+        asm volatile("kandw  %k7,%k6,%k5");
+        asm volatile("kandq  %k7,%k6,%k5");
+        asm volatile("kandb  %k7,%k6,%k5");
+        asm volatile("kandd  %k7,%k6,%k5");
+
+        asm volatile("kandnw  %k7,%k6,%k5");
+        asm volatile("kandnq  %k7,%k6,%k5");
+        asm volatile("kandnb  %k7,%k6,%k5");
+        asm volatile("kandnd  %k7,%k6,%k5");
+
+        asm volatile("knotw  %k7,%k6");
+        asm volatile("knotq  %k7,%k6");
+        asm volatile("knotb  %k7,%k6");
+        asm volatile("knotd  %k7,%k6");
+
+        asm volatile("korw  %k7,%k6,%k5");
+        asm volatile("korq  %k7,%k6,%k5");
+        asm volatile("korb  %k7,%k6,%k5");
+        asm volatile("kord  %k7,%k6,%k5");
+
+        asm volatile("kxnorw  %k7,%k6,%k5");
+        asm volatile("kxnorq  %k7,%k6,%k5");
+        asm volatile("kxnorb  %k7,%k6,%k5");
+        asm volatile("kxnord  %k7,%k6,%k5");
+
+        asm volatile("kxorw  %k7,%k6,%k5");
+        asm volatile("kxorq  %k7,%k6,%k5");
+        asm volatile("kxorb  %k7,%k6,%k5");
+        asm volatile("kxord  %k7,%k6,%k5");
+
+        asm volatile("kaddw  %k7,%k6,%k5");
+        asm volatile("kaddq  %k7,%k6,%k5");
+        asm volatile("kaddb  %k7,%k6,%k5");
+        asm volatile("kaddd  %k7,%k6,%k5");
+
+        asm volatile("kunpckbw %k7,%k6,%k5");
+        asm volatile("kunpckwd %k7,%k6,%k5");
+        asm volatile("kunpckdq %k7,%k6,%k5");
+
+        asm volatile("kmovw  %k6,%k5");
+        asm volatile("kmovw  (%rcx),%k5");
+        asm volatile("kmovw  0x123(%rax,%r14,8),%k5");
+        asm volatile("kmovw  %k5,(%rcx)");
+        asm volatile("kmovw  %k5,0x123(%rax,%r14,8)");
+        asm volatile("kmovw  %eax,%k5");
+        asm volatile("kmovw  %ebp,%k5");
+        asm volatile("kmovw  %r13d,%k5");
+        asm volatile("kmovw  %k5,%eax");
+        asm volatile("kmovw  %k5,%ebp");
+        asm volatile("kmovw  %k5,%r13d");
+
+        asm volatile("kmovq  %k6,%k5");
+        asm volatile("kmovq  (%rcx),%k5");
+        asm volatile("kmovq  0x123(%rax,%r14,8),%k5");
+        asm volatile("kmovq  %k5,(%rcx)");
+        asm volatile("kmovq  %k5,0x123(%rax,%r14,8)");
+        asm volatile("kmovq  %rax,%k5");
+        asm volatile("kmovq  %rbp,%k5");
+        asm volatile("kmovq  %r13,%k5");
+        asm volatile("kmovq  %k5,%rax");
+        asm volatile("kmovq  %k5,%rbp");
+        asm volatile("kmovq  %k5,%r13");
+
+        asm volatile("kmovb  %k6,%k5");
+        asm volatile("kmovb  (%rcx),%k5");
+        asm volatile("kmovb  0x123(%rax,%r14,8),%k5");
+        asm volatile("kmovb  %k5,(%rcx)");
+        asm volatile("kmovb  %k5,0x123(%rax,%r14,8)");
+        asm volatile("kmovb  %eax,%k5");
+        asm volatile("kmovb  %ebp,%k5");
+        asm volatile("kmovb  %r13d,%k5");
+        asm volatile("kmovb  %k5,%eax");
+        asm volatile("kmovb  %k5,%ebp");
+        asm volatile("kmovb  %k5,%r13d");
+
+        asm volatile("kmovd  %k6,%k5");
+        asm volatile("kmovd  (%rcx),%k5");
+        asm volatile("kmovd  0x123(%rax,%r14,8),%k5");
+        asm volatile("kmovd  %k5,(%rcx)");
+        asm volatile("kmovd  %k5,0x123(%rax,%r14,8)");
+        asm volatile("kmovd  %eax,%k5");
+        asm volatile("kmovd  %ebp,%k5");
+        asm volatile("kmovd  %r13d,%k5");
+        asm volatile("kmovd  %k5,%eax");
+        asm volatile("kmovd  %k5,%ebp");
+        asm volatile("kmovd %k5,%r13d");
+
+        asm volatile("kortestw %k6,%k5");
+        asm volatile("kortestq %k6,%k5");
+        asm volatile("kortestb %k6,%k5");
+        asm volatile("kortestd %k6,%k5");
+
+        asm volatile("ktestw %k6,%k5");
+        asm volatile("ktestq %k6,%k5");
+        asm volatile("ktestb %k6,%k5");
+        asm volatile("ktestd %k6,%k5");
+
+        asm volatile("kshiftrw $0x12,%k6,%k5");
+        asm volatile("kshiftrq $0x5b,%k6,%k5");
+        asm volatile("kshiftlw $0x12,%k6,%k5");
+        asm volatile("kshiftlq $0x5b,%k6,%k5");
+
+        /* AVX-512: Op code 0f 5b */
+        asm volatile("vcvtdq2ps %xmm5,%xmm6");
+        asm volatile("vcvtqq2ps %zmm29,%ymm6{%k7}");
+        asm volatile("vcvtps2dq %xmm5,%xmm6");
+        asm volatile("vcvttps2dq %xmm5,%xmm6");
+
+        /* AVX-512: Op code 0f 6f */
+
+        asm volatile("movq   %mm0,%mm4");
+        asm volatile("vmovdqa %ymm4,%ymm6");
+        asm volatile("vmovdqa32 %zmm25,%zmm26");
+        asm volatile("vmovdqa64 %zmm25,%zmm26");
+        asm volatile("vmovdqu %ymm4,%ymm6");
+        asm volatile("vmovdqu32 %zmm29,%zmm30");
+        asm volatile("vmovdqu64 %zmm25,%zmm26");
+        asm volatile("vmovdqu8 %zmm29,%zmm30");
+        asm volatile("vmovdqu16 %zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 78 */
+
+        asm volatile("vmread %rax,%rbx");
+        asm volatile("vcvttps2udq %zmm25,%zmm26");
+        asm volatile("vcvttpd2udq %zmm29,%ymm6{%k7}");
+        asm volatile("vcvttsd2usi %xmm6,%rax");
+        asm volatile("vcvttss2usi %xmm6,%rax");
+        asm volatile("vcvttps2uqq %ymm5,%zmm26{%k7}");
+        asm volatile("vcvttpd2uqq %zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 79 */
+
+        asm volatile("vmwrite %rax,%rbx");
+        asm volatile("vcvtps2udq %zmm25,%zmm26");
+        asm volatile("vcvtpd2udq %zmm29,%ymm6{%k7}");
+        asm volatile("vcvtsd2usi %xmm6,%rax");
+        asm volatile("vcvtss2usi %xmm6,%rax");
+        asm volatile("vcvtps2uqq %ymm5,%zmm26{%k7}");
+        asm volatile("vcvtpd2uqq %zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 7a */
+
+        asm volatile("vcvtudq2pd %ymm5,%zmm29{%k7}");
+        asm volatile("vcvtuqq2pd %zmm25,%zmm26");
+        asm volatile("vcvtudq2ps %zmm29,%zmm30");
+        asm volatile("vcvtuqq2ps %zmm25,%ymm26{%k7}");
+        asm volatile("vcvttps2qq %ymm25,%zmm26{%k7}");
+        asm volatile("vcvttpd2qq %zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 7b */
+
+        asm volatile("vcvtusi2sd %eax,%xmm5,%xmm6");
+        asm volatile("vcvtusi2ss %eax,%xmm5,%xmm6");
+        asm volatile("vcvtps2qq %ymm5,%zmm26{%k7}");
+        asm volatile("vcvtpd2qq %zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 7f */
+
+        asm volatile("movq.s  %mm0,%mm4");
+        asm volatile("vmovdqa %ymm8,%ymm6");
+        asm volatile("vmovdqa32.s %zmm25,%zmm26");
+        asm volatile("vmovdqa64.s %zmm25,%zmm26");
+        asm volatile("vmovdqu %ymm8,%ymm6");
+        asm volatile("vmovdqu32.s %zmm25,%zmm26");
+        asm volatile("vmovdqu64.s %zmm25,%zmm26");
+        asm volatile("vmovdqu8.s %zmm30,(%rcx)");
+        asm volatile("vmovdqu16.s %zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f db */
+
+        asm volatile("pand  %mm1,%mm2");
+        asm volatile("pand  %xmm1,%xmm2");
+        asm volatile("vpand  %ymm4,%ymm6,%ymm2");
+        asm volatile("vpandd %zmm24,%zmm25,%zmm26");
+        asm volatile("vpandq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f df */
+
+        asm volatile("pandn  %mm1,%mm2");
+        asm volatile("pandn  %xmm1,%xmm2");
+        asm volatile("vpandn %ymm4,%ymm6,%ymm2");
+        asm volatile("vpandnd %zmm24,%zmm25,%zmm26");
+        asm volatile("vpandnq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f e6 */
+
+        asm volatile("vcvttpd2dq %xmm1,%xmm2");
+        asm volatile("vcvtdq2pd %xmm5,%xmm6");
+        asm volatile("vcvtdq2pd %ymm5,%zmm26{%k7}");
+        asm volatile("vcvtqq2pd %zmm25,%zmm26");
+        asm volatile("vcvtpd2dq %xmm1,%xmm2");
+
+        /* AVX-512: Op code 0f eb */
+
+        asm volatile("por   %mm4,%mm6");
+        asm volatile("vpor   %ymm4,%ymm6,%ymm2");
+        asm volatile("vpord  %zmm24,%zmm25,%zmm26");
+        asm volatile("vporq  %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f ef */
+
+        asm volatile("pxor   %mm4,%mm6");
+        asm volatile("vpxor  %ymm4,%ymm6,%ymm2");
+        asm volatile("vpxord %zmm24,%zmm25,%zmm26");
+        asm volatile("vpxorq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 10 */
+
+        asm volatile("pblendvb %xmm1,%xmm0");
+        asm volatile("vpsrlvw %zmm27,%zmm28,%zmm29");
+        asm volatile("vpmovuswb %zmm28,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 11 */
+
+        asm volatile("vpmovusdb %zmm28,%xmm6{%k7}");
+        asm volatile("vpsravw %zmm27,%zmm28,%zmm29");
+
+        /* AVX-512: Op code 0f 38 12 */
+
+        asm volatile("vpmovusqb %zmm27,%xmm6{%k7}");
+        asm volatile("vpsllvw %zmm27,%zmm28,%zmm29");
+
+        /* AVX-512: Op code 0f 38 13 */
+
+        asm volatile("vcvtph2ps %xmm3,%ymm5");
+        asm volatile("vcvtph2ps %ymm5,%zmm27{%k7}");
+        asm volatile("vpmovusdw %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 14 */
+
+        asm volatile("blendvps %xmm1,%xmm0");
+        asm volatile("vpmovusqw %zmm27,%xmm6{%k7}");
+        asm volatile("vprorvd %zmm27,%zmm28,%zmm29");
+        asm volatile("vprorvq %zmm27,%zmm28,%zmm29");
+
+        /* AVX-512: Op code 0f 38 15 */
+
+        asm volatile("blendvpd %xmm1,%xmm0");
+        asm volatile("vpmovusqd %zmm27,%ymm6{%k7}");
+        asm volatile("vprolvd %zmm27,%zmm28,%zmm29");
+        asm volatile("vprolvq %zmm27,%zmm28,%zmm29");
+
+        /* AVX-512: Op code 0f 38 16 */
+
+        asm volatile("vpermps %ymm4,%ymm6,%ymm2");
+        asm volatile("vpermps %ymm24,%ymm26,%ymm22{%k7}");
+        asm volatile("vpermpd %ymm24,%ymm26,%ymm22{%k7}");
+
+        /* AVX-512: Op code 0f 38 19 */
+
+        asm volatile("vbroadcastsd %xmm4,%ymm6");
+        asm volatile("vbroadcastf32x2 %xmm27,%zmm26");
+
+        /* AVX-512: Op code 0f 38 1a */
+
+        asm volatile("vbroadcastf128 (%rcx),%ymm4");
+        asm volatile("vbroadcastf32x4 (%rcx),%zmm26");
+        asm volatile("vbroadcastf64x2 (%rcx),%zmm26");
+
+        /* AVX-512: Op code 0f 38 1b */
+
+        asm volatile("vbroadcastf32x8 (%rcx),%zmm27");
+        asm volatile("vbroadcastf64x4 (%rcx),%zmm26");
+
+        /* AVX-512: Op code 0f 38 1f */
+
+        asm volatile("vpabsq %zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 20 */
+
+        asm volatile("vpmovsxbw %xmm4,%xmm5");
+        asm volatile("vpmovswb %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 21 */
+
+        asm volatile("vpmovsxbd %xmm4,%ymm6");
+        asm volatile("vpmovsdb %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 22 */
+
+        asm volatile("vpmovsxbq %xmm4,%ymm4");
+        asm volatile("vpmovsqb %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 23 */
+
+        asm volatile("vpmovsxwd %xmm4,%ymm4");
+        asm volatile("vpmovsdw %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 24 */
+
+        asm volatile("vpmovsxwq %xmm4,%ymm6");
+        asm volatile("vpmovsqw %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 25 */
+
+        asm volatile("vpmovsxdq %xmm4,%ymm4");
+        asm volatile("vpmovsqd %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 26 */
+
+        asm volatile("vptestmb %zmm27,%zmm28,%k5");
+        asm volatile("vptestmw %zmm27,%zmm28,%k5");
+        asm volatile("vptestnmb %zmm26,%zmm27,%k5");
+        asm volatile("vptestnmw %zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 38 27 */
+
+        asm volatile("vptestmd %zmm27,%zmm28,%k5");
+        asm volatile("vptestmq %zmm27,%zmm28,%k5");
+        asm volatile("vptestnmd %zmm26,%zmm27,%k5");
+        asm volatile("vptestnmq %zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 38 28 */
+
+        asm volatile("vpmuldq %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovm2b %k5,%zmm28");
+        asm volatile("vpmovm2w %k5,%zmm28");
+
+        /* AVX-512: Op code 0f 38 29 */
+
+        asm volatile("vpcmpeqq %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovb2m %zmm28,%k5");
+        asm volatile("vpmovw2m %zmm28,%k5");
+
+        /* AVX-512: Op code 0f 38 2a */
+
+        asm volatile("vmovntdqa (%rcx),%ymm4");
+        asm volatile("vpbroadcastmb2q %k6,%zmm30");
+
+        /* AVX-512: Op code 0f 38 2c */
+
+        asm volatile("vmaskmovps (%rcx),%ymm4,%ymm6");
+        asm volatile("vscalefps %zmm24,%zmm25,%zmm26");
+        asm volatile("vscalefpd %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 2d */
+
+        asm volatile("vmaskmovpd (%rcx),%ymm4,%ymm6");
+        asm volatile("vscalefss %xmm24,%xmm25,%xmm26{%k7}");
+        asm volatile("vscalefsd %xmm24,%xmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 38 30 */
+
+        asm volatile("vpmovzxbw %xmm4,%ymm4");
+        asm volatile("vpmovwb %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 31 */
+
+        asm volatile("vpmovzxbd %xmm4,%ymm6");
+        asm volatile("vpmovdb %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 32 */
+
+        asm volatile("vpmovzxbq %xmm4,%ymm4");
+        asm volatile("vpmovqb %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 33 */
+
+        asm volatile("vpmovzxwd %xmm4,%ymm4");
+        asm volatile("vpmovdw %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 34 */
+
+        asm volatile("vpmovzxwq %xmm4,%ymm6");
+        asm volatile("vpmovqw %zmm27,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 35 */
+
+        asm volatile("vpmovzxdq %xmm4,%ymm4");
+        asm volatile("vpmovqd %zmm27,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 38 */
+
+        asm volatile("vpermd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpermd %ymm24,%ymm26,%ymm22{%k7}");
+        asm volatile("vpermq %ymm24,%ymm26,%ymm22{%k7}");
+
+        /* AVX-512: Op code 0f 38 38 */
+
+        asm volatile("vpminsb %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovm2d %k5,%zmm28");
+        asm volatile("vpmovm2q %k5,%zmm28");
+
+        /* AVX-512: Op code 0f 38 39 */
+
+        asm volatile("vpminsd %xmm1,%xmm2,%xmm3");
+        asm volatile("vpminsd %zmm24,%zmm25,%zmm26");
+        asm volatile("vpminsq %zmm24,%zmm25,%zmm26");
+        asm volatile("vpmovd2m %zmm28,%k5");
+        asm volatile("vpmovq2m %zmm28,%k5");
+
+        /* AVX-512: Op code 0f 38 3a */
+
+        asm volatile("vpminuw %ymm4,%ymm6,%ymm2");
+        asm volatile("vpbroadcastmw2d %k6,%zmm28");
+
+        /* AVX-512: Op code 0f 38 3b */
+
+        asm volatile("vpminud %ymm4,%ymm6,%ymm2");
+        asm volatile("vpminud %zmm24,%zmm25,%zmm26");
+        asm volatile("vpminuq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 3d */
+
+        asm volatile("vpmaxsd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmaxsd %zmm24,%zmm25,%zmm26");
+        asm volatile("vpmaxsq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 3f */
+
+        asm volatile("vpmaxud %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmaxud %zmm24,%zmm25,%zmm26");
+        asm volatile("vpmaxuq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 42 */
+
+        asm volatile("vpmulld %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmulld %zmm24,%zmm25,%zmm26");
+        asm volatile("vpmullq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 42 */
+
+        asm volatile("vgetexpps %zmm25,%zmm26");
+        asm volatile("vgetexppd %zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 43 */
+
+        asm volatile("vgetexpss %xmm24,%xmm25,%xmm26{%k7}");
+        asm volatile("vgetexpsd %xmm28,%xmm29,%xmm30{%k7}");
+
+        /* AVX-512: Op code 0f 38 44 */
+
+        asm volatile("vplzcntd %zmm27,%zmm28");
+        asm volatile("vplzcntq %zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 46 */
+
+        asm volatile("vpsravd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpsravd %zmm24,%zmm25,%zmm26");
+        asm volatile("vpsravq %zmm24,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 38 4c */
+
+        asm volatile("vrcp14ps %zmm25,%zmm26");
+        asm volatile("vrcp14pd %zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 4d */
+
+        asm volatile("vrcp14ss %xmm24,%xmm25,%xmm26{%k7}");
+        asm volatile("vrcp14sd %xmm24,%xmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 38 4e */
+
+        asm volatile("vrsqrt14ps %zmm25,%zmm26");
+        asm volatile("vrsqrt14pd %zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 4f */
+
+        asm volatile("vrsqrt14ss %xmm24,%xmm25,%xmm26{%k7}");
+        asm volatile("vrsqrt14sd %xmm24,%xmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 38 59 */
+
+        asm volatile("vpbroadcastq %xmm4,%xmm6");
+        asm volatile("vbroadcasti32x2 %xmm27,%zmm26");
+
+        /* AVX-512: Op code 0f 38 5a */
+
+        asm volatile("vbroadcasti128 (%rcx),%ymm4");
+        asm volatile("vbroadcasti32x4 (%rcx),%zmm26");
+        asm volatile("vbroadcasti64x2 (%rcx),%zmm26");
+
+        /* AVX-512: Op code 0f 38 5b */
+
+        asm volatile("vbroadcasti32x8 (%rcx),%zmm28");
+        asm volatile("vbroadcasti64x4 (%rcx),%zmm26");
+
+        /* AVX-512: Op code 0f 38 64 */
+
+        asm volatile("vpblendmd %zmm26,%zmm27,%zmm28");
+        asm volatile("vpblendmq %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 65 */
+
+        asm volatile("vblendmps %zmm24,%zmm25,%zmm26");
+        asm volatile("vblendmpd %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 66 */
+
+        asm volatile("vpblendmb %zmm26,%zmm27,%zmm28");
+        asm volatile("vpblendmw %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 75 */
+
+        asm volatile("vpermi2b %zmm24,%zmm25,%zmm26");
+        asm volatile("vpermi2w %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 76 */
+
+        asm volatile("vpermi2d %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermi2q %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 77 */
+
+        asm volatile("vpermi2ps %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermi2pd %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 7a */
+
+        asm volatile("vpbroadcastb %eax,%xmm30");
+
+        /* AVX-512: Op code 0f 38 7b */
+
+        asm volatile("vpbroadcastw %eax,%xmm30");
+
+        /* AVX-512: Op code 0f 38 7c */
+
+        asm volatile("vpbroadcastd %eax,%xmm30");
+        asm volatile("vpbroadcastq %rax,%zmm30");
+
+        /* AVX-512: Op code 0f 38 7d */
+
+        asm volatile("vpermt2b %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermt2w %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 7e */
+
+        asm volatile("vpermt2d %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermt2q %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 7f */
+
+        asm volatile("vpermt2ps %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermt2pd %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 83 */
+
+        asm volatile("vpmultishiftqb %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 88 */
+
+        asm volatile("vexpandps (%rcx),%zmm26");
+        asm volatile("vexpandpd (%rcx),%zmm28");
+
+        /* AVX-512: Op code 0f 38 89 */
+
+        asm volatile("vpexpandd (%rcx),%zmm28");
+        asm volatile("vpexpandq (%rcx),%zmm26");
+
+        /* AVX-512: Op code 0f 38 8a */
+
+        asm volatile("vcompressps %zmm28,(%rcx)");
+        asm volatile("vcompresspd %zmm28,(%rcx)");
+
+        /* AVX-512: Op code 0f 38 8b */
+
+        asm volatile("vpcompressd %zmm28,(%rcx)");
+        asm volatile("vpcompressq %zmm26,(%rcx)");
+
+        /* AVX-512: Op code 0f 38 8d */
+
+        asm volatile("vpermb %zmm26,%zmm27,%zmm28");
+        asm volatile("vpermw %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 90 */
+
+        asm volatile("vpgatherdd %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherdq %xmm2,0x04(%rbp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherdd 0x7b(%rbp,%zmm27,8),%zmm26{%k1}");
+        asm volatile("vpgatherdq 0x7b(%rbp,%ymm27,8),%zmm26{%k1}");
+
+        /* AVX-512: Op code 0f 38 91 */
+
+        asm volatile("vpgatherqd %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherqq %xmm2,0x02(%rbp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherqd 0x7b(%rbp,%zmm27,8),%ymm26{%k1}");
+        asm volatile("vpgatherqq 0x7b(%rbp,%zmm27,8),%zmm26{%k1}");
+
+        /* AVX-512: Op code 0f 38 a0 */
+
+        asm volatile("vpscatterdd %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
+        asm volatile("vpscatterdq %zmm26,0x7b(%rbp,%ymm27,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a1 */
+
+        asm volatile("vpscatterqd %ymm6,0x7b(%rbp,%zmm29,8){%k1}");
+        asm volatile("vpscatterqq %ymm6,0x7b(%rbp,%ymm27,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a2 */
+
+        asm volatile("vscatterdps %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
+        asm volatile("vscatterdpd %zmm28,0x7b(%rbp,%ymm27,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a3 */
+
+        asm volatile("vscatterqps %ymm6,0x7b(%rbp,%zmm29,8){%k1}");
+        asm volatile("vscatterqpd %zmm28,0x7b(%rbp,%zmm29,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 b4 */
+
+        asm volatile("vpmadd52luq %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 b5 */
+
+        asm volatile("vpmadd52huq %zmm26,%zmm27,%zmm28");
+
+        /* AVX-512: Op code 0f 38 c4 */
+
+        asm volatile("vpconflictd %zmm26,%zmm27");
+        asm volatile("vpconflictq %zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 38 c8 */
+
+        asm volatile("vexp2ps %zmm29,%zmm30");
+        asm volatile("vexp2pd %zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 38 ca */
+
+        asm volatile("vrcp28ps %zmm29,%zmm30");
+        asm volatile("vrcp28pd %zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 38 cb */
+
+        asm volatile("vrcp28ss %xmm28,%xmm29,%xmm30{%k7}");
+        asm volatile("vrcp28sd %xmm25,%xmm26,%xmm27{%k7}");
+
+        /* AVX-512: Op code 0f 38 cc */
+
+        asm volatile("vrsqrt28ps %zmm29,%zmm30");
+        asm volatile("vrsqrt28pd %zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 38 cd */
+
+        asm volatile("vrsqrt28ss %xmm28,%xmm29,%xmm30{%k7}");
+        asm volatile("vrsqrt28sd %xmm25,%xmm26,%xmm27{%k7}");
+
+        /* AVX-512: Op code 0f 3a 03 */
+
+        asm volatile("valignd $0x12,%zmm28,%zmm29,%zmm30");
+        asm volatile("valignq $0x12,%zmm25,%zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 3a 08 */
+
+        asm volatile("vroundps $0x5,%ymm6,%ymm2");
+        asm volatile("vrndscaleps $0x12,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 3a 09 */
+
+        asm volatile("vroundpd $0x5,%ymm6,%ymm2");
+        asm volatile("vrndscalepd $0x12,%zmm25,%zmm26");
+
+        /* AVX-512: Op code 0f 3a 1a */
+
+        asm volatile("vroundss $0x5,%xmm4,%xmm6,%xmm2");
+        asm volatile("vrndscaless $0x12,%xmm24,%xmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 0b */
+
+        asm volatile("vroundsd $0x5,%xmm4,%xmm6,%xmm2");
+        asm volatile("vrndscalesd $0x12,%xmm24,%xmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 18 */
+
+        asm volatile("vinsertf128 $0x5,%xmm4,%ymm4,%ymm6");
+        asm volatile("vinsertf32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
+        asm volatile("vinsertf64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 19 */
+
+        asm volatile("vextractf128 $0x5,%ymm4,%xmm4");
+        asm volatile("vextractf32x4 $0x12,%zmm25,%xmm26{%k7}");
+        asm volatile("vextractf64x2 $0x12,%zmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1a */
+
+        asm volatile("vinsertf32x8 $0x12,%ymm25,%zmm26,%zmm27{%k7}");
+        asm volatile("vinsertf64x4 $0x12,%ymm28,%zmm29,%zmm30{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1b */
+
+        asm volatile("vextractf32x8 $0x12,%zmm29,%ymm30{%k7}");
+        asm volatile("vextractf64x4 $0x12,%zmm26,%ymm27{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1e */
+
+        asm volatile("vpcmpud $0x12,%zmm29,%zmm30,%k5");
+        asm volatile("vpcmpuq $0x12,%zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 3a 1f */
+
+        asm volatile("vpcmpd $0x12,%zmm29,%zmm30,%k5");
+        asm volatile("vpcmpq $0x12,%zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 3a 23 */
+
+        asm volatile("vshuff32x4 $0x12,%zmm28,%zmm29,%zmm30");
+        asm volatile("vshuff64x2 $0x12,%zmm25,%zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 3a 25 */
+
+        asm volatile("vpternlogd $0x12,%zmm28,%zmm29,%zmm30");
+        asm volatile("vpternlogq $0x12,%zmm28,%zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 3a 26 */
+
+        asm volatile("vgetmantps $0x12,%zmm26,%zmm27");
+        asm volatile("vgetmantpd $0x12,%zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 3a 27 */
+
+        asm volatile("vgetmantss $0x12,%xmm25,%xmm26,%xmm27{%k7}");
+        asm volatile("vgetmantsd $0x12,%xmm28,%xmm29,%xmm30{%k7}");
+
+        /* AVX-512: Op code 0f 3a 38 */
+
+        asm volatile("vinserti128 $0x5,%xmm4,%ymm4,%ymm6");
+        asm volatile("vinserti32x4 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
+        asm volatile("vinserti64x2 $0x12,%xmm24,%zmm25,%zmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 39 */
+
+        asm volatile("vextracti128 $0x5,%ymm4,%xmm6");
+        asm volatile("vextracti32x4 $0x12,%zmm25,%xmm26{%k7}");
+        asm volatile("vextracti64x2 $0x12,%zmm25,%xmm26{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3a */
+
+        asm volatile("vinserti32x8 $0x12,%ymm28,%zmm29,%zmm30{%k7}");
+        asm volatile("vinserti64x4 $0x12,%ymm25,%zmm26,%zmm27{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3b */
+
+        asm volatile("vextracti32x8 $0x12,%zmm29,%ymm30{%k7}");
+        asm volatile("vextracti64x4 $0x12,%zmm26,%ymm27{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3e */
+
+        asm volatile("vpcmpub $0x12,%zmm29,%zmm30,%k5");
+        asm volatile("vpcmpuw $0x12,%zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 3a 3f */
+
+        asm volatile("vpcmpb $0x12,%zmm29,%zmm30,%k5");
+        asm volatile("vpcmpw $0x12,%zmm26,%zmm27,%k5");
+
+        /* AVX-512: Op code 0f 3a 43 */
+
+        asm volatile("vmpsadbw $0x5,%ymm4,%ymm6,%ymm2");
+        asm volatile("vdbpsadbw $0x12,%zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 3a 43 */
+
+        asm volatile("vshufi32x4 $0x12,%zmm25,%zmm26,%zmm27");
+        asm volatile("vshufi64x2 $0x12,%zmm28,%zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 3a 50 */
+
+        asm volatile("vrangeps $0x12,%zmm25,%zmm26,%zmm27");
+        asm volatile("vrangepd $0x12,%zmm28,%zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 3a 51 */
+
+        asm volatile("vrangess $0x12,%xmm25,%xmm26,%xmm27");
+        asm volatile("vrangesd $0x12,%xmm28,%xmm29,%xmm30");
+
+        /* AVX-512: Op code 0f 3a 54 */
+
+        asm volatile("vfixupimmps $0x12,%zmm28,%zmm29,%zmm30");
+        asm volatile("vfixupimmpd $0x12,%zmm25,%zmm26,%zmm27");
+
+        /* AVX-512: Op code 0f 3a 55 */
+
+        asm volatile("vfixupimmss $0x12,%xmm28,%xmm29,%xmm30{%k7}");
+        asm volatile("vfixupimmsd $0x12,%xmm25,%xmm26,%xmm27{%k7}");
+
+        /* AVX-512: Op code 0f 3a 56 */
+
+        asm volatile("vreduceps $0x12,%zmm26,%zmm27");
+        asm volatile("vreducepd $0x12,%zmm29,%zmm30");
+
+        /* AVX-512: Op code 0f 3a 57 */
+
+        asm volatile("vreducess $0x12,%xmm25,%xmm26,%xmm27");
+        asm volatile("vreducesd $0x12,%xmm28,%xmm29,%xmm30");
+
+        /* AVX-512: Op code 0f 3a 66 */
+
+        asm volatile("vfpclassps $0x12,%zmm27,%k5");
+        asm volatile("vfpclasspd $0x12,%zmm30,%k5");
+
+        /* AVX-512: Op code 0f 3a 67 */
+
+        asm volatile("vfpclassss $0x12,%xmm27,%k5");
+        asm volatile("vfpclasssd $0x12,%xmm30,%k5");
+
+        /* AVX-512: Op code 0f 72 (Grp13) */
+
+        asm volatile("vprord $0x12,%zmm25,%zmm26");
+        asm volatile("vprorq $0x12,%zmm25,%zmm26");
+        asm volatile("vprold $0x12,%zmm29,%zmm30");
+        asm volatile("vprolq $0x12,%zmm29,%zmm30");
+        asm volatile("psrad  $0x2,%mm6");
+        asm volatile("vpsrad $0x5,%ymm6,%ymm2");
+        asm volatile("vpsrad $0x5,%zmm26,%zmm22");
+        asm volatile("vpsraq $0x5,%zmm26,%zmm22");
+
+        /* AVX-512: Op code 0f 38 c6 (Grp18) */
+
+        asm volatile("vgatherpf0dps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vgatherpf0dpd 0x7b(%r14,%ymm31,8){%k1}");
+        asm volatile("vgatherpf1dps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vgatherpf1dpd 0x7b(%r14,%ymm31,8){%k1}");
+        asm volatile("vscatterpf0dps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf0dpd 0x7b(%r14,%ymm31,8){%k1}");
+        asm volatile("vscatterpf1dps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf1dpd 0x7b(%r14,%ymm31,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 c7 (Grp19) */
+
+        asm volatile("vgatherpf0qps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vgatherpf0qpd 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vgatherpf1qps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vgatherpf1qpd 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf0qps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf0qpd 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf1qps 0x7b(%r14,%zmm31,8){%k1}");
+        asm volatile("vscatterpf1qpd 0x7b(%r14,%zmm31,8){%k1}");
+
+        /* AVX-512: Examples */
+
+        asm volatile("vaddpd %zmm28,%zmm29,%zmm30");
+        asm volatile("vaddpd %zmm28,%zmm29,%zmm30{%k7}");
+        asm volatile("vaddpd %zmm28,%zmm29,%zmm30{%k7}{z}");
+        asm volatile("vaddpd {rn-sae},%zmm28,%zmm29,%zmm30");
+        asm volatile("vaddpd {ru-sae},%zmm28,%zmm29,%zmm30");
+        asm volatile("vaddpd {rd-sae},%zmm28,%zmm29,%zmm30");
+        asm volatile("vaddpd {rz-sae},%zmm28,%zmm29,%zmm30");
+        asm volatile("vaddpd (%rcx),%zmm29,%zmm30");
+        asm volatile("vaddpd 0x123(%rax,%r14,8),%zmm29,%zmm30");
+        asm volatile("vaddpd (%rcx){1to8},%zmm29,%zmm30");
+        asm volatile("vaddpd 0x1fc0(%rdx),%zmm29,%zmm30");
+        asm volatile("vaddpd 0x3f8(%rdx){1to8},%zmm29,%zmm30");
+        asm volatile("vcmpeq_uqps 0x1fc(%rdx){1to16},%zmm30,%k5");
+        asm volatile("vcmpltsd 0x123(%rax,%r14,8),%xmm29,%k5{%k7}");
+        asm volatile("vcmplesd {sae},%xmm28,%xmm29,%k5{%k7}");
+        asm volatile("vgetmantss $0x5b,0x123(%rax,%r14,8),%xmm29,%xmm30{%k7}");
+
         /* bndmk m64, bnd */
 
         asm volatile("bndmk (%rax), %bnd0");
@@ -471,6 +1345,921 @@ int main(void)
 
 #else  /* #ifdef __x86_64__ */
 
+        /* bound r32, mem (same op code as EVEX prefix) */
+
+        asm volatile("bound %eax, 0x12345678(%ecx)");
+        asm volatile("bound %ecx, 0x12345678(%eax)");
+        asm volatile("bound %edx, 0x12345678(%eax)");
+        asm volatile("bound %ebx, 0x12345678(%eax)");
+        asm volatile("bound %esp, 0x12345678(%eax)");
+        asm volatile("bound %ebp, 0x12345678(%eax)");
+        asm volatile("bound %esi, 0x12345678(%eax)");
+        asm volatile("bound %edi, 0x12345678(%eax)");
+        asm volatile("bound %ecx, (%eax)");
+        asm volatile("bound %eax, (0x12345678)");
+        asm volatile("bound %edx, (%ecx,%eax,1)");
+        asm volatile("bound %edx, 0x12345678(,%eax,1)");
+        asm volatile("bound %edx, (%eax,%ecx,1)");
+        asm volatile("bound %edx, (%eax,%ecx,8)");
+        asm volatile("bound %edx, 0x12(%eax)");
+        asm volatile("bound %edx, 0x12(%ebp)");
+        asm volatile("bound %edx, 0x12(%ecx,%eax,1)");
+        asm volatile("bound %edx, 0x12(%ebp,%eax,1)");
+        asm volatile("bound %edx, 0x12(%eax,%ecx,1)");
+        asm volatile("bound %edx, 0x12(%eax,%ecx,8)");
+        asm volatile("bound %edx, 0x12345678(%eax)");
+        asm volatile("bound %edx, 0x12345678(%ebp)");
+        asm volatile("bound %edx, 0x12345678(%ecx,%eax,1)");
+        asm volatile("bound %edx, 0x12345678(%ebp,%eax,1)");
+        asm volatile("bound %edx, 0x12345678(%eax,%ecx,1)");
+        asm volatile("bound %edx, 0x12345678(%eax,%ecx,8)");
+
+        /* bound r16, mem (same op code as EVEX prefix) */
+
+        asm volatile("bound %ax, 0x12345678(%ecx)");
+        asm volatile("bound %cx, 0x12345678(%eax)");
+        asm volatile("bound %dx, 0x12345678(%eax)");
+        asm volatile("bound %bx, 0x12345678(%eax)");
+        asm volatile("bound %sp, 0x12345678(%eax)");
+        asm volatile("bound %bp, 0x12345678(%eax)");
+        asm volatile("bound %si, 0x12345678(%eax)");
+        asm volatile("bound %di, 0x12345678(%eax)");
+        asm volatile("bound %cx, (%eax)");
+        asm volatile("bound %ax, (0x12345678)");
+        asm volatile("bound %dx, (%ecx,%eax,1)");
+        asm volatile("bound %dx, 0x12345678(,%eax,1)");
+        asm volatile("bound %dx, (%eax,%ecx,1)");
+        asm volatile("bound %dx, (%eax,%ecx,8)");
+        asm volatile("bound %dx, 0x12(%eax)");
+        asm volatile("bound %dx, 0x12(%ebp)");
+        asm volatile("bound %dx, 0x12(%ecx,%eax,1)");
+        asm volatile("bound %dx, 0x12(%ebp,%eax,1)");
+        asm volatile("bound %dx, 0x12(%eax,%ecx,1)");
+        asm volatile("bound %dx, 0x12(%eax,%ecx,8)");
+        asm volatile("bound %dx, 0x12345678(%eax)");
+        asm volatile("bound %dx, 0x12345678(%ebp)");
+        asm volatile("bound %dx, 0x12345678(%ecx,%eax,1)");
+        asm volatile("bound %dx, 0x12345678(%ebp,%eax,1)");
+        asm volatile("bound %dx, 0x12345678(%eax,%ecx,1)");
+        asm volatile("bound %dx, 0x12345678(%eax,%ecx,8)");
+
+        /* AVX-512: Instructions with the same op codes as Mask Instructions  */
+
+        asm volatile("cmovno %eax,%ebx");
+        asm volatile("cmovno 0x12345678(%eax),%ecx");
+        asm volatile("cmovno 0x12345678(%eax),%cx");
+
+        asm volatile("cmove  %eax,%ebx");
+        asm volatile("cmove 0x12345678(%eax),%ecx");
+        asm volatile("cmove 0x12345678(%eax),%cx");
+
+        asm volatile("seto    0x12345678(%eax)");
+        asm volatile("setno   0x12345678(%eax)");
+        asm volatile("setb    0x12345678(%eax)");
+        asm volatile("setc    0x12345678(%eax)");
+        asm volatile("setnae  0x12345678(%eax)");
+        asm volatile("setae   0x12345678(%eax)");
+        asm volatile("setnb   0x12345678(%eax)");
+        asm volatile("setnc   0x12345678(%eax)");
+        asm volatile("sets    0x12345678(%eax)");
+        asm volatile("setns   0x12345678(%eax)");
+
+        /* AVX-512: Mask Instructions */
+
+        asm volatile("kandw  %k7,%k6,%k5");
+        asm volatile("kandq  %k7,%k6,%k5");
+        asm volatile("kandb  %k7,%k6,%k5");
+        asm volatile("kandd  %k7,%k6,%k5");
+
+        asm volatile("kandnw  %k7,%k6,%k5");
+        asm volatile("kandnq  %k7,%k6,%k5");
+        asm volatile("kandnb  %k7,%k6,%k5");
+        asm volatile("kandnd  %k7,%k6,%k5");
+
+        asm volatile("knotw  %k7,%k6");
+        asm volatile("knotq  %k7,%k6");
+        asm volatile("knotb  %k7,%k6");
+        asm volatile("knotd  %k7,%k6");
+
+        asm volatile("korw  %k7,%k6,%k5");
+        asm volatile("korq  %k7,%k6,%k5");
+        asm volatile("korb  %k7,%k6,%k5");
+        asm volatile("kord  %k7,%k6,%k5");
+
+        asm volatile("kxnorw  %k7,%k6,%k5");
+        asm volatile("kxnorq  %k7,%k6,%k5");
+        asm volatile("kxnorb  %k7,%k6,%k5");
+        asm volatile("kxnord  %k7,%k6,%k5");
+
+        asm volatile("kxorw  %k7,%k6,%k5");
+        asm volatile("kxorq  %k7,%k6,%k5");
+        asm volatile("kxorb  %k7,%k6,%k5");
+        asm volatile("kxord  %k7,%k6,%k5");
+
+        asm volatile("kaddw  %k7,%k6,%k5");
+        asm volatile("kaddq  %k7,%k6,%k5");
+        asm volatile("kaddb  %k7,%k6,%k5");
+        asm volatile("kaddd  %k7,%k6,%k5");
+
+        asm volatile("kunpckbw %k7,%k6,%k5");
+        asm volatile("kunpckwd %k7,%k6,%k5");
+        asm volatile("kunpckdq %k7,%k6,%k5");
+
+        asm volatile("kmovw  %k6,%k5");
+        asm volatile("kmovw  (%ecx),%k5");
+        asm volatile("kmovw  0x123(%eax,%ecx,8),%k5");
+        asm volatile("kmovw  %k5,(%ecx)");
+        asm volatile("kmovw  %k5,0x123(%eax,%ecx,8)");
+        asm volatile("kmovw  %eax,%k5");
+        asm volatile("kmovw  %ebp,%k5");
+        asm volatile("kmovw  %k5,%eax");
+        asm volatile("kmovw  %k5,%ebp");
+
+        asm volatile("kmovq  %k6,%k5");
+        asm volatile("kmovq  (%ecx),%k5");
+        asm volatile("kmovq  0x123(%eax,%ecx,8),%k5");
+        asm volatile("kmovq  %k5,(%ecx)");
+        asm volatile("kmovq  %k5,0x123(%eax,%ecx,8)");
+
+        asm volatile("kmovb  %k6,%k5");
+        asm volatile("kmovb  (%ecx),%k5");
+        asm volatile("kmovb  0x123(%eax,%ecx,8),%k5");
+        asm volatile("kmovb  %k5,(%ecx)");
+        asm volatile("kmovb  %k5,0x123(%eax,%ecx,8)");
+        asm volatile("kmovb  %eax,%k5");
+        asm volatile("kmovb  %ebp,%k5");
+        asm volatile("kmovb  %k5,%eax");
+        asm volatile("kmovb  %k5,%ebp");
+
+        asm volatile("kmovd  %k6,%k5");
+        asm volatile("kmovd  (%ecx),%k5");
+        asm volatile("kmovd  0x123(%eax,%ecx,8),%k5");
+        asm volatile("kmovd  %k5,(%ecx)");
+        asm volatile("kmovd  %k5,0x123(%eax,%ecx,8)");
+        asm volatile("kmovd  %eax,%k5");
+        asm volatile("kmovd  %ebp,%k5");
+        asm volatile("kmovd  %k5,%eax");
+        asm volatile("kmovd  %k5,%ebp");
+
+        asm volatile("kortestw %k6,%k5");
+        asm volatile("kortestq %k6,%k5");
+        asm volatile("kortestb %k6,%k5");
+        asm volatile("kortestd %k6,%k5");
+
+        asm volatile("ktestw %k6,%k5");
+        asm volatile("ktestq %k6,%k5");
+        asm volatile("ktestb %k6,%k5");
+        asm volatile("ktestd %k6,%k5");
+
+        asm volatile("kshiftrw $0x12,%k6,%k5");
+        asm volatile("kshiftrq $0x5b,%k6,%k5");
+        asm volatile("kshiftlw $0x12,%k6,%k5");
+        asm volatile("kshiftlq $0x5b,%k6,%k5");
+
+        /* AVX-512: Op code 0f 5b */
+        asm volatile("vcvtdq2ps %xmm5,%xmm6");
+        asm volatile("vcvtqq2ps %zmm5,%ymm6{%k7}");
+        asm volatile("vcvtps2dq %xmm5,%xmm6");
+        asm volatile("vcvttps2dq %xmm5,%xmm6");
+
+        /* AVX-512: Op code 0f 6f */
+
+        asm volatile("movq   %mm0,%mm4");
+        asm volatile("vmovdqa %ymm4,%ymm6");
+        asm volatile("vmovdqa32 %zmm5,%zmm6");
+        asm volatile("vmovdqa64 %zmm5,%zmm6");
+        asm volatile("vmovdqu %ymm4,%ymm6");
+        asm volatile("vmovdqu32 %zmm5,%zmm6");
+        asm volatile("vmovdqu64 %zmm5,%zmm6");
+        asm volatile("vmovdqu8 %zmm5,%zmm6");
+        asm volatile("vmovdqu16 %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 78 */
+
+        asm volatile("vmread %eax,%ebx");
+        asm volatile("vcvttps2udq %zmm5,%zmm6");
+        asm volatile("vcvttpd2udq %zmm5,%ymm6{%k7}");
+        asm volatile("vcvttsd2usi %xmm6,%eax");
+        asm volatile("vcvttss2usi %xmm6,%eax");
+        asm volatile("vcvttps2uqq %ymm5,%zmm6{%k7}");
+        asm volatile("vcvttpd2uqq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 79 */
+
+        asm volatile("vmwrite %eax,%ebx");
+        asm volatile("vcvtps2udq %zmm5,%zmm6");
+        asm volatile("vcvtpd2udq %zmm5,%ymm6{%k7}");
+        asm volatile("vcvtsd2usi %xmm6,%eax");
+        asm volatile("vcvtss2usi %xmm6,%eax");
+        asm volatile("vcvtps2uqq %ymm5,%zmm6{%k7}");
+        asm volatile("vcvtpd2uqq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 7a */
+
+        asm volatile("vcvtudq2pd %ymm5,%zmm6{%k7}");
+        asm volatile("vcvtuqq2pd %zmm5,%zmm6");
+        asm volatile("vcvtudq2ps %zmm5,%zmm6");
+        asm volatile("vcvtuqq2ps %zmm5,%ymm6{%k7}");
+        asm volatile("vcvttps2qq %ymm5,%zmm6{%k7}");
+        asm volatile("vcvttpd2qq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 7b */
+
+        asm volatile("vcvtusi2sd %eax,%xmm5,%xmm6");
+        asm volatile("vcvtusi2ss %eax,%xmm5,%xmm6");
+        asm volatile("vcvtps2qq %ymm5,%zmm6{%k7}");
+        asm volatile("vcvtpd2qq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 7f */
+
+        asm volatile("movq.s  %mm0,%mm4");
+        asm volatile("vmovdqa.s %ymm5,%ymm6");
+        asm volatile("vmovdqa32.s %zmm5,%zmm6");
+        asm volatile("vmovdqa64.s %zmm5,%zmm6");
+        asm volatile("vmovdqu.s %ymm5,%ymm6");
+        asm volatile("vmovdqu32.s %zmm5,%zmm6");
+        asm volatile("vmovdqu64.s %zmm5,%zmm6");
+        asm volatile("vmovdqu8.s %zmm5,%zmm6");
+        asm volatile("vmovdqu16.s %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f db */
+
+        asm volatile("pand  %mm1,%mm2");
+        asm volatile("pand  %xmm1,%xmm2");
+        asm volatile("vpand  %ymm4,%ymm6,%ymm2");
+        asm volatile("vpandd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpandq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f df */
+
+        asm volatile("pandn  %mm1,%mm2");
+        asm volatile("pandn  %xmm1,%xmm2");
+        asm volatile("vpandn %ymm4,%ymm6,%ymm2");
+        asm volatile("vpandnd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpandnq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f e6 */
+
+        asm volatile("vcvttpd2dq %xmm1,%xmm2");
+        asm volatile("vcvtdq2pd %xmm5,%xmm6");
+        asm volatile("vcvtdq2pd %ymm5,%zmm6{%k7}");
+        asm volatile("vcvtqq2pd %zmm5,%zmm6");
+        asm volatile("vcvtpd2dq %xmm1,%xmm2");
+
+        /* AVX-512: Op code 0f eb */
+
+        asm volatile("por   %mm4,%mm6");
+        asm volatile("vpor   %ymm4,%ymm6,%ymm2");
+        asm volatile("vpord  %zmm4,%zmm5,%zmm6");
+        asm volatile("vporq  %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f ef */
+
+        asm volatile("pxor   %mm4,%mm6");
+        asm volatile("vpxor  %ymm4,%ymm6,%ymm2");
+        asm volatile("vpxord %zmm4,%zmm5,%zmm6");
+        asm volatile("vpxorq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 10 */
+
+        asm volatile("pblendvb %xmm1,%xmm0");
+        asm volatile("vpsrlvw %zmm4,%zmm5,%zmm6");
+        asm volatile("vpmovuswb %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 11 */
+
+        asm volatile("vpmovusdb %zmm5,%xmm6{%k7}");
+        asm volatile("vpsravw %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 12 */
+
+        asm volatile("vpmovusqb %zmm5,%xmm6{%k7}");
+        asm volatile("vpsllvw %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 13 */
+
+        asm volatile("vcvtph2ps %xmm3,%ymm5");
+        asm volatile("vcvtph2ps %ymm5,%zmm6{%k7}");
+        asm volatile("vpmovusdw %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 14 */
+
+        asm volatile("blendvps %xmm1,%xmm0");
+        asm volatile("vpmovusqw %zmm5,%xmm6{%k7}");
+        asm volatile("vprorvd %zmm4,%zmm5,%zmm6");
+        asm volatile("vprorvq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 15 */
+
+        asm volatile("blendvpd %xmm1,%xmm0");
+        asm volatile("vpmovusqd %zmm5,%ymm6{%k7}");
+        asm volatile("vprolvd %zmm4,%zmm5,%zmm6");
+        asm volatile("vprolvq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 16 */
+
+        asm volatile("vpermps %ymm4,%ymm6,%ymm2");
+        asm volatile("vpermps %ymm4,%ymm6,%ymm2{%k7}");
+        asm volatile("vpermpd %ymm4,%ymm6,%ymm2{%k7}");
+
+        /* AVX-512: Op code 0f 38 19 */
+
+        asm volatile("vbroadcastsd %xmm4,%ymm6");
+        asm volatile("vbroadcastf32x2 %xmm7,%zmm6");
+
+        /* AVX-512: Op code 0f 38 1a */
+
+        asm volatile("vbroadcastf128 (%ecx),%ymm4");
+        asm volatile("vbroadcastf32x4 (%ecx),%zmm6");
+        asm volatile("vbroadcastf64x2 (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 1b */
+
+        asm volatile("vbroadcastf32x8 (%ecx),%zmm6");
+        asm volatile("vbroadcastf64x4 (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 1f */
+
+        asm volatile("vpabsq %zmm4,%zmm6");
+
+        /* AVX-512: Op code 0f 38 20 */
+
+        asm volatile("vpmovsxbw %xmm4,%xmm5");
+        asm volatile("vpmovswb %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 21 */
+
+        asm volatile("vpmovsxbd %xmm4,%ymm6");
+        asm volatile("vpmovsdb %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 22 */
+
+        asm volatile("vpmovsxbq %xmm4,%ymm4");
+        asm volatile("vpmovsqb %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 23 */
+
+        asm volatile("vpmovsxwd %xmm4,%ymm4");
+        asm volatile("vpmovsdw %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 24 */
+
+        asm volatile("vpmovsxwq %xmm4,%ymm6");
+        asm volatile("vpmovsqw %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 25 */
+
+        asm volatile("vpmovsxdq %xmm4,%ymm4");
+        asm volatile("vpmovsqd %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 26 */
+
+        asm volatile("vptestmb %zmm5,%zmm6,%k5");
+        asm volatile("vptestmw %zmm5,%zmm6,%k5");
+        asm volatile("vptestnmb %zmm4,%zmm5,%k5");
+        asm volatile("vptestnmw %zmm4,%zmm5,%k5");
+
+        /* AVX-512: Op code 0f 38 27 */
+
+        asm volatile("vptestmd %zmm5,%zmm6,%k5");
+        asm volatile("vptestmq %zmm5,%zmm6,%k5");
+        asm volatile("vptestnmd %zmm4,%zmm5,%k5");
+        asm volatile("vptestnmq %zmm4,%zmm5,%k5");
+
+        /* AVX-512: Op code 0f 38 28 */
+
+        asm volatile("vpmuldq %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovm2b %k5,%zmm6");
+        asm volatile("vpmovm2w %k5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 29 */
+
+        asm volatile("vpcmpeqq %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovb2m %zmm6,%k5");
+        asm volatile("vpmovw2m %zmm6,%k5");
+
+        /* AVX-512: Op code 0f 38 2a */
+
+        asm volatile("vmovntdqa (%ecx),%ymm4");
+        asm volatile("vpbroadcastmb2q %k6,%zmm1");
+
+        /* AVX-512: Op code 0f 38 2c */
+
+        asm volatile("vmaskmovps (%ecx),%ymm4,%ymm6");
+        asm volatile("vscalefps %zmm4,%zmm5,%zmm6");
+        asm volatile("vscalefpd %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 2d */
+
+        asm volatile("vmaskmovpd (%ecx),%ymm4,%ymm6");
+        asm volatile("vscalefss %xmm4,%xmm5,%xmm6{%k7}");
+        asm volatile("vscalefsd %xmm4,%xmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 30 */
+
+        asm volatile("vpmovzxbw %xmm4,%ymm4");
+        asm volatile("vpmovwb %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 31 */
+
+        asm volatile("vpmovzxbd %xmm4,%ymm6");
+        asm volatile("vpmovdb %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 32 */
+
+        asm volatile("vpmovzxbq %xmm4,%ymm4");
+        asm volatile("vpmovqb %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 33 */
+
+        asm volatile("vpmovzxwd %xmm4,%ymm4");
+        asm volatile("vpmovdw %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 34 */
+
+        asm volatile("vpmovzxwq %xmm4,%ymm6");
+        asm volatile("vpmovqw %zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 35 */
+
+        asm volatile("vpmovzxdq %xmm4,%ymm4");
+        asm volatile("vpmovqd %zmm5,%ymm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 36 */
+
+        asm volatile("vpermd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpermd %ymm4,%ymm6,%ymm2{%k7}");
+        asm volatile("vpermq %ymm4,%ymm6,%ymm2{%k7}");
+
+        /* AVX-512: Op code 0f 38 38 */
+
+        asm volatile("vpminsb %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmovm2d %k5,%zmm6");
+        asm volatile("vpmovm2q %k5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 39 */
+
+        asm volatile("vpminsd %xmm1,%xmm2,%xmm3");
+        asm volatile("vpminsd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpminsq %zmm4,%zmm5,%zmm6");
+        asm volatile("vpmovd2m %zmm6,%k5");
+        asm volatile("vpmovq2m %zmm6,%k5");
+
+        /* AVX-512: Op code 0f 38 3a */
+
+        asm volatile("vpminuw %ymm4,%ymm6,%ymm2");
+        asm volatile("vpbroadcastmw2d %k6,%zmm6");
+
+        /* AVX-512: Op code 0f 38 3b */
+
+        asm volatile("vpminud %ymm4,%ymm6,%ymm2");
+        asm volatile("vpminud %zmm4,%zmm5,%zmm6");
+        asm volatile("vpminuq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 3d */
+
+        asm volatile("vpmaxsd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmaxsd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpmaxsq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 3f */
+
+        asm volatile("vpmaxud %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmaxud %zmm4,%zmm5,%zmm6");
+        asm volatile("vpmaxuq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 40 */
+
+        asm volatile("vpmulld %ymm4,%ymm6,%ymm2");
+        asm volatile("vpmulld %zmm4,%zmm5,%zmm6");
+        asm volatile("vpmullq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 42 */
+
+        asm volatile("vgetexpps %zmm5,%zmm6");
+        asm volatile("vgetexppd %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 43 */
+
+        asm volatile("vgetexpss %xmm4,%xmm5,%xmm6{%k7}");
+        asm volatile("vgetexpsd %xmm2,%xmm3,%xmm4{%k7}");
+
+        /* AVX-512: Op code 0f 38 44 */
+
+        asm volatile("vplzcntd %zmm5,%zmm6");
+        asm volatile("vplzcntq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 46 */
+
+        asm volatile("vpsravd %ymm4,%ymm6,%ymm2");
+        asm volatile("vpsravd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpsravq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 4c */
+
+        asm volatile("vrcp14ps %zmm5,%zmm6");
+        asm volatile("vrcp14pd %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 4d */
+
+        asm volatile("vrcp14ss %xmm4,%xmm5,%xmm6{%k7}");
+        asm volatile("vrcp14sd %xmm4,%xmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 4e */
+
+        asm volatile("vrsqrt14ps %zmm5,%zmm6");
+        asm volatile("vrsqrt14pd %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 4f */
+
+        asm volatile("vrsqrt14ss %xmm4,%xmm5,%xmm6{%k7}");
+        asm volatile("vrsqrt14sd %xmm4,%xmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 38 59 */
+
+        asm volatile("vpbroadcastq %xmm4,%xmm6");
+        asm volatile("vbroadcasti32x2 %xmm7,%zmm6");
+
+        /* AVX-512: Op code 0f 38 5a */
+
+        asm volatile("vbroadcasti128 (%ecx),%ymm4");
+        asm volatile("vbroadcasti32x4 (%ecx),%zmm6");
+        asm volatile("vbroadcasti64x2 (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 5b */
+
+        asm volatile("vbroadcasti32x8 (%ecx),%zmm6");
+        asm volatile("vbroadcasti64x4 (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 64 */
+
+        asm volatile("vpblendmd %zmm4,%zmm5,%zmm6");
+        asm volatile("vpblendmq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 65 */
+
+        asm volatile("vblendmps %zmm4,%zmm5,%zmm6");
+        asm volatile("vblendmpd %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 66 */
+
+        asm volatile("vpblendmb %zmm4,%zmm5,%zmm6");
+        asm volatile("vpblendmw %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 75 */
+
+        asm volatile("vpermi2b %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermi2w %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 76 */
+
+        asm volatile("vpermi2d %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermi2q %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 77 */
+
+        asm volatile("vpermi2ps %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermi2pd %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 7a */
+
+        asm volatile("vpbroadcastb %eax,%xmm3");
+
+        /* AVX-512: Op code 0f 38 7b */
+
+        asm volatile("vpbroadcastw %eax,%xmm3");
+
+        /* AVX-512: Op code 0f 38 7c */
+
+        asm volatile("vpbroadcastd %eax,%xmm3");
+
+        /* AVX-512: Op code 0f 38 7d */
+
+        asm volatile("vpermt2b %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermt2w %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 7e */
+
+        asm volatile("vpermt2d %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermt2q %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 7f */
+
+        asm volatile("vpermt2ps %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermt2pd %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 83 */
+
+        asm volatile("vpmultishiftqb %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 88 */
+
+        asm volatile("vexpandps (%ecx),%zmm6");
+        asm volatile("vexpandpd (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 89 */
+
+        asm volatile("vpexpandd (%ecx),%zmm6");
+        asm volatile("vpexpandq (%ecx),%zmm6");
+
+        /* AVX-512: Op code 0f 38 8a */
+
+        asm volatile("vcompressps %zmm6,(%ecx)");
+        asm volatile("vcompresspd %zmm6,(%ecx)");
+
+        /* AVX-512: Op code 0f 38 8b */
+
+        asm volatile("vpcompressd %zmm6,(%ecx)");
+        asm volatile("vpcompressq %zmm6,(%ecx)");
+
+        /* AVX-512: Op code 0f 38 8d */
+
+        asm volatile("vpermb %zmm4,%zmm5,%zmm6");
+        asm volatile("vpermw %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 90 */
+
+        asm volatile("vpgatherdd %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherdq %xmm2,0x04(%ebp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherdd 0x7b(%ebp,%zmm7,8),%zmm6{%k1}");
+        asm volatile("vpgatherdq 0x7b(%ebp,%ymm7,8),%zmm6{%k1}");
+
+        /* AVX-512: Op code 0f 38 91 */
+
+        asm volatile("vpgatherqd %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherqq %xmm2,0x02(%ebp,%xmm7,2),%xmm1");
+        asm volatile("vpgatherqd 0x7b(%ebp,%zmm7,8),%ymm6{%k1}");
+        asm volatile("vpgatherqq 0x7b(%ebp,%zmm7,8),%zmm6{%k1}");
+
+        /* AVX-512: Op code 0f 38 a0 */
+
+        asm volatile("vpscatterdd %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vpscatterdq %zmm6,0x7b(%ebp,%ymm7,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a1 */
+
+        asm volatile("vpscatterqd %ymm6,0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vpscatterqq %ymm6,0x7b(%ebp,%ymm7,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a2 */
+
+        asm volatile("vscatterdps %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterdpd %zmm6,0x7b(%ebp,%ymm7,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 a3 */
+
+        asm volatile("vscatterqps %ymm6,0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterqpd %zmm6,0x7b(%ebp,%zmm7,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 b4 */
+
+        asm volatile("vpmadd52luq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 b5 */
+
+        asm volatile("vpmadd52huq %zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 c4 */
+
+        asm volatile("vpconflictd %zmm5,%zmm6");
+        asm volatile("vpconflictq %zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 38 c8 */
+
+        asm volatile("vexp2ps %zmm6,%zmm7");
+        asm volatile("vexp2pd %zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 38 ca */
+
+        asm volatile("vrcp28ps %zmm6,%zmm7");
+        asm volatile("vrcp28pd %zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 38 cb */
+
+        asm volatile("vrcp28ss %xmm5,%xmm6,%xmm7{%k7}");
+        asm volatile("vrcp28sd %xmm5,%xmm6,%xmm7{%k7}");
+
+        /* AVX-512: Op code 0f 38 cc */
+
+        asm volatile("vrsqrt28ps %zmm6,%zmm7");
+        asm volatile("vrsqrt28pd %zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 38 cd */
+
+        asm volatile("vrsqrt28ss %xmm5,%xmm6,%xmm7{%k7}");
+        asm volatile("vrsqrt28sd %xmm5,%xmm6,%xmm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 03 */
+
+        asm volatile("valignd $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("valignq $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 08 */
+
+        asm volatile("vroundps $0x5,%ymm6,%ymm2");
+        asm volatile("vrndscaleps $0x12,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 3a 09 */
+
+        asm volatile("vroundpd $0x5,%ymm6,%ymm2");
+        asm volatile("vrndscalepd $0x12,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 3a 0a */
+
+        asm volatile("vroundss $0x5,%xmm4,%xmm6,%xmm2");
+        asm volatile("vrndscaless $0x12,%xmm4,%xmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 0b */
+
+        asm volatile("vroundsd $0x5,%xmm4,%xmm6,%xmm2");
+        asm volatile("vrndscalesd $0x12,%xmm4,%xmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 18 */
+
+        asm volatile("vinsertf128 $0x5,%xmm4,%ymm4,%ymm6");
+        asm volatile("vinsertf32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
+        asm volatile("vinsertf64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 19 */
+
+        asm volatile("vextractf128 $0x5,%ymm4,%xmm4");
+        asm volatile("vextractf32x4 $0x12,%zmm5,%xmm6{%k7}");
+        asm volatile("vextractf64x2 $0x12,%zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1a */
+
+        asm volatile("vinsertf32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
+        asm volatile("vinsertf64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1b */
+
+        asm volatile("vextractf32x8 $0x12,%zmm6,%ymm7{%k7}");
+        asm volatile("vextractf64x4 $0x12,%zmm6,%ymm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 1e */
+
+        asm volatile("vpcmpud $0x12,%zmm6,%zmm7,%k5");
+        asm volatile("vpcmpuq $0x12,%zmm6,%zmm7,%k5");
+
+        /* AVX-512: Op code 0f 3a 1f */
+
+        asm volatile("vpcmpd $0x12,%zmm6,%zmm7,%k5");
+        asm volatile("vpcmpq $0x12,%zmm6,%zmm7,%k5");
+
+        /* AVX-512: Op code 0f 3a 23 */
+
+        asm volatile("vshuff32x4 $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("vshuff64x2 $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 25 */
+
+        asm volatile("vpternlogd $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("vpternlogq $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 26 */
+
+        asm volatile("vgetmantps $0x12,%zmm6,%zmm7");
+        asm volatile("vgetmantpd $0x12,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 27 */
+
+        asm volatile("vgetmantss $0x12,%xmm5,%xmm6,%xmm7{%k7}");
+        asm volatile("vgetmantsd $0x12,%xmm5,%xmm6,%xmm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 38 */
+
+        asm volatile("vinserti128 $0x5,%xmm4,%ymm4,%ymm6");
+        asm volatile("vinserti32x4 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
+        asm volatile("vinserti64x2 $0x12,%xmm4,%zmm5,%zmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 39 */
+
+        asm volatile("vextracti128 $0x5,%ymm4,%xmm6");
+        asm volatile("vextracti32x4 $0x12,%zmm5,%xmm6{%k7}");
+        asm volatile("vextracti64x2 $0x12,%zmm5,%xmm6{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3a */
+
+        asm volatile("vinserti32x8 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
+        asm volatile("vinserti64x4 $0x12,%ymm5,%zmm6,%zmm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3b */
+
+        asm volatile("vextracti32x8 $0x12,%zmm6,%ymm7{%k7}");
+        asm volatile("vextracti64x4 $0x12,%zmm6,%ymm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 3e */
+
+        asm volatile("vpcmpub $0x12,%zmm6,%zmm7,%k5");
+        asm volatile("vpcmpuw $0x12,%zmm6,%zmm7,%k5");
+
+        /* AVX-512: Op code 0f 3a 3f */
+
+        asm volatile("vpcmpb $0x12,%zmm6,%zmm7,%k5");
+        asm volatile("vpcmpw $0x12,%zmm6,%zmm7,%k5");
+
+        /* AVX-512: Op code 0f 3a 42 */
+
+        asm volatile("vmpsadbw $0x5,%ymm4,%ymm6,%ymm2");
+        asm volatile("vdbpsadbw $0x12,%zmm4,%zmm5,%zmm6");
+
+        /* AVX-512: Op code 0f 3a 43 */
+
+        asm volatile("vshufi32x4 $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("vshufi64x2 $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 50 */
+
+        asm volatile("vrangeps $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("vrangepd $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 51 */
+
+        asm volatile("vrangess $0x12,%xmm5,%xmm6,%xmm7");
+        asm volatile("vrangesd $0x12,%xmm5,%xmm6,%xmm7");
+
+        /* AVX-512: Op code 0f 3a 54 */
+
+        asm volatile("vfixupimmps $0x12,%zmm5,%zmm6,%zmm7");
+        asm volatile("vfixupimmpd $0x12,%zmm5,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 55 */
+
+        asm volatile("vfixupimmss $0x12,%xmm5,%xmm6,%xmm7{%k7}");
+        asm volatile("vfixupimmsd $0x12,%xmm5,%xmm6,%xmm7{%k7}");
+
+        /* AVX-512: Op code 0f 3a 56 */
+
+        asm volatile("vreduceps $0x12,%zmm6,%zmm7");
+        asm volatile("vreducepd $0x12,%zmm6,%zmm7");
+
+        /* AVX-512: Op code 0f 3a 57 */
+
+        asm volatile("vreducess $0x12,%xmm5,%xmm6,%xmm7");
+        asm volatile("vreducesd $0x12,%xmm5,%xmm6,%xmm7");
+
+        /* AVX-512: Op code 0f 3a 66 */
+
+        asm volatile("vfpclassps $0x12,%zmm7,%k5");
+        asm volatile("vfpclasspd $0x12,%zmm7,%k5");
+
+        /* AVX-512: Op code 0f 3a 67 */
+
+        asm volatile("vfpclassss $0x12,%xmm7,%k5");
+        asm volatile("vfpclasssd $0x12,%xmm7,%k5");
+
+        /* AVX-512: Op code 0f 72 (Grp13) */
+
+        asm volatile("vprord $0x12,%zmm5,%zmm6");
+        asm volatile("vprorq $0x12,%zmm5,%zmm6");
+        asm volatile("vprold $0x12,%zmm5,%zmm6");
+        asm volatile("vprolq $0x12,%zmm5,%zmm6");
+        asm volatile("psrad  $0x2,%mm6");
+        asm volatile("vpsrad $0x5,%ymm6,%ymm2");
+        asm volatile("vpsrad $0x5,%zmm6,%zmm2");
+        asm volatile("vpsraq $0x5,%zmm6,%zmm2");
+
+        /* AVX-512: Op code 0f 38 c6 (Grp18) */
+
+        asm volatile("vgatherpf0dps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vgatherpf0dpd 0x7b(%ebp,%ymm7,8){%k1}");
+        asm volatile("vgatherpf1dps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vgatherpf1dpd 0x7b(%ebp,%ymm7,8){%k1}");
+        asm volatile("vscatterpf0dps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf0dpd 0x7b(%ebp,%ymm7,8){%k1}");
+        asm volatile("vscatterpf1dps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf1dpd 0x7b(%ebp,%ymm7,8){%k1}");
+
+        /* AVX-512: Op code 0f 38 c7 (Grp19) */
+
+        asm volatile("vgatherpf0qps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vgatherpf0qpd 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vgatherpf1qps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vgatherpf1qpd 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf0qps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf0qpd 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf1qps 0x7b(%ebp,%zmm7,8){%k1}");
+        asm volatile("vscatterpf1qpd 0x7b(%ebp,%zmm7,8){%k1}");
+
+        /* AVX-512: Examples */
+
+        asm volatile("vaddpd %zmm4,%zmm5,%zmm6");
+        asm volatile("vaddpd %zmm4,%zmm5,%zmm6{%k7}");
+        asm volatile("vaddpd %zmm4,%zmm5,%zmm6{%k7}{z}");
+        asm volatile("vaddpd {rn-sae},%zmm4,%zmm5,%zmm6");
+        asm volatile("vaddpd {ru-sae},%zmm4,%zmm5,%zmm6");
+        asm volatile("vaddpd {rd-sae},%zmm4,%zmm5,%zmm6");
+        asm volatile("vaddpd {rz-sae},%zmm4,%zmm5,%zmm6");
+        asm volatile("vaddpd (%ecx),%zmm5,%zmm6");
+        asm volatile("vaddpd 0x123(%eax,%ecx,8),%zmm5,%zmm6");
+        asm volatile("vaddpd (%ecx){1to8},%zmm5,%zmm6");
+        asm volatile("vaddpd 0x1fc0(%edx),%zmm5,%zmm6");
+        asm volatile("vaddpd 0x3f8(%edx){1to8},%zmm5,%zmm6");
+        asm volatile("vcmpeq_uqps 0x1fc(%edx){1to16},%zmm6,%k5");
+        asm volatile("vcmpltsd 0x123(%eax,%ecx,8),%xmm3,%k5{%k7}");
+        asm volatile("vcmplesd {sae},%xmm4,%xmm5,%k5{%k7}");
+        asm volatile("vgetmantss $0x5b,0x123(%eax,%ecx,8),%xmm4,%xmm5{%k7}");
+
         /* bndmk m32, bnd */
 
         asm volatile("bndmk (%eax), %bnd0");
@@ -866,10 +2655,6 @@ int main(void)
 
 #endif /* #ifndef __x86_64__ */
 
-        /* pcommit */
-
-        asm volatile("pcommit");
-
         /* Following line is a marker for the awk script - do not change */
         asm volatile("rdtsc"); /* Stop here */
 
diff --git a/tools/perf/arch/x86/tests/perf-time-to-tsc.c b/tools/perf/arch/x86/tests/perf-time-to-tsc.c
index d4aa567a29c4..5c76cc83186a 100644
--- a/tools/perf/arch/x86/tests/perf-time-to-tsc.c
+++ b/tools/perf/arch/x86/tests/perf-time-to-tsc.c
@@ -154,10 +154,6 @@ next_event:
         err = 0;
 
 out_err:
-        if (evlist) {
-                perf_evlist__disable(evlist);
-                perf_evlist__delete(evlist);
-        }
-
+        perf_evlist__delete(evlist);
         return err;
 }
diff --git a/tools/perf/arch/x86/tests/rdpmc.c b/tools/perf/arch/x86/tests/rdpmc.c
index 72193f19d6d7..500cf96db979 100644
--- a/tools/perf/arch/x86/tests/rdpmc.c
+++ b/tools/perf/arch/x86/tests/rdpmc.c
@@ -1,12 +1,16 @@
+#include <errno.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 #include <linux/types.h>
 #include "perf.h"
 #include "debug.h"
 #include "tests/tests.h"
 #include "cloexec.h"
+#include "util.h"
 #include "arch-tests.h"
 
 static u64 rdpmc(unsigned int counter)
@@ -111,14 +115,14 @@ static int __test__rdpmc(void)
         if (fd < 0) {
                 pr_err("Error: sys_perf_event_open() syscall returned "
                        "with %d (%s)\n", fd,
-                       strerror_r(errno, sbuf, sizeof(sbuf)));
+                       str_error_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
 
         addr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, fd, 0);
         if (addr == (void *)(-1)) {
                 pr_err("Error: mmap() syscall returned with (%s)\n",
-                       strerror_r(errno, sbuf, sizeof(sbuf)));
+                       str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_close;
         }
 
diff --git a/tools/perf/arch/x86/util/Build b/tools/perf/arch/x86/util/Build
index 465970370f3e..f95e6f46ef0d 100644
--- a/tools/perf/arch/x86/util/Build
+++ b/tools/perf/arch/x86/util/Build
@@ -3,11 +3,12 @@ libperf-y += tsc.o
 libperf-y += pmu.o
 libperf-y += kvm-stat.o
 libperf-y += perf_regs.o
+libperf-y += group.o
 
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
 libperf-$(CONFIG_BPF_PROLOGUE) += dwarf-regs.o
 
-libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LOCAL_LIBUNWIND)    += unwind-libunwind.o
 libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
 
 libperf-$(CONFIG_AUXTRACE) += auxtrace.o
diff --git a/tools/perf/arch/x86/util/auxtrace.c b/tools/perf/arch/x86/util/auxtrace.c
index 7a7805583e3f..cc1d865e31f1 100644
--- a/tools/perf/arch/x86/util/auxtrace.c
+++ b/tools/perf/arch/x86/util/auxtrace.c
@@ -37,7 +37,7 @@ struct auxtrace_record *auxtrace_record__init_intel(struct perf_evlist *evlist,
         intel_bts_pmu = perf_pmu__find(INTEL_BTS_PMU_NAME);
 
         if (evlist) {
-                evlist__for_each(evlist, evsel) {
+                evlist__for_each_entry(evlist, evsel) {
                         if (intel_pt_pmu &&
                             evsel->attr.type == intel_pt_pmu->type)
                                 found_pt = true;
diff --git a/tools/perf/arch/x86/util/group.c b/tools/perf/arch/x86/util/group.c
new file mode 100644
index 000000000000..37f92aa39a5d
--- /dev/null
+++ b/tools/perf/arch/x86/util/group.c
@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include "api/fs/fs.h"
+#include "util/group.h"
+
+/*
+ * Check whether we can use a group for top down.
+ * Without a group may get bad results due to multiplexing.
+ */
+bool arch_topdown_check_group(bool *warn)
+{
+        int n;
+
+        if (sysctl__read_int("kernel/nmi_watchdog", &n) < 0)
+                return false;
+        if (n > 0) {
+                *warn = true;
+                return false;
+        }
+        return true;
+}
+
+void arch_topdown_group_warn(void)
+{
+        fprintf(stderr,
+                "nmi_watchdog enabled with topdown. May give wrong results.\n"
+                "Disable with echo 0 > /proc/sys/kernel/nmi_watchdog\n");
+}
diff --git a/tools/perf/arch/x86/util/header.c b/tools/perf/arch/x86/util/header.c
index 146d12a1cec0..a74a48db26f5 100644
--- a/tools/perf/arch/x86/util/header.c
+++ b/tools/perf/arch/x86/util/header.c
@@ -19,8 +19,8 @@ cpuid(unsigned int op, unsigned int *a, unsigned int *b, unsigned int *c,
                         : "a" (op));
 }
 
-int
-get_cpuid(char *buffer, size_t sz)
+static int
+__get_cpuid(char *buffer, size_t sz, const char *fmt)
 {
         unsigned int a, b, c, d, lvl;
         int family = -1, model = -1, step = -1;
@@ -48,7 +48,7 @@ get_cpuid(char *buffer, size_t sz)
                 if (family >= 0x6)
                         model += ((a >> 16) & 0xf) << 4;
         }
-        nb = scnprintf(buffer, sz, "%s,%u,%u,%u$", vendor, family, model, step);
+        nb = scnprintf(buffer, sz, fmt, vendor, family, model, step);
 
         /* look for end marker to ensure the entire data fit */
         if (strchr(buffer, '$')) {
@@ -57,3 +57,21 @@ get_cpuid(char *buffer, size_t sz)
         }
         return -1;
 }
+
+int
+get_cpuid(char *buffer, size_t sz)
+{
+        return __get_cpuid(buffer, sz, "%s,%u,%u,%u$");
+}
+
+char *
+get_cpuid_str(void)
+{
+        char *buf = malloc(128);
+
+        if (__get_cpuid(buf, 128, "%s-%u-%X$") < 0) {
+                free(buf);
+                return NULL;
+        }
+        return buf;
+}
diff --git a/tools/perf/arch/x86/util/intel-bts.c b/tools/perf/arch/x86/util/intel-bts.c
index 7dc30637cf66..5132775a044f 100644
--- a/tools/perf/arch/x86/util/intel-bts.c
+++ b/tools/perf/arch/x86/util/intel-bts.c
@@ -124,7 +124,7 @@ static int intel_bts_recording_options(struct auxtrace_record *itr,
         btsr->evlist = evlist;
         btsr->snapshot_mode = opts->auxtrace_snapshot_mode;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type == intel_bts_pmu->type) {
                         if (intel_bts_evsel) {
                                 pr_err("There may be only one " INTEL_BTS_PMU_NAME " event\n");
@@ -327,7 +327,7 @@ static int intel_bts_snapshot_start(struct auxtrace_record *itr)
                         container_of(itr, struct intel_bts_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(btsr->evlist, evsel) {
+        evlist__for_each_entry(btsr->evlist, evsel) {
                 if (evsel->attr.type == btsr->intel_bts_pmu->type)
                         return perf_evsel__disable(evsel);
         }
@@ -340,7 +340,7 @@ static int intel_bts_snapshot_finish(struct auxtrace_record *itr)
                         container_of(itr, struct intel_bts_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(btsr->evlist, evsel) {
+        evlist__for_each_entry(btsr->evlist, evsel) {
                 if (evsel->attr.type == btsr->intel_bts_pmu->type)
                         return perf_evsel__enable(evsel);
         }
@@ -422,7 +422,7 @@ static int intel_bts_read_finish(struct auxtrace_record *itr, int idx)
                         container_of(itr, struct intel_bts_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(btsr->evlist, evsel) {
+        evlist__for_each_entry(btsr->evlist, evsel) {
                 if (evsel->attr.type == btsr->intel_bts_pmu->type)
                         return perf_evlist__enable_event_idx(btsr->evlist,
                                                              evsel, idx);
diff --git a/tools/perf/arch/x86/util/intel-pt.c b/tools/perf/arch/x86/util/intel-pt.c
index a07b9605e93b..90fa2286edcf 100644
--- a/tools/perf/arch/x86/util/intel-pt.c
+++ b/tools/perf/arch/x86/util/intel-pt.c
@@ -62,6 +62,7 @@ struct intel_pt_recording {
         size_t                          snapshot_ref_buf_size;
         int                             snapshot_ref_cnt;
         struct intel_pt_snapshot_ref    *snapshot_refs;
+        size_t                          priv_size;
 };
 
 static int intel_pt_parse_terms_with_default(struct list_head *formats,
@@ -131,7 +132,7 @@ static int intel_pt_read_config(struct perf_pmu *intel_pt_pmu, const char *str,
         if (!mask)
                 return -EINVAL;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type == intel_pt_pmu->type) {
                         *res = intel_pt_masked_bits(mask, evsel->attr.config);
                         return 0;
@@ -273,11 +274,37 @@ intel_pt_pmu_default_config(struct perf_pmu *intel_pt_pmu)
         return attr;
 }
 
+static const char *intel_pt_find_filter(struct perf_evlist *evlist,
+                                        struct perf_pmu *intel_pt_pmu)
+{
+        struct perf_evsel *evsel;
+
+        evlist__for_each_entry(evlist, evsel) {
+                if (evsel->attr.type == intel_pt_pmu->type)
+                        return evsel->filter;
+        }
+
+        return NULL;
+}
+
+static size_t intel_pt_filter_bytes(const char *filter)
+{
+        size_t len = filter ? strlen(filter) : 0;
+
+        return len ? roundup(len + 1, 8) : 0;
+}
+
 static size_t
-intel_pt_info_priv_size(struct auxtrace_record *itr __maybe_unused,
-                        struct perf_evlist *evlist __maybe_unused)
+intel_pt_info_priv_size(struct auxtrace_record *itr, struct perf_evlist *evlist)
 {
-        return INTEL_PT_AUXTRACE_PRIV_SIZE;
+        struct intel_pt_recording *ptr =
+                        container_of(itr, struct intel_pt_recording, itr);
+        const char *filter = intel_pt_find_filter(evlist, ptr->intel_pt_pmu);
+
+        ptr->priv_size = (INTEL_PT_AUXTRACE_PRIV_MAX * sizeof(u64)) +
+                         intel_pt_filter_bytes(filter);
+
+        return ptr->priv_size;
 }
 
 static void intel_pt_tsc_ctc_ratio(u32 *n, u32 *d)
@@ -302,9 +329,13 @@ static int intel_pt_info_fill(struct auxtrace_record *itr,
         bool cap_user_time_zero = false, per_cpu_mmaps;
         u64 tsc_bit, mtc_bit, mtc_freq_bits, cyc_bit, noretcomp_bit;
         u32 tsc_ctc_ratio_n, tsc_ctc_ratio_d;
+        unsigned long max_non_turbo_ratio;
+        size_t filter_str_len;
+        const char *filter;
+        u64 *info;
         int err;
 
-        if (priv_size != INTEL_PT_AUXTRACE_PRIV_SIZE)
+        if (priv_size != ptr->priv_size)
                 return -EINVAL;
 
         intel_pt_parse_terms(&intel_pt_pmu->format, "tsc", &tsc_bit);
@@ -317,6 +348,13 @@ static int intel_pt_info_fill(struct auxtrace_record *itr,
 
         intel_pt_tsc_ctc_ratio(&tsc_ctc_ratio_n, &tsc_ctc_ratio_d);
 
+        if (perf_pmu__scan_file(intel_pt_pmu, "max_nonturbo_ratio",
+                                "%lu", &max_non_turbo_ratio) != 1)
+                max_non_turbo_ratio = 0;
+
+        filter = intel_pt_find_filter(session->evlist, ptr->intel_pt_pmu);
+        filter_str_len = filter ? strlen(filter) : 0;
+
         if (!session->evlist->nr_mmaps)
                 return -EINVAL;
 
@@ -351,6 +389,17 @@ static int intel_pt_info_fill(struct auxtrace_record *itr,
         auxtrace_info->priv[INTEL_PT_TSC_CTC_N] = tsc_ctc_ratio_n;
         auxtrace_info->priv[INTEL_PT_TSC_CTC_D] = tsc_ctc_ratio_d;
         auxtrace_info->priv[INTEL_PT_CYC_BIT] = cyc_bit;
+        auxtrace_info->priv[INTEL_PT_MAX_NONTURBO_RATIO] = max_non_turbo_ratio;
+        auxtrace_info->priv[INTEL_PT_FILTER_STR_LEN] = filter_str_len;
+
+        info = &auxtrace_info->priv[INTEL_PT_FILTER_STR_LEN] + 1;
+
+        if (filter_str_len) {
+                size_t len = intel_pt_filter_bytes(filter);
+
+                strncpy((char *)info, filter, len);
+                info += len >> 3;
+        }
 
         return 0;
 }
@@ -501,7 +550,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr,
         struct intel_pt_recording *ptr =
                         container_of(itr, struct intel_pt_recording, itr);
         struct perf_pmu *intel_pt_pmu = ptr->intel_pt_pmu;
-        bool have_timing_info;
+        bool have_timing_info, need_immediate = false;
         struct perf_evsel *evsel, *intel_pt_evsel = NULL;
         const struct cpu_map *cpus = evlist->cpus;
         bool privileged = geteuid() == 0 || perf_event_paranoid() < 0;
@@ -511,7 +560,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr,
         ptr->evlist = evlist;
         ptr->snapshot_mode = opts->auxtrace_snapshot_mode;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type == intel_pt_pmu->type) {
                         if (intel_pt_evsel) {
                                 pr_err("There may be only one " INTEL_PT_PMU_NAME " event\n");
@@ -655,6 +704,7 @@ static int intel_pt_recording_options(struct auxtrace_record *itr,
                                 ptr->have_sched_switch = 3;
                         } else {
                                 opts->record_switch_events = true;
+                                need_immediate = true;
                                 if (cpu_wide)
                                         ptr->have_sched_switch = 3;
                                 else
@@ -700,6 +750,9 @@ static int intel_pt_recording_options(struct auxtrace_record *itr,
                 tracking_evsel->attr.freq = 0;
                 tracking_evsel->attr.sample_period = 1;
 
+                if (need_immediate)
+                        tracking_evsel->immediate = true;
+
                 /* In per-cpu case, always need the time of mmap events etc */
                 if (!cpu_map__empty(cpus)) {
                         perf_evsel__set_sample_bit(tracking_evsel, TIME);
@@ -725,7 +778,7 @@ static int intel_pt_snapshot_start(struct auxtrace_record *itr)
                         container_of(itr, struct intel_pt_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(ptr->evlist, evsel) {
+        evlist__for_each_entry(ptr->evlist, evsel) {
                 if (evsel->attr.type == ptr->intel_pt_pmu->type)
                         return perf_evsel__disable(evsel);
         }
@@ -738,7 +791,7 @@ static int intel_pt_snapshot_finish(struct auxtrace_record *itr)
                         container_of(itr, struct intel_pt_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(ptr->evlist, evsel) {
+        evlist__for_each_entry(ptr->evlist, evsel) {
                 if (evsel->attr.type == ptr->intel_pt_pmu->type)
                         return perf_evsel__enable(evsel);
         }
@@ -1011,7 +1064,7 @@ static int intel_pt_read_finish(struct auxtrace_record *itr, int idx)
                         container_of(itr, struct intel_pt_recording, itr);
         struct perf_evsel *evsel;
 
-        evlist__for_each(ptr->evlist, evsel) {
+        evlist__for_each_entry(ptr->evlist, evsel) {
                 if (evsel->attr.type == ptr->intel_pt_pmu->type)
                         return perf_evlist__enable_event_idx(ptr->evlist, evsel,
                                                              idx);
diff --git a/tools/perf/arch/x86/util/tsc.c b/tools/perf/arch/x86/util/tsc.c
index 357f1b13b5ae..2e5567c94e09 100644
--- a/tools/perf/arch/x86/util/tsc.c
+++ b/tools/perf/arch/x86/util/tsc.c
@@ -62,6 +62,8 @@ int perf_event__synth_time_conv(const struct perf_event_mmap_page *pc,
         struct perf_tsc_conversion tc;
         int err;
 
+        if (!pc)
+                return 0;
         err = perf_read_tsc_conversion(pc, &tc);
         if (err == -EOPNOTSUPP)
                 return 0;
diff --git a/tools/perf/arch/x86/util/unwind-libunwind.c b/tools/perf/arch/x86/util/unwind-libunwind.c
index db25e93d989c..4f16661cbdbb 100644
--- a/tools/perf/arch/x86/util/unwind-libunwind.c
+++ b/tools/perf/arch/x86/util/unwind-libunwind.c
@@ -1,12 +1,14 @@
 
+#ifndef REMOTE_UNWIND_LIBUNWIND
 #include <errno.h>
 #include <libunwind.h>
 #include "perf_regs.h"
 #include "../../util/unwind.h"
 #include "../../util/debug.h"
+#endif
 
 #ifdef HAVE_ARCH_X86_64_SUPPORT
-int libunwind__arch_reg_id(int regnum)
+int LIBUNWIND__ARCH_REG_ID(int regnum)
 {
         int id;
 
@@ -70,7 +72,7 @@ int libunwind__arch_reg_id(int regnum)
         return id;
 }
 #else
-int libunwind__arch_reg_id(int regnum)
+int LIBUNWIND__ARCH_REG_ID(int regnum)
 {
         int id;
 
diff --git a/tools/perf/arch/xtensa/include/dwarf-regs-table.h b/tools/perf/arch/xtensa/include/dwarf-regs-table.h
new file mode 100644
index 000000000000..aa0444a33fe6
--- /dev/null
+++ b/tools/perf/arch/xtensa/include/dwarf-regs-table.h
@@ -0,0 +1,8 @@
+#ifdef DEFINE_DWARF_REGSTR_TABLE
+/* This is included in perf/util/dwarf-regs.c */
+
+static const char * const xtensa_regstr_tbl[] = {
+        "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7",
+        "a8", "a9", "a10", "a11", "a12", "a13", "a14", "a15",
+};
+#endif
diff --git a/tools/perf/bench/futex-hash.c b/tools/perf/bench/futex-hash.c
index 0999ac536d86..8024cd5febd2 100644
--- a/tools/perf/bench/futex-hash.c
+++ b/tools/perf/bench/futex-hash.c
@@ -8,18 +8,23 @@
  * many threads and futexes as possible.
  */
 
-#include "../perf.h"
-#include "../util/util.h"
+/* For the CLR_() macros */
+#include <pthread.h>
+
+#include <errno.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <sys/time.h>
+
 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
-#include "../util/header.h"
 #include "bench.h"
 #include "futex.h"
 
 #include <err.h>
-#include <stdlib.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 10;
diff --git a/tools/perf/bench/futex-lock-pi.c b/tools/perf/bench/futex-lock-pi.c
index 6952db65508a..936d89d30483 100644
--- a/tools/perf/bench/futex-lock-pi.c
+++ b/tools/perf/bench/futex-lock-pi.c
@@ -2,18 +2,21 @@
  * Copyright (C) 2015 Davidlohr Bueso.
  */
 
-#include "../perf.h"
-#include "../util/util.h"
+/* For the CLR_() macros */
+#include <pthread.h>
+
+#include <signal.h>
 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
-#include "../util/header.h"
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <errno.h>
 #include "bench.h"
 #include "futex.h"
 
 #include <err.h>
 #include <stdlib.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 struct worker {
         int tid;
diff --git a/tools/perf/bench/futex-requeue.c b/tools/perf/bench/futex-requeue.c
index 718238683013..2b9705a8734c 100644
--- a/tools/perf/bench/futex-requeue.c
+++ b/tools/perf/bench/futex-requeue.c
@@ -8,18 +8,22 @@
  * requeues without waking up any tasks -- thus mimicking a regular futex_wait.
  */
 
-#include "../perf.h"
-#include "../util/util.h"
+/* For the CLR_() macros */
+#include <pthread.h>
+
+#include <signal.h>
 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
-#include "../util/header.h"
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <linux/time64.h>
+#include <errno.h>
 #include "bench.h"
 #include "futex.h"
 
 #include <err.h>
 #include <stdlib.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 static u_int32_t futex1 = 0, futex2 = 0;
 
@@ -59,7 +63,7 @@ static void print_summary(void)
         printf("Requeued %d of %d threads in %.4f ms (+-%.2f%%)\n",
                requeued_avg,
                nthreads,
-               requeuetime_avg/1e3,
+               requeuetime_avg / USEC_PER_MSEC,
                rel_stddev_stats(requeuetime_stddev, requeuetime_avg));
 }
 
@@ -181,7 +185,7 @@ int bench_futex_requeue(int argc, const char **argv,
 
                 if (!silent) {
                         printf("[Run %d]: Requeued %d of %d threads in %.4f ms\n",
-                               j + 1, nrequeued, nthreads, runtime.tv_usec/1e3);
+                               j + 1, nrequeued, nthreads, runtime.tv_usec / (double)USEC_PER_MSEC);
                 }
 
                 /* everybody should be blocked on futex2, wake'em up */
diff --git a/tools/perf/bench/futex-wake-parallel.c b/tools/perf/bench/futex-wake-parallel.c
index 91aaf2a1fa90..2c8fa67ad537 100644
--- a/tools/perf/bench/futex-wake-parallel.c
+++ b/tools/perf/bench/futex-wake-parallel.c
@@ -7,18 +7,22 @@
  * it can be used to measure futex_wake() changes.
  */
 
-#include "../perf.h"
-#include "../util/util.h"
+/* For the CLR_() macros */
+#include <pthread.h>
+
+#include <signal.h>
 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
-#include "../util/header.h"
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <linux/time64.h>
+#include <errno.h>
 #include "bench.h"
 #include "futex.h"
 
 #include <err.h>
 #include <stdlib.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 struct thread_data {
         pthread_t worker;
@@ -153,7 +157,7 @@ static void print_run(struct thread_data *waking_worker, unsigned int run_num)
 
         printf("[Run %d]: Avg per-thread latency (waking %d/%d threads) "
                "in %.4f ms (+-%.2f%%)\n", run_num + 1, wakeup_avg,
-               nblocked_threads, waketime_avg/1e3,
+               nblocked_threads, waketime_avg / USEC_PER_MSEC,
                rel_stddev_stats(waketime_stddev, waketime_avg));
 }
 
@@ -169,7 +173,7 @@ static void print_summary(void)
         printf("Avg per-thread latency (waking %d/%d threads) in %.4f ms (+-%.2f%%)\n",
                wakeup_avg,
                nblocked_threads,
-               waketime_avg/1e3,
+               waketime_avg / USEC_PER_MSEC,
                rel_stddev_stats(waketime_stddev, waketime_avg));
 }
 
diff --git a/tools/perf/bench/futex-wake.c b/tools/perf/bench/futex-wake.c
index f416bd705f66..e246b1b8388a 100644
--- a/tools/perf/bench/futex-wake.c
+++ b/tools/perf/bench/futex-wake.c
@@ -8,18 +8,22 @@
  * one or more tasks, and thus the waitqueue is never empty.
  */
 
-#include "../perf.h"
-#include "../util/util.h"
+/* For the CLR_() macros */
+#include <pthread.h>
+
+#include <signal.h>
 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
-#include "../util/header.h"
+#include <linux/compiler.h>
+#include <linux/kernel.h>
+#include <linux/time64.h>
+#include <errno.h>
 #include "bench.h"
 #include "futex.h"
 
 #include <err.h>
 #include <stdlib.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 /* all threads will block on the same futex */
 static u_int32_t futex1 = 0;
@@ -78,7 +82,7 @@ static void print_summary(void)
         printf("Wokeup %d of %d threads in %.4f ms (+-%.2f%%)\n",
                wakeup_avg,
                nthreads,
-               waketime_avg/1e3,
+               waketime_avg / USEC_PER_MSEC,
                rel_stddev_stats(waketime_stddev, waketime_avg));
 }
 
@@ -179,7 +183,7 @@ int bench_futex_wake(int argc, const char **argv,
 
                 if (!silent) {
                         printf("[Run %d]: Wokeup %d of %d threads in %.4f ms\n",
-                               j + 1, nwoken, nthreads, runtime.tv_usec/1e3);
+                               j + 1, nwoken, nthreads, runtime.tv_usec / (double)USEC_PER_MSEC);
                 }
 
                 for (i = 0; i < nthreads; i++) {
diff --git a/tools/perf/bench/mem-functions.c b/tools/perf/bench/mem-functions.c
index 2b54d0f2672a..c684910e5a48 100644
--- a/tools/perf/bench/mem-functions.c
+++ b/tools/perf/bench/mem-functions.c
@@ -21,6 +21,7 @@
 #include <string.h>
 #include <sys/time.h>
 #include <errno.h>
+#include <linux/time64.h>
 
 #define K 1024
 
@@ -89,7 +90,7 @@ static u64 get_cycles(void)
 
 static double timeval2double(struct timeval *ts)
 {
-        return (double)ts->tv_sec + (double)ts->tv_usec / (double)1000000;
+        return (double)ts->tv_sec + (double)ts->tv_usec / (double)USEC_PER_SEC;
 }
 
 #define print_bps(x) do {                                               \
diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm.S b/tools/perf/bench/mem-memcpy-x86-64-asm.S
index 5c3cce082cb8..f700369bb0f6 100644
--- a/tools/perf/bench/mem-memcpy-x86-64-asm.S
+++ b/tools/perf/bench/mem-memcpy-x86-64-asm.S
@@ -6,7 +6,7 @@
 #define globl p2align 4; .globl
 #define _ASM_EXTABLE_FAULT(x, y)
 
-#include "../../../arch/x86/lib/memcpy_64.S"
+#include "../../arch/x86/lib/memcpy_64.S"
 /*
  * We need to provide note.GNU-stack section, saying that we want
  * NOT executable stack. Otherwise the final linking will assume that
diff --git a/tools/perf/bench/mem-memset-x86-64-asm.S b/tools/perf/bench/mem-memset-x86-64-asm.S
index de278784c866..58407aa24c1b 100644
--- a/tools/perf/bench/mem-memset-x86-64-asm.S
+++ b/tools/perf/bench/mem-memset-x86-64-asm.S
@@ -1,7 +1,7 @@
 #define memset MEMSET /* don't hide glibc's memset() */
 #define altinstr_replacement text
 #define globl p2align 4; .globl
-#include "../../../arch/x86/lib/memset_64.S"
+#include "../../arch/x86/lib/memset_64.S"
 
 /*
  * We need to provide note.GNU-stack section, saying that we want
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 7500d959d7eb..8efe904e486b 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -4,6 +4,9 @@
  * numa: Simulate NUMA-sensitive workload and measure their NUMA performance
  */
 
+/* For the CLR_() macros */
+#include <pthread.h>
+
 #include "../perf.h"
 #include "../builtin.h"
 #include "../util/util.h"
@@ -21,13 +24,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
-#include <pthread.h>
 #include <sys/mman.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/wait.h>
 #include <sys/prctl.h>
 #include <sys/types.h>
+#include <linux/time64.h>
 
 #include <numa.h>
 #include <numaif.h>
@@ -1002,7 +1005,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
         if (strong && process_groups == g->p.nr_proc) {
                 if (!*convergence) {
                         *convergence = runtime_ns_max;
-                        tprintf(" (%6.1fs converged)\n", *convergence/1e9);
+                        tprintf(" (%6.1fs converged)\n", *convergence / NSEC_PER_SEC);
                         if (g->p.measure_convergence) {
                                 g->all_converged = true;
                                 g->stop_work = true;
@@ -1010,7 +1013,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
                 }
         } else {
                 if (*convergence) {
-                        tprintf(" (%6.1fs de-converged)", runtime_ns_max/1e9);
+                        tprintf(" (%6.1fs de-converged)", runtime_ns_max / NSEC_PER_SEC);
                         *convergence = 0;
                 }
                 tprintf("\n");
@@ -1020,7 +1023,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
 static void show_summary(double runtime_ns_max, int l, double *convergence)
 {
         tprintf("\r #  %5.1f%%  [%.1f mins]",
-                (double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max/1e9 / 60.0);
+                (double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max / NSEC_PER_SEC / 60.0);
 
         calc_convergence(runtime_ns_max, convergence);
 
@@ -1177,8 +1180,8 @@ static void *worker_thread(void *__tdata)
 
                 if (details >= 3) {
                         timersub(&stop, &start, &diff);
-                        runtime_ns_max = diff.tv_sec * 1000000000;
-                        runtime_ns_max += diff.tv_usec * 1000;
+                        runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;
+                        runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;
 
                         if (details >= 0) {
                                 printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64"]\n",
@@ -1190,23 +1193,23 @@ static void *worker_thread(void *__tdata)
                         continue;
 
                 timersub(&stop, &start0, &diff);
-                runtime_ns_max = diff.tv_sec * 1000000000ULL;
-                runtime_ns_max += diff.tv_usec * 1000ULL;
+                runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;
+                runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;
 
                 show_summary(runtime_ns_max, l, &convergence);
         }
 
         gettimeofday(&stop, NULL);
         timersub(&stop, &start0, &diff);
-        td->runtime_ns = diff.tv_sec * 1000000000ULL;
-        td->runtime_ns += diff.tv_usec * 1000ULL;
-        td->speed_gbs = bytes_done / (td->runtime_ns / 1e9) / 1e9;
+        td->runtime_ns = diff.tv_sec * NSEC_PER_SEC;
+        td->runtime_ns += diff.tv_usec * NSEC_PER_USEC;
+        td->speed_gbs = bytes_done / (td->runtime_ns / NSEC_PER_SEC) / 1e9;
 
         getrusage(RUSAGE_THREAD, &rusage);
-        td->system_time_ns = rusage.ru_stime.tv_sec * 1000000000ULL;
-        td->system_time_ns += rusage.ru_stime.tv_usec * 1000ULL;
-        td->user_time_ns = rusage.ru_utime.tv_sec * 1000000000ULL;
-        td->user_time_ns += rusage.ru_utime.tv_usec * 1000ULL;
+        td->system_time_ns = rusage.ru_stime.tv_sec * NSEC_PER_SEC;
+        td->system_time_ns += rusage.ru_stime.tv_usec * NSEC_PER_USEC;
+        td->user_time_ns = rusage.ru_utime.tv_sec * NSEC_PER_SEC;
+        td->user_time_ns += rusage.ru_utime.tv_usec * NSEC_PER_USEC;
 
         free_data(thread_data, g->p.bytes_thread);
 
@@ -1467,7 +1470,7 @@ static int __bench_numa(const char *name)
         }
         /* Wait for all the threads to start up: */
         while (g->nr_tasks_started != g->p.nr_tasks)
-                usleep(1000);
+                usleep(USEC_PER_MSEC);
 
         BUG_ON(g->nr_tasks_started != g->p.nr_tasks);
 
@@ -1486,9 +1489,9 @@ static int __bench_numa(const char *name)
 
                 timersub(&stop, &start, &diff);
 
-                startup_sec = diff.tv_sec * 1000000000.0;
-                startup_sec += diff.tv_usec * 1000.0;
-                startup_sec /= 1e9;
+                startup_sec = diff.tv_sec * NSEC_PER_SEC;
+                startup_sec += diff.tv_usec * NSEC_PER_USEC;
+                startup_sec /= NSEC_PER_SEC;
 
                 tprintf(" threads initialized in %.6f seconds.\n", startup_sec);
                 tprintf(" #\n");
@@ -1527,14 +1530,14 @@ static int __bench_numa(const char *name)
         tprintf("\n ###\n");
         tprintf("\n");
 
-        runtime_sec_max = diff.tv_sec * 1000000000.0;
-        runtime_sec_max += diff.tv_usec * 1000.0;
-        runtime_sec_max /= 1e9;
+        runtime_sec_max = diff.tv_sec * NSEC_PER_SEC;
+        runtime_sec_max += diff.tv_usec * NSEC_PER_USEC;
+        runtime_sec_max /= NSEC_PER_SEC;
 
-        runtime_sec_min = runtime_ns_min/1e9;
+        runtime_sec_min = runtime_ns_min / NSEC_PER_SEC;
 
         bytes = g->bytes_done;
-        runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / 1e9;
+        runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / NSEC_PER_SEC;
 
         if (g->p.measure_convergence) {
                 print_res(name, runtime_sec_max,
@@ -1560,7 +1563,7 @@ static int __bench_numa(const char *name)
         print_res(name, bytes / 1e9,
                 "GB,", "data-total",            "GB data processed, total");
 
-        print_res(name, runtime_sec_max * 1e9 / (bytes / g->p.nr_tasks),
+        print_res(name, runtime_sec_max * NSEC_PER_SEC / (bytes / g->p.nr_tasks),
                 "nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime");
 
         print_res(name, bytes / g->p.nr_tasks / 1e9 / runtime_sec_max,
@@ -1579,9 +1582,9 @@ static int __bench_numa(const char *name)
                                 snprintf(tname, 32, "process%d:thread%d", p, t);
                                 print_res(tname, td->speed_gbs,
                                         "GB/sec",       "thread-speed", "GB/sec/thread speed");
-                                print_res(tname, td->system_time_ns / 1e9,
+                                print_res(tname, td->system_time_ns / NSEC_PER_SEC,
                                         "secs", "thread-system-time", "system CPU time/thread");
-                                print_res(tname, td->user_time_ns / 1e9,
+                                print_res(tname, td->user_time_ns / NSEC_PER_SEC,
                                         "secs", "thread-user-time", "user CPU time/thread");
                         }
                 }
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index bfaf9503de8e..6a111e775210 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -29,6 +29,7 @@
 #include <poll.h>
 #include <limits.h>
 #include <err.h>
+#include <linux/time64.h>
 
 #define DATASIZE 100
 
@@ -312,11 +313,11 @@ int bench_sched_messaging(int argc, const char **argv,
                        thread_mode ? "threads" : "processes");
                 printf(" %14s: %lu.%03lu [sec]\n", "Total time",
                        diff.tv_sec,
-                       (unsigned long) (diff.tv_usec/1000));
+                       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
                 break;
         case BENCH_FORMAT_SIMPLE:
                 printf("%lu.%03lu\n", diff.tv_sec,
-                       (unsigned long) (diff.tv_usec/1000));
+                       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
                 break;
         default:
                 /* reaching here is something disaster */
diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
index 1dc2d13cc272..2243f0150d76 100644
--- a/tools/perf/bench/sched-pipe.c
+++ b/tools/perf/bench/sched-pipe.c
@@ -25,6 +25,7 @@
 #include <sys/time.h>
 #include <sys/types.h>
 #include <sys/syscall.h>
+#include <linux/time64.h>
 
 #include <pthread.h>
 
@@ -153,24 +154,24 @@ int bench_sched_pipe(int argc, const char **argv, const char *prefix __maybe_unu
                 printf("# Executed %d pipe operations between two %s\n\n",
                         loops, threaded ? "threads" : "processes");
 
-                result_usec = diff.tv_sec * 1000000;
+                result_usec = diff.tv_sec * USEC_PER_SEC;
                 result_usec += diff.tv_usec;
 
                 printf(" %14s: %lu.%03lu [sec]\n\n", "Total time",
                        diff.tv_sec,
-                       (unsigned long) (diff.tv_usec/1000));
+                       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
 
                 printf(" %14lf usecs/op\n",
                        (double)result_usec / (double)loops);
                 printf(" %14d ops/sec\n",
                        (int)((double)loops /
-                             ((double)result_usec / (double)1000000)));
+                             ((double)result_usec / (double)USEC_PER_SEC)));
                 break;
 
         case BENCH_FORMAT_SIMPLE:
                 printf("%lu.%03lu\n",
                        diff.tv_sec,
-                       (unsigned long) (diff.tv_usec / 1000));
+                       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
                 break;
 
         default:
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 25c81734a950..ebb628332a6e 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -30,6 +30,7 @@
 #include "util/tool.h"
 #include "util/data.h"
 #include "arch/common.h"
+#include "util/block-range.h"
 
 #include <dlfcn.h>
 #include <linux/bitmap.h>
@@ -46,6 +47,103 @@ struct perf_annotate {
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
+/*
+ * Given one basic block:
+ *
+ *      from    to              branch_i
+ *      * ----> *
+ *              |
+ *              | block
+ *              v
+ *              * ----> *
+ *              from    to      branch_i+1
+ *
+ * where the horizontal are the branches and the vertical is the executed
+ * block of instructions.
+ *
+ * We count, for each 'instruction', the number of blocks that covered it as
+ * well as count the ratio each branch is taken.
+ *
+ * We can do this without knowing the actual instruction stream by keeping
+ * track of the address ranges. We break down ranges such that there is no
+ * overlap and iterate from the start until the end.
+ *
+ * @acme: once we parse the objdump output _before_ processing the samples,
+ * we can easily fold the branch.cycles IPC bits in.
+ */
+static void process_basic_block(struct addr_map_symbol *start,
+                                struct addr_map_symbol *end,
+                                struct branch_flags *flags)
+{
+        struct symbol *sym = start->sym;
+        struct annotation *notes = sym ? symbol__annotation(sym) : NULL;
+        struct block_range_iter iter;
+        struct block_range *entry;
+
+        /*
+         * Sanity; NULL isn't executable and the CPU cannot execute backwards
+         */
+        if (!start->addr || start->addr > end->addr)
+                return;
+
+        iter = block_range__create(start->addr, end->addr);
+        if (!block_range_iter__valid(&iter))
+                return;
+
+        /*
+         * First block in range is a branch target.
+         */
+        entry = block_range_iter(&iter);
+        assert(entry->is_target);
+        entry->entry++;
+
+        do {
+                entry = block_range_iter(&iter);
+
+                entry->coverage++;
+                entry->sym = sym;
+
+                if (notes)
+                        notes->max_coverage = max(notes->max_coverage, entry->coverage);
+
+        } while (block_range_iter__next(&iter));
+
+        /*
+         * Last block in rage is a branch.
+         */
+        entry = block_range_iter(&iter);
+        assert(entry->is_branch);
+        entry->taken++;
+        if (flags->predicted)
+                entry->pred++;
+}
+
+static void process_branch_stack(struct branch_stack *bs, struct addr_location *al,
+                                 struct perf_sample *sample)
+{
+        struct addr_map_symbol *prev = NULL;
+        struct branch_info *bi;
+        int i;
+
+        if (!bs || !bs->nr)
+                return;
+
+        bi = sample__resolve_bstack(sample, al);
+        if (!bi)
+                return;
+
+        for (i = bs->nr - 1; i >= 0; i--) {
+                /*
+                 * XXX filter against symbol
+                 */
+                if (prev)
+                        process_basic_block(prev, &bi[i].from, &bi[i].flags);
+                prev = &bi[i].to;
+        }
+
+        free(bi);
+}
+
 static int perf_evsel__add_sample(struct perf_evsel *evsel,
                                   struct perf_sample *sample,
                                   struct addr_location *al,
@@ -72,10 +170,16 @@ static int perf_evsel__add_sample(struct perf_evsel *evsel,
                 return 0;
         }
 
+        /*
+         * XXX filtered samples can still have branch entires pointing into our
+         * symbol and are missed.
+         */
+        process_branch_stack(sample->branch_stack, al, sample);
+
         sample->period = 1;
         sample->weight = 1;
 
-        he = __hists__add_entry(hists, al, NULL, NULL, NULL, sample, true);
+        he = hists__add_entry(hists, al, NULL, NULL, NULL, sample, true);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -204,8 +308,6 @@ static int __cmd_annotate(struct perf_annotate *ann)
         struct perf_evsel *pos;
         u64 total_nr_samples;
 
-        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);
@@ -236,7 +338,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
                 perf_session__fprintf_dsos(session, stdout);
 
         total_nr_samples = 0;
-        evlist__for_each(session->evlist, pos) {
+        evlist__for_each_entry(session->evlist, pos) {
                 struct hists *hists = evsel__hists(pos);
                 u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
 
@@ -339,6 +441,9 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show event group information together"),
         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
                     "Show a column with the sum of periods"),
+        OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
+                             "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
+                             stdio__config_color, "always"),
         OPT_END()
         };
         int ret = hists__init();
@@ -364,7 +469,10 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
         if (annotate.session == NULL)
                 return -1;
 
-        symbol_conf.priv_size = sizeof(struct annotation);
+        ret = symbol__annotation_init();
+        if (ret < 0)
+                goto out_delete;
+
         symbol_conf.try_vmlinux_path = true;
 
         ret = symbol__init(&annotate.session->header.env);
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
index d75bded21fe0..30e2b2cb2421 100644
--- a/tools/perf/builtin-buildid-cache.c
+++ b/tools/perf/builtin-buildid-cache.c
@@ -209,7 +209,7 @@ static int build_id_cache__purge_path(const char *pathname)
         if (err)
                 goto out;
 
-        strlist__for_each(pos, list) {
+        strlist__for_each_entry(pos, list) {
                 err = build_id_cache__remove_s(pos->s);
                 pr_debug("Removing %s %s: %s\n", pos->s, pathname,
                          err ? "FAIL" : "Ok");
@@ -343,7 +343,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         if (add_name_list_str) {
                 list = strlist__new(add_name_list_str, NULL);
                 if (list) {
-                        strlist__for_each(pos, list)
+                        strlist__for_each_entry(pos, list)
                                 if (build_id_cache__add_file(pos->s)) {
                                         if (errno == EEXIST) {
                                                 pr_debug("%s already in the cache\n",
@@ -351,7 +351,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't add %s: %s\n",
-                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                                   pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -361,7 +361,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         if (remove_name_list_str) {
                 list = strlist__new(remove_name_list_str, NULL);
                 if (list) {
-                        strlist__for_each(pos, list)
+                        strlist__for_each_entry(pos, list)
                                 if (build_id_cache__remove_file(pos->s)) {
                                         if (errno == ENOENT) {
                                                 pr_debug("%s wasn't in the cache\n",
@@ -369,7 +369,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't remove %s: %s\n",
-                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                                   pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -379,7 +379,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         if (purge_name_list_str) {
                 list = strlist__new(purge_name_list_str, NULL);
                 if (list) {
-                        strlist__for_each(pos, list)
+                        strlist__for_each_entry(pos, list)
                                 if (build_id_cache__purge_path(pos->s)) {
                                         if (errno == ENOENT) {
                                                 pr_debug("%s wasn't in the cache\n",
@@ -387,7 +387,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't remove %s: %s\n",
-                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                                   pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -400,7 +400,7 @@ int cmd_buildid_cache(int argc, const char **argv,
         if (update_name_list_str) {
                 list = strlist__new(update_name_list_str, NULL);
                 if (list) {
-                        strlist__for_each(pos, list)
+                        strlist__for_each_entry(pos, list)
                                 if (build_id_cache__update_file(pos->s)) {
                                         if (errno == ENOENT) {
                                                 pr_debug("%s wasn't in the cache\n",
@@ -408,7 +408,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                                                 continue;
                                         }
                                         pr_warning("Couldn't update %s: %s\n",
-                                                   pos->s, strerror_r(errno, sbuf, sizeof(sbuf)));
+                                                   pos->s, str_error_r(errno, sbuf, sizeof(sbuf)));
                                 }
 
                         strlist__delete(list);
@@ -419,8 +419,7 @@ int cmd_buildid_cache(int argc, const char **argv,
                 pr_warning("Couldn't add %s\n", kcore_filename);
 
 out:
-        if (session)
-                perf_session__delete(session);
+        perf_session__delete(session);
 
         return ret;
 }
diff --git a/tools/perf/builtin-config.c b/tools/perf/builtin-config.c
index fe1b77fa21f9..e4207a23b52c 100644
--- a/tools/perf/builtin-config.c
+++ b/tools/perf/builtin-config.c
@@ -37,23 +37,16 @@ static int show_config(struct perf_config_set *set)
 {
         struct perf_config_section *section;
         struct perf_config_item *item;
-        struct list_head *sections;
 
         if (set == NULL)
                 return -1;
 
-        sections = &set->sections;
-        if (list_empty(sections))
-                return -1;
-
-        list_for_each_entry(section, sections, node) {
-                list_for_each_entry(item, &section->items, node) {
-                        char *value = item->value;
+        perf_config_set__for_each_entry(set, section, item) {
+                char *value = item->value;
 
-                        if (value)
-                                printf("%s.%s=%s\n", section->name,
-                                       item->name, value);
-                }
+                if (value)
+                        printf("%s.%s=%s\n", section->name,
+                               item->name, value);
         }
 
         return 0;
@@ -80,6 +73,10 @@ int cmd_config(int argc, const char **argv, const char *prefix __maybe_unused)
         else if (use_user_config)
                 config_exclusive_filename = user_config;
 
+        /*
+         * At only 'config' sub-command, individually use the config set
+         * because of reinitializing with options config file location.
+         */
         set = perf_config_set__new();
         if (!set) {
                 ret = -1;
diff --git a/tools/perf/builtin-data.c b/tools/perf/builtin-data.c
index b97bc1518b44..7ad6e17ac6b3 100644
--- a/tools/perf/builtin-data.c
+++ b/tools/perf/builtin-data.c
@@ -3,6 +3,7 @@
 #include "perf.h"
 #include "debug.h"
 #include <subcmd/parse-options.h>
+#include "data-convert.h"
 #include "data-convert-bt.h"
 
 typedef int (*data_cmd_fn_t)(int argc, const char **argv, const char *prefix);
@@ -53,14 +54,18 @@ static int cmd_data_convert(int argc, const char **argv,
                             const char *prefix __maybe_unused)
 {
         const char *to_ctf     = NULL;
-        bool force = false;
+        struct perf_data_convert_opts opts = {
+                .force = false,
+                .all = false,
+        };
         const struct option options[] = {
                 OPT_INCR('v', "verbose", &verbose, "be more verbose"),
                 OPT_STRING('i', "input", &input_name, "file", "input file name"),
 #ifdef HAVE_LIBBABELTRACE_SUPPORT
                 OPT_STRING(0, "to-ctf", &to_ctf, NULL, "Convert to CTF format"),
 #endif
-                OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+                OPT_BOOLEAN('f', "force", &opts.force, "don't complain, do it"),
+                OPT_BOOLEAN(0, "all", &opts.all, "Convert all events"),
                 OPT_END()
         };
 
@@ -78,7 +83,7 @@ static int cmd_data_convert(int argc, const char **argv,
 
         if (to_ctf) {
 #ifdef HAVE_LIBBABELTRACE_SUPPORT
-                return bt_convert__perf2ctf(input_name, to_ctf, force);
+                return bt_convert__perf2ctf(input_name, to_ctf, &opts);
 #else
                 pr_err("The libbabeltrace support is not compiled in.\n");
                 return -1;
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index f7645a42708e..9ff0db4e2d0c 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -310,16 +310,6 @@ static int formula_fprintf(struct hist_entry *he, struct hist_entry *pair,
         return -1;
 }
 
-static int hists__add_entry(struct hists *hists,
-                            struct addr_location *al,
-                            struct perf_sample *sample)
-{
-        if (__hists__add_entry(hists, al, NULL, NULL, NULL,
-                               sample, true) != NULL)
-                return 0;
-        return -ENOMEM;
-}
-
 static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
                                       union perf_event *event,
                                       struct perf_sample *sample,
@@ -336,7 +326,7 @@ static int diff__process_sample_event(struct perf_tool *tool __maybe_unused,
                 return -1;
         }
 
-        if (hists__add_entry(hists, &al, sample)) {
+        if (!hists__add_entry(hists, &al, NULL, NULL, NULL, sample, true)) {
                 pr_warning("problem incrementing symbol period, skipping event\n");
                 goto out_put;
         }
@@ -373,7 +363,7 @@ static struct perf_evsel *evsel_match(struct perf_evsel *evsel,
 {
         struct perf_evsel *e;
 
-        evlist__for_each(evlist, e) {
+        evlist__for_each_entry(evlist, e) {
                 if (perf_evsel__match2(evsel, e))
                         return e;
         }
@@ -385,7 +375,7 @@ static void perf_evlist__collapse_resort(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 struct hists *hists = evsel__hists(evsel);
 
                 hists__collapse_resort(hists, NULL);
@@ -666,7 +656,8 @@ static void hists__process(struct hists *hists)
         hists__precompute(hists);
         hists__output_resort(hists, NULL);
 
-        hists__fprintf(hists, true, 0, 0, 0, stdout);
+        hists__fprintf(hists, true, 0, 0, 0, stdout,
+                       symbol_conf.use_callchain);
 }
 
 static void data__fprintf(void)
@@ -690,7 +681,7 @@ static void data_process(void)
         struct perf_evsel *evsel_base;
         bool first = true;
 
-        evlist__for_each(evlist_base, evsel_base) {
+        evlist__for_each_entry(evlist_base, evsel_base) {
                 struct hists *hists_base = evsel__hists(evsel_base);
                 struct data__file *d;
                 int i;
@@ -765,9 +756,7 @@ static int __cmd_diff(void)
 
  out_delete:
         data__for_each_file(i, d) {
-                if (d->session)
-                        perf_session__delete(d->session);
-
+                perf_session__delete(d->session);
                 data__free(d);
         }
 
@@ -1044,7 +1033,9 @@ static int hpp__entry_global(struct perf_hpp_fmt *_fmt, struct perf_hpp *hpp,
 }
 
 static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                       struct perf_evsel *evsel __maybe_unused)
+                       struct hists *hists __maybe_unused,
+                       int line __maybe_unused,
+                       int *span __maybe_unused)
 {
         struct diff_hpp_fmt *dfmt =
                 container_of(fmt, struct diff_hpp_fmt, fmt);
@@ -1055,7 +1046,7 @@ static int hpp__header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
 
 static int hpp__width(struct perf_hpp_fmt *fmt,
                       struct perf_hpp *hpp __maybe_unused,
-                      struct perf_evsel *evsel __maybe_unused)
+                      struct hists *hists __maybe_unused)
 {
         struct diff_hpp_fmt *dfmt =
                 container_of(fmt, struct diff_hpp_fmt, fmt);
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index 8a31f511e1a0..e09c4287fe87 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -32,7 +32,7 @@ static int __cmd_evlist(const char *file_name, struct perf_attr_details *details
         if (session == NULL)
                 return -1;
 
-        evlist__for_each(session->evlist, pos) {
+        evlist__for_each_entry(session->evlist, pos) {
                 perf_evsel__fprintf(pos, details, stdout);
 
                 if (pos->attr.type == PERF_TYPE_TRACEPOINT)
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index f9830c902b78..3bdb2c78a21b 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -4,7 +4,7 @@
  * Builtin help command
  */
 #include "perf.h"
-#include "util/cache.h"
+#include "util/config.h"
 #include "builtin.h"
 #include <subcmd/exec-cmd.h>
 #include "common-cmds.h"
@@ -117,7 +117,7 @@ static void exec_woman_emacs(const char *path, const char *page)
                         free(man_page);
                 }
                 warning("failed to exec '%s': %s", path,
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
         }
 }
 
@@ -150,7 +150,7 @@ static void exec_man_konqueror(const char *path, const char *page)
                         free(man_page);
                 }
                 warning("failed to exec '%s': %s", path,
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
         }
 }
 
@@ -162,7 +162,7 @@ static void exec_man_man(const char *path, const char *page)
                 path = "man";
         execlp(path, "man", page, NULL);
         warning("failed to exec '%s': %s", path,
-                strerror_r(errno, sbuf, sizeof(sbuf)));
+                str_error_r(errno, sbuf, sizeof(sbuf)));
 }
 
 static void exec_man_cmd(const char *cmd, const char *page)
@@ -175,7 +175,7 @@ static void exec_man_cmd(const char *cmd, const char *page)
                 free(shell_cmd);
         }
         warning("failed to exec '%s': %s", cmd,
-                strerror_r(errno, sbuf, sizeof(sbuf)));
+                str_error_r(errno, sbuf, sizeof(sbuf)));
 }
 
 static void add_man_viewer(const char *name)
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index e5afa8fe1bf1..b9bc7e39833a 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -429,7 +429,7 @@ static int perf_event__inject_buildid(struct perf_tool *tool,
         if (al.map != NULL) {
                 if (!al.map->dso->hit) {
                         al.map->dso->hit = 1;
-                        if (map__load(al.map, NULL) >= 0) {
+                        if (map__load(al.map) >= 0) {
                                 dso__inject_build_id(al.map->dso, tool, machine);
                                 /*
                                  * If this fails, too bad, let the other side
@@ -562,7 +562,7 @@ static void strip_init(struct perf_inject *inject)
 
         inject->tool.context_switch = perf_event__drop;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 evsel->handler = drop_sample;
 }
 
@@ -590,7 +590,7 @@ static bool ok_to_remove(struct perf_evlist *evlist,
         if (!has_tracking(evsel_to_remove))
                 return true;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->handler != drop_sample) {
                         cnt += 1;
                         if ((evsel->attr.sample_type & COMPAT_MASK) ==
@@ -608,7 +608,7 @@ static void strip_fini(struct perf_inject *inject)
         struct perf_evsel *evsel, *tmp;
 
         /* Remove non-synthesized evsels if possible */
-        evlist__for_each_safe(evlist, tmp, evsel) {
+        evlist__for_each_entry_safe(evlist, tmp, evsel) {
                 if (evsel->handler == drop_sample &&
                     ok_to_remove(evlist, evsel)) {
                         pr_debug("Deleting %s\n", perf_evsel__name(evsel));
@@ -643,7 +643,7 @@ static int __cmd_inject(struct perf_inject *inject)
         } else if (inject->sched_stat) {
                 struct perf_evsel *evsel;
 
-                evlist__for_each(session->evlist, evsel) {
+                evlist__for_each_entry(session->evlist, evsel) {
                         const char *name = perf_evsel__name(evsel);
 
                         if (!strcmp(name, "sched:sched_switch")) {
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 58adfee230de..d426dcb18ce9 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -4,7 +4,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/util.h"
-#include "util/cache.h"
+#include "util/config.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
@@ -330,7 +330,7 @@ static int build_alloc_func_list(void)
         }
 
         kernel_map = machine__kernel_map(machine);
-        if (map__load(kernel_map, NULL) < 0) {
+        if (map__load(kernel_map) < 0) {
                 pr_err("cannot load kernel map\n");
                 return -ENOENT;
         }
@@ -608,6 +608,7 @@ static const struct {
         const char *compact;
 } gfp_compact_table[] = {
         { "GFP_TRANSHUGE",              "THP" },
+        { "GFP_TRANSHUGE_LIGHT",        "THL" },
         { "GFP_HIGHUSER_MOVABLE",       "HUM" },
         { "GFP_HIGHUSER",               "HU" },
         { "GFP_USER",                   "U" },
@@ -978,7 +979,7 @@ static void __print_slab_result(struct rb_root *root,
                 if (is_caller) {
                         addr = data->call_site;
                         if (!raw_ip)
-                                sym = machine__find_kernel_function(machine, addr, &map, NULL);
+                                sym = machine__find_kernel_function(machine, addr, &map);
                 } else
                         addr = data->ptr;
 
@@ -1042,8 +1043,7 @@ static void __print_page_alloc_result(struct perf_session *session, int n_lines)
                 char *caller = buf;
 
                 data = rb_entry(next, struct page_stat, node);
-                sym = machine__find_kernel_function(machine, data->callsite,
-                                                    &map, NULL);
+                sym = machine__find_kernel_function(machine, data->callsite, &map);
                 if (sym && sym->name)
                         caller = sym->name;
                 else
@@ -1085,8 +1085,7 @@ static void __print_page_caller_result(struct perf_session *session, int n_lines
                 char *caller = buf;
 
                 data = rb_entry(next, struct page_stat, node);
-                sym = machine__find_kernel_function(machine, data->callsite,
-                                                    &map, NULL);
+                sym = machine__find_kernel_function(machine, data->callsite, &map);
                 if (sym && sym->name)
                         caller = sym->name;
                 else
@@ -1354,7 +1353,7 @@ static int __cmd_kmem(struct perf_session *session)
                 goto out;
         }
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (!strcmp(perf_evsel__name(evsel), "kmem:mm_page_alloc") &&
                     perf_evsel__field(evsel, "pfn")) {
                         use_pfn = true;
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 6487c06d2708..08fa88f62a24 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -24,6 +24,7 @@
 #include <sys/timerfd.h>
 #endif
 
+#include <linux/time64.h>
 #include <termios.h>
 #include <semaphore.h>
 #include <pthread.h>
@@ -362,7 +363,7 @@ static bool handle_end_event(struct perf_kvm_stat *kvm,
                 if (!skip_event(decode)) {
                         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);
+                                 decode, time_diff / NSEC_PER_USEC);
                 }
         }
 
@@ -608,15 +609,15 @@ static void print_result(struct perf_kvm_stat *kvm)
                 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("%9.2fus ", (double)min / 1e3);
-                pr_info("%9.2fus ", (double)max / 1e3);
-                pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount/1e3,
+                pr_info("%9.2fus ", (double)min / NSEC_PER_USEC);
+                pr_info("%9.2fus ", (double)max / NSEC_PER_USEC);
+                pr_info("%9.2fus ( +-%7.2f%% )", (double)etime / ecount / NSEC_PER_USEC,
                         kvm_event_rel_stddev(vcpu, event));
                 pr_info("\n");
         }
 
         pr_info("\nTotal Samples:%" PRIu64 ", Total events handled time:%.2fus.\n\n",
-                kvm->total_count, kvm->total_time / 1e3);
+                kvm->total_count, kvm->total_time / (double)NSEC_PER_USEC);
 
         if (kvm->lost_events)
                 pr_info("\nLost events: %" PRIu64 "\n\n", kvm->lost_events);
@@ -988,7 +989,7 @@ static int kvm_live_open_events(struct perf_kvm_stat *kvm)
          * Note: exclude_{guest,host} do not apply here.
          *       This command processes KVM tracepoints from host only
          */
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 struct perf_event_attr *attr = &pos->attr;
 
                 /* make sure these *are* set */
@@ -1018,13 +1019,13 @@ static int kvm_live_open_events(struct perf_kvm_stat *kvm)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 printf("Couldn't create the events: %s\n",
-                       strerror_r(errno, sbuf, sizeof(sbuf)));
+                       str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
 
         if (perf_evlist__mmap(evlist, kvm->opts.mmap_pages, false) < 0) {
                 ui__error("Failed to mmap the events: %s\n",
-                          strerror_r(errno, sbuf, sizeof(sbuf)));
+                          str_error_r(errno, sbuf, sizeof(sbuf)));
                 perf_evlist__close(evlist);
                 goto out;
         }
@@ -1426,11 +1427,9 @@ static int kvm_events_live(struct perf_kvm_stat *kvm,
         err = kvm_events_live_report(kvm);
 
 out:
-        if (kvm->session)
-                perf_session__delete(kvm->session);
+        perf_session__delete(kvm->session);
         kvm->session = NULL;
-        if (kvm->evlist)
-                perf_evlist__delete(kvm->evlist);
+        perf_evlist__delete(kvm->evlist);
 
         return err;
 }
diff --git a/tools/perf/builtin-list.c b/tools/perf/builtin-list.c
index 5e22db4684b8..ba9322ff858b 100644
--- a/tools/perf/builtin-list.c
+++ b/tools/perf/builtin-list.c
@@ -16,16 +16,23 @@
 #include "util/pmu.h"
 #include <subcmd/parse-options.h>
 
+static bool desc_flag = true;
+
 int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 {
         int i;
         bool raw_dump = false;
+        bool long_desc_flag = false;
         struct option list_options[] = {
                 OPT_BOOLEAN(0, "raw-dump", &raw_dump, "Dump raw events"),
+                OPT_BOOLEAN('d', "desc", &desc_flag,
+                            "Print extra event descriptions. --no-desc to not print."),
+                OPT_BOOLEAN('v', "long-desc", &long_desc_flag,
+                            "Print longer event descriptions."),
                 OPT_END()
         };
         const char * const list_usage[] = {
-                "perf list [hw|sw|cache|tracepoint|pmu|event_glob]",
+                "perf list [<options>] [hw|sw|cache|tracepoint|pmu|sdt|event_glob]",
                 NULL
         };
 
@@ -40,7 +47,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                 printf("\nList of pre-defined events (to be used in -e):\n\n");
 
         if (argc == 0) {
-                print_events(NULL, raw_dump);
+                print_events(NULL, raw_dump, !desc_flag, long_desc_flag);
                 return 0;
         }
 
@@ -61,12 +68,16 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                          strcmp(argv[i], "hwcache") == 0)
                         print_hwcache_events(NULL, raw_dump);
                 else if (strcmp(argv[i], "pmu") == 0)
-                        print_pmu_events(NULL, raw_dump);
+                        print_pmu_events(NULL, raw_dump, !desc_flag,
+                                                long_desc_flag);
+                else if (strcmp(argv[i], "sdt") == 0)
+                        print_sdt_events(NULL, NULL, raw_dump);
                 else if ((sep = strchr(argv[i], ':')) != NULL) {
                         int sep_idx;
 
                         if (sep == NULL) {
-                                print_events(argv[i], raw_dump);
+                                print_events(argv[i], raw_dump, !desc_flag,
+                                                        long_desc_flag);
                                 continue;
                         }
                         sep_idx = sep - argv[i];
@@ -76,6 +87,7 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
 
                         s[sep_idx] = '\0';
                         print_tracepoint_events(s, s + sep_idx + 1, raw_dump);
+                        print_sdt_events(s, s + sep_idx + 1, raw_dump);
                         free(s);
                 } else {
                         if (asprintf(&s, "*%s*", argv[i]) < 0) {
@@ -87,8 +99,10 @@ int cmd_list(int argc, const char **argv, const char *prefix __maybe_unused)
                         print_symbol_events(s, PERF_TYPE_SOFTWARE,
                                             event_symbols_sw, PERF_COUNT_SW_MAX, raw_dump);
                         print_hwcache_events(s, raw_dump);
-                        print_pmu_events(s, raw_dump);
+                        print_pmu_events(s, raw_dump, !desc_flag,
+                                                long_desc_flag);
                         print_tracepoint_events(NULL, s, raw_dump);
+                        print_sdt_events(NULL, s, raw_dump);
                         free(s);
                 }
         }
diff --git a/tools/perf/builtin-mem.c b/tools/perf/builtin-mem.c
index 1dc140c5481d..d1ce29be560e 100644
--- a/tools/perf/builtin-mem.c
+++ b/tools/perf/builtin-mem.c
@@ -67,6 +67,7 @@ static int __cmd_record(int argc, const char **argv, struct perf_mem *mem)
         OPT_CALLBACK('e', "event", &mem, "event",
                      "event selector. use 'perf mem record -e list' to list available events",
                      parse_record_events),
+        OPT_UINTEGER(0, "ldlat", &perf_mem_events__loads_ldlat, "mem-loads latency"),
         OPT_INCR('v', "verbose", &verbose,
                  "be more verbose (show counter open errors, etc)"),
         OPT_BOOLEAN('U', "--all-user", &all_user, "collect only user level data"),
@@ -87,6 +88,9 @@ static int __cmd_record(int argc, const char **argv, struct perf_mem *mem)
         if (mem->operation & MEM_OPERATION_LOAD)
                 perf_mem_events[PERF_MEM_EVENTS__LOAD].record = true;
 
+        if (mem->operation & MEM_OPERATION_STORE)
+                perf_mem_events[PERF_MEM_EVENTS__STORE].record = true;
+
         if (perf_mem_events[PERF_MEM_EVENTS__LOAD].record)
                 rec_argv[i++] = "-W";
 
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 9af859b28b15..f87996b0cb29 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -44,7 +44,7 @@
 
 #define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
 #define DEFAULT_FUNC_FILTER "!_*"
-#define DEFAULT_LIST_FILTER "*:*"
+#define DEFAULT_LIST_FILTER "*"
 
 /* Session management structure */
 static struct {
@@ -308,7 +308,7 @@ static void pr_err_with_code(const char *msg, int err)
 
         pr_err("%s", msg);
         pr_debug(" Reason: %s (Code: %d)",
-                 strerror_r(-err, sbuf, sizeof(sbuf)), err);
+                 str_error_r(-err, sbuf, sizeof(sbuf)), err);
         pr_err("\n");
 }
 
@@ -326,6 +326,11 @@ static int perf_add_probe_events(struct perf_probe_event *pevs, int npevs)
         if (ret < 0)
                 goto out_cleanup;
 
+        if (params.command == 'D') {    /* it shows definition */
+                ret = show_probe_trace_events(pevs, npevs);
+                goto out_cleanup;
+        }
+
         ret = apply_perf_probe_events(pevs, npevs);
         if (ret < 0)
                 goto out_cleanup;
@@ -363,6 +368,32 @@ out_cleanup:
         return ret;
 }
 
+static int del_perf_probe_caches(struct strfilter *filter)
+{
+        struct probe_cache *cache;
+        struct strlist *bidlist;
+        struct str_node *nd;
+        int ret;
+
+        bidlist = build_id_cache__list_all(false);
+        if (!bidlist) {
+                ret = -errno;
+                pr_debug("Failed to get buildids: %d\n", ret);
+                return ret ?: -ENOMEM;
+        }
+
+        strlist__for_each_entry(nd, bidlist) {
+                cache = probe_cache__new(nd->s);
+                if (!cache)
+                        continue;
+                if (probe_cache__filter_purge(cache, filter) < 0 ||
+                    probe_cache__commit(cache) < 0)
+                        pr_warning("Failed to remove entries for %s\n", nd->s);
+                probe_cache__delete(cache);
+        }
+        return 0;
+}
+
 static int perf_del_probe_events(struct strfilter *filter)
 {
         int ret, ret2, ufd = -1, kfd = -1;
@@ -375,6 +406,9 @@ static int perf_del_probe_events(struct strfilter *filter)
 
         pr_debug("Delete filter: \'%s\'\n", str);
 
+        if (probe_conf.cache)
+                return del_perf_probe_caches(filter);
+
         /* Get current event names */
         ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
         if (ret < 0)
@@ -389,7 +423,7 @@ static int perf_del_probe_events(struct strfilter *filter)
 
         ret = probe_file__get_events(kfd, filter, klist);
         if (ret == 0) {
-                strlist__for_each(ent, klist)
+                strlist__for_each_entry(ent, klist)
                         pr_info("Removed event: %s\n", ent->s);
 
                 ret = probe_file__del_strlist(kfd, klist);
@@ -399,7 +433,7 @@ static int perf_del_probe_events(struct strfilter *filter)
 
         ret2 = probe_file__get_events(ufd, filter, ulist);
         if (ret2 == 0) {
-                strlist__for_each(ent, ulist)
+                strlist__for_each_entry(ent, ulist)
                         pr_info("Removed event: %s\n", ent->s);
 
                 ret2 = probe_file__del_strlist(ufd, ulist);
@@ -425,6 +459,14 @@ out:
         return ret;
 }
 
+#ifdef HAVE_DWARF_SUPPORT
+#define PROBEDEF_STR    \
+        "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT [[NAME=]ARG ...]"
+#else
+#define PROBEDEF_STR    "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]"
+#endif
+
+
 static int
 __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
 {
@@ -450,13 +492,7 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                              opt_set_filter_with_command, DEFAULT_LIST_FILTER),
         OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
                      opt_set_filter_with_command),
-        OPT_CALLBACK('a', "add", NULL,
-#ifdef HAVE_DWARF_SUPPORT
-                "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
-                " [[NAME=]ARG ...]",
-#else
-                "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
-#endif
+        OPT_CALLBACK('a', "add", NULL, PROBEDEF_STR,
                 "probe point definition, where\n"
                 "\t\tGROUP:\tGroup name (optional)\n"
                 "\t\tEVENT:\tEvent name\n"
@@ -474,6 +510,9 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                 "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
 #endif
                 opt_add_probe_event),
+        OPT_CALLBACK('D', "definition", NULL, PROBEDEF_STR,
+                "Show trace event definition of given traceevent for k/uprobe_events.",
+                opt_add_probe_event),
         OPT_BOOLEAN('f', "force", &probe_conf.force_add, "forcibly add events"
                     " with existing name"),
         OPT_CALLBACK('L', "line", NULL,
@@ -512,12 +551,14 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Enable symbol demangling"),
         OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
                     "Enable kernel symbol demangling"),
+        OPT_BOOLEAN(0, "cache", &probe_conf.cache, "Manipulate probe cache"),
         OPT_END()
         };
         int ret;
 
         set_option_flag(options, 'a', "add", PARSE_OPT_EXCLUSIVE);
         set_option_flag(options, 'd', "del", PARSE_OPT_EXCLUSIVE);
+        set_option_flag(options, 'D', "definition", PARSE_OPT_EXCLUSIVE);
         set_option_flag(options, 'l', "list", PARSE_OPT_EXCLUSIVE);
 #ifdef HAVE_DWARF_SUPPORT
         set_option_flag(options, 'L', "line", PARSE_OPT_EXCLUSIVE);
@@ -570,6 +611,14 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
          */
         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
 
+        /*
+         * Except for --list, --del and --add, other command doesn't depend
+         * nor change running kernel. So if user gives offline vmlinux,
+         * ignore its buildid.
+         */
+        if (!strchr("lda", params.command) && symbol_conf.vmlinux_name)
+                symbol_conf.ignore_vmlinux_buildid = true;
+
         switch (params.command) {
         case 'l':
                 if (params.uprobes) {
@@ -613,7 +662,9 @@ __cmd_probe(int argc, const char **argv, const char *prefix __maybe_unused)
                         return ret;
                 }
                 break;
+        case 'D':
         case 'a':
+
                 /* Ensure the last given target is used */
                 if (params.target && !params.target_used) {
                         pr_err("  Error: -x/-m must follow the probe definitions.\n");
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index dc3fcb597e4c..67d2a9003294 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -13,6 +13,7 @@
 #include "util/util.h"
 #include <subcmd/parse-options.h>
 #include "util/parse-events.h"
+#include "util/config.h"
 
 #include "util/callchain.h"
 #include "util/cgroup.h"
@@ -21,6 +22,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/debug.h"
+#include "util/drv_configs.h"
 #include "util/session.h"
 #include "util/tool.h"
 #include "util/symbol.h"
@@ -41,7 +43,7 @@
 #include <sched.h>
 #include <sys/mman.h>
 #include <asm/bug.h>
-
+#include <linux/time64.h>
 
 struct record {
         struct perf_tool        tool;
@@ -95,7 +97,7 @@ backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
         *start = head;
         while (true) {
                 if (evt_head - head >= (unsigned int)size) {
-                        pr_debug("Finshed reading backward ring buffer: rewind\n");
+                        pr_debug("Finished reading backward ring buffer: rewind\n");
                         if (evt_head - head > (unsigned int)size)
                                 evt_head -= pheader->size;
                         *end = evt_head;
@@ -105,7 +107,7 @@ backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
                 pheader = (struct perf_event_header *)(buf + (evt_head & mask));
 
                 if (pheader->size == 0) {
-                        pr_debug("Finshed reading backward ring buffer: get start\n");
+                        pr_debug("Finished reading backward ring buffer: get start\n");
                         *end = evt_head;
                         return 0;
                 }
@@ -118,11 +120,10 @@ backward_rb_find_range(void *buf, int mask, u64 head, u64 *start, u64 *end)
 }
 
 static int
-rb_find_range(struct perf_evlist *evlist,
-              void *data, int mask, u64 head, u64 old,
-              u64 *start, u64 *end)
+rb_find_range(void *data, int mask, u64 head, u64 old,
+              u64 *start, u64 *end, bool backward)
 {
-        if (!evlist->backward) {
+        if (!backward) {
                 *start = old;
                 *end = head;
                 return 0;
@@ -131,9 +132,10 @@ rb_find_range(struct perf_evlist *evlist,
         return backward_rb_find_range(data, mask, head, start, end);
 }
 
-static int record__mmap_read(struct record *rec, int idx)
+static int
+record__mmap_read(struct record *rec, struct perf_mmap *md,
+                  bool overwrite, bool backward)
 {
-        struct perf_mmap *md = &rec->evlist->mmap[idx];
         u64 head = perf_mmap__read_head(md);
         u64 old = md->prev;
         u64 end = head, start = old;
@@ -142,8 +144,8 @@ static int record__mmap_read(struct record *rec, int idx)
         void *buf;
         int rc = 0;
 
-        if (rb_find_range(rec->evlist, data, md->mask, head,
-                          old, &start, &end))
+        if (rb_find_range(data, md->mask, head,
+                          old, &start, &end, backward))
                 return -1;
 
         if (start == end)
@@ -156,7 +158,7 @@ static int record__mmap_read(struct record *rec, int idx)
                 WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n");
 
                 md->prev = head;
-                perf_evlist__mmap_consume(rec->evlist, idx);
+                perf_mmap__consume(md, overwrite || backward);
                 return 0;
         }
 
@@ -181,7 +183,7 @@ static int record__mmap_read(struct record *rec, int idx)
         }
 
         md->prev = head;
-        perf_evlist__mmap_consume(rec->evlist, idx);
+        perf_mmap__consume(md, overwrite || backward);
 out:
         return rc;
 }
@@ -341,6 +343,40 @@ int auxtrace_record__snapshot_start(struct auxtrace_record *itr __maybe_unused)
 
 #endif
 
+static int record__mmap_evlist(struct record *rec,
+                               struct perf_evlist *evlist)
+{
+        struct record_opts *opts = &rec->opts;
+        char msg[512];
+
+        if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
+                                 opts->auxtrace_mmap_pages,
+                                 opts->auxtrace_snapshot_mode) < 0) {
+                if (errno == EPERM) {
+                        pr_err("Permission error mapping pages.\n"
+                               "Consider increasing "
+                               "/proc/sys/kernel/perf_event_mlock_kb,\n"
+                               "or try again with a smaller value of -m/--mmap_pages.\n"
+                               "(current value: %u,%u)\n",
+                               opts->mmap_pages, opts->auxtrace_mmap_pages);
+                        return -errno;
+                } else {
+                        pr_err("failed to mmap with %d (%s)\n", errno,
+                                str_error_r(errno, msg, sizeof(msg)));
+                        if (errno)
+                                return -errno;
+                        else
+                                return -EINVAL;
+                }
+        }
+        return 0;
+}
+
+static int record__mmap(struct record *rec)
+{
+        return record__mmap_evlist(rec, rec->evlist);
+}
+
 static int record__open(struct record *rec)
 {
         char msg[512];
@@ -348,11 +384,12 @@ static int record__open(struct record *rec)
         struct perf_evlist *evlist = rec->evlist;
         struct perf_session *session = rec->session;
         struct record_opts *opts = &rec->opts;
+        struct perf_evsel_config_term *err_term;
         int rc = 0;
 
         perf_evlist__config(evlist, opts, &callchain_param);
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
 try_again:
                 if (perf_evsel__open(pos, pos->cpus, pos->threads) < 0) {
                         if (perf_evsel__fallback(pos, errno, msg, sizeof(msg))) {
@@ -372,33 +409,23 @@ try_again:
         if (perf_evlist__apply_filters(evlist, &pos)) {
                 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
                         pos->filter, perf_evsel__name(pos), errno,
-                        strerror_r(errno, msg, sizeof(msg)));
+                        str_error_r(errno, msg, sizeof(msg)));
                 rc = -1;
                 goto out;
         }
 
-        if (perf_evlist__mmap_ex(evlist, opts->mmap_pages, false,
-                                 opts->auxtrace_mmap_pages,
-                                 opts->auxtrace_snapshot_mode) < 0) {
-                if (errno == EPERM) {
-                        pr_err("Permission error mapping pages.\n"
-                               "Consider increasing "
-                               "/proc/sys/kernel/perf_event_mlock_kb,\n"
-                               "or try again with a smaller value of -m/--mmap_pages.\n"
-                               "(current value: %u,%u)\n",
-                               opts->mmap_pages, opts->auxtrace_mmap_pages);
-                        rc = -errno;
-                } else {
-                        pr_err("failed to mmap with %d (%s)\n", errno,
-                                strerror_r(errno, msg, sizeof(msg)));
-                        if (errno)
-                                rc = -errno;
-                        else
-                                rc = -EINVAL;
-                }
+        if (perf_evlist__apply_drv_configs(evlist, &pos, &err_term)) {
+                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                      err_term->val.drv_cfg, perf_evsel__name(pos), errno,
+                      str_error_r(errno, msg, sizeof(msg)));
+                rc = -1;
                 goto out;
         }
 
+        rc = record__mmap(rec);
+        if (rc)
+                goto out;
+
         session->evlist = evlist;
         perf_session__set_id_hdr_size(session);
 out:
@@ -481,17 +508,30 @@ static struct perf_event_header finished_round_event = {
         .type = PERF_RECORD_FINISHED_ROUND,
 };
 
-static int record__mmap_read_all(struct record *rec)
+static int record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist,
+                                    bool backward)
 {
         u64 bytes_written = rec->bytes_written;
         int i;
         int rc = 0;
+        struct perf_mmap *maps;
 
-        for (i = 0; i < rec->evlist->nr_mmaps; i++) {
-                struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap;
+        if (!evlist)
+                return 0;
+
+        maps = backward ? evlist->backward_mmap : evlist->mmap;
+        if (!maps)
+                return 0;
 
-                if (rec->evlist->mmap[i].base) {
-                        if (record__mmap_read(rec, i) != 0) {
+        if (backward && evlist->bkw_mmap_state != BKW_MMAP_DATA_PENDING)
+                return 0;
+
+        for (i = 0; i < evlist->nr_mmaps; i++) {
+                struct auxtrace_mmap *mm = &maps[i].auxtrace_mmap;
+
+                if (maps[i].base) {
+                        if (record__mmap_read(rec, &maps[i],
+                                              evlist->overwrite, backward) != 0) {
                                 rc = -1;
                                 goto out;
                         }
@@ -511,10 +551,23 @@ static int record__mmap_read_all(struct record *rec)
         if (bytes_written != rec->bytes_written)
                 rc = record__write(rec, &finished_round_event, sizeof(finished_round_event));
 
+        if (backward)
+                perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_EMPTY);
 out:
         return rc;
 }
 
+static int record__mmap_read_all(struct record *rec)
+{
+        int err;
+
+        err = record__mmap_read_evlist(rec, rec->evlist, false);
+        if (err)
+                return err;
+
+        return record__mmap_read_evlist(rec, rec->evlist, true);
+}
+
 static void record__init_features(struct record *rec)
 {
         struct perf_session *session = rec->session;
@@ -561,13 +614,16 @@ record__finish_output(struct record *rec)
         return;
 }
 
-static int record__synthesize_workload(struct record *rec)
+static int record__synthesize_workload(struct record *rec, bool tail)
 {
         struct {
                 struct thread_map map;
                 struct thread_map_data map_data;
         } thread_map;
 
+        if (rec->opts.tail_synthesize != tail)
+                return 0;
+
         thread_map.map.nr = 1;
         thread_map.map.map[0].pid = rec->evlist->workload.pid;
         thread_map.map.map[0].comm = NULL;
@@ -578,7 +634,7 @@ static int record__synthesize_workload(struct record *rec)
                                                  rec->opts.proc_map_timeout);
 }
 
-static int record__synthesize(struct record *rec);
+static int record__synthesize(struct record *rec, bool tail);
 
 static int
 record__switch_output(struct record *rec, bool at_exit)
@@ -589,6 +645,10 @@ record__switch_output(struct record *rec, bool at_exit)
         /* Same Size:      "2015122520103046"*/
         char timestamp[] = "InvalidTimestamp";
 
+        record__synthesize(rec, true);
+        if (target__none(&rec->opts.target))
+                record__synthesize_workload(rec, true);
+
         rec->samples = 0;
         record__finish_output(rec);
         err = fetch_current_timestamp(timestamp, sizeof(timestamp));
@@ -611,7 +671,7 @@ record__switch_output(struct record *rec, bool at_exit)
 
         /* Output tracking events */
         if (!at_exit) {
-                record__synthesize(rec);
+                record__synthesize(rec, false);
 
                 /*
                  * In 'perf record --switch-output' without -a,
@@ -623,7 +683,7 @@ record__switch_output(struct record *rec, bool at_exit)
                  * perf_event__synthesize_thread_map() for those events.
                  */
                 if (target__none(&rec->opts.target))
-                        record__synthesize_workload(rec);
+                        record__synthesize_workload(rec, false);
         }
         return fd;
 }
@@ -655,7 +715,29 @@ perf_event__synth_time_conv(const struct perf_event_mmap_page *pc __maybe_unused
         return 0;
 }
 
-static int record__synthesize(struct record *rec)
+static const struct perf_event_mmap_page *
+perf_evlist__pick_pc(struct perf_evlist *evlist)
+{
+        if (evlist) {
+                if (evlist->mmap && evlist->mmap[0].base)
+                        return evlist->mmap[0].base;
+                if (evlist->backward_mmap && evlist->backward_mmap[0].base)
+                        return evlist->backward_mmap[0].base;
+        }
+        return NULL;
+}
+
+static const struct perf_event_mmap_page *record__pick_pc(struct record *rec)
+{
+        const struct perf_event_mmap_page *pc;
+
+        pc = perf_evlist__pick_pc(rec->evlist);
+        if (pc)
+                return pc;
+        return NULL;
+}
+
+static int record__synthesize(struct record *rec, bool tail)
 {
         struct perf_session *session = rec->session;
         struct machine *machine = &session->machines.host;
@@ -665,6 +747,9 @@ static int record__synthesize(struct record *rec)
         int fd = perf_data_file__fd(file);
         int err = 0;
 
+        if (rec->opts.tail_synthesize != tail)
+                return 0;
+
         if (file->is_pipe) {
                 err = perf_event__synthesize_attrs(tool, session,
                                                    process_synthesized_event);
@@ -692,7 +777,7 @@ static int record__synthesize(struct record *rec)
                 }
         }
 
-        err = perf_event__synth_time_conv(rec->evlist->mmap[0].base, tool,
+        err = perf_event__synth_time_conv(record__pick_pc(rec), tool,
                                           process_synthesized_event, machine);
         if (err)
                 goto out;
@@ -828,7 +913,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
 
         machine = &session->machines.host;
 
-        err = record__synthesize(rec);
+        err = record__synthesize(rec, false);
         if (err < 0)
                 goto out_child;
 
@@ -879,7 +964,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         }
 
         if (opts->initial_delay) {
-                usleep(opts->initial_delay * 1000);
+                usleep(opts->initial_delay * USEC_PER_MSEC);
                 perf_evlist__enable(rec->evlist);
         }
 
@@ -888,6 +973,17 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         for (;;) {
                 unsigned long long hits = rec->samples;
 
+                /*
+                 * rec->evlist->bkw_mmap_state is possible to be
+                 * BKW_MMAP_EMPTY here: when done == true and
+                 * hits != rec->samples in previous round.
+                 *
+                 * perf_evlist__toggle_bkw_mmap ensure we never
+                 * convert BKW_MMAP_EMPTY to BKW_MMAP_DATA_PENDING.
+                 */
+                if (trigger_is_hit(&switch_output_trigger) || done || draining)
+                        perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_DATA_PENDING);
+
                 if (record__mmap_read_all(rec) < 0) {
                         trigger_error(&auxtrace_snapshot_trigger);
                         trigger_error(&switch_output_trigger);
@@ -907,8 +1003,26 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
                 }
 
                 if (trigger_is_hit(&switch_output_trigger)) {
+                        /*
+                         * If switch_output_trigger is hit, the data in
+                         * overwritable ring buffer should have been collected,
+                         * so bkw_mmap_state should be set to BKW_MMAP_EMPTY.
+                         *
+                         * If SIGUSR2 raise after or during record__mmap_read_all(),
+                         * record__mmap_read_all() didn't collect data from
+                         * overwritable ring buffer. Read again.
+                         */
+                        if (rec->evlist->bkw_mmap_state == BKW_MMAP_RUNNING)
+                                continue;
                         trigger_ready(&switch_output_trigger);
 
+                        /*
+                         * Reenable events in overwrite ring buffer after
+                         * record__mmap_read_all(): we should have collected
+                         * data from it.
+                         */
+                        perf_evlist__toggle_bkw_mmap(rec->evlist, BKW_MMAP_RUNNING);
+
                         if (!quiet)
                                 fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n",
                                         waking);
@@ -954,7 +1068,7 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
 
         if (forks && workload_exec_errno) {
                 char msg[STRERR_BUFSIZE];
-                const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
+                const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
                 pr_err("Workload failed: %s\n", emsg);
                 err = -1;
                 goto out_child;
@@ -963,6 +1077,9 @@ static int __cmd_record(struct record *rec, int argc, const char **argv)
         if (!quiet)
                 fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 
+        if (target__none(&rec->opts.target))
+                record__synthesize_workload(rec, true);
+
 out_child:
         if (forks) {
                 int exit_status;
@@ -981,6 +1098,7 @@ out_child:
         } else
                 status = err;
 
+        record__synthesize(rec, true);
         /* this will be recalculated during process_buildids() */
         rec->samples = 0;
 
@@ -1267,6 +1385,8 @@ static struct record record = {
 const char record_callchain_help[] = CALLCHAIN_RECORD_HELP
         "\n\t\t\t\tDefault: fp";
 
+static bool dry_run;
+
 /*
  * XXX Will stay a global variable till we fix builtin-script.c to stop messing
  * with it and switch to use the library functions in perf_evlist that came
@@ -1303,6 +1423,9 @@ struct option __record_options[] = {
         OPT_BOOLEAN_SET('i', "no-inherit", &record.opts.no_inherit,
                         &record.opts.no_inherit_set,
                         "child tasks do not inherit counters"),
+        OPT_BOOLEAN(0, "tail-synthesize", &record.opts.tail_synthesize,
+                    "synthesize non-sample events at the end of output"),
+        OPT_BOOLEAN(0, "overwrite", &record.opts.overwrite, "use overwrite mode"),
         OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
         OPT_CALLBACK('m', "mmap-pages", &record.opts, "pages[,pages]",
                      "number of mmap data pages and AUX area tracing mmap pages",
@@ -1321,6 +1444,7 @@ struct option __record_options[] = {
         OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
                     "per thread counts"),
         OPT_BOOLEAN('d', "data", &record.opts.sample_address, "Record the sample addresses"),
+        OPT_BOOLEAN(0, "sample-cpu", &record.opts.sample_cpu, "Record the sample cpu"),
         OPT_BOOLEAN_SET('T', "timestamp", &record.opts.sample_time,
                         &record.opts.sample_time_set,
                         "Record the sample timestamps"),
@@ -1386,6 +1510,8 @@ struct option __record_options[] = {
                     "append timestamp to output filename"),
         OPT_BOOLEAN(0, "switch-output", &record.switch_output,
                     "Switch output when receive SIGUSR2"),
+        OPT_BOOLEAN(0, "dry-run", &dry_run,
+                    "Parse options then exit"),
         OPT_END()
 };
 
@@ -1447,26 +1573,39 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
         if (!rec->itr) {
                 rec->itr = auxtrace_record__init(rec->evlist, &err);
                 if (err)
-                        return err;
+                        goto out;
         }
 
         err = auxtrace_parse_snapshot_options(rec->itr, &rec->opts,
                                               rec->opts.auxtrace_snapshot_opts);
         if (err)
-                return err;
+                goto out;
+
+        /*
+         * Allow aliases to facilitate the lookup of symbols for address
+         * filters. Refer to auxtrace_parse_filters().
+         */
+        symbol_conf.allow_aliases = true;
+
+        symbol__init(NULL);
+
+        err = auxtrace_parse_filters(rec->evlist);
+        if (err)
+                goto out;
+
+        if (dry_run)
+                goto out;
 
         err = bpf__setup_stdout(rec->evlist);
         if (err) {
                 bpf__strerror_setup_stdout(rec->evlist, err, errbuf, sizeof(errbuf));
                 pr_err("ERROR: Setup BPF stdout failed: %s\n",
                          errbuf);
-                return err;
+                goto out;
         }
 
         err = -ENOMEM;
 
-        symbol__init(NULL);
-
         if (symbol_conf.kptr_restrict)
                 pr_warning(
 "WARNING: Kernel address maps (/proc/{kallsyms,modules}) are restricted,\n"
@@ -1508,10 +1647,13 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
                 }
         }
 
+        if (record.opts.overwrite)
+                record.opts.tail_synthesize = true;
+
         if (rec->evlist->nr_entries == 0 &&
             perf_evlist__add_default(rec->evlist) < 0) {
                 pr_err("Not enough memory for event selector list\n");
-                goto out_symbol_exit;
+                goto out;
         }
 
         if (rec->opts.target.tid && !rec->opts.no_inherit_set)
@@ -1531,7 +1673,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
                 ui__error("%s", errbuf);
 
                 err = -saved_errno;
-                goto out_symbol_exit;
+                goto out;
         }
 
         err = -ENOMEM;
@@ -1540,7 +1682,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
 
         err = auxtrace_record__options(rec->itr, rec->evlist, &rec->opts);
         if (err)
-                goto out_symbol_exit;
+                goto out;
 
         /*
          * We take all buildids when the file contains
@@ -1552,11 +1694,11 @@ int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
 
         if (record_opts__config(&rec->opts)) {
                 err = -EINVAL;
-                goto out_symbol_exit;
+                goto out;
         }
 
         err = __cmd_record(&record, argc, argv);
-out_symbol_exit:
+out:
         perf_evlist__delete(rec->evlist);
         symbol__exit();
         auxtrace_record__free(rec->itr);
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index a87cb338bdf1..6e88460cd13d 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -8,7 +8,7 @@
 #include "builtin.h"
 
 #include "util/util.h"
-#include "util/cache.h"
+#include "util/config.h"
 
 #include "util/annotate.h"
 #include "util/color.h"
@@ -89,6 +89,10 @@ static int report__config(const char *var, const char *value, void *cb)
                 rep->queue_size = perf_config_u64(var, value);
                 return 0;
         }
+        if (!strcmp(var, "report.sort_order")) {
+                default_sort_order = strdup(value);
+                return 0;
+        }
 
         return 0;
 }
@@ -361,7 +365,7 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
         struct perf_evsel *pos;
 
         fprintf(stdout, "#\n# Total Lost Samples: %" PRIu64 "\n#\n", evlist->stats.total_lost_samples);
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 struct hists *hists = evsel__hists(pos);
                 const char *evname = perf_evsel__name(pos);
 
@@ -370,7 +374,8 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
                         continue;
 
                 hists__fprintf_nr_sample_events(hists, rep, evname, stdout);
-                hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout);
+                hists__fprintf(hists, true, 0, 0, rep->min_percent, stdout,
+                               symbol_conf.use_callchain);
                 fprintf(stdout, "\n\n");
         }
 
@@ -477,7 +482,7 @@ static int report__collapse_hists(struct report *rep)
 
         ui_progress__init(&prog, rep->nr_entries, "Merging related events...");
 
-        evlist__for_each(rep->session->evlist, pos) {
+        evlist__for_each_entry(rep->session->evlist, pos) {
                 struct hists *hists = evsel__hists(pos);
 
                 if (pos->idx == 0)
@@ -510,7 +515,7 @@ static void report__output_resort(struct report *rep)
 
         ui_progress__init(&prog, rep->nr_entries, "Sorting events for output...");
 
-        evlist__for_each(rep->session->evlist, pos)
+        evlist__for_each_entry(rep->session->evlist, pos)
                 perf_evsel__output_resort(pos, &prog);
 
         ui_progress__finish();
@@ -551,7 +556,7 @@ static int __cmd_report(struct report *rep)
 
         report__warn_kptr_restrict(rep);
 
-        evlist__for_each(session->evlist, pos)
+        evlist__for_each_entry(session->evlist, pos)
                 rep->nr_entries += evsel__hists(pos)->nr_entries;
 
         if (use_browser == 0) {
@@ -582,7 +587,7 @@ static int __cmd_report(struct report *rep)
          * might be changed during the collapse phase.
          */
         rep->nr_entries = 0;
-        evlist__for_each(session->evlist, pos)
+        evlist__for_each_entry(session->evlist, pos)
                 rep->nr_entries += evsel__hists(pos)->nr_entries;
 
         if (rep->nr_entries == 0) {
@@ -816,6 +821,9 @@ int cmd_report(int argc, const char **argv, const char *prefix __maybe_unused)
                     "Show raw trace event output (do not use print fmt or plugins)"),
         OPT_BOOLEAN(0, "hierarchy", &symbol_conf.report_hierarchy,
                     "Show entries in a hierarchy"),
+        OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
+                             "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
+                             stdio__config_color, "always"),
         OPT_END()
         };
         struct perf_data_file file = {
@@ -927,7 +935,6 @@ repeat:
 
         if (symbol_conf.report_hierarchy) {
                 /* disable incompatible options */
-                symbol_conf.event_group = false;
                 symbol_conf.cumulate_callchain = false;
 
                 if (field_order) {
@@ -976,9 +983,9 @@ repeat:
          * implementation.
          */
         if (ui__has_annotation()) {
-                symbol_conf.priv_size = sizeof(struct annotation);
-                machines__set_symbol_filter(&session->machines,
-                                            symbol__annotate_init);
+                ret = symbol__annotation_init();
+                if (ret < 0)
+                        goto error;
                 /*
                  * For searching by name on the "Browse map details".
                  * providing it only in verbose mode not to bloat too
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index afa057666c2a..f5503ca22e1c 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -26,6 +26,7 @@
 #include <pthread.h>
 #include <math.h>
 #include <api/fs/fs.h>
+#include <linux/time64.h>
 
 #define PR_SET_NAME             15               /* Set process name */
 #define MAX_CPUS                4096
@@ -199,7 +200,7 @@ static u64 get_nsecs(void)
 
         clock_gettime(CLOCK_MONOTONIC, &ts);
 
-        return ts.tv_sec * 1000000000ULL + ts.tv_nsec;
+        return ts.tv_sec * NSEC_PER_SEC + ts.tv_nsec;
 }
 
 static void burn_nsecs(struct perf_sched *sched, u64 nsecs)
@@ -223,7 +224,7 @@ static void sleep_nsecs(u64 nsecs)
 
 static void calibrate_run_measurement_overhead(struct perf_sched *sched)
 {
-        u64 T0, T1, delta, min_delta = 1000000000ULL;
+        u64 T0, T1, delta, min_delta = NSEC_PER_SEC;
         int i;
 
         for (i = 0; i < 10; i++) {
@@ -240,7 +241,7 @@ static void calibrate_run_measurement_overhead(struct perf_sched *sched)
 
 static void calibrate_sleep_measurement_overhead(struct perf_sched *sched)
 {
-        u64 T0, T1, delta, min_delta = 1000000000ULL;
+        u64 T0, T1, delta, min_delta = NSEC_PER_SEC;
         int i;
 
         for (i = 0; i < 10; i++) {
@@ -452,8 +453,8 @@ static u64 get_cpu_usage_nsec_parent(void)
         err = getrusage(RUSAGE_SELF, &ru);
         BUG_ON(err);
 
-        sum =  ru.ru_utime.tv_sec*1e9 + ru.ru_utime.tv_usec*1e3;
-        sum += ru.ru_stime.tv_sec*1e9 + ru.ru_stime.tv_usec*1e3;
+        sum =  ru.ru_utime.tv_sec * NSEC_PER_SEC + ru.ru_utime.tv_usec * NSEC_PER_USEC;
+        sum += ru.ru_stime.tv_sec * NSEC_PER_SEC + ru.ru_stime.tv_usec * NSEC_PER_USEC;
 
         return sum;
 }
@@ -494,7 +495,7 @@ force_again:
                 }
                 pr_err("Error: sys_perf_event_open() syscall returned "
                        "with %d (%s)\n%s", fd,
-                       strerror_r(errno, sbuf, sizeof(sbuf)), info);
+                       str_error_r(errno, sbuf, sizeof(sbuf)), info);
                 exit(EXIT_FAILURE);
         }
         return fd;
@@ -667,12 +668,12 @@ static void run_one_test(struct perf_sched *sched)
                 sched->run_avg = delta;
         sched->run_avg = (sched->run_avg * (sched->replay_repeat - 1) + delta) / sched->replay_repeat;
 
-        printf("#%-3ld: %0.3f, ", sched->nr_runs, (double)delta / 1000000.0);
+        printf("#%-3ld: %0.3f, ", sched->nr_runs, (double)delta / NSEC_PER_MSEC);
 
-        printf("ravg: %0.2f, ", (double)sched->run_avg / 1e6);
+        printf("ravg: %0.2f, ", (double)sched->run_avg / NSEC_PER_MSEC);
 
         printf("cpu: %0.2f / %0.2f",
-                (double)sched->cpu_usage / 1e6, (double)sched->runavg_cpu_usage / 1e6);
+                (double)sched->cpu_usage / NSEC_PER_MSEC, (double)sched->runavg_cpu_usage / NSEC_PER_MSEC);
 
 #if 0
         /*
@@ -680,8 +681,8 @@ static void run_one_test(struct perf_sched *sched)
          * accurate than the sched->sum_exec_runtime based statistics:
          */
         printf(" [%0.2f / %0.2f]",
-                (double)sched->parent_cpu_usage/1e6,
-                (double)sched->runavg_parent_cpu_usage/1e6);
+                (double)sched->parent_cpu_usage / NSEC_PER_MSEC,
+                (double)sched->runavg_parent_cpu_usage / NSEC_PER_MSEC);
 #endif
 
         printf("\n");
@@ -696,13 +697,13 @@ static void test_calibrations(struct perf_sched *sched)
         u64 T0, T1;
 
         T0 = get_nsecs();
-        burn_nsecs(sched, 1e6);
+        burn_nsecs(sched, NSEC_PER_MSEC);
         T1 = get_nsecs();
 
         printf("the run test took %" PRIu64 " nsecs\n", T1 - T0);
 
         T0 = get_nsecs();
-        sleep_nsecs(1e6);
+        sleep_nsecs(NSEC_PER_MSEC);
         T1 = get_nsecs();
 
         printf("the sleep test took %" PRIu64 " nsecs\n", T1 - T0);
@@ -1213,10 +1214,10 @@ static void output_lat_thread(struct perf_sched *sched, struct work_atoms *work_
         avg = work_list->total_lat / work_list->nb_atoms;
 
         printf("|%11.3f ms |%9" PRIu64 " | avg:%9.3f ms | max:%9.3f ms | max at: %13.6f s\n",
-              (double)work_list->total_runtime / 1e6,
-                 work_list->nb_atoms, (double)avg / 1e6,
-                 (double)work_list->max_lat / 1e6,
-                 (double)work_list->max_lat_at / 1e9);
+              (double)work_list->total_runtime / NSEC_PER_MSEC,
+                 work_list->nb_atoms, (double)avg / NSEC_PER_MSEC,
+                 (double)work_list->max_lat / NSEC_PER_MSEC,
+                 (double)work_list->max_lat_at / NSEC_PER_SEC);
 }
 
 static int pid_cmp(struct work_atoms *l, struct work_atoms *r)
@@ -1491,7 +1492,7 @@ static int map_switch_event(struct perf_sched *sched, struct perf_evsel *evsel,
         if (sched->map.cpus && !cpu_map__has(sched->map.cpus, this_cpu))
                 goto out;
 
-        color_fprintf(stdout, color, "  %12.6f secs ", (double)timestamp/1e9);
+        color_fprintf(stdout, color, "  %12.6f secs ", (double)timestamp / NSEC_PER_SEC);
         if (new_shortname) {
                 const char *pid_color = color;
 
@@ -1753,7 +1754,7 @@ static int perf_sched__lat(struct perf_sched *sched)
 
         printf(" -----------------------------------------------------------------------------------------------------------------\n");
         printf("  TOTAL:                |%11.3f ms |%9" PRIu64 " |\n",
-                (double)sched->all_runtime / 1e6, sched->all_count);
+                (double)sched->all_runtime / NSEC_PER_MSEC, sched->all_count);
 
         printf(" ---------------------------------------------------\n");
 
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index e3ce2f34d3ad..7228d141a789 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -21,8 +21,10 @@
 #include "util/cpumap.h"
 #include "util/thread_map.h"
 #include "util/stat.h"
+#include "util/thread-stack.h"
 #include <linux/bitmap.h>
 #include <linux/stringify.h>
+#include <linux/time64.h>
 #include "asm/bug.h"
 #include "util/mem-events.h"
 
@@ -63,6 +65,7 @@ enum perf_output_field {
         PERF_OUTPUT_DATA_SRC        = 1U << 17,
         PERF_OUTPUT_WEIGHT          = 1U << 18,
         PERF_OUTPUT_BPF_OUTPUT      = 1U << 19,
+        PERF_OUTPUT_CALLINDENT      = 1U << 20,
 };
 
 struct output_option {
@@ -89,6 +92,7 @@ struct output_option {
         {.str = "data_src", .field = PERF_OUTPUT_DATA_SRC},
         {.str = "weight",   .field = PERF_OUTPUT_WEIGHT},
         {.str = "bpf-output",   .field = PERF_OUTPUT_BPF_OUTPUT},
+        {.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},
 };
 
 /* default set to maintain compatibility with current format */
@@ -339,7 +343,7 @@ static void set_print_ip_opts(struct perf_event_attr *attr)
  */
 static int perf_session__check_output_opt(struct perf_session *session)
 {
-        int j;
+        unsigned int j;
         struct perf_evsel *evsel;
 
         for (j = 0; j < PERF_TYPE_MAX; ++j) {
@@ -368,14 +372,16 @@ static int perf_session__check_output_opt(struct perf_session *session)
 
         if (!no_callchain) {
                 bool use_callchain = false;
+                bool not_pipe = false;
 
-                evlist__for_each(session->evlist, evsel) {
+                evlist__for_each_entry(session->evlist, evsel) {
+                        not_pipe = true;
                         if (evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
                                 use_callchain = true;
                                 break;
                         }
                 }
-                if (!use_callchain)
+                if (not_pipe && !use_callchain)
                         symbol_conf.use_callchain = false;
         }
 
@@ -388,17 +394,20 @@ static int perf_session__check_output_opt(struct perf_session *session)
                 struct perf_event_attr *attr;
 
                 j = PERF_TYPE_TRACEPOINT;
-                evsel = perf_session__find_first_evtype(session, j);
-                if (evsel == NULL)
-                        goto out;
 
-                attr = &evsel->attr;
+                evlist__for_each_entry(session->evlist, evsel) {
+                        if (evsel->attr.type != j)
+                                continue;
+
+                        attr = &evsel->attr;
 
-                if (attr->sample_type & PERF_SAMPLE_CALLCHAIN) {
-                        output[j].fields |= PERF_OUTPUT_IP;
-                        output[j].fields |= PERF_OUTPUT_SYM;
-                        output[j].fields |= PERF_OUTPUT_DSO;
-                        set_print_ip_opts(attr);
+                        if (attr->sample_type & PERF_SAMPLE_CALLCHAIN) {
+                                output[j].fields |= PERF_OUTPUT_IP;
+                                output[j].fields |= PERF_OUTPUT_SYM;
+                                output[j].fields |= PERF_OUTPUT_DSO;
+                                set_print_ip_opts(attr);
+                                goto out;
+                        }
                 }
         }
 
@@ -456,9 +465,9 @@ static void print_sample_start(struct perf_sample *sample,
 
         if (PRINT_FIELD(TIME)) {
                 nsecs = sample->time;
-                secs = nsecs / NSECS_PER_SEC;
-                nsecs -= secs * NSECS_PER_SEC;
-                usecs = nsecs / NSECS_PER_USEC;
+                secs = nsecs / NSEC_PER_SEC;
+                nsecs -= secs * NSEC_PER_SEC;
+                usecs = nsecs / NSEC_PER_USEC;
                 if (nanosecs)
                         printf("%5lu.%09llu: ", secs, nsecs);
                 else
@@ -513,11 +522,11 @@ static void print_sample_brstacksym(struct perf_sample *sample,
 
                 thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
                 if (alf.map)
-                        alf.sym = map__find_symbol(alf.map, alf.addr, NULL);
+                        alf.sym = map__find_symbol(alf.map, alf.addr);
 
                 thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
                 if (alt.map)
-                        alt.sym = map__find_symbol(alt.map, alt.addr, NULL);
+                        alt.sym = map__find_symbol(alt.map, alt.addr);
 
                 symbol__fprintf_symname_offs(alf.sym, &alf, stdout);
                 putchar('/');
@@ -559,6 +568,62 @@ static void print_sample_addr(struct perf_sample *sample,
         }
 }
 
+static void print_sample_callindent(struct perf_sample *sample,
+                                    struct perf_evsel *evsel,
+                                    struct thread *thread,
+                                    struct addr_location *al)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+        size_t depth = thread_stack__depth(thread);
+        struct addr_location addr_al;
+        const char *name = NULL;
+        static int spacing;
+        int len = 0;
+        u64 ip = 0;
+
+        /*
+         * The 'return' has already been popped off the stack so the depth has
+         * to be adjusted to match the 'call'.
+         */
+        if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
+                depth += 1;
+
+        if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
+                if (sample_addr_correlates_sym(attr)) {
+                        thread__resolve(thread, &addr_al, sample);
+                        if (addr_al.sym)
+                                name = addr_al.sym->name;
+                        else
+                                ip = sample->addr;
+                } else {
+                        ip = sample->addr;
+                }
+        } else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
+                if (al->sym)
+                        name = al->sym->name;
+                else
+                        ip = sample->ip;
+        }
+
+        if (name)
+                len = printf("%*s%s", (int)depth * 4, "", name);
+        else if (ip)
+                len = printf("%*s%16" PRIx64, (int)depth * 4, "", ip);
+
+        if (len < 0)
+                return;
+
+        /*
+         * Try to keep the output length from changing frequently so that the
+         * output lines up more nicely.
+         */
+        if (len > spacing || (len && len < spacing - 52))
+                spacing = round_up(len + 4, 32);
+
+        if (len < spacing)
+                printf("%*s", spacing - len, "");
+}
+
 static void print_sample_bts(struct perf_sample *sample,
                              struct perf_evsel *evsel,
                              struct thread *thread,
@@ -567,6 +632,9 @@ static void print_sample_bts(struct perf_sample *sample,
         struct perf_event_attr *attr = &evsel->attr;
         bool print_srcline_last = false;
 
+        if (PRINT_FIELD(CALLINDENT))
+                print_sample_callindent(sample, evsel, thread, al);
+
         /* print branch_from information */
         if (PRINT_FIELD(IP)) {
                 unsigned int print_opts = output[attr->type].print_ip_opts;
@@ -603,13 +671,42 @@ static void print_sample_bts(struct perf_sample *sample,
         printf("\n");
 }
 
+static struct {
+        u32 flags;
+        const char *name;
+} sample_flags[] = {
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL, "call"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN, "return"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL, "jcc"},
+        {PERF_IP_FLAG_BRANCH, "jmp"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_INTERRUPT, "int"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_INTERRUPT, "iret"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_SYSCALLRET, "syscall"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_SYSCALLRET, "sysret"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_ASYNC, "async"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC | PERF_IP_FLAG_INTERRUPT, "hw int"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TX_ABORT, "tx abrt"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_BEGIN, "tr strt"},
+        {PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_END, "tr end"},
+        {0, NULL}
+};
+
 static void print_sample_flags(u32 flags)
 {
         const char *chars = PERF_IP_FLAG_CHARS;
         const int n = strlen(PERF_IP_FLAG_CHARS);
+        bool in_tx = flags & PERF_IP_FLAG_IN_TX;
+        const char *name = NULL;
         char str[33];
         int i, pos = 0;
 
+        for (i = 0; sample_flags[i].name ; i++) {
+                if (sample_flags[i].flags == (flags & ~PERF_IP_FLAG_IN_TX)) {
+                        name = sample_flags[i].name;
+                        break;
+                }
+        }
+
         for (i = 0; i < n; i++, flags >>= 1) {
                 if (flags & 1)
                         str[pos++] = chars[i];
@@ -619,7 +716,11 @@ static void print_sample_flags(u32 flags)
                         str[pos++] = '?';
         }
         str[pos] = 0;
-        printf("  %-4s ", str);
+
+        if (name)
+                printf("  %-7s%4s ", name, in_tx ? "(x)" : "");
+        else
+                printf("  %-11s ", str);
 }
 
 struct printer_data {
@@ -717,7 +818,7 @@ static int perf_evlist__max_name_len(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         int max = 0;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 int len = strlen(perf_evsel__name(evsel));
 
                 max = MAX(len, max);
@@ -942,7 +1043,7 @@ static int process_attr(struct perf_tool *tool, union perf_event *event,
         if (evsel->attr.type >= PERF_TYPE_MAX)
                 return 0;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (pos->attr.type == evsel->attr.type && pos != evsel)
                         return 0;
         }
@@ -1592,8 +1693,13 @@ static int list_available_scripts(const struct option *opt __maybe_unused,
         snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
 
         scripts_dir = opendir(scripts_path);
-        if (!scripts_dir)
-                return -1;
+        if (!scripts_dir) {
+                fprintf(stdout,
+                        "open(%s) failed.\n"
+                        "Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
+                        scripts_path);
+                exit(-1);
+        }
 
         for_each_lang(scripts_path, scripts_dir, lang_dirent) {
                 snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
@@ -1668,7 +1774,7 @@ static int check_ev_match(char *dir_name, char *scriptname,
                         snprintf(evname, len + 1, "%s", p);
 
                         match = 0;
-                        evlist__for_each(session->evlist, pos) {
+                        evlist__for_each_entry(session->evlist, pos) {
                                 if (!strcmp(perf_evsel__name(pos), evname)) {
                                         match = 1;
                                         break;
@@ -1870,7 +1976,7 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
         struct stat_round_event *round = &event->stat_round;
         struct perf_evsel *counter;
 
-        evlist__for_each(session->evlist, counter) {
+        evlist__for_each_entry(session->evlist, counter) {
                 perf_stat_process_counter(&stat_config, counter);
                 process_stat(counter, round->time);
         }
@@ -2017,7 +2123,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
                      "comma separated output fields prepend with 'type:'. "
                      "Valid types: hw,sw,trace,raw. "
                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
-                     "addr,symoff,period,iregs,brstack,brstacksym,flags", parse_output_fields),
+                     "addr,symoff,period,iregs,brstack,brstacksym,flags,"
+                     "bpf-output,callindent", parse_output_fields),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
         OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
@@ -2256,6 +2363,9 @@ int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
         script.session = session;
         script__setup_sample_type(&script);
 
+        if (output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT)
+                itrace_synth_opts.thread_stack = true;
+
         session->itrace_synth_opts = &itrace_synth_opts;
 
         if (cpu_list) {
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index ee7ada78d86f..688dea7cb08f 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -52,6 +52,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/debug.h"
+#include "util/drv_configs.h"
 #include "util/color.h"
 #include "util/stat.h"
 #include "util/header.h"
@@ -59,10 +60,14 @@
 #include "util/thread.h"
 #include "util/thread_map.h"
 #include "util/counts.h"
+#include "util/group.h"
 #include "util/session.h"
 #include "util/tool.h"
+#include "util/group.h"
 #include "asm/bug.h"
 
+#include <linux/time64.h>
+#include <api/fs/fs.h>
 #include <stdlib.h>
 #include <sys/prctl.h>
 #include <locale.h>
@@ -98,6 +103,15 @@ static const char * transaction_limited_attrs = {
         "}"
 };
 
+static const char * topdown_attrs[] = {
+        "topdown-total-slots",
+        "topdown-slots-retired",
+        "topdown-recovery-bubbles",
+        "topdown-fetch-bubbles",
+        "topdown-slots-issued",
+        NULL,
+};
+
 static struct perf_evlist       *evsel_list;
 
 static struct target target = {
@@ -112,6 +126,7 @@ static volatile pid_t		child_pid			= -1;
 static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
 static bool                     transaction_run;
+static bool                     topdown_run                     = false;
 static bool                     big_num                         =  true;
 static int                      big_num_opt                     =  -1;
 static const char               *csv_sep                        = NULL;
@@ -124,6 +139,7 @@ static unsigned int		initial_delay			= 0;
 static unsigned int             unit_width                      = 4; /* strlen("unit") */
 static bool                     forever                         = false;
 static bool                     metric_only                     = false;
+static bool                     force_metric_only               = false;
 static struct timespec          ref_time;
 static struct cpu_map           *aggr_map;
 static aggr_get_id_t            aggr_get_id;
@@ -158,7 +174,7 @@ static inline void diff_timespec(struct timespec *r, struct timespec *a,
 {
         r->tv_sec = a->tv_sec - b->tv_sec;
         if (a->tv_nsec < b->tv_nsec) {
-                r->tv_nsec = a->tv_nsec + 1000000000L - b->tv_nsec;
+                r->tv_nsec = a->tv_nsec + NSEC_PER_SEC - b->tv_nsec;
                 r->tv_sec--;
         } else {
                 r->tv_nsec = a->tv_nsec - b->tv_nsec ;
@@ -276,8 +292,12 @@ perf_evsel__write_stat_event(struct perf_evsel *counter, u32 cpu, u32 thread,
 static int read_counter(struct perf_evsel *counter)
 {
         int nthreads = thread_map__nr(evsel_list->threads);
-        int ncpus = perf_evsel__nr_cpus(counter);
-        int cpu, thread;
+        int ncpus, cpu, thread;
+
+        if (target__has_cpu(&target))
+                ncpus = perf_evsel__nr_cpus(counter);
+        else
+                ncpus = 1;
 
         if (!counter->supported)
                 return -ENOENT;
@@ -313,21 +333,16 @@ static int read_counter(struct perf_evsel *counter)
         return 0;
 }
 
-static void read_counters(bool close_counters)
+static void read_counters(void)
 {
         struct perf_evsel *counter;
 
-        evlist__for_each(evsel_list, counter) {
+        evlist__for_each_entry(evsel_list, counter) {
                 if (read_counter(counter))
                         pr_debug("failed to read counter %s\n", counter->name);
 
                 if (perf_stat_process_counter(&stat_config, counter))
                         pr_warning("failed to process counter %s\n", counter->name);
-
-                if (close_counters) {
-                        perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter),
-                                             thread_map__nr(evsel_list->threads));
-                }
         }
 }
 
@@ -335,13 +350,13 @@ static void process_interval(void)
 {
         struct timespec ts, rs;
 
-        read_counters(false);
+        read_counters();
 
         clock_gettime(CLOCK_MONOTONIC, &ts);
         diff_timespec(&rs, &ts, &ref_time);
 
         if (STAT_RECORD) {
-                if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSECS_PER_SEC + rs.tv_nsec, INTERVAL))
+                if (WRITE_STAT_ROUND_EVENT(rs.tv_sec * NSEC_PER_SEC + rs.tv_nsec, INTERVAL))
                         pr_err("failed to write stat round event\n");
         }
 
@@ -351,7 +366,7 @@ static void process_interval(void)
 static void enable_counters(void)
 {
         if (initial_delay)
-                usleep(initial_delay * 1000);
+                usleep(initial_delay * USEC_PER_MSEC);
 
         /*
          * We need to enable counters only if:
@@ -362,6 +377,17 @@ static void enable_counters(void)
                 perf_evlist__enable(evsel_list);
 }
 
+static void disable_counters(void)
+{
+        /*
+         * If we don't have tracee (attaching to task or cpu), counters may
+         * still be running. To get accurate group ratios, we must stop groups
+         * from counting before reading their constituent counters.
+         */
+        if (!target__none(&target))
+                perf_evlist__disable(evsel_list);
+}
+
 static volatile int workload_exec_errno;
 
 /*
@@ -403,7 +429,7 @@ static int perf_stat_synthesize_config(bool is_pipe)
          * Synthesize other events stuff not carried within
          * attr event - unit, scale, name
          */
-        evlist__for_each(evsel_list, counter) {
+        evlist__for_each_entry(evsel_list, counter) {
                 if (!counter->supported)
                         continue;
 
@@ -515,10 +541,11 @@ static int __run_perf_stat(int argc, const char **argv)
         int status = 0;
         const bool forks = (argc > 0);
         bool is_pipe = STAT_RECORD ? perf_stat.file.is_pipe : false;
+        struct perf_evsel_config_term *err_term;
 
         if (interval) {
-                ts.tv_sec  = interval / 1000;
-                ts.tv_nsec = (interval % 1000) * 1000000;
+                ts.tv_sec  = interval / USEC_PER_MSEC;
+                ts.tv_nsec = (interval % USEC_PER_MSEC) * NSEC_PER_MSEC;
         } else {
                 ts.tv_sec  = 1;
                 ts.tv_nsec = 0;
@@ -536,7 +563,7 @@ static int __run_perf_stat(int argc, const char **argv)
         if (group)
                 perf_evlist__set_leader(evsel_list);
 
-        evlist__for_each(evsel_list, counter) {
+        evlist__for_each_entry(evsel_list, counter) {
 try_again:
                 if (create_perf_stat_counter(counter) < 0) {
                         /*
@@ -582,7 +609,14 @@ try_again:
         if (perf_evlist__apply_filters(evsel_list, &counter)) {
                 error("failed to set filter \"%s\" on event %s with %d (%s)\n",
                         counter->filter, perf_evsel__name(counter), errno,
-                        strerror_r(errno, msg, sizeof(msg)));
+                        str_error_r(errno, msg, sizeof(msg)));
+                return -1;
+        }
+
+        if (perf_evlist__apply_drv_configs(evsel_list, &counter, &err_term)) {
+                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                      err_term->val.drv_cfg, perf_evsel__name(counter), errno,
+                      str_error_r(errno, msg, sizeof(msg)));
                 return -1;
         }
 
@@ -623,7 +657,7 @@ try_again:
                 wait(&status);
 
                 if (workload_exec_errno) {
-                        const char *emsg = strerror_r(workload_exec_errno, msg, sizeof(msg));
+                        const char *emsg = str_error_r(workload_exec_errno, msg, sizeof(msg));
                         pr_err("Workload failed: %s\n", emsg);
                         return -1;
                 }
@@ -639,11 +673,20 @@ try_again:
                 }
         }
 
+        disable_counters();
+
         t1 = rdclock();
 
         update_stats(&walltime_nsecs_stats, t1 - t0);
 
-        read_counters(true);
+        /*
+         * Closing a group leader splits the group, and as we only disable
+         * group leaders, results in remaining events becoming enabled. To
+         * avoid arbitrary skew, we must read all counters before closing any
+         * group leaders.
+         */
+        read_counters();
+        perf_evlist__close(evsel_list);
 
         return WEXITSTATUS(status);
 }
@@ -938,7 +981,7 @@ static void print_metric_header(void *ctx, const char *color __maybe_unused,
 static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
 {
         FILE *output = stat_config.output;
-        double msecs = avg / 1e6;
+        double msecs = avg / NSEC_PER_MSEC;
         const char *fmt_v, *fmt_n;
         char name[25];
 
@@ -1120,7 +1163,7 @@ static void aggr_update_shadow(void)
 
         for (s = 0; s < aggr_map->nr; s++) {
                 id = aggr_map->map[s];
-                evlist__for_each(evsel_list, counter) {
+                evlist__for_each_entry(evsel_list, counter) {
                         val = 0;
                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
                                 s2 = aggr_get_id(evsel_list->cpus, cpu);
@@ -1159,7 +1202,7 @@ static void print_aggr(char *prefix)
 
                 id = aggr_map->map[s];
                 first = true;
-                evlist__for_each(evsel_list, counter) {
+                evlist__for_each_entry(evsel_list, counter) {
                         val = ena = run = 0;
                         nr = 0;
                         for (cpu = 0; cpu < perf_evsel__nr_cpus(counter); cpu++) {
@@ -1278,7 +1321,7 @@ static void print_no_aggr_metric(char *prefix)
 
                 if (prefix)
                         fputs(prefix, stat_config.output);
-                evlist__for_each(evsel_list, counter) {
+                evlist__for_each_entry(evsel_list, counter) {
                         if (first) {
                                 aggr_printout(counter, cpu, 0);
                                 first = false;
@@ -1302,7 +1345,15 @@ static int aggr_header_lens[] = {
         [AGGR_GLOBAL] = 0,
 };
 
-static void print_metric_headers(char *prefix)
+static const char *aggr_header_csv[] = {
+        [AGGR_CORE]     =       "core,cpus,",
+        [AGGR_SOCKET]   =       "socket,cpus",
+        [AGGR_NONE]     =       "cpu,",
+        [AGGR_THREAD]   =       "comm-pid,",
+        [AGGR_GLOBAL]   =       ""
+};
+
+static void print_metric_headers(const char *prefix, bool no_indent)
 {
         struct perf_stat_output_ctx out;
         struct perf_evsel *counter;
@@ -1313,12 +1364,18 @@ static void print_metric_headers(char *prefix)
         if (prefix)
                 fprintf(stat_config.output, "%s", prefix);
 
-        if (!csv_output)
+        if (!csv_output && !no_indent)
                 fprintf(stat_config.output, "%*s",
                         aggr_header_lens[stat_config.aggr_mode], "");
+        if (csv_output) {
+                if (stat_config.interval)
+                        fputs("time,", stat_config.output);
+                fputs(aggr_header_csv[stat_config.aggr_mode],
+                        stat_config.output);
+        }
 
         /* Print metrics headers only */
-        evlist__for_each(evsel_list, counter) {
+        evlist__for_each_entry(evsel_list, counter) {
                 os.evsel = counter;
                 out.ctx = &os;
                 out.print_metric = print_metric_header;
@@ -1338,28 +1395,40 @@ static void print_interval(char *prefix, struct timespec *ts)
 
         sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);
 
-        if (num_print_interval == 0 && !csv_output && !metric_only) {
+        if (num_print_interval == 0 && !csv_output) {
                 switch (stat_config.aggr_mode) {
                 case AGGR_SOCKET:
-                        fprintf(output, "#           time socket cpus             counts %*s events\n", unit_width, "unit");
+                        fprintf(output, "#           time socket cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
                         break;
                 case AGGR_CORE:
-                        fprintf(output, "#           time core         cpus             counts %*s events\n", unit_width, "unit");
+                        fprintf(output, "#           time core         cpus");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
                         break;
                 case AGGR_NONE:
-                        fprintf(output, "#           time CPU                counts %*s events\n", unit_width, "unit");
+                        fprintf(output, "#           time CPU");
+                        if (!metric_only)
+                                fprintf(output, "                counts %*s events\n", unit_width, "unit");
                         break;
                 case AGGR_THREAD:
-                        fprintf(output, "#           time             comm-pid                  counts %*s events\n", unit_width, "unit");
+                        fprintf(output, "#           time             comm-pid");
+                        if (!metric_only)
+                                fprintf(output, "                  counts %*s events\n", unit_width, "unit");
                         break;
                 case AGGR_GLOBAL:
                 default:
-                        fprintf(output, "#           time             counts %*s events\n", unit_width, "unit");
+                        fprintf(output, "#           time");
+                        if (!metric_only)
+                                fprintf(output, "             counts %*s events\n", unit_width, "unit");
                 case AGGR_UNSET:
                         break;
                 }
         }
 
+        if (num_print_interval == 0 && metric_only)
+                print_metric_headers(" ", true);
         if (++num_print_interval == 25)
                 num_print_interval = 0;
 }
@@ -1401,7 +1470,7 @@ static void print_footer(void)
         if (!null_run)
                 fprintf(output, "\n");
         fprintf(output, " %17.9f seconds time elapsed",
-                        avg_stats(&walltime_nsecs_stats)/1e9);
+                        avg_stats(&walltime_nsecs_stats) / NSEC_PER_SEC);
         if (run_count > 1) {
                 fprintf(output, "                                        ");
                 print_noise_pct(stddev_stats(&walltime_nsecs_stats),
@@ -1428,8 +1497,8 @@ static void print_counters(struct timespec *ts, int argc, const char **argv)
         if (metric_only) {
                 static int num_print_iv;
 
-                if (num_print_iv == 0)
-                        print_metric_headers(prefix);
+                if (num_print_iv == 0 && !interval)
+                        print_metric_headers(prefix, false);
                 if (num_print_iv++ == 25)
                         num_print_iv = 0;
                 if (stat_config.aggr_mode == AGGR_GLOBAL && prefix)
@@ -1442,11 +1511,11 @@ static void print_counters(struct timespec *ts, int argc, const char **argv)
                 print_aggr(prefix);
                 break;
         case AGGR_THREAD:
-                evlist__for_each(evsel_list, counter)
+                evlist__for_each_entry(evsel_list, counter)
                         print_aggr_thread(counter, prefix);
                 break;
         case AGGR_GLOBAL:
-                evlist__for_each(evsel_list, counter)
+                evlist__for_each_entry(evsel_list, counter)
                         print_counter_aggr(counter, prefix);
                 if (metric_only)
                         fputc('\n', stat_config.output);
@@ -1455,7 +1524,7 @@ static void print_counters(struct timespec *ts, int argc, const char **argv)
                 if (metric_only)
                         print_no_aggr_metric(prefix);
                 else {
-                        evlist__for_each(evsel_list, counter)
+                        evlist__for_each_entry(evsel_list, counter)
                                 print_counter(counter, prefix);
                 }
                 break;
@@ -1520,6 +1589,14 @@ static int stat__set_big_num(const struct option *opt __maybe_unused,
         return 0;
 }
 
+static int enable_metric_only(const struct option *opt __maybe_unused,
+                              const char *s __maybe_unused, int unset)
+{
+        force_metric_only = true;
+        metric_only = !unset;
+        return 0;
+}
+
 static const struct option stat_options[] = {
         OPT_BOOLEAN('T', "transaction", &transaction_run,
                     "hardware transaction statistics"),
@@ -1578,8 +1655,10 @@ static const struct option stat_options[] = {
                      "aggregate counts per thread", AGGR_THREAD),
         OPT_UINTEGER('D', "delay", &initial_delay,
                      "ms to wait before starting measurement after program start"),
-        OPT_BOOLEAN(0, "metric-only", &metric_only,
-                        "Only print computed metrics. No raw values"),
+        OPT_CALLBACK_NOOPT(0, "metric-only", &metric_only, NULL,
+                        "Only print computed metrics. No raw values", enable_metric_only),
+        OPT_BOOLEAN(0, "topdown", &topdown_run,
+                        "measure topdown level 1 statistics"),
         OPT_END()
 };
 
@@ -1772,12 +1851,62 @@ static int perf_stat_init_aggr_mode_file(struct perf_stat *st)
         return 0;
 }
 
+static int topdown_filter_events(const char **attr, char **str, bool use_group)
+{
+        int off = 0;
+        int i;
+        int len = 0;
+        char *s;
+
+        for (i = 0; attr[i]; i++) {
+                if (pmu_have_event("cpu", attr[i])) {
+                        len += strlen(attr[i]) + 1;
+                        attr[i - off] = attr[i];
+                } else
+                        off++;
+        }
+        attr[i - off] = NULL;
+
+        *str = malloc(len + 1 + 2);
+        if (!*str)
+                return -1;
+        s = *str;
+        if (i - off == 0) {
+                *s = 0;
+                return 0;
+        }
+        if (use_group)
+                *s++ = '{';
+        for (i = 0; attr[i]; i++) {
+                strcpy(s, attr[i]);
+                s += strlen(s);
+                *s++ = ',';
+        }
+        if (use_group) {
+                s[-1] = '}';
+                *s = 0;
+        } else
+                s[-1] = 0;
+        return 0;
+}
+
+__weak bool arch_topdown_check_group(bool *warn)
+{
+        *warn = false;
+        return false;
+}
+
+__weak void arch_topdown_group_warn(void)
+{
+}
+
 /*
  * Add default attributes, if there were no attributes specified or
  * if -d/--detailed, -d -d or -d -d -d is used:
  */
 static int add_default_attributes(void)
 {
+        int err;
         struct perf_event_attr default_attrs0[] = {
 
   { .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_TASK_CLOCK              },
@@ -1896,7 +2025,6 @@ static int add_default_attributes(void)
                 return 0;
 
         if (transaction_run) {
-                int err;
                 if (pmu_have_event("cpu", "cycles-ct") &&
                     pmu_have_event("cpu", "el-start"))
                         err = parse_events(evsel_list, transaction_attrs, NULL);
@@ -1909,6 +2037,46 @@ static int add_default_attributes(void)
                 return 0;
         }
 
+        if (topdown_run) {
+                char *str = NULL;
+                bool warn = false;
+
+                if (stat_config.aggr_mode != AGGR_GLOBAL &&
+                    stat_config.aggr_mode != AGGR_CORE) {
+                        pr_err("top down event configuration requires --per-core mode\n");
+                        return -1;
+                }
+                stat_config.aggr_mode = AGGR_CORE;
+                if (nr_cgroups || !target__has_cpu(&target)) {
+                        pr_err("top down event configuration requires system-wide mode (-a)\n");
+                        return -1;
+                }
+
+                if (!force_metric_only)
+                        metric_only = true;
+                if (topdown_filter_events(topdown_attrs, &str,
+                                arch_topdown_check_group(&warn)) < 0) {
+                        pr_err("Out of memory\n");
+                        return -1;
+                }
+                if (topdown_attrs[0] && str) {
+                        if (warn)
+                                arch_topdown_group_warn();
+                        err = parse_events(evsel_list, str, NULL);
+                        if (err) {
+                                fprintf(stderr,
+                                        "Cannot set up top down events %s: %d\n",
+                                        str, err);
+                                free(str);
+                                return -1;
+                        }
+                } else {
+                        fprintf(stderr, "System does not support topdown\n");
+                        return -1;
+                }
+                free(str);
+        }
+
         if (!evsel_list->nr_entries) {
                 if (target__has_cpu(&target))
                         default_attrs0[0].config = PERF_COUNT_SW_CPU_CLOCK;
@@ -2010,15 +2178,15 @@ static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
         const char **argv = session->header.env.cmdline_argv;
         int argc = session->header.env.nr_cmdline;
 
-        evlist__for_each(evsel_list, counter)
+        evlist__for_each_entry(evsel_list, counter)
                 perf_stat_process_counter(&stat_config, counter);
 
         if (stat_round->type == PERF_STAT_ROUND_TYPE__FINAL)
                 update_stats(&walltime_nsecs_stats, stat_round->time);
 
         if (stat_config.interval && stat_round->time) {
-                tsh.tv_sec  = stat_round->time / NSECS_PER_SEC;
-                tsh.tv_nsec = stat_round->time % NSECS_PER_SEC;
+                tsh.tv_sec  = stat_round->time / NSEC_PER_SEC;
+                tsh.tv_nsec = stat_round->time % NSEC_PER_SEC;
                 ts = &tsh;
         }
 
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 733a55422d03..e7eaa298d34a 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -24,6 +24,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include <linux/rbtree.h>
+#include <linux/time64.h>
 #include "util/symbol.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
@@ -1288,9 +1289,9 @@ static void draw_process_bars(struct timechart *tchart)
                         if (c->comm) {
                                 char comm[256];
                                 if (c->total_time > 5000000000) /* 5 seconds */
-                                        sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / 1000000000.0);
+                                        sprintf(comm, "%s:%i (%2.2fs)", c->comm, p->pid, c->total_time / (double)NSEC_PER_SEC);
                                 else
-                                        sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / 1000000.0);
+                                        sprintf(comm, "%s:%i (%3.1fms)", c->comm, p->pid, c->total_time / (double)NSEC_PER_MSEC);
 
                                 svg_text(Y, c->start_time, comm);
                         }
@@ -1637,7 +1638,7 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
         write_svg_file(tchart, output_name);
 
         pr_info("Written %2.1f seconds of trace to %s.\n",
-                (tchart->last_time - tchart->first_time) / 1000000000.0, output_name);
+                (tchart->last_time - tchart->first_time) / (double)NSEC_PER_SEC, output_name);
 out_delete:
         perf_session__delete(session);
         return ret;
@@ -1901,10 +1902,10 @@ parse_time(const struct option *opt, const char *arg, int __maybe_unused unset)
         if (sscanf(arg, "%" PRIu64 "%cs", value, &unit) > 0) {
                 switch (unit) {
                 case 'm':
-                        *value *= 1000000;
+                        *value *= NSEC_PER_MSEC;
                         break;
                 case 'u':
-                        *value *= 1000;
+                        *value *= NSEC_PER_USEC;
                         break;
                 case 'n':
                         break;
@@ -1928,7 +1929,7 @@ int cmd_timechart(int argc, const char **argv,
                         .ordered_events  = true,
                 },
                 .proc_num = 15,
-                .min_time = 1000000,
+                .min_time = NSEC_PER_MSEC,
                 .merge_dist = 1000,
         };
         const char *output_name = "output.svg";
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 2a6cc254ad0c..fe3af9535e85 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -22,8 +22,9 @@
 #include "perf.h"
 
 #include "util/annotate.h"
-#include "util/cache.h"
+#include "util/config.h"
 #include "util/color.h"
+#include "util/drv_configs.h"
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/machine.h"
@@ -68,6 +69,7 @@
 #include <sys/mman.h>
 
 #include <linux/stringify.h>
+#include <linux/time64.h>
 #include <linux/types.h>
 
 static volatile int done;
@@ -128,10 +130,14 @@ static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
                 return err;
         }
 
-        err = symbol__annotate(sym, map, 0);
+        err = symbol__disassemble(sym, map, 0);
         if (err == 0) {
 out_assign:
                 top->sym_filter_entry = he;
+        } else {
+                char msg[BUFSIZ];
+                symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
+                pr_err("Couldn't annotate %s: %s\n", sym->name, msg);
         }
 
         pthread_mutex_unlock(&notes->lock);
@@ -295,7 +301,7 @@ static void perf_top__print_sym_table(struct perf_top *top)
         hists__output_recalc_col_len(hists, top->print_entries - printed);
         putchar('\n');
         hists__fprintf(hists, false, top->print_entries - printed, win_width,
-                       top->min_percent, stdout);
+                       top->min_percent, stdout, symbol_conf.use_callchain);
 }
 
 static void prompt_integer(int *target, const char *msg)
@@ -479,7 +485,7 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
 
                                 fprintf(stderr, "\nAvailable events:");
 
-                                evlist__for_each(top->evlist, top->sym_evsel)
+                                evlist__for_each_entry(top->evlist, top->sym_evsel)
                                         fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel));
 
                                 prompt_integer(&counter, "Enter details event counter");
@@ -490,7 +496,7 @@ static bool perf_top__handle_keypress(struct perf_top *top, int c)
                                         sleep(1);
                                         break;
                                 }
-                                evlist__for_each(top->evlist, top->sym_evsel)
+                                evlist__for_each_entry(top->evlist, top->sym_evsel)
                                         if (top->sym_evsel->idx == counter)
                                                 break;
                         } else
@@ -583,7 +589,7 @@ static void *display_thread_tui(void *arg)
          * Zooming in/out UIDs. For now juse use whatever the user passed
          * via --uid.
          */
-        evlist__for_each(top->evlist, pos) {
+        evlist__for_each_entry(top->evlist, pos) {
                 struct hists *hists = evsel__hists(pos);
                 hists->uid_filter_str = top->record_opts.target.uid_str;
         }
@@ -620,7 +626,7 @@ static void *display_thread(void *arg)
         display_setup_sig();
         pthread__unblock_sigwinch();
 repeat:
-        delay_msecs = top->delay_secs * 1000;
+        delay_msecs = top->delay_secs * MSEC_PER_SEC;
         set_term_quiet_input(&save);
         /* trash return*/
         getc(stdin);
@@ -652,34 +658,6 @@ repeat:
         return NULL;
 }
 
-static int symbol_filter(struct map *map, struct symbol *sym)
-{
-        const char *name = sym->name;
-
-        if (!__map__is_kernel(map))
-                return 0;
-        /*
-         * ppc64 uses function descriptors and appends a '.' to the
-         * start of every instruction address. Remove it.
-         */
-        if (name[0] == '.')
-                name++;
-
-        if (!strcmp(name, "_text") ||
-            !strcmp(name, "_etext") ||
-            !strcmp(name, "_sinittext") ||
-            !strncmp("init_module", name, 11) ||
-            !strncmp("cleanup_module", name, 14) ||
-            strstr(name, "_text_start") ||
-            strstr(name, "_text_end"))
-                return 1;
-
-        if (symbol__is_idle(sym))
-                sym->ignore = true;
-
-        return 0;
-}
-
 static int hist_iter__top_callback(struct hist_entry_iter *iter,
                                    struct addr_location *al, bool single,
                                    void *arg)
@@ -778,7 +756,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
                 }
         }
 
-        if (al.sym == NULL || !al.sym->ignore) {
+        if (al.sym == NULL || !al.sym->idle) {
                 struct hists *hists = evsel__hists(evsel);
                 struct hist_entry_iter iter = {
                         .evsel          = evsel,
@@ -888,7 +866,7 @@ static int perf_top__start_counters(struct perf_top *top)
 
         perf_evlist__config(evlist, opts, &callchain_param);
 
-        evlist__for_each(evlist, counter) {
+        evlist__for_each_entry(evlist, counter) {
 try_again:
                 if (perf_evsel__open(counter, top->evlist->cpus,
                                      top->evlist->threads) < 0) {
@@ -907,7 +885,7 @@ try_again:
 
         if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
                 ui__error("Failed to mmap with %d (%s)\n",
-                            errno, strerror_r(errno, msg, sizeof(msg)));
+                            errno, str_error_r(errno, msg, sizeof(msg)));
                 goto out_err;
         }
 
@@ -936,6 +914,10 @@ static int callchain_param__setup_sample_type(struct callchain_param *callchain)
 
 static int __cmd_top(struct perf_top *top)
 {
+        char msg[512];
+        struct perf_evsel *pos;
+        struct perf_evsel_config_term *err_term;
+        struct perf_evlist *evlist = top->evlist;
         struct record_opts *opts = &top->record_opts;
         pthread_t thread;
         int ret;
@@ -944,8 +926,6 @@ static int __cmd_top(struct perf_top *top)
         if (top->session == NULL)
                 return -1;
 
-        machines__set_symbol_filter(&top->session->machines, symbol_filter);
-
         if (!objdump_path) {
                 ret = perf_env__lookup_objdump(&top->session->header.env);
                 if (ret)
@@ -972,6 +952,14 @@ static int __cmd_top(struct perf_top *top)
         if (ret)
                 goto out_delete;
 
+        ret = perf_evlist__apply_drv_configs(evlist, &pos, &err_term);
+        if (ret) {
+                error("failed to set config \"%s\" on event %s with %d (%s)\n",
+                        err_term->val.drv_cfg, perf_evsel__name(pos), errno,
+                        str_error_r(errno, msg, sizeof(msg)));
+                goto out_delete;
+        }
+
         top->session->evlist = top->evlist;
         perf_session__set_id_hdr_size(top->session);
 
@@ -1028,7 +1016,7 @@ out_delete:
 
 out_err_cpu_topo: {
         char errbuf[BUFSIZ];
-        const char *err = strerror_r(-ret, errbuf, sizeof(errbuf));
+        const char *err = str_error_r(-ret, errbuf, sizeof(errbuf));
 
         ui__error("Could not read the CPU topology map: %s\n", err);
         goto out_delete;
@@ -1295,7 +1283,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 
         if (perf_evlist__create_maps(top.evlist, target) < 0) {
                 ui__error("Couldn't create thread/CPU maps: %s\n",
-                          errno == ENOENT ? "No such process" : strerror_r(errno, errbuf, sizeof(errbuf)));
+                          errno == ENOENT ? "No such process" : str_error_r(errno, errbuf, sizeof(errbuf)));
                 goto out_delete_evlist;
         }
 
@@ -1319,7 +1307,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
         if (symbol_conf.cumulate_callchain && !callchain_param.order_set)
                 callchain_param.order = ORDER_CALLER;
 
-        symbol_conf.priv_size = sizeof(struct annotation);
+        status = symbol__annotation_init();
+        if (status < 0)
+                goto out_delete_evlist;
 
         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
         if (symbol__init(NULL) < 0)
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 5c50fe70d6b3..c298bd3e1d90 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -43,9 +43,9 @@
 #include <linux/err.h>
 #include <linux/filter.h>
 #include <linux/audit.h>
-#include <sys/ptrace.h>
 #include <linux/random.h>
 #include <linux/stringify.h>
+#include <linux/time64.h>
 
 #ifndef O_CLOEXEC
 # define O_CLOEXEC              02000000
@@ -334,6 +334,10 @@ static size_t syscall_arg__scnprintf_fd(char *bf, size_t size,
 
 #define SCA_FD syscall_arg__scnprintf_fd
 
+#ifndef AT_FDCWD
+#define AT_FDCWD        -100
+#endif
+
 static size_t syscall_arg__scnprintf_fd_at(char *bf, size_t size,
                                            struct syscall_arg *arg)
 {
@@ -738,6 +742,8 @@ static struct syscall_fmt {
           .arg_scnprintf = { [1] = SCA_SIGNUM, /* sig */ }, },
         { .name     = "rt_tgsigqueueinfo", .errmsg = true,
           .arg_scnprintf = { [2] = SCA_SIGNUM, /* sig */ }, },
+        { .name     = "sched_getattr",        .errmsg = true, },
+        { .name     = "sched_setattr",        .errmsg = true, },
         { .name     = "sched_setscheduler",   .errmsg = true,
           .arg_scnprintf = { [1] = SCA_SCHED_POLICY, /* policy */ }, },
         { .name     = "seccomp", .errmsg = true,
@@ -1247,7 +1253,7 @@ static int trace__validate_ev_qualifier(struct trace *trace)
 
         i = 0;
 
-        strlist__for_each(pos, trace->ev_qualifier) {
+        strlist__for_each_entry(pos, trace->ev_qualifier) {
                 const char *sc = pos->s;
                 int id = syscalltbl__id(trace->sctbl, sc);
 
@@ -1601,7 +1607,7 @@ signed_print:
                 fprintf(trace->output, ") = %ld", ret);
         } else if (ret < 0 && (sc->fmt->errmsg || sc->fmt->errpid)) {
                 char bf[STRERR_BUFSIZE];
-                const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
+                const char *emsg = str_error_r(-ret, bf, sizeof(bf)),
                            *e = audit_errno_to_name(-ret);
 
                 fprintf(trace->output, ") = -1 %s %s", e, emsg);
@@ -2137,6 +2143,7 @@ out_delete_sys_enter:
 static int trace__set_ev_qualifier_filter(struct trace *trace)
 {
         int err = -1;
+        struct perf_evsel *sys_exit;
         char *filter = asprintf_expr_inout_ints("id", !trace->not_ev_qualifier,
                                                 trace->ev_qualifier_ids.nr,
                                                 trace->ev_qualifier_ids.entries);
@@ -2144,8 +2151,11 @@ static int trace__set_ev_qualifier_filter(struct trace *trace)
         if (filter == NULL)
                 goto out_enomem;
 
-        if (!perf_evsel__append_filter(trace->syscalls.events.sys_enter, "&&", filter))
-                err = perf_evsel__append_filter(trace->syscalls.events.sys_exit, "&&", filter);
+        if (!perf_evsel__append_tp_filter(trace->syscalls.events.sys_enter,
+                                          filter)) {
+                sys_exit = trace->syscalls.events.sys_exit;
+                err = perf_evsel__append_tp_filter(sys_exit, filter);
+        }
 
         free(filter);
 out:
@@ -2402,7 +2412,7 @@ out_error_apply_filters:
         fprintf(trace->output,
                 "Failed to set filter \"%s\" on event %s with %d (%s)\n",
                 evsel->filter, perf_evsel__name(evsel), errno,
-                strerror_r(errno, errbuf, sizeof(errbuf)));
+                str_error_r(errno, errbuf, sizeof(errbuf)));
         goto out_delete_evlist;
 }
 out_error_mem:
@@ -2483,7 +2493,7 @@ static int trace__replay(struct trace *trace)
                 goto out;
         }
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (evsel->attr.type == PERF_TYPE_SOFTWARE &&
                     (evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MAJ ||
                      evsel->attr.config == PERF_COUNT_SW_PAGE_FAULTS_MIN ||
@@ -2550,7 +2560,7 @@ static size_t thread__dump_stats(struct thread_trace *ttrace,
         printed += fprintf(fp, "                               (msec)    (msec)    (msec)    (msec)        (%%)\n");
         printed += fprintf(fp, "   --------------- -------- --------- --------- --------- ---------     ------\n");
 
-        resort_rb__for_each(nd, syscall_stats) {
+        resort_rb__for_each_entry(nd, syscall_stats) {
                 struct stats *stats = syscall_stats_entry->stats;
                 if (stats) {
                         double min = (double)(stats->min) / NSEC_PER_MSEC;
@@ -2627,7 +2637,7 @@ static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
                 return 0;
         }
 
-        resort_rb__for_each(nd, threads)
+        resort_rb__for_each_entry(nd, threads)
                 printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
 
         resort_rb__delete(threads);
@@ -2714,7 +2724,7 @@ static void evlist__set_evsel_handler(struct perf_evlist *evlist, void *handler)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 evsel->handler = handler;
 }
 
diff --git a/tools/perf/jvmti/jvmti_agent.c b/tools/perf/jvmti/jvmti_agent.c
index 3573f315f955..55daefff0d54 100644
--- a/tools/perf/jvmti/jvmti_agent.c
+++ b/tools/perf/jvmti/jvmti_agent.c
@@ -59,7 +59,6 @@ static int get_e_machine(struct jitheader *hdr)
         ssize_t sret;
         char id[16];
         int fd, ret = -1;
-        int m = -1;
         struct {
                 uint16_t e_type;
                 uint16_t e_machine;
@@ -81,11 +80,7 @@ static int get_e_machine(struct jitheader *hdr)
         if (sret != sizeof(info))
                 goto error;
 
-        m = info.e_machine;
-        if (m < 0)
-                m = 0; /* ELF EM_NONE */
-
-        hdr->elf_mach = m;
+        hdr->elf_mach = info.e_machine;
         ret = 0;
 error:
         close(fd);
@@ -491,10 +486,11 @@ jvmti_write_debug_info(void *agent, uint64_t code, const char *file,
                 if (sret != 1)
                         goto error;
         }
-        if (padding_count)
+        if (padding_count) {
                 sret = fwrite_unlocked(pad_bytes, padding_count, 1, fp);
                 if (sret != 1)
                         goto error;
+        }
 
         funlockfile(fp);
         return 0;
diff --git a/tools/perf/perf-sys.h b/tools/perf/perf-sys.h
index 83a25cef82fd..e4b717e9eb6c 100644
--- a/tools/perf/perf-sys.h
+++ b/tools/perf/perf-sys.h
@@ -5,39 +5,21 @@
 #include <sys/types.h>
 #include <sys/syscall.h>
 #include <linux/types.h>
+#include <linux/compiler.h>
 #include <linux/perf_event.h>
 #include <asm/barrier.h>
 
 #if defined(__i386__)
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC    {"model name"}
-#ifndef __NR_perf_event_open
-# define __NR_perf_event_open 336
-#endif
-#ifndef __NR_futex
-# define __NR_futex 240
-#endif
-#ifndef __NR_gettid
-# define __NR_gettid 224
-#endif
 #endif
 
 #if defined(__x86_64__)
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC    {"model name"}
-#ifndef __NR_perf_event_open
-# define __NR_perf_event_open 298
-#endif
-#ifndef __NR_futex
-# define __NR_futex 202
-#endif
-#ifndef __NR_gettid
-# define __NR_gettid 186
-#endif
 #endif
 
 #ifdef __powerpc__
-#include "../../arch/powerpc/include/uapi/asm/unistd.h"
 #define CPUINFO_PROC    {"cpu"}
 #endif
 
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 15982cee5ef3..64c06961bfe4 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -10,7 +10,7 @@
 
 #include "util/env.h"
 #include <subcmd/exec-cmd.h>
-#include "util/cache.h"
+#include "util/config.h"
 #include "util/quote.h"
 #include <subcmd/run-command.h>
 #include "util/parse-events.h"
@@ -139,8 +139,6 @@ struct option options[] = {
         OPT_ARGUMENT("html-path", "html-path"),
         OPT_ARGUMENT("paginate", "paginate"),
         OPT_ARGUMENT("no-pager", "no-pager"),
-        OPT_ARGUMENT("perf-dir", "perf-dir"),
-        OPT_ARGUMENT("work-tree", "work-tree"),
         OPT_ARGUMENT("debugfs-dir", "debugfs-dir"),
         OPT_ARGUMENT("buildid-dir", "buildid-dir"),
         OPT_ARGUMENT("list-cmds", "list-cmds"),
@@ -200,35 +198,6 @@ static int handle_options(const char ***argv, int *argc, int *envchanged)
                         use_pager = 0;
                         if (envchanged)
                                 *envchanged = 1;
-                } else if (!strcmp(cmd, "--perf-dir")) {
-                        if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --perf-dir.\n");
-                                usage(perf_usage_string);
-                        }
-                        setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
-                        if (envchanged)
-                                *envchanged = 1;
-                        (*argv)++;
-                        (*argc)--;
-                        handled++;
-                } else if (!prefixcmp(cmd, CMD_PERF_DIR)) {
-                        setenv(PERF_DIR_ENVIRONMENT, cmd + strlen(CMD_PERF_DIR), 1);
-                        if (envchanged)
-                                *envchanged = 1;
-                } else if (!strcmp(cmd, "--work-tree")) {
-                        if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --work-tree.\n");
-                                usage(perf_usage_string);
-                        }
-                        setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
-                        if (envchanged)
-                                *envchanged = 1;
-                        (*argv)++;
-                        (*argc)--;
-                } else if (!prefixcmp(cmd, CMD_WORK_TREE)) {
-                        setenv(PERF_WORK_TREE_ENVIRONMENT, cmd + strlen(CMD_WORK_TREE), 1);
-                        if (envchanged)
-                                *envchanged = 1;
                 } else if (!strcmp(cmd, "--debugfs-dir")) {
                         if (*argc < 2) {
                                 fprintf(stderr, "No directory given for --debugfs-dir.\n");
@@ -363,11 +332,6 @@ const char perf_version_string[] = PERF_VERSION;
 
 #define RUN_SETUP       (1<<0)
 #define USE_PAGER       (1<<1)
-/*
- * require working tree to be present -- anything uses this needs
- * RUN_SETUP for reading from the configuration file.
- */
-#define NEED_WORK_TREE  (1<<2)
 
 static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 {
@@ -391,6 +355,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
 
         perf_env__set_cmdline(&perf_env, argc, argv);
         status = p->fn(argc, argv, prefix);
+        perf_config__exit();
         exit_browser(status);
         perf_env__exit(&perf_env);
         bpf__clear();
@@ -409,7 +374,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         /* Check for ENOSPC and EIO errors.. */
         if (fflush(stdout)) {
                 fprintf(stderr, "write failure on standard output: %s",
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
         if (ferror(stdout)) {
@@ -418,7 +383,7 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         }
         if (fclose(stdout)) {
                 fprintf(stderr, "close failed on standard output: %s",
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out;
         }
         status = 0;
@@ -532,6 +497,16 @@ void pthread__unblock_sigwinch(void)
         pthread_sigmask(SIG_UNBLOCK, &set, NULL);
 }
 
+#ifdef _SC_LEVEL1_DCACHE_LINESIZE
+#define cache_line_size(cacheline_sizep) *cacheline_sizep = sysconf(_SC_LEVEL1_DCACHE_LINESIZE)
+#else
+static void cache_line_size(int *cacheline_sizep)
+{
+        if (sysfs__read_int("devices/system/cpu/cpu0/cache/index0/coherency_line_size", cacheline_sizep))
+                pr_debug("cannot determine cache line size");
+}
+#endif
+
 int main(int argc, const char **argv)
 {
         const char *cmd;
@@ -544,7 +519,7 @@ int main(int argc, const char **argv)
 
         /* The page_size is placed in util object. */
         page_size = sysconf(_SC_PAGE_SIZE);
-        cacheline_size = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);
+        cache_line_size(&cacheline_size);
 
         if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
                 sysctl_perf_event_max_stack = value;
@@ -558,6 +533,7 @@ int main(int argc, const char **argv)
 
         srandom(time(NULL));
 
+        perf_config__init();
         perf_config(perf_default_config, NULL);
         set_buildid_dir(NULL);
 
@@ -649,7 +625,7 @@ int main(int argc, const char **argv)
         }
 
         fprintf(stderr, "Failed to run command '%s': %s\n",
-                cmd, strerror_r(errno, sbuf, sizeof(sbuf)));
+                cmd, str_error_r(errno, sbuf, sizeof(sbuf)));
 out:
         return 1;
 }
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index cd8f1b150f9e..9a0236a4cf95 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -14,13 +14,6 @@ void test_attr__open(struct perf_event_attr *attr, pid_t pid, int cpu,
 #define HAVE_ATTR_TEST
 #include "perf-sys.h"
 
-#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)
 {
         struct timespec ts;
@@ -52,6 +45,7 @@ struct record_opts {
         bool         sample_weight;
         bool         sample_time;
         bool         sample_time_set;
+        bool         sample_cpu;
         bool         period;
         bool         running_time;
         bool         full_auxtrace;
@@ -59,6 +53,8 @@ struct record_opts {
         bool         record_switch_events;
         bool         all_kernel;
         bool         all_user;
+        bool         tail_synthesize;
+        bool         overwrite;
         unsigned int freq;
         unsigned int mmap_pages;
         unsigned int auxtrace_mmap_pages;
diff --git a/tools/perf/pmu-events/Build b/tools/perf/pmu-events/Build
new file mode 100644
index 000000000000..9213a1273697
--- /dev/null
+++ b/tools/perf/pmu-events/Build
@@ -0,0 +1,13 @@
+hostprogs := jevents
+
+jevents-y       += json.o jsmn.o jevents.o
+pmu-events-y    += pmu-events.o
+JDIR            =  pmu-events/arch/$(ARCH)
+JSON            =  $(shell [ -d $(JDIR) ] &&                            \
+                        find $(JDIR) -name '*.json' -o -name 'mapfile.csv')
+#
+# Locate/process JSON files in pmu-events/arch/
+# directory and create tables in pmu-events.c.
+#
+$(OUTPUT)pmu-events/pmu-events.c: $(JSON) $(JEVENTS)
+        $(Q)$(call echo-cmd,gen)$(JEVENTS) $(ARCH) pmu-events/arch $(OUTPUT)pmu-events/pmu-events.c $(V)
diff --git a/tools/perf/pmu-events/README b/tools/perf/pmu-events/README
new file mode 100644
index 000000000000..1408ade0d773
--- /dev/null
+++ b/tools/perf/pmu-events/README
@@ -0,0 +1,147 @@
+
+The contents of this directory allow users to specify PMU events in their
+CPUs by their symbolic names rather than raw event codes (see example below).
+
+The main program in this directory, is the 'jevents', which is built and
+executed _BEFORE_ the perf binary itself is built.
+
+The 'jevents' program tries to locate and process JSON files in the directory
+tree tools/perf/pmu-events/arch/foo.
+
+        - Regular files with '.json' extension in the name are assumed to be
+          JSON files, each of which describes a set of PMU events.
+
+        - Regular files with basename starting with 'mapfile.csv' are assumed
+          to be a CSV file that maps a specific CPU to its set of PMU events.
+          (see below for mapfile format)
+
+        - Directories are traversed, but all other files are ignored.
+
+The PMU events supported by a CPU model are expected to grouped into topics
+such as Pipelining, Cache, Memory, Floating-point etc. All events for a topic
+should be placed in a separate JSON file - where the file name identifies
+the topic. Eg: "Floating-point.json".
+
+All the topic JSON files for a CPU model/family should be in a separate
+sub directory. Thus for the Silvermont X86 CPU:
+
+        $ ls tools/perf/pmu-events/arch/x86/Silvermont_core
+        Cache.json      Memory.json     Virtual-Memory.json
+        Frontend.json   Pipeline.json
+
+Using the JSON files and the mapfile, 'jevents' generates the C source file,
+'pmu-events.c', which encodes the two sets of tables:
+
+        - Set of 'PMU events tables' for all known CPUs in the architecture,
+          (one table like the following, per JSON file; table name 'pme_power8'
+          is derived from JSON file name, 'power8.json').
+
+                struct pmu_event pme_power8[] = {
+
+                        ...
+
+                        {
+                                .name = "pm_1plus_ppc_cmpl",
+                                .event = "event=0x100f2",
+                                .desc = "1 or more ppc insts finished,",
+                        },
+
+                        ...
+                }
+
+        - A 'mapping table' that maps each CPU of the architecture, to its
+          'PMU events table'
+
+                struct pmu_events_map pmu_events_map[] = {
+                {
+                        .cpuid = "004b0000",
+                        .version = "1",
+                        .type = "core",
+                        .table = pme_power8
+                },
+                        ...
+
+                };
+
+After the 'pmu-events.c' is generated, it is compiled and the resulting
+'pmu-events.o' is added to 'libperf.a' which is then used to build perf.
+
+NOTES:
+        1. Several CPUs can support same set of events and hence use a common
+           JSON file. Hence several entries in the pmu_events_map[] could map
+           to a single 'PMU events table'.
+
+        2. The 'pmu-events.h' has an extern declaration for the mapping table
+           and the generated 'pmu-events.c' defines this table.
+
+        3. _All_ known CPU tables for architecture are included in the perf
+           binary.
+
+At run time, perf determines the actual CPU it is running on, finds the
+matching events table and builds aliases for those events. This allows
+users to specify events by their name:
+
+        $ perf stat -e pm_1plus_ppc_cmpl sleep 1
+
+where 'pm_1plus_ppc_cmpl' is a Power8 PMU event.
+
+In case of errors when processing files in the tools/perf/pmu-events/arch
+directory, 'jevents' tries to create an empty mapping file to allow the perf
+build to succeed even if the PMU event aliases cannot be used.
+
+However some errors in processing may cause the perf build to fail.
+
+Mapfile format
+===============
+
+The mapfile enables multiple CPU models to share a single set of PMU events.
+It is required even if such mapping is 1:1.
+
+The mapfile.csv format is expected to be:
+
+        Header line
+        CPUID,Version,Dir/path/name,Type
+
+where:
+
+        Comma:
+                is the required field delimiter (i.e other fields cannot
+                have commas within them).
+
+        Comments:
+                Lines in which the first character is either '\n' or '#'
+                are ignored.
+
+        Header line
+                The header line is the first line in the file, which is
+                always _IGNORED_. It can empty.
+
+        CPUID:
+                CPUID is an arch-specific char string, that can be used
+                to identify CPU (and associate it with a set of PMU events
+                it supports). Multiple CPUIDS can point to the same
+                File/path/name.json.
+
+                Example:
+                        CPUID == 'GenuineIntel-6-2E' (on x86).
+                        CPUID == '004b0100' (PVR value in Powerpc)
+        Version:
+                is the Version of the mapfile.
+
+        Dir/path/name:
+                is the pathname to the directory containing the CPU's JSON
+                files, relative to the directory containing the mapfile.csv
+
+        Type:
+                indicates whether the events or "core" or "uncore" events.
+
+
+        Eg:
+
+        $ grep Silvermont tools/perf/pmu-events/arch/x86/mapfile.csv
+        GenuineIntel-6-37,V13,Silvermont_core,core
+        GenuineIntel-6-4D,V13,Silvermont_core,core
+        GenuineIntel-6-4C,V13,Silvermont_core,core
+
+        i.e the three CPU models use the JSON files (i.e PMU events) listed
+        in the directory 'tools/perf/pmu-events/arch/x86/Silvermont_core'.
diff --git a/tools/perf/pmu-events/jevents.c b/tools/perf/pmu-events/jevents.c
new file mode 100644
index 000000000000..41611d7f9873
--- /dev/null
+++ b/tools/perf/pmu-events/jevents.c
@@ -0,0 +1,814 @@
+#define  _XOPEN_SOURCE 500      /* needed for nftw() */
+#define  _GNU_SOURCE            /* needed for asprintf() */
+
+/* Parse event JSON files */
+
+/*
+ * Copyright (c) 2014, Intel Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <libgen.h>
+#include <dirent.h>
+#include <sys/time.h>                   /* getrlimit */
+#include <sys/resource.h>               /* getrlimit */
+#include <ftw.h>
+#include <sys/stat.h>
+#include "jsmn.h"
+#include "json.h"
+#include "jevents.h"
+
+#ifndef __maybe_unused
+#define __maybe_unused                  __attribute__((unused))
+#endif
+
+int verbose;
+char *prog;
+
+int eprintf(int level, int var, const char *fmt, ...)
+{
+
+        int ret;
+        va_list args;
+
+        if (var < level)
+                return 0;
+
+        va_start(args, fmt);
+
+        ret = vfprintf(stderr, fmt, args);
+
+        va_end(args);
+
+        return ret;
+}
+
+__attribute__((weak)) char *get_cpu_str(void)
+{
+        return NULL;
+}
+
+static void addfield(char *map, char **dst, const char *sep,
+                     const char *a, jsmntok_t *bt)
+{
+        unsigned int len = strlen(a) + 1 + strlen(sep);
+        int olen = *dst ? strlen(*dst) : 0;
+        int blen = bt ? json_len(bt) : 0;
+        char *out;
+
+        out = realloc(*dst, len + olen + blen);
+        if (!out) {
+                /* Don't add field in this case */
+                return;
+        }
+        *dst = out;
+
+        if (!olen)
+                *(*dst) = 0;
+        else
+                strcat(*dst, sep);
+        strcat(*dst, a);
+        if (bt)
+                strncat(*dst, map + bt->start, blen);
+}
+
+static void fixname(char *s)
+{
+        for (; *s; s++)
+                *s = tolower(*s);
+}
+
+static void fixdesc(char *s)
+{
+        char *e = s + strlen(s);
+
+        /* Remove trailing dots that look ugly in perf list */
+        --e;
+        while (e >= s && isspace(*e))
+                --e;
+        if (*e == '.')
+                *e = 0;
+}
+
+static struct msrmap {
+        const char *num;
+        const char *pname;
+} msrmap[] = {
+        { "0x3F6", "ldlat=" },
+        { "0x1A6", "offcore_rsp=" },
+        { "0x1A7", "offcore_rsp=" },
+        { "0x3F7", "frontend=" },
+        { NULL, NULL }
+};
+
+static struct field {
+        const char *field;
+        const char *kernel;
+} fields[] = {
+        { "EventCode",  "event=" },
+        { "UMask",      "umask=" },
+        { "CounterMask", "cmask=" },
+        { "Invert",     "inv=" },
+        { "AnyThread",  "any=" },
+        { "EdgeDetect", "edge=" },
+        { "SampleAfterValue", "period=" },
+        { NULL, NULL }
+};
+
+static void cut_comma(char *map, jsmntok_t *newval)
+{
+        int i;
+
+        /* Cut off everything after comma */
+        for (i = newval->start; i < newval->end; i++) {
+                if (map[i] == ',')
+                        newval->end = i;
+        }
+}
+
+static int match_field(char *map, jsmntok_t *field, int nz,
+                       char **event, jsmntok_t *val)
+{
+        struct field *f;
+        jsmntok_t newval = *val;
+
+        for (f = fields; f->field; f++)
+                if (json_streq(map, field, f->field) && nz) {
+                        cut_comma(map, &newval);
+                        addfield(map, event, ",", f->kernel, &newval);
+                        return 1;
+                }
+        return 0;
+}
+
+static struct msrmap *lookup_msr(char *map, jsmntok_t *val)
+{
+        jsmntok_t newval = *val;
+        static bool warned;
+        int i;
+
+        cut_comma(map, &newval);
+        for (i = 0; msrmap[i].num; i++)
+                if (json_streq(map, &newval, msrmap[i].num))
+                        return &msrmap[i];
+        if (!warned) {
+                warned = true;
+                pr_err("%s: Unknown MSR in event file %.*s\n", prog,
+                        json_len(val), map + val->start);
+        }
+        return NULL;
+}
+
+#define EXPECT(e, t, m) do { if (!(e)) {                        \
+        jsmntok_t *loc = (t);                                   \
+        if (!(t)->start && (t) > tokens)                        \
+                loc = (t) - 1;                                  \
+                pr_err("%s:%d: " m ", got %s\n", fn,            \
+                        json_line(map, loc),                    \
+                        json_name(t));                          \
+        goto out_free;                                          \
+} } while (0)
+
+#define TOPIC_DEPTH 256
+static char *topic_array[TOPIC_DEPTH];
+static int   topic_level;
+
+static char *get_topic(void)
+{
+        char *tp_old, *tp = NULL;
+        int i;
+
+        for (i = 0; i < topic_level + 1; i++) {
+                int n;
+
+                tp_old = tp;
+                n = asprintf(&tp, "%s%s", tp ?: "", topic_array[i]);
+                if (n < 0) {
+                        pr_info("%s: asprintf() error %s\n", prog);
+                        return NULL;
+                }
+                free(tp_old);
+        }
+
+        for (i = 0; i < (int) strlen(tp); i++) {
+                char c = tp[i];
+
+                if (c == '-')
+                        tp[i] = ' ';
+                else if (c == '.') {
+                        tp[i] = '\0';
+                        break;
+                }
+        }
+
+        return tp;
+}
+
+static int add_topic(int level, char *bname)
+{
+        char *topic;
+
+        level -= 2;
+
+        if (level >= TOPIC_DEPTH)
+                return -EINVAL;
+
+        topic = strdup(bname);
+        if (!topic) {
+                pr_info("%s: strdup() error %s for file %s\n", prog,
+                                strerror(errno), bname);
+                return -ENOMEM;
+        }
+
+        free(topic_array[topic_level]);
+        topic_array[topic_level] = topic;
+        topic_level              = level;
+        return 0;
+}
+
+struct perf_entry_data {
+        FILE *outfp;
+        char *topic;
+};
+
+static int close_table;
+
+static void print_events_table_prefix(FILE *fp, const char *tblname)
+{
+        fprintf(fp, "struct pmu_event %s[] = {\n", tblname);
+        close_table = 1;
+}
+
+static int print_events_table_entry(void *data, char *name, char *event,
+                                    char *desc, char *long_desc)
+{
+        struct perf_entry_data *pd = data;
+        FILE *outfp = pd->outfp;
+        char *topic = pd->topic;
+
+        /*
+         * TODO: Remove formatting chars after debugging to reduce
+         *       string lengths.
+         */
+        fprintf(outfp, "{\n");
+
+        fprintf(outfp, "\t.name = \"%s\",\n", name);
+        fprintf(outfp, "\t.event = \"%s\",\n", event);
+        fprintf(outfp, "\t.desc = \"%s\",\n", desc);
+        fprintf(outfp, "\t.topic = \"%s\",\n", topic);
+        if (long_desc && long_desc[0])
+                fprintf(outfp, "\t.long_desc = \"%s\",\n", long_desc);
+
+        fprintf(outfp, "},\n");
+
+        return 0;
+}
+
+static void print_events_table_suffix(FILE *outfp)
+{
+        fprintf(outfp, "{\n");
+
+        fprintf(outfp, "\t.name = 0,\n");
+        fprintf(outfp, "\t.event = 0,\n");
+        fprintf(outfp, "\t.desc = 0,\n");
+
+        fprintf(outfp, "},\n");
+        fprintf(outfp, "};\n");
+        close_table = 0;
+}
+
+static struct fixed {
+        const char *name;
+        const char *event;
+} fixed[] = {
+        { "inst_retired.any", "event=0xc0" },
+        { "inst_retired.any_p", "event=0xc0" },
+        { "cpu_clk_unhalted.ref", "event=0x0,umask=0x03" },
+        { "cpu_clk_unhalted.thread", "event=0x3c" },
+        { "cpu_clk_unhalted.thread_any", "event=0x3c,any=1" },
+        { NULL, NULL},
+};
+
+/*
+ * Handle different fixed counter encodings between JSON and perf.
+ */
+static char *real_event(const char *name, char *event)
+{
+        int i;
+
+        for (i = 0; fixed[i].name; i++)
+                if (!strcasecmp(name, fixed[i].name))
+                        return (char *)fixed[i].event;
+        return event;
+}
+
+/* Call func with each event in the json file */
+int json_events(const char *fn,
+          int (*func)(void *data, char *name, char *event, char *desc,
+                      char *long_desc),
+          void *data)
+{
+        int err = -EIO;
+        size_t size;
+        jsmntok_t *tokens, *tok;
+        int i, j, len;
+        char *map;
+
+        if (!fn)
+                return -ENOENT;
+
+        tokens = parse_json(fn, &map, &size, &len);
+        if (!tokens)
+                return -EIO;
+        EXPECT(tokens->type == JSMN_ARRAY, tokens, "expected top level array");
+        tok = tokens + 1;
+        for (i = 0; i < tokens->size; i++) {
+                char *event = NULL, *desc = NULL, *name = NULL;
+                char *long_desc = NULL;
+                char *extra_desc = NULL;
+                struct msrmap *msr = NULL;
+                jsmntok_t *msrval = NULL;
+                jsmntok_t *precise = NULL;
+                jsmntok_t *obj = tok++;
+
+                EXPECT(obj->type == JSMN_OBJECT, obj, "expected object");
+                for (j = 0; j < obj->size; j += 2) {
+                        jsmntok_t *field, *val;
+                        int nz;
+
+                        field = tok + j;
+                        EXPECT(field->type == JSMN_STRING, tok + j,
+                               "Expected field name");
+                        val = tok + j + 1;
+                        EXPECT(val->type == JSMN_STRING, tok + j + 1,
+                               "Expected string value");
+
+                        nz = !json_streq(map, val, "0");
+                        if (match_field(map, field, nz, &event, val)) {
+                                /* ok */
+                        } else if (json_streq(map, field, "EventName")) {
+                                addfield(map, &name, "", "", val);
+                        } else if (json_streq(map, field, "BriefDescription")) {
+                                addfield(map, &desc, "", "", val);
+                                fixdesc(desc);
+                        } else if (json_streq(map, field,
+                                             "PublicDescription")) {
+                                addfield(map, &long_desc, "", "", val);
+                                fixdesc(long_desc);
+                        } else if (json_streq(map, field, "PEBS") && nz) {
+                                precise = val;
+                        } else if (json_streq(map, field, "MSRIndex") && nz) {
+                                msr = lookup_msr(map, val);
+                        } else if (json_streq(map, field, "MSRValue")) {
+                                msrval = val;
+                        } else if (json_streq(map, field, "Errata") &&
+                                   !json_streq(map, val, "null")) {
+                                addfield(map, &extra_desc, ". ",
+                                        " Spec update: ", val);
+                        } else if (json_streq(map, field, "Data_LA") && nz) {
+                                addfield(map, &extra_desc, ". ",
+                                        " Supports address when precise",
+                                        NULL);
+                        }
+                        /* ignore unknown fields */
+                }
+                if (precise && desc && !strstr(desc, "(Precise Event)")) {
+                        if (json_streq(map, precise, "2"))
+                                addfield(map, &extra_desc, " ",
+                                                "(Must be precise)", NULL);
+                        else
+                                addfield(map, &extra_desc, " ",
+                                                "(Precise event)", NULL);
+                }
+                if (desc && extra_desc)
+                        addfield(map, &desc, " ", extra_desc, NULL);
+                if (long_desc && extra_desc)
+                        addfield(map, &long_desc, " ", extra_desc, NULL);
+                if (msr != NULL)
+                        addfield(map, &event, ",", msr->pname, msrval);
+                fixname(name);
+
+                err = func(data, name, real_event(name, event), desc, long_desc);
+                free(event);
+                free(desc);
+                free(name);
+                free(long_desc);
+                free(extra_desc);
+                if (err)
+                        break;
+                tok += j;
+        }
+        EXPECT(tok - tokens == len, tok, "unexpected objects at end");
+        err = 0;
+out_free:
+        free_json(map, size, tokens);
+        return err;
+}
+
+static char *file_name_to_table_name(char *fname)
+{
+        unsigned int i;
+        int n;
+        int c;
+        char *tblname;
+
+        /*
+         * Ensure tablename starts with alphabetic character.
+         * Derive rest of table name from basename of the JSON file,
+         * replacing hyphens and stripping out .json suffix.
+         */
+        n = asprintf(&tblname, "pme_%s", basename(fname));
+        if (n < 0) {
+                pr_info("%s: asprintf() error %s for file %s\n", prog,
+                                strerror(errno), fname);
+                return NULL;
+        }
+
+        for (i = 0; i < strlen(tblname); i++) {
+                c = tblname[i];
+
+                if (c == '-')
+                        tblname[i] = '_';
+                else if (c == '.') {
+                        tblname[i] = '\0';
+                        break;
+                } else if (!isalnum(c) && c != '_') {
+                        pr_err("%s: Invalid character '%c' in file name %s\n",
+                                        prog, c, basename(fname));
+                        free(tblname);
+                        tblname = NULL;
+                        break;
+                }
+        }
+
+        return tblname;
+}
+
+static void print_mapping_table_prefix(FILE *outfp)
+{
+        fprintf(outfp, "struct pmu_events_map pmu_events_map[] = {\n");
+}
+
+static void print_mapping_table_suffix(FILE *outfp)
+{
+        /*
+         * Print the terminating, NULL entry.
+         */
+        fprintf(outfp, "{\n");
+        fprintf(outfp, "\t.cpuid = 0,\n");
+        fprintf(outfp, "\t.version = 0,\n");
+        fprintf(outfp, "\t.type = 0,\n");
+        fprintf(outfp, "\t.table = 0,\n");
+        fprintf(outfp, "},\n");
+
+        /* and finally, the closing curly bracket for the struct */
+        fprintf(outfp, "};\n");
+}
+
+static int process_mapfile(FILE *outfp, char *fpath)
+{
+        int n = 16384;
+        FILE *mapfp;
+        char *save = NULL;
+        char *line, *p;
+        int line_num;
+        char *tblname;
+
+        pr_info("%s: Processing mapfile %s\n", prog, fpath);
+
+        line = malloc(n);
+        if (!line)
+                return -1;
+
+        mapfp = fopen(fpath, "r");
+        if (!mapfp) {
+                pr_info("%s: Error %s opening %s\n", prog, strerror(errno),
+                                fpath);
+                return -1;
+        }
+
+        print_mapping_table_prefix(outfp);
+
+        /* Skip first line (header) */
+        p = fgets(line, n, mapfp);
+        if (!p)
+                goto out;
+
+        line_num = 1;
+        while (1) {
+                char *cpuid, *version, *type, *fname;
+
+                line_num++;
+                p = fgets(line, n, mapfp);
+                if (!p)
+                        break;
+
+                if (line[0] == '#' || line[0] == '\n')
+                        continue;
+
+                if (line[strlen(line)-1] != '\n') {
+                        /* TODO Deal with lines longer than 16K */
+                        pr_info("%s: Mapfile %s: line %d too long, aborting\n",
+                                        prog, fpath, line_num);
+                        return -1;
+                }
+                line[strlen(line)-1] = '\0';
+
+                cpuid = strtok_r(p, ",", &save);
+                version = strtok_r(NULL, ",", &save);
+                fname = strtok_r(NULL, ",", &save);
+                type = strtok_r(NULL, ",", &save);
+
+                tblname = file_name_to_table_name(fname);
+                fprintf(outfp, "{\n");
+                fprintf(outfp, "\t.cpuid = \"%s\",\n", cpuid);
+                fprintf(outfp, "\t.version = \"%s\",\n", version);
+                fprintf(outfp, "\t.type = \"%s\",\n", type);
+
+                /*
+                 * CHECK: We can't use the type (eg "core") field in the
+                 * table name. For us to do that, we need to somehow tweak
+                 * the other caller of file_name_to_table(), process_json()
+                 * to determine the type. process_json() file has no way
+                 * of knowing these are "core" events unless file name has
+                 * core in it. If filename has core in it, we can safely
+                 * ignore the type field here also.
+                 */
+                fprintf(outfp, "\t.table = %s\n", tblname);
+                fprintf(outfp, "},\n");
+        }
+
+out:
+        print_mapping_table_suffix(outfp);
+        return 0;
+}
+
+/*
+ * If we fail to locate/process JSON and map files, create a NULL mapping
+ * table. This would at least allow perf to build even if we can't find/use
+ * the aliases.
+ */
+static void create_empty_mapping(const char *output_file)
+{
+        FILE *outfp;
+
+        pr_info("%s: Creating empty pmu_events_map[] table\n", prog);
+
+        /* Truncate file to clear any partial writes to it */
+        outfp = fopen(output_file, "w");
+        if (!outfp) {
+                perror("fopen()");
+                _Exit(1);
+        }
+
+        fprintf(outfp, "#include \"../../pmu-events/pmu-events.h\"\n");
+        print_mapping_table_prefix(outfp);
+        print_mapping_table_suffix(outfp);
+        fclose(outfp);
+}
+
+static int get_maxfds(void)
+{
+        struct rlimit rlim;
+
+        if (getrlimit(RLIMIT_NOFILE, &rlim) == 0)
+                return min((int)rlim.rlim_max / 2, 512);
+
+        return 512;
+}
+
+/*
+ * nftw() doesn't let us pass an argument to the processing function,
+ * so use a global variables.
+ */
+static FILE *eventsfp;
+static char *mapfile;
+
+static int process_one_file(const char *fpath, const struct stat *sb,
+                            int typeflag, struct FTW *ftwbuf)
+{
+        char *tblname, *bname  = (char *) fpath + ftwbuf->base;
+        int is_dir  = typeflag == FTW_D;
+        int is_file = typeflag == FTW_F;
+        int level   = ftwbuf->level;
+        int err = 0;
+
+        pr_debug("%s %d %7jd %-20s %s\n",
+                 is_file ? "f" : is_dir ? "d" : "x",
+                 level, sb->st_size, bname, fpath);
+
+        /* base dir */
+        if (level == 0)
+                return 0;
+
+        /* model directory, reset topic */
+        if (level == 1 && is_dir) {
+                if (close_table)
+                        print_events_table_suffix(eventsfp);
+
+                /*
+                 * Drop file name suffix. Replace hyphens with underscores.
+                 * Fail if file name contains any alphanum characters besides
+                 * underscores.
+                 */
+                tblname = file_name_to_table_name(bname);
+                if (!tblname) {
+                        pr_info("%s: Error determining table name for %s\n", prog,
+                                bname);
+                        return -1;
+                }
+
+                print_events_table_prefix(eventsfp, tblname);
+                return 0;
+        }
+
+        /*
+         * Save the mapfile name for now. We will process mapfile
+         * after processing all JSON files (so we can write out the
+         * mapping table after all PMU events tables).
+         *
+         * TODO: Allow for multiple mapfiles? Punt for now.
+         */
+        if (level == 1 && is_file) {
+                if (!strncmp(bname, "mapfile.csv", 11)) {
+                        if (mapfile) {
+                                pr_info("%s: Many mapfiles? Using %s, ignoring %s\n",
+                                                prog, mapfile, fpath);
+                        } else {
+                                mapfile = strdup(fpath);
+                        }
+                        return 0;
+                }
+
+                pr_info("%s: Ignoring file %s\n", prog, fpath);
+                return 0;
+        }
+
+        /*
+         * If the file name does not have a .json extension,
+         * ignore it. It could be a readme.txt for instance.
+         */
+        if (is_file) {
+                char *suffix = bname + strlen(bname) - 5;
+
+                if (strncmp(suffix, ".json", 5)) {
+                        pr_info("%s: Ignoring file without .json suffix %s\n", prog,
+                                fpath);
+                        return 0;
+                }
+        }
+
+        if (level > 1 && add_topic(level, bname))
+                return -ENOMEM;
+
+        /*
+         * Assume all other files are JSON files.
+         *
+         * If mapfile refers to 'power7_core.json', we create a table
+         * named 'power7_core'. Any inconsistencies between the mapfile
+         * and directory tree could result in build failure due to table
+         * names not being found.
+         *
+         * Atleast for now, be strict with processing JSON file names.
+         * i.e. if JSON file name cannot be mapped to C-style table name,
+         * fail.
+         */
+        if (is_file) {
+                struct perf_entry_data data = {
+                        .topic = get_topic(),
+                        .outfp = eventsfp,
+                };
+
+                err = json_events(fpath, print_events_table_entry, &data);
+
+                free(data.topic);
+        }
+
+        return err;
+}
+
+#ifndef PATH_MAX
+#define PATH_MAX        4096
+#endif
+
+/*
+ * Starting in directory 'start_dirname', find the "mapfile.csv" and
+ * the set of JSON files for the architecture 'arch'.
+ *
+ * From each JSON file, create a C-style "PMU events table" from the
+ * JSON file (see struct pmu_event).
+ *
+ * From the mapfile, create a mapping between the CPU revisions and
+ * PMU event tables (see struct pmu_events_map).
+ *
+ * Write out the PMU events tables and the mapping table to pmu-event.c.
+ *
+ * If unable to process the JSON or arch files, create an empty mapping
+ * table so we can continue to build/use  perf even if we cannot use the
+ * PMU event aliases.
+ */
+int main(int argc, char *argv[])
+{
+        int rc;
+        int maxfds;
+        char ldirname[PATH_MAX];
+
+        const char *arch;
+        const char *output_file;
+        const char *start_dirname;
+
+        prog = basename(argv[0]);
+        if (argc < 4) {
+                pr_err("Usage: %s <arch> <starting_dir> <output_file>\n", prog);
+                return 1;
+        }
+
+        arch = argv[1];
+        start_dirname = argv[2];
+        output_file = argv[3];
+
+        if (argc > 4)
+                verbose = atoi(argv[4]);
+
+        eventsfp = fopen(output_file, "w");
+        if (!eventsfp) {
+                pr_err("%s Unable to create required file %s (%s)\n",
+                                prog, output_file, strerror(errno));
+                return 2;
+        }
+
+        /* Include pmu-events.h first */
+        fprintf(eventsfp, "#include \"../../pmu-events/pmu-events.h\"\n");
+
+        sprintf(ldirname, "%s/%s", start_dirname, arch);
+
+        /*
+         * The mapfile allows multiple CPUids to point to the same JSON file,
+         * so, not sure if there is a need for symlinks within the pmu-events
+         * directory.
+         *
+         * For now, treat symlinks of JSON files as regular files and create
+         * separate tables for each symlink (presumably, each symlink refers
+         * to specific version of the CPU).
+         */
+
+        maxfds = get_maxfds();
+        mapfile = NULL;
+        rc = nftw(ldirname, process_one_file, maxfds, 0);
+        if (rc && verbose) {
+                pr_info("%s: Error walking file tree %s\n", prog, ldirname);
+                goto empty_map;
+        } else if (rc) {
+                goto empty_map;
+        }
+
+        if (close_table)
+                print_events_table_suffix(eventsfp);
+
+        if (!mapfile) {
+                pr_info("%s: No CPU->JSON mapping?\n", prog);
+                goto empty_map;
+        }
+
+        if (process_mapfile(eventsfp, mapfile)) {
+                pr_info("%s: Error processing mapfile %s\n", prog, mapfile);
+                goto empty_map;
+        }
+
+        return 0;
+
+empty_map:
+        fclose(eventsfp);
+        create_empty_mapping(output_file);
+        return 0;
+}
diff --git a/tools/perf/pmu-events/jevents.h b/tools/perf/pmu-events/jevents.h
new file mode 100644
index 000000000000..b0eb2744b498
--- /dev/null
+++ b/tools/perf/pmu-events/jevents.h
@@ -0,0 +1,18 @@
+#ifndef JEVENTS_H
+#define JEVENTS_H 1
+
+int json_events(const char *fn,
+                int (*func)(void *data, char *name, char *event, char *desc,
+                                char *long_desc),
+                void *data);
+char *get_cpu_str(void);
+
+#ifndef min
+#define min(x, y) ({                            \
+        typeof(x) _min1 = (x);                  \
+        typeof(y) _min2 = (y);                  \
+        (void) (&_min1 == &_min2);              \
+        _min1 < _min2 ? _min1 : _min2; })
+#endif
+
+#endif
diff --git a/tools/perf/pmu-events/jsmn.c b/tools/perf/pmu-events/jsmn.c
new file mode 100644
index 000000000000..11d1fa18bfa5
--- /dev/null
+++ b/tools/perf/pmu-events/jsmn.c
@@ -0,0 +1,313 @@
+/*
+ * Copyright (c) 2010 Serge A. Zaitsev
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * Slightly modified by AK to not assume 0 terminated input.
+ */
+
+#include <stdlib.h>
+#include "jsmn.h"
+
+/*
+ * Allocates a fresh unused token from the token pool.
+ */
+static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
+                                   jsmntok_t *tokens, size_t num_tokens)
+{
+        jsmntok_t *tok;
+
+        if ((unsigned)parser->toknext >= num_tokens)
+                return NULL;
+        tok = &tokens[parser->toknext++];
+        tok->start = tok->end = -1;
+        tok->size = 0;
+        return tok;
+}
+
+/*
+ * Fills token type and boundaries.
+ */
+static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
+                            int start, int end)
+{
+        token->type = type;
+        token->start = start;
+        token->end = end;
+        token->size = 0;
+}
+
+/*
+ * Fills next available token with JSON primitive.
+ */
+static jsmnerr_t jsmn_parse_primitive(jsmn_parser *parser, const char *js,
+                                      size_t len,
+                                      jsmntok_t *tokens, size_t num_tokens)
+{
+        jsmntok_t *token;
+        int start;
+
+        start = parser->pos;
+
+        for (; parser->pos < len; parser->pos++) {
+                switch (js[parser->pos]) {
+#ifndef JSMN_STRICT
+                /*
+                 * In strict mode primitive must be followed by ","
+                 * or "}" or "]"
+                 */
+                case ':':
+#endif
+                case '\t':
+                case '\r':
+                case '\n':
+                case ' ':
+                case ',':
+                case ']':
+                case '}':
+                        goto found;
+                default:
+                        break;
+                }
+                if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
+                        parser->pos = start;
+                        return JSMN_ERROR_INVAL;
+                }
+        }
+#ifdef JSMN_STRICT
+        /*
+         * In strict mode primitive must be followed by a
+         * comma/object/array.
+         */
+        parser->pos = start;
+        return JSMN_ERROR_PART;
+#endif
+
+found:
+        token = jsmn_alloc_token(parser, tokens, num_tokens);
+        if (token == NULL) {
+                parser->pos = start;
+                return JSMN_ERROR_NOMEM;
+        }
+        jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
+        parser->pos--; /* parent sees closing brackets */
+        return JSMN_SUCCESS;
+}
+
+/*
+ * Fills next token with JSON string.
+ */
+static jsmnerr_t jsmn_parse_string(jsmn_parser *parser, const char *js,
+                                   size_t len,
+                                   jsmntok_t *tokens, size_t num_tokens)
+{
+        jsmntok_t *token;
+        int start = parser->pos;
+
+        /* Skip starting quote */
+        parser->pos++;
+
+        for (; parser->pos < len; parser->pos++) {
+                char c = js[parser->pos];
+
+                /* Quote: end of string */
+                if (c == '\"') {
+                        token = jsmn_alloc_token(parser, tokens, num_tokens);
+                        if (token == NULL) {
+                                parser->pos = start;
+                                return JSMN_ERROR_NOMEM;
+                        }
+                        jsmn_fill_token(token, JSMN_STRING, start+1,
+                                        parser->pos);
+                        return JSMN_SUCCESS;
+                }
+
+                /* Backslash: Quoted symbol expected */
+                if (c == '\\') {
+                        parser->pos++;
+                        switch (js[parser->pos]) {
+                                /* Allowed escaped symbols */
+                        case '\"':
+                        case '/':
+                        case '\\':
+                        case 'b':
+                        case 'f':
+                        case 'r':
+                        case 'n':
+                        case 't':
+                                break;
+                                /* Allows escaped symbol \uXXXX */
+                        case 'u':
+                                /* TODO */
+                                break;
+                                /* Unexpected symbol */
+                        default:
+                                parser->pos = start;
+                                return JSMN_ERROR_INVAL;
+                        }
+                }
+        }
+        parser->pos = start;
+        return JSMN_ERROR_PART;
+}
+
+/*
+ * Parse JSON string and fill tokens.
+ */
+jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
+                     jsmntok_t *tokens, unsigned int num_tokens)
+{
+        jsmnerr_t r;
+        int i;
+        jsmntok_t *token;
+
+        for (; parser->pos < len; parser->pos++) {
+                char c;
+                jsmntype_t type;
+
+                c = js[parser->pos];
+                switch (c) {
+                case '{':
+                case '[':
+                        token = jsmn_alloc_token(parser, tokens, num_tokens);
+                        if (token == NULL)
+                                return JSMN_ERROR_NOMEM;
+                        if (parser->toksuper != -1)
+                                tokens[parser->toksuper].size++;
+                        token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
+                        token->start = parser->pos;
+                        parser->toksuper = parser->toknext - 1;
+                        break;
+                case '}':
+                case ']':
+                        type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
+                        for (i = parser->toknext - 1; i >= 0; i--) {
+                                token = &tokens[i];
+                                if (token->start != -1 && token->end == -1) {
+                                        if (token->type != type)
+                                                return JSMN_ERROR_INVAL;
+                                        parser->toksuper = -1;
+                                        token->end = parser->pos + 1;
+                                        break;
+                                }
+                        }
+                        /* Error if unmatched closing bracket */
+                        if (i == -1)
+                                return JSMN_ERROR_INVAL;
+                        for (; i >= 0; i--) {
+                                token = &tokens[i];
+                                if (token->start != -1 && token->end == -1) {
+                                        parser->toksuper = i;
+                                        break;
+                                }
+                        }
+                        break;
+                case '\"':
+                        r = jsmn_parse_string(parser, js, len, tokens,
+                                              num_tokens);
+                        if (r < 0)
+                                return r;
+                        if (parser->toksuper != -1)
+                                tokens[parser->toksuper].size++;
+                        break;
+                case '\t':
+                case '\r':
+                case '\n':
+                case ':':
+                case ',':
+                case ' ':
+                        break;
+#ifdef JSMN_STRICT
+                        /*
+                         * In strict mode primitives are:
+                         * numbers and booleans.
+                         */
+                case '-':
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                case 't':
+                case 'f':
+                case 'n':
+#else
+                        /*
+                         * In non-strict mode every unquoted value
+                         * is a primitive.
+                         */
+                        /*FALL THROUGH */
+                default:
+#endif
+                        r = jsmn_parse_primitive(parser, js, len, tokens,
+                                                 num_tokens);
+                        if (r < 0)
+                                return r;
+                        if (parser->toksuper != -1)
+                                tokens[parser->toksuper].size++;
+                        break;
+
+#ifdef JSMN_STRICT
+                        /* Unexpected char in strict mode */
+                default:
+                        return JSMN_ERROR_INVAL;
+#endif
+                }
+        }
+
+        for (i = parser->toknext - 1; i >= 0; i--) {
+                /* Unmatched opened object or array */
+                if (tokens[i].start != -1 && tokens[i].end == -1)
+                        return JSMN_ERROR_PART;
+        }
+
+        return JSMN_SUCCESS;
+}
+
+/*
+ * Creates a new parser based over a given  buffer with an array of tokens
+ * available.
+ */
+void jsmn_init(jsmn_parser *parser)
+{
+        parser->pos = 0;
+        parser->toknext = 0;
+        parser->toksuper = -1;
+}
+
+const char *jsmn_strerror(jsmnerr_t err)
+{
+        switch (err) {
+        case JSMN_ERROR_NOMEM:
+                return "No enough tokens";
+        case JSMN_ERROR_INVAL:
+                return "Invalid character inside JSON string";
+        case JSMN_ERROR_PART:
+                return "The string is not a full JSON packet, more bytes expected";
+        case JSMN_SUCCESS:
+                return "Success";
+        default:
+                return "Unknown json error";
+        }
+}
diff --git a/tools/perf/pmu-events/jsmn.h b/tools/perf/pmu-events/jsmn.h
new file mode 100644
index 000000000000..d666b10cf25b
--- /dev/null
+++ b/tools/perf/pmu-events/jsmn.h
@@ -0,0 +1,67 @@
+#ifndef __JSMN_H_
+#define __JSMN_H_
+
+/*
+ * JSON type identifier. Basic types are:
+ *      o Object
+ *      o Array
+ *      o String
+ *      o Other primitive: number, boolean (true/false) or null
+ */
+typedef enum {
+        JSMN_PRIMITIVE = 0,
+        JSMN_OBJECT = 1,
+        JSMN_ARRAY = 2,
+        JSMN_STRING = 3
+} jsmntype_t;
+
+typedef enum {
+        /* Not enough tokens were provided */
+        JSMN_ERROR_NOMEM = -1,
+        /* Invalid character inside JSON string */
+        JSMN_ERROR_INVAL = -2,
+        /* The string is not a full JSON packet, more bytes expected */
+        JSMN_ERROR_PART = -3,
+        /* Everything was fine */
+        JSMN_SUCCESS = 0
+} jsmnerr_t;
+
+/*
+ * JSON token description.
+ * @param               type    type (object, array, string etc.)
+ * @param               start   start position in JSON data string
+ * @param               end             end position in JSON data string
+ */
+typedef struct {
+        jsmntype_t type;
+        int start;
+        int end;
+        int size;
+} jsmntok_t;
+
+/*
+ * JSON parser. Contains an array of token blocks available. Also stores
+ * the string being parsed now and current position in that string
+ */
+typedef struct {
+        unsigned int pos; /* offset in the JSON string */
+        int toknext; /* next token to allocate */
+        int toksuper; /* superior token node, e.g parent object or array */
+} jsmn_parser;
+
+/*
+ * Create JSON parser over an array of tokens
+ */
+void jsmn_init(jsmn_parser *parser);
+
+/*
+ * Run JSON parser. It parses a JSON data string into and array of tokens,
+ * each describing a single JSON object.
+ */
+jsmnerr_t jsmn_parse(jsmn_parser *parser, const char *js,
+                     size_t len,
+                     jsmntok_t *tokens, unsigned int num_tokens);
+
+const char *jsmn_strerror(jsmnerr_t err);
+
+#endif /* __JSMN_H_ */
diff --git a/tools/perf/pmu-events/json.c b/tools/perf/pmu-events/json.c
new file mode 100644
index 000000000000..f67bbb0aa36e
--- /dev/null
+++ b/tools/perf/pmu-events/json.c
@@ -0,0 +1,162 @@
+/* Parse JSON files using the JSMN parser. */
+
+/*
+ * Copyright (c) 2014, Intel Corporation
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include "jsmn.h"
+#include "json.h"
+#include <linux/kernel.h>
+
+
+static char *mapfile(const char *fn, size_t *size)
+{
+        unsigned ps = sysconf(_SC_PAGESIZE);
+        struct stat st;
+        char *map = NULL;
+        int err;
+        int fd = open(fn, O_RDONLY);
+
+        if (fd < 0 && verbose && fn) {
+                pr_err("Error opening events file '%s': %s\n", fn,
+                                strerror(errno));
+        }
+
+        if (fd < 0)
+                return NULL;
+        err = fstat(fd, &st);
+        if (err < 0)
+                goto out;
+        *size = st.st_size;
+        map = mmap(NULL,
+                   (st.st_size + ps - 1) & ~(ps - 1),
+                   PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
+        if (map == MAP_FAILED)
+                map = NULL;
+out:
+        close(fd);
+        return map;
+}
+
+static void unmapfile(char *map, size_t size)
+{
+        unsigned ps = sysconf(_SC_PAGESIZE);
+        munmap(map, roundup(size, ps));
+}
+
+/*
+ * Parse json file using jsmn. Return array of tokens,
+ * and mapped file. Caller needs to free array.
+ */
+jsmntok_t *parse_json(const char *fn, char **map, size_t *size, int *len)
+{
+        jsmn_parser parser;
+        jsmntok_t *tokens;
+        jsmnerr_t res;
+        unsigned sz;
+
+        *map = mapfile(fn, size);
+        if (!*map)
+                return NULL;
+        /* Heuristic */
+        sz = *size * 16;
+        tokens = malloc(sz);
+        if (!tokens)
+                goto error;
+        jsmn_init(&parser);
+        res = jsmn_parse(&parser, *map, *size, tokens,
+                         sz / sizeof(jsmntok_t));
+        if (res != JSMN_SUCCESS) {
+                pr_err("%s: json error %s\n", fn, jsmn_strerror(res));
+                goto error_free;
+        }
+        if (len)
+                *len = parser.toknext;
+        return tokens;
+error_free:
+        free(tokens);
+error:
+        unmapfile(*map, *size);
+        return NULL;
+}
+
+void free_json(char *map, size_t size, jsmntok_t *tokens)
+{
+        free(tokens);
+        unmapfile(map, size);
+}
+
+static int countchar(char *map, char c, int end)
+{
+        int i;
+        int count = 0;
+        for (i = 0; i < end; i++)
+                if (map[i] == c)
+                        count++;
+        return count;
+}
+
+/* Return line number of a jsmn token */
+int json_line(char *map, jsmntok_t *t)
+{
+        return countchar(map, '\n', t->start) + 1;
+}
+
+static const char * const jsmn_types[] = {
+        [JSMN_PRIMITIVE] = "primitive",
+        [JSMN_ARRAY] = "array",
+        [JSMN_OBJECT] = "object",
+        [JSMN_STRING] = "string"
+};
+
+#define LOOKUP(a, i) ((i) < (sizeof(a)/sizeof(*(a))) ? ((a)[i]) : "?")
+
+/* Return type name of a jsmn token */
+const char *json_name(jsmntok_t *t)
+{
+        return LOOKUP(jsmn_types, t->type);
+}
+
+int json_len(jsmntok_t *t)
+{
+        return t->end - t->start;
+}
+
+/* Is string t equal to s? */
+int json_streq(char *map, jsmntok_t *t, const char *s)
+{
+        unsigned len = json_len(t);
+        return len == strlen(s) && !strncasecmp(map + t->start, s, len);
+}
diff --git a/tools/perf/pmu-events/json.h b/tools/perf/pmu-events/json.h
new file mode 100644
index 000000000000..278ebd32cfb6
--- /dev/null
+++ b/tools/perf/pmu-events/json.h
@@ -0,0 +1,38 @@
+#ifndef JSON_H
+#define JSON_H 1
+
+#include "jsmn.h"
+
+jsmntok_t *parse_json(const char *fn, char **map, size_t *size, int *len);
+void free_json(char *map, size_t size, jsmntok_t *tokens);
+int json_line(char *map, jsmntok_t *t);
+const char *json_name(jsmntok_t *t);
+int json_streq(char *map, jsmntok_t *t, const char *s);
+int json_len(jsmntok_t *t);
+
+extern int verbose;
+
+#include <stdbool.h>
+
+extern int eprintf(int level, int var, const char *fmt, ...);
+#define pr_fmt(fmt)     fmt
+
+#define pr_err(fmt, ...) \
+        eprintf(0, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+
+#define pr_info(fmt, ...) \
+        eprintf(1, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+
+#define pr_debug(fmt, ...) \
+        eprintf(2, verbose, pr_fmt(fmt), ##__VA_ARGS__)
+
+#ifndef roundup
+#define roundup(x, y) (                                \
+{                                                      \
+        const typeof(y) __y = y;                       \
+        (((x) + (__y - 1)) / __y) * __y;               \
+}                                                      \
+)
+#endif
+
+#endif
diff --git a/tools/perf/pmu-events/pmu-events.h b/tools/perf/pmu-events/pmu-events.h
new file mode 100644
index 000000000000..2eaef595d8a0
--- /dev/null
+++ b/tools/perf/pmu-events/pmu-events.h
@@ -0,0 +1,37 @@
+#ifndef PMU_EVENTS_H
+#define PMU_EVENTS_H
+
+/*
+ * Describe each PMU event. Each CPU has a table of PMU events.
+ */
+struct pmu_event {
+        const char *name;
+        const char *event;
+        const char *desc;
+        const char *topic;
+        const char *long_desc;
+};
+
+/*
+ *
+ * Map a CPU to its table of PMU events. The CPU is identified by the
+ * cpuid field, which is an arch-specific identifier for the CPU.
+ * The identifier specified in tools/perf/pmu-events/arch/xxx/mapfile
+ * must match the get_cpustr() in tools/perf/arch/xxx/util/header.c)
+ *
+ * The  cpuid can contain any character other than the comma.
+ */
+struct pmu_events_map {
+        const char *cpuid;
+        const char *version;
+        const char *type;               /* core, uncore etc */
+        struct pmu_event *table;
+};
+
+/*
+ * Global table mapping each known CPU for the architecture to its
+ * table of PMU events.
+ */
+extern struct pmu_events_map pmu_events_map[];
+
+#endif
diff --git a/tools/perf/python/tracepoint.py b/tools/perf/python/tracepoint.py
new file mode 100755
index 000000000000..eb4dbed57de7
--- /dev/null
+++ b/tools/perf/python/tracepoint.py
@@ -0,0 +1,47 @@
+#! /usr/bin/python
+# -*- python -*-
+# -*- coding: utf-8 -*-
+
+import perf
+
+class tracepoint(perf.evsel):
+    def __init__(self, sys, name):
+        config = perf.tracepoint(sys, name)
+        perf.evsel.__init__(self,
+                            type   = perf.TYPE_TRACEPOINT,
+                            config = config,
+                            freq = 0, sample_period = 1, wakeup_events = 1,
+                            sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU | perf.SAMPLE_RAW | perf.SAMPLE_TIME)
+
+def main():
+    tp      = tracepoint("sched", "sched_switch")
+    cpus    = perf.cpu_map()
+    threads = perf.thread_map(-1)
+
+    evlist = perf.evlist(cpus, threads)
+    evlist.add(tp)
+    evlist.open()
+    evlist.mmap()
+
+    while True:
+        evlist.poll(timeout = -1)
+        for cpu in cpus:
+            event = evlist.read_on_cpu(cpu)
+            if not event:
+                continue
+
+            if not isinstance(event, perf.sample_event):
+                continue
+
+            print "time %u prev_comm=%s prev_pid=%d prev_prio=%d prev_state=0x%x ==> next_comm=%s next_pid=%d next_prio=%d" % (
+                   event.sample_time,
+                   event.prev_comm,
+                   event.prev_pid,
+                   event.prev_prio,
+                   event.prev_state,
+                   event.next_comm,
+                   event.next_pid,
+                   event.next_prio)
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Build b/tools/perf/scripts/perl/Perf-Trace-Util/Build
index 928e110179cb..34faecf774ae 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/Build
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Build
@@ -1,3 +1,5 @@
 libperf-y += Context.o
 
-CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs -Wno-undef -Wno-switch-default
+CFLAGS_Context.o += $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes
+CFLAGS_Context.o += -Wno-unused-parameter -Wno-nested-externs -Wno-undef
+CFLAGS_Context.o += -Wno-switch-default -Wno-shadow
diff --git a/tools/perf/scripts/python/bin/stackcollapse-record b/tools/perf/scripts/python/bin/stackcollapse-record
new file mode 100755
index 000000000000..9d8f9f0f3a17
--- /dev/null
+++ b/tools/perf/scripts/python/bin/stackcollapse-record
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+#
+# stackcollapse.py can cover all type of perf samples including
+# the tracepoints, so no special record requirements, just record what
+# you want to analyze.
+#
+perf record "$@"
diff --git a/tools/perf/scripts/python/bin/stackcollapse-report b/tools/perf/scripts/python/bin/stackcollapse-report
new file mode 100755
index 000000000000..356b9656393d
--- /dev/null
+++ b/tools/perf/scripts/python/bin/stackcollapse-report
@@ -0,0 +1,3 @@
+#!/bin/sh
+# description: produce callgraphs in short form for scripting use
+perf script -s "$PERF_EXEC_PATH"/scripts/python/stackcollapse.py -- "$@"
diff --git a/tools/perf/scripts/python/netdev-times.py b/tools/perf/scripts/python/netdev-times.py
index 4d21ef2d601d..4c6f09ac7d12 100644
--- a/tools/perf/scripts/python/netdev-times.py
+++ b/tools/perf/scripts/python/netdev-times.py
@@ -252,9 +252,10 @@ def irq__irq_handler_exit(name, context, cpu, sec, nsec, pid, comm, callchain, i
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, irq, ret)
         all_event_list.append(event_info)
 
-def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, callchain, napi, dev_name):
+def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, callchain, napi,
+                    dev_name, work=None, budget=None):
         event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
-                        napi, dev_name)
+                        napi, dev_name, work, budget)
         all_event_list.append(event_info)
 
 def net__netif_receive_skb(name, context, cpu, sec, nsec, pid, comm, callchain, skbaddr,
@@ -354,11 +355,13 @@ def handle_irq_softirq_exit(event_info):
         receive_hunk_list.append(rec_data)
 
 def handle_napi_poll(event_info):
-        (name, context, cpu, time, pid, comm, napi, dev_name) = event_info
+        (name, context, cpu, time, pid, comm, napi, dev_name,
+                work, budget) = event_info
         if cpu in net_rx_dic.keys():
                 event_list = net_rx_dic[cpu]['event_list']
                 rec_data = {'event_name':'napi_poll',
-                                'dev':dev_name, 'event_t':time}
+                                'dev':dev_name, 'event_t':time,
+                                'work':work, 'budget':budget}
                 event_list.append(rec_data)
 
 def handle_netif_rx(event_info):
diff --git a/tools/perf/scripts/python/stackcollapse.py b/tools/perf/scripts/python/stackcollapse.py
new file mode 100755
index 000000000000..5a605f70ef32
--- /dev/null
+++ b/tools/perf/scripts/python/stackcollapse.py
@@ -0,0 +1,125 @@
+# stackcollapse.py - format perf samples with one line per distinct call stack
+#
+# This script's output has two space-separated fields.  The first is a semicolon
+# separated stack including the program name (from the "comm" field) and the
+# function names from the call stack.  The second is a count:
+#
+#  swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 2
+#
+# The file is sorted according to the first field.
+#
+# Input may be created and processed using:
+#
+#  perf record -a -g -F 99 sleep 60
+#  perf script report stackcollapse > out.stacks-folded
+#
+# (perf script record stackcollapse works too).
+#
+# Written by Paolo Bonzini <pbonzini@redhat.com>
+# Based on Brendan Gregg's stackcollapse-perf.pl script.
+
+import os
+import sys
+from collections import defaultdict
+from optparse import OptionParser, make_option
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+                '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from EventClass import *
+
+# command line parsing
+
+option_list = [
+    # formatting options for the bottom entry of the stack
+    make_option("--include-tid", dest="include_tid",
+                 action="store_true", default=False,
+                 help="include thread id in stack"),
+    make_option("--include-pid", dest="include_pid",
+                 action="store_true", default=False,
+                 help="include process id in stack"),
+    make_option("--no-comm", dest="include_comm",
+                 action="store_false", default=True,
+                 help="do not separate stacks according to comm"),
+    make_option("--tidy-java", dest="tidy_java",
+                 action="store_true", default=False,
+                 help="beautify Java signatures"),
+    make_option("--kernel", dest="annotate_kernel",
+                 action="store_true", default=False,
+                 help="annotate kernel functions with _[k]")
+]
+
+parser = OptionParser(option_list=option_list)
+(opts, args) = parser.parse_args()
+
+if len(args) != 0:
+    parser.error("unexpected command line argument")
+if opts.include_tid and not opts.include_comm:
+    parser.error("requesting tid but not comm is invalid")
+if opts.include_pid and not opts.include_comm:
+    parser.error("requesting pid but not comm is invalid")
+
+# event handlers
+
+lines = defaultdict(lambda: 0)
+
+def process_event(param_dict):
+    def tidy_function_name(sym, dso):
+        if sym is None:
+            sym = '[unknown]'
+
+        sym = sym.replace(';', ':')
+        if opts.tidy_java:
+            # the original stackcollapse-perf.pl script gives the
+            # example of converting this:
+            #    Lorg/mozilla/javascript/MemberBox;.<init>(Ljava/lang/reflect/Method;)V
+            # to this:
+            #    org/mozilla/javascript/MemberBox:.init
+            sym = sym.replace('<', '')
+            sym = sym.replace('>', '')
+            if sym[0] == 'L' and sym.find('/'):
+                sym = sym[1:]
+            try:
+                sym = sym[:sym.index('(')]
+            except ValueError:
+                pass
+
+        if opts.annotate_kernel and dso == '[kernel.kallsyms]':
+            return sym + '_[k]'
+        else:
+            return sym
+
+    stack = list()
+    if 'callchain' in param_dict:
+        for entry in param_dict['callchain']:
+            entry.setdefault('sym', dict())
+            entry['sym'].setdefault('name', None)
+            entry.setdefault('dso', None)
+            stack.append(tidy_function_name(entry['sym']['name'],
+                                            entry['dso']))
+    else:
+        param_dict.setdefault('symbol', None)
+        param_dict.setdefault('dso', None)
+        stack.append(tidy_function_name(param_dict['symbol'],
+                                        param_dict['dso']))
+
+    if opts.include_comm:
+        comm = param_dict["comm"].replace(' ', '_')
+        sep = "-"
+        if opts.include_pid:
+            comm = comm + sep + str(param_dict['sample']['pid'])
+            sep = "/"
+        if opts.include_tid:
+            comm = comm + sep + str(param_dict['sample']['tid'])
+        stack.append(comm)
+
+    stack_string = ';'.join(reversed(stack))
+    lines[stack_string] = lines[stack_string] + 1
+
+def trace_end():
+    list = lines.keys()
+    list.sort()
+    for stack in list:
+        print "%s %d" % (stack, lines[stack])
diff --git a/tools/perf/tests/Build b/tools/perf/tests/Build
index 66a28982547b..8a4ce492f7b2 100644
--- a/tools/perf/tests/Build
+++ b/tools/perf/tests/Build
@@ -39,6 +39,9 @@ perf-y += stat.o
 perf-y += event_update.o
 perf-y += event-times.o
 perf-y += backward-ring-buffer.o
+perf-y += sdt.o
+perf-y += is_printable_array.o
+perf-y += bitmap.o
 
 $(OUTPUT)tests/llvm-src-base.c: tests/bpf-script-example.c tests/Build
         $(call rule_mkdir)
@@ -68,7 +71,7 @@ $(OUTPUT)tests/llvm-src-relocation.c: tests/bpf-script-test-relocation.c tests/B
         $(Q)sed -e 's/"/\\"/g' -e 's/\(.*\)/"\1\\n"/g' $< >> $@
         $(Q)echo ';' >> $@
 
-ifeq ($(ARCH),$(filter $(ARCH),x86 arm arm64))
+ifeq ($(ARCH),$(filter $(ARCH),x86 arm arm64 powerpc))
 perf-$(CONFIG_DWARF_UNWIND) += dwarf-unwind.o
 endif
 
diff --git a/tools/perf/tests/backward-ring-buffer.c b/tools/perf/tests/backward-ring-buffer.c
index d9ba991a9a30..e6d1816e431a 100644
--- a/tools/perf/tests/backward-ring-buffer.c
+++ b/tools/perf/tests/backward-ring-buffer.c
@@ -31,8 +31,8 @@ static int count_samples(struct perf_evlist *evlist, int *sample_count,
         for (i = 0; i < evlist->nr_mmaps; i++) {
                 union perf_event *event;
 
-                perf_evlist__mmap_read_catchup(evlist, i);
-                while ((event = perf_evlist__mmap_read_backward(evlist, i)) != NULL) {
+                perf_mmap__read_catchup(&evlist->backward_mmap[i]);
+                while ((event = perf_mmap__read_backward(&evlist->backward_mmap[i])) != NULL) {
                         const u32 type = event->header.type;
 
                         switch (type) {
@@ -60,7 +60,7 @@ static int do_test(struct perf_evlist *evlist, int mmap_pages,
         err = perf_evlist__mmap(evlist, mmap_pages, true);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 return TEST_FAIL;
         }
 
@@ -97,7 +97,7 @@ int test__backward_ring_buffer(int subtest __maybe_unused)
 
         evlist = perf_evlist__new();
         if (!evlist) {
-                pr_debug("No ehough memory to create evlist\n");
+                pr_debug("No enough memory to create evlist\n");
                 return TEST_FAIL;
         }
 
@@ -108,7 +108,11 @@ int test__backward_ring_buffer(int subtest __maybe_unused)
         }
 
         bzero(&parse_error, sizeof(parse_error));
-        err = parse_events(evlist, "syscalls:sys_enter_prctl", &parse_error);
+        /*
+         * Set backward bit, ring buffer should be writing from end. Record
+         * it in aux evlist
+         */
+        err = parse_events(evlist, "syscalls:sys_enter_prctl/overwrite/", &parse_error);
         if (err) {
                 pr_debug("Failed to parse tracepoint event, try use root\n");
                 ret = TEST_SKIP;
@@ -117,14 +121,10 @@ int test__backward_ring_buffer(int subtest __maybe_unused)
 
         perf_evlist__config(evlist, &opts, NULL);
 
-        /* Set backward bit, ring buffer should be writing from end */
-        evlist__for_each(evlist, evsel)
-                evsel->attr.write_backward = 1;
-
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/bitmap.c b/tools/perf/tests/bitmap.c
new file mode 100644
index 000000000000..9abe6c13090f
--- /dev/null
+++ b/tools/perf/tests/bitmap.c
@@ -0,0 +1,53 @@
+#include <linux/compiler.h>
+#include <linux/bitmap.h>
+#include "tests.h"
+#include "cpumap.h"
+#include "debug.h"
+
+#define NBITS 100
+
+static unsigned long *get_bitmap(const char *str, int nbits)
+{
+        struct cpu_map *map = cpu_map__new(str);
+        unsigned long *bm = NULL;
+        int i;
+
+        bm = bitmap_alloc(nbits);
+
+        if (map && bm) {
+                bitmap_zero(bm, nbits);
+
+                for (i = 0; i < map->nr; i++)
+                        set_bit(map->map[i], bm);
+        }
+
+        if (map)
+                cpu_map__put(map);
+        return bm;
+}
+
+static int test_bitmap(const char *str)
+{
+        unsigned long *bm = get_bitmap(str, NBITS);
+        char buf[100];
+        int ret;
+
+        bitmap_scnprintf(bm, NBITS, buf, sizeof(buf));
+        pr_debug("bitmap: %s\n", buf);
+
+        ret = !strcmp(buf, str);
+        free(bm);
+        return ret;
+}
+
+int test__bitmap_print(int subtest __maybe_unused)
+{
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1,5"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1,3,5,7,9,11,13,15,17,19,21-40"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("2-5"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1,3-6,8-10,24,35-37"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1,3-6,8-10,24,35-37"));
+        TEST_ASSERT_VAL("failed to convert map", test_bitmap("1-10,12-20,22-30,32-40"));
+        return 0;
+}
diff --git a/tools/perf/tests/bpf-script-example.c b/tools/perf/tests/bpf-script-example.c
index 0ec9c2c03164..268e5f8e4aa2 100644
--- a/tools/perf/tests/bpf-script-example.c
+++ b/tools/perf/tests/bpf-script-example.c
@@ -31,8 +31,8 @@ struct bpf_map_def SEC("maps") flip_table = {
         .max_entries = 1,
 };
 
-SEC("func=sys_epoll_pwait")
-int bpf_func__sys_epoll_pwait(void *ctx)
+SEC("func=SyS_epoll_wait")
+int bpf_func__SyS_epoll_wait(void *ctx)
 {
         int ind =0;
         int *flag = bpf_map_lookup_elem(&flip_table, &ind);
diff --git a/tools/perf/tests/bpf.c b/tools/perf/tests/bpf.c
index f31eed31c1a9..2673e86ed50f 100644
--- a/tools/perf/tests/bpf.c
+++ b/tools/perf/tests/bpf.c
@@ -13,13 +13,13 @@
 
 #ifdef HAVE_LIBBPF_SUPPORT
 
-static int epoll_pwait_loop(void)
+static int epoll_wait_loop(void)
 {
         int i;
 
         /* Should fail NR_ITERS times */
         for (i = 0; i < NR_ITERS; i++)
-                epoll_pwait(-(i + 1), NULL, 0, 0, NULL);
+                epoll_wait(-(i + 1), NULL, 0, 0);
         return 0;
 }
 
@@ -61,7 +61,7 @@ static struct {
                 "[basic_bpf_test]",
                 "fix 'perf test LLVM' first",
                 "load bpf object failed",
-                &epoll_pwait_loop,
+                &epoll_wait_loop,
                 (NR_ITERS + 1) / 2,
         },
 #ifdef HAVE_BPF_PROLOGUE
@@ -125,7 +125,7 @@ static int do_test(struct bpf_object *obj, int (*func)(void),
         /* Instead of perf_evlist__new_default, don't add default events */
         evlist = perf_evlist__new();
         if (!evlist) {
-                pr_debug("No ehough memory to create evlist\n");
+                pr_debug("No enough memory to create evlist\n");
                 return TEST_FAIL;
         }
 
@@ -143,14 +143,14 @@ static int do_test(struct bpf_object *obj, int (*func)(void),
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
         err = perf_evlist__mmap(evlist, opts.mmap_pages, false);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 0e95c20ecf6e..778668a2a966 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -14,6 +14,8 @@
 #include <subcmd/parse-options.h>
 #include "symbol.h"
 
+static bool dont_fork;
+
 struct test __weak arch_tests[] = {
         {
                 .func = NULL,
@@ -212,6 +214,22 @@ static struct test generic_tests[] = {
                 .func = test__backward_ring_buffer,
         },
         {
+                .desc = "Test cpu map print",
+                .func = test__cpu_map_print,
+        },
+        {
+                .desc = "Test SDT event probing",
+                .func = test__sdt_event,
+        },
+        {
+                .desc = "Test is_printable_array function",
+                .func = test__is_printable_array,
+        },
+        {
+                .desc = "Test bitmap print",
+                .func = test__bitmap_print,
+        },
+        {
                 .func = NULL,
         },
 };
@@ -247,44 +265,51 @@ static bool perf_test__matches(struct test *test, int curr, int argc, const char
 
 static int run_test(struct test *test, int subtest)
 {
-        int status, err = -1, child = fork();
+        int status, err = -1, child = dont_fork ? 0 : fork();
         char sbuf[STRERR_BUFSIZE];
 
         if (child < 0) {
                 pr_err("failed to fork test: %s\n",
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
 
         if (!child) {
-                pr_debug("test child forked, pid %d\n", getpid());
-                if (!verbose) {
-                        int nullfd = open("/dev/null", O_WRONLY);
-                        if (nullfd >= 0) {
-                                close(STDERR_FILENO);
-                                close(STDOUT_FILENO);
-
-                                dup2(nullfd, STDOUT_FILENO);
-                                dup2(STDOUT_FILENO, STDERR_FILENO);
-                                close(nullfd);
+                if (!dont_fork) {
+                        pr_debug("test child forked, pid %d\n", getpid());
+
+                        if (!verbose) {
+                                int nullfd = open("/dev/null", O_WRONLY);
+
+                                if (nullfd >= 0) {
+                                        close(STDERR_FILENO);
+                                        close(STDOUT_FILENO);
+
+                                        dup2(nullfd, STDOUT_FILENO);
+                                        dup2(STDOUT_FILENO, STDERR_FILENO);
+                                        close(nullfd);
+                                }
+                        } else {
+                                signal(SIGSEGV, sighandler_dump_stack);
+                                signal(SIGFPE, sighandler_dump_stack);
                         }
-                } else {
-                        signal(SIGSEGV, sighandler_dump_stack);
-                        signal(SIGFPE, sighandler_dump_stack);
                 }
 
                 err = test->func(subtest);
-                exit(err);
+                if (!dont_fork)
+                        exit(err);
         }
 
-        wait(&status);
+        if (!dont_fork) {
+                wait(&status);
 
-        if (WIFEXITED(status)) {
-                err = (signed char)WEXITSTATUS(status);
-                pr_debug("test child finished with %d\n", err);
-        } else if (WIFSIGNALED(status)) {
-                err = -1;
-                pr_debug("test child interrupted\n");
+                if (WIFEXITED(status)) {
+                        err = (signed char)WEXITSTATUS(status);
+                        pr_debug("test child finished with %d\n", err);
+                } else if (WIFSIGNALED(status)) {
+                        err = -1;
+                        pr_debug("test child interrupted\n");
+                }
         }
 
         return err;
@@ -425,6 +450,8 @@ int cmd_test(int argc, const char **argv, const char *prefix __maybe_unused)
         OPT_STRING('s', "skip", &skip, "tests", "tests to skip"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
+        OPT_BOOLEAN('F', "dont-fork", &dont_fork,
+                    "Do not fork for testcase"),
         OPT_END()
         };
         const char * const test_subcommands[] = { "list", NULL };
diff --git a/tools/perf/tests/code-reading.c b/tools/perf/tests/code-reading.c
index 68a69a195545..ff5bc6363a79 100644
--- a/tools/perf/tests/code-reading.c
+++ b/tools/perf/tests/code-reading.c
@@ -33,44 +33,86 @@ static unsigned int hex(char c)
         return c - 'A' + 10;
 }
 
-static size_t read_objdump_line(const char *line, size_t line_len, void *buf,
-                              size_t len)
+static size_t read_objdump_chunk(const char **line, unsigned char **buf,
+                                 size_t *buf_len)
 {
-        const char *p;
-        size_t i, j = 0;
-
-        /* Skip to a colon */
-        p = strchr(line, ':');
-        if (!p)
-                return 0;
-        i = p + 1 - line;
+        size_t bytes_read = 0;
+        unsigned char *chunk_start = *buf;
 
         /* Read bytes */
-        while (j < len) {
+        while (*buf_len > 0) {
                 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]))
+                c1 = *(*line)++;
+                if (!isxdigit(c1))
                         break;
-                c1 = line[i++];
-                if (i >= line_len || !isxdigit(line[i]))
+                c2 = *(*line)++;
+                if (!isxdigit(c2))
                         break;
-                c2 = line[i++];
-                /* Followed by a space */
-                if (i < line_len && line[i] && !isspace(line[i]))
+
+                /* Store byte and advance buf */
+                **buf = (hex(c1) << 4) | hex(c2);
+                (*buf)++;
+                (*buf_len)--;
+                bytes_read++;
+
+                /* End of chunk? */
+                if (isspace(**line))
                         break;
-                /* Store byte */
-                *(unsigned char *)buf = (hex(c1) << 4) | hex(c2);
-                buf += 1;
-                j++;
         }
+
+        /*
+         * objdump will display raw insn as LE if code endian
+         * is LE and bytes_per_chunk > 1. In that case reverse
+         * the chunk we just read.
+         *
+         * see disassemble_bytes() at binutils/objdump.c for details
+         * how objdump chooses display endian)
+         */
+        if (bytes_read > 1 && !bigendian()) {
+                unsigned char *chunk_end = chunk_start + bytes_read - 1;
+                unsigned char tmp;
+
+                while (chunk_start < chunk_end) {
+                        tmp = *chunk_start;
+                        *chunk_start = *chunk_end;
+                        *chunk_end = tmp;
+                        chunk_start++;
+                        chunk_end--;
+                }
+        }
+
+        return bytes_read;
+}
+
+static size_t read_objdump_line(const char *line, unsigned char *buf,
+                                size_t buf_len)
+{
+        const char *p;
+        size_t ret, bytes_read = 0;
+
+        /* Skip to a colon */
+        p = strchr(line, ':');
+        if (!p)
+                return 0;
+        p++;
+
+        /* Skip initial spaces */
+        while (*p) {
+                if (!isspace(*p))
+                        break;
+                p++;
+        }
+
+        do {
+                ret = read_objdump_chunk(&p, &buf, &buf_len);
+                bytes_read += ret;
+                p++;
+        } while (ret > 0);
+
         /* return number of successfully read bytes */
-        return j;
+        return bytes_read;
 }
 
 static int read_objdump_output(FILE *f, void *buf, size_t *len, u64 start_addr)
@@ -95,7 +137,7 @@ static int read_objdump_output(FILE *f, void *buf, size_t *len, u64 start_addr)
                 }
 
                 /* read objdump data into temporary buffer */
-                read_bytes = read_objdump_line(line, ret, tmp, sizeof(tmp));
+                read_bytes = read_objdump_line(line, tmp, sizeof(tmp));
                 if (!read_bytes)
                         continue;
 
@@ -152,7 +194,7 @@ static int read_via_objdump(const char *filename, u64 addr, void *buf,
 
         ret = read_objdump_output(f, buf, &len, addr);
         if (len) {
-                pr_debug("objdump read too few bytes\n");
+                pr_debug("objdump read too few bytes: %zd\n", len);
                 if (!ret)
                         ret = len;
         }
@@ -221,7 +263,7 @@ static int read_object_code(u64 addr, size_t len, u8 cpumode,
          * 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))
+        if (map__load(al.map))
                 return -1;
 
         /* objdump struggles with kcore - try each map only once */
@@ -469,7 +511,7 @@ static int do_test_code_reading(bool try_kcore)
 
         /* Load kernel map */
         map = machine__kernel_map(machine);
-        ret = map__load(map, NULL);
+        ret = map__load(map);
         if (ret < 0) {
                 pr_debug("map__load failed\n");
                 goto out_err;
diff --git a/tools/perf/tests/cpumap.c b/tools/perf/tests/cpumap.c
index 4cb6418a8ffc..f168a85992d0 100644
--- a/tools/perf/tests/cpumap.c
+++ b/tools/perf/tests/cpumap.c
@@ -1,5 +1,12 @@
 #include "tests.h"
+#include <stdio.h>
 #include "cpumap.h"
+#include "event.h"
+#include <string.h>
+#include <linux/bitops.h>
+#include "debug.h"
+
+struct machine;
 
 static int process_event_mask(struct perf_tool *tool __maybe_unused,
                          union perf_event *event,
@@ -86,3 +93,27 @@ int test__cpu_map_synthesize(int subtest __maybe_unused)
         cpu_map__put(cpus);
         return 0;
 }
+
+static int cpu_map_print(const char *str)
+{
+        struct cpu_map *map = cpu_map__new(str);
+        char buf[100];
+
+        if (!map)
+                return -1;
+
+        cpu_map__snprint(map, buf, sizeof(buf));
+        return !strcmp(buf, str);
+}
+
+int test__cpu_map_print(int subtest __maybe_unused)
+{
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1,5"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1,3,5,7,9,11,13,15,17,19,21-40"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("2-5"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1,3-6,8-10,24,35-37"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1,3-6,8-10,24,35-37"));
+        TEST_ASSERT_VAL("failed to convert map", cpu_map_print("1-10,12-20,22-30,32-40"));
+        return 0;
+}
diff --git a/tools/perf/tests/dso-data.c b/tools/perf/tests/dso-data.c
index 8cf0d9e189a8..13725e09ba22 100644
--- a/tools/perf/tests/dso-data.c
+++ b/tools/perf/tests/dso-data.c
@@ -251,6 +251,9 @@ int test__dso_data_cache(int subtest __maybe_unused)
         long nr_end, nr = open_files_cnt();
         int dso_cnt, limit, i, fd;
 
+        /* Rest the internal dso open counter limit. */
+        reset_fd_limit();
+
         memset(&machine, 0, sizeof(machine));
 
         /* set as system limit */
@@ -312,6 +315,9 @@ int test__dso_data_reopen(int subtest __maybe_unused)
 #define dso_1 (dsos[1])
 #define dso_2 (dsos[2])
 
+        /* Rest the internal dso open counter limit. */
+        reset_fd_limit();
+
         memset(&machine, 0, sizeof(machine));
 
         /*
diff --git a/tools/perf/tests/dwarf-unwind.c b/tools/perf/tests/dwarf-unwind.c
index 8f6eb853aaf7..1046491de4b2 100644
--- a/tools/perf/tests/dwarf-unwind.c
+++ b/tools/perf/tests/dwarf-unwind.c
@@ -11,7 +11,7 @@
 #include "thread.h"
 #include "callchain.h"
 
-#if defined (__x86_64__) || defined (__i386__)
+#if defined (__x86_64__) || defined (__i386__) || defined (__powerpc__)
 #include "arch-tests.h"
 #endif
 
diff --git a/tools/perf/tests/event-times.c b/tools/perf/tests/event-times.c
index 95fb744f6628..19ef77bd6eb4 100644
--- a/tools/perf/tests/event-times.c
+++ b/tools/perf/tests/event-times.c
@@ -37,7 +37,7 @@ static int attach__enable_on_exec(struct perf_evlist *evlist)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 return err;
         }
 
@@ -200,8 +200,7 @@ static int test_times(int (attach)(struct perf_evlist *),
                  count.ena, count.run);
 
 out_err:
-        if (evlist)
-                perf_evlist__delete(evlist);
+        perf_evlist__delete(evlist);
         return !err ? TEST_OK : TEST_FAIL;
 }
 
diff --git a/tools/perf/tests/evsel-roundtrip-name.c b/tools/perf/tests/evsel-roundtrip-name.c
index 2de4a4f2c3ed..60926a1f6fd7 100644
--- a/tools/perf/tests/evsel-roundtrip-name.c
+++ b/tools/perf/tests/evsel-roundtrip-name.c
@@ -80,7 +80,7 @@ static int __perf_evsel__name_array_test(const char *names[], int nr_names)
         }
 
         err = 0;
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (strcmp(perf_evsel__name(evsel), names[evsel->idx])) {
                         --err;
                         pr_debug("%s != %s\n", perf_evsel__name(evsel), names[evsel->idx]);
diff --git a/tools/perf/tests/fdarray.c b/tools/perf/tests/fdarray.c
index c809463edbe5..a2b5ff9bf83d 100644
--- a/tools/perf/tests/fdarray.c
+++ b/tools/perf/tests/fdarray.c
@@ -1,4 +1,5 @@
 #include <api/fd/array.h>
+#include <poll.h>
 #include "util/debug.h"
 #include "tests/tests.h"
 
@@ -36,7 +37,7 @@ int test__fdarray__filter(int subtest __maybe_unused)
         }
 
         fdarray__init_revents(fda, POLLIN);
-        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL, NULL);
         if (nr_fds != fda->nr_alloc) {
                 pr_debug("\nfdarray__filter()=%d != %d shouldn't have filtered anything",
                          nr_fds, fda->nr_alloc);
@@ -44,7 +45,7 @@ int test__fdarray__filter(int subtest __maybe_unused)
         }
 
         fdarray__init_revents(fda, POLLHUP);
-        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL, NULL);
         if (nr_fds != 0) {
                 pr_debug("\nfdarray__filter()=%d != %d, should have filtered all fds",
                          nr_fds, fda->nr_alloc);
@@ -57,7 +58,7 @@ int test__fdarray__filter(int subtest __maybe_unused)
 
         pr_debug("\nfiltering all but fda->entries[2]:");
         fdarray__fprintf_prefix(fda, "before", stderr);
-        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL, NULL);
         fdarray__fprintf_prefix(fda, " after", stderr);
         if (nr_fds != 1) {
                 pr_debug("\nfdarray__filter()=%d != 1, should have left just one event", nr_fds);
@@ -78,7 +79,7 @@ int test__fdarray__filter(int subtest __maybe_unused)
 
         pr_debug("\nfiltering all but (fda->entries[0], fda->entries[3]):");
         fdarray__fprintf_prefix(fda, "before", stderr);
-        nr_fds = fdarray__filter(fda, POLLHUP, NULL);
+        nr_fds = fdarray__filter(fda, POLLHUP, NULL, NULL);
         fdarray__fprintf_prefix(fda, " after", stderr);
         if (nr_fds != 2) {
                 pr_debug("\nfdarray__filter()=%d != 2, should have left just two events",
diff --git a/tools/perf/tests/hists_cumulate.c b/tools/perf/tests/hists_cumulate.c
index a9e3db3afac4..9fd54b79a788 100644
--- a/tools/perf/tests/hists_cumulate.c
+++ b/tools/perf/tests/hists_cumulate.c
@@ -216,6 +216,8 @@ static int do_test(struct hists *hists, struct result *expected, size_t nr_expec
 
                 /* check callchain entries */
                 root = &he->callchain->node.rb_root;
+
+                TEST_ASSERT_VAL("callchains expected", !RB_EMPTY_ROOT(root));
                 cnode = rb_entry(rb_first(root), struct callchain_node, rb_node);
 
                 c = 0;
@@ -666,6 +668,8 @@ static int test4(struct perf_evsel *evsel, struct machine *machine)
         perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 
         setup_sorting(NULL);
+
+        callchain_param = callchain_param_default;
         callchain_register_param(&callchain_param);
 
         err = add_hist_entries(hists, machine);
diff --git a/tools/perf/tests/hists_filter.c b/tools/perf/tests/hists_filter.c
index e846f8c42013..62efb14f3a5a 100644
--- a/tools/perf/tests/hists_filter.c
+++ b/tools/perf/tests/hists_filter.c
@@ -56,7 +56,7 @@ static int add_hist_entries(struct perf_evlist *evlist,
          * (perf [perf] main) will be collapsed to an existing entry
          * so total 9 entries will be in the tree.
          */
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
                         struct hist_entry_iter iter = {
                                 .evsel = evsel,
@@ -136,7 +136,7 @@ int test__hists_filter(int subtest __maybe_unused)
         if (err < 0)
                 goto out;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 struct hists *hists = evsel__hists(evsel);
 
                 hists__collapse_resort(hists, NULL);
diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
index acf5a1301c07..eddc7407ff8a 100644
--- a/tools/perf/tests/hists_link.c
+++ b/tools/perf/tests/hists_link.c
@@ -72,7 +72,7 @@ static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
          * However the second evsel also has a collapsed entry for
          * "bash [libc] malloc" so total 9 entries will be in the tree.
          */
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 struct hists *hists = evsel__hists(evsel);
 
                 for (k = 0; k < ARRAY_SIZE(fake_common_samples); k++) {
@@ -84,7 +84,7 @@ static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
                         if (machine__resolve(machine, &al, &sample) < 0)
                                 goto out;
 
-                        he = __hists__add_entry(hists, &al, NULL,
+                        he = hists__add_entry(hists, &al, NULL,
                                                 NULL, NULL, &sample, true);
                         if (he == NULL) {
                                 addr_location__put(&al);
@@ -103,7 +103,7 @@ static int add_hist_entries(struct perf_evlist *evlist, struct machine *machine)
                         if (machine__resolve(machine, &al, &sample) < 0)
                                 goto out;
 
-                        he = __hists__add_entry(hists, &al, NULL,
+                        he = hists__add_entry(hists, &al, NULL,
                                                 NULL, NULL, &sample, true);
                         if (he == NULL) {
                                 addr_location__put(&al);
@@ -301,7 +301,7 @@ int test__hists_link(int subtest __maybe_unused)
         if (err < 0)
                 goto out;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 hists = evsel__hists(evsel);
                 hists__collapse_resort(hists, NULL);
 
diff --git a/tools/perf/tests/is_printable_array.c b/tools/perf/tests/is_printable_array.c
new file mode 100644
index 000000000000..42e13393e502
--- /dev/null
+++ b/tools/perf/tests/is_printable_array.c
@@ -0,0 +1,36 @@
+#include <linux/compiler.h>
+#include "tests.h"
+#include "debug.h"
+#include "util.h"
+
+int test__is_printable_array(int subtest __maybe_unused)
+{
+        char buf1[] = { 'k', 'r', 4, 'v', 'a', 0 };
+        char buf2[] = { 'k', 'r', 'a', 'v', 4, 0 };
+        struct {
+                char            *buf;
+                unsigned int     len;
+                int              ret;
+        } t[] = {
+                { (char *) "krava",     sizeof("krava"),        1 },
+                { (char *) "krava",     sizeof("krava") - 1,    0 },
+                { (char *) "",          sizeof(""),             1 },
+                { (char *) "",          0,                      0 },
+                { NULL,                 0,                      0 },
+                { buf1,                 sizeof(buf1),           0 },
+                { buf2,                 sizeof(buf2),           0 },
+        };
+        unsigned int i;
+
+        for (i = 0; i < ARRAY_SIZE(t); i++) {
+                int ret;
+
+                ret = is_printable_array((char *) t[i].buf, t[i].len);
+                if (ret != t[i].ret) {
+                        pr_err("failed: test %u\n", i);
+                        return TEST_FAIL;
+                }
+        }
+
+        return TEST_OK;
+}
diff --git a/tools/perf/tests/kmod-path.c b/tools/perf/tests/kmod-path.c
index d2af78193153..76f41f249944 100644
--- a/tools/perf/tests/kmod-path.c
+++ b/tools/perf/tests/kmod-path.c
@@ -1,4 +1,5 @@
 #include <stdbool.h>
+#include <stdlib.h>
 #include "tests.h"
 #include "dso.h"
 #include "debug.h"
diff --git a/tools/perf/tests/llvm.c b/tools/perf/tests/llvm.c
index cff564fb4b66..b798a4bfd238 100644
--- a/tools/perf/tests/llvm.c
+++ b/tools/perf/tests/llvm.c
@@ -5,6 +5,7 @@
 #include "llvm.h"
 #include "tests.h"
 #include "debug.h"
+#include "util.h"
 
 #ifdef HAVE_LIBBPF_SUPPORT
 static int test__bpf_parsing(void *obj_buf, size_t obj_buf_sz)
diff --git a/tools/perf/tests/make b/tools/perf/tests/make
index cac15d93aea6..143f4d549769 100644
--- a/tools/perf/tests/make
+++ b/tools/perf/tests/make
@@ -81,6 +81,8 @@ make_no_libbionic   := NO_LIBBIONIC=1
 make_no_auxtrace    := NO_AUXTRACE=1
 make_no_libbpf      := NO_LIBBPF=1
 make_no_libcrypto   := NO_LIBCRYPTO=1
+make_with_babeltrace:= LIBBABELTRACE=1
+make_no_sdt         := NO_SDT=1
 make_tags           := tags
 make_cscope         := cscope
 make_help           := help
@@ -104,7 +106,7 @@ 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
 make_minimal        += NO_LIBDW_DWARF_UNWIND=1 NO_AUXTRACE=1 NO_LIBBPF=1
-make_minimal        += NO_LIBCRYPTO=1
+make_minimal        += NO_LIBCRYPTO=1 NO_SDT=1
 
 # $(run) contains all available tests
 run := make_pure
@@ -136,6 +138,7 @@ run += make_no_libaudit
 run += make_no_libbionic
 run += make_no_auxtrace
 run += make_no_libbpf
+run += make_with_babeltrace
 run += make_help
 run += make_doc
 run += make_perf_o
diff --git a/tools/perf/tests/mmap-basic.c b/tools/perf/tests/mmap-basic.c
index 359e98fcd94c..634bce9caebd 100644
--- a/tools/perf/tests/mmap-basic.c
+++ b/tools/perf/tests/mmap-basic.c
@@ -1,3 +1,6 @@
+/* For the CLR_() macros */
+#include <pthread.h>
+
 #include "evlist.h"
 #include "evsel.h"
 #include "thread_map.h"
@@ -49,7 +52,7 @@ int test__basic_mmap(int subtest __maybe_unused)
         sched_setaffinity(0, sizeof(cpu_set), &cpu_set);
         if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
                 pr_debug("sched_setaffinity() failed on CPU %d: %s ",
-                         cpus->map[0], strerror_r(errno, sbuf, sizeof(sbuf)));
+                         cpus->map[0], str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_free_cpus;
         }
 
@@ -79,7 +82,7 @@ int test__basic_mmap(int subtest __maybe_unused)
                 if (perf_evsel__open(evsels[i], cpus, threads) < 0) {
                         pr_debug("failed to open counter: %s, "
                                  "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                                 strerror_r(errno, sbuf, sizeof(sbuf)));
+                                 str_error_r(errno, sbuf, sizeof(sbuf)));
                         goto out_delete_evlist;
                 }
 
@@ -89,7 +92,7 @@ int test__basic_mmap(int subtest __maybe_unused)
 
         if (perf_evlist__mmap(evlist, 128, true) < 0) {
                 pr_debug("failed to mmap events: %d (%s)\n", errno,
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -126,7 +129,7 @@ int test__basic_mmap(int subtest __maybe_unused)
         }
 
         err = 0;
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
                         pr_debug("expected %d %s events, got %d\n",
                                  expected_nr_events[evsel->idx],
diff --git a/tools/perf/tests/openat-syscall-all-cpus.c b/tools/perf/tests/openat-syscall-all-cpus.c
index ad1cb63139a7..c8d9592eb142 100644
--- a/tools/perf/tests/openat-syscall-all-cpus.c
+++ b/tools/perf/tests/openat-syscall-all-cpus.c
@@ -1,3 +1,6 @@
+/* For the CPU_* macros */
+#include <pthread.h>
+
 #include <api/fs/fs.h>
 #include <linux/err.h>
 #include "evsel.h"
@@ -41,7 +44,7 @@ int test__openat_syscall_event_on_all_cpus(int subtest __maybe_unused)
         if (perf_evsel__open(evsel, cpus, threads) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_evsel_delete;
         }
 
@@ -62,7 +65,7 @@ int test__openat_syscall_event_on_all_cpus(int subtest __maybe_unused)
                 if (sched_setaffinity(0, sizeof(cpu_set), &cpu_set) < 0) {
                         pr_debug("sched_setaffinity() failed on CPU %d: %s ",
                                  cpus->map[cpu],
-                                 strerror_r(errno, sbuf, sizeof(sbuf)));
+                                 str_error_r(errno, sbuf, sizeof(sbuf)));
                         goto out_close_fd;
                 }
                 for (i = 0; i < ncalls; ++i) {
diff --git a/tools/perf/tests/openat-syscall-tp-fields.c b/tools/perf/tests/openat-syscall-tp-fields.c
index 4344fe482c1d..f52239fed361 100644
--- a/tools/perf/tests/openat-syscall-tp-fields.c
+++ b/tools/perf/tests/openat-syscall-tp-fields.c
@@ -6,6 +6,13 @@
 #include "tests.h"
 #include "debug.h"
 
+#ifndef O_DIRECTORY
+#define O_DIRECTORY    00200000
+#endif
+#ifndef AT_FDCWD
+#define AT_FDCWD       -100
+#endif
+
 int test__syscall_openat_tp_fields(int subtest __maybe_unused)
 {
         struct record_opts opts = {
@@ -51,14 +58,14 @@ int test__syscall_openat_tp_fields(int subtest __maybe_unused)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
         err = perf_evlist__mmap(evlist, UINT_MAX, false);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/openat-syscall.c b/tools/perf/tests/openat-syscall.c
index 1184f9ba6499..d7414128d7fe 100644
--- a/tools/perf/tests/openat-syscall.c
+++ b/tools/perf/tests/openat-syscall.c
@@ -29,7 +29,7 @@ int test__openat_syscall_event(int subtest __maybe_unused)
         if (perf_evsel__open_per_thread(evsel, threads) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_evsel_delete;
         }
 
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 7865f68dc0d8..20c2e641c422 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -32,7 +32,7 @@ static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
         TEST_ASSERT_VAL("wrong number of groups", 0 == evlist->nr_groups);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 TEST_ASSERT_VAL("wrong type",
                         PERF_TYPE_TRACEPOINT == evsel->attr.type);
                 TEST_ASSERT_VAL("wrong sample_type",
@@ -207,7 +207,7 @@ test__checkevent_tracepoint_multi_modifier(struct perf_evlist *evlist)
 
         TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 TEST_ASSERT_VAL("wrong exclude_user",
                                 !evsel->attr.exclude_user);
                 TEST_ASSERT_VAL("wrong exclude_kernel",
@@ -1783,8 +1783,8 @@ static int test_pmu_events(void)
                 struct evlist_test e;
                 char name[MAX_NAME];
 
-                if (!strcmp(ent->d_name, ".") ||
-                    !strcmp(ent->d_name, ".."))
+                /* Names containing . are special and cannot be used directly */
+                if (strchr(ent->d_name, '.'))
                         continue;
 
                 snprintf(name, MAX_NAME, "cpu/event=%s/u", ent->d_name);
diff --git a/tools/perf/tests/parse-no-sample-id-all.c b/tools/perf/tests/parse-no-sample-id-all.c
index 294c76b01b41..81c6eeaca0f5 100644
--- a/tools/perf/tests/parse-no-sample-id-all.c
+++ b/tools/perf/tests/parse-no-sample-id-all.c
@@ -44,8 +44,7 @@ static int process_events(union perf_event **events, size_t count)
         for (i = 0; i < count && !err; i++)
                 err = process_event(&evlist, events[i]);
 
-        if (evlist)
-                perf_evlist__delete(evlist);
+        perf_evlist__delete(evlist);
 
         return err;
 }
diff --git a/tools/perf/tests/perf-record.c b/tools/perf/tests/perf-record.c
index b836ee6a8d9b..8f2e1de6d0ea 100644
--- a/tools/perf/tests/perf-record.c
+++ b/tools/perf/tests/perf-record.c
@@ -1,3 +1,6 @@
+/* For the CLR_() macros */
+#include <pthread.h>
+
 #include <sched.h>
 #include "evlist.h"
 #include "evsel.h"
@@ -104,7 +107,7 @@ int test__PERF_RECORD(int subtest __maybe_unused)
         err = sched__get_first_possible_cpu(evlist->workload.pid, &cpu_mask);
         if (err < 0) {
                 pr_debug("sched__get_first_possible_cpu: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -115,7 +118,7 @@ int test__PERF_RECORD(int subtest __maybe_unused)
          */
         if (sched_setaffinity(evlist->workload.pid, cpu_mask_size, &cpu_mask) < 0) {
                 pr_debug("sched_setaffinity: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -126,7 +129,7 @@ int test__PERF_RECORD(int subtest __maybe_unused)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("perf_evlist__open: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
@@ -138,7 +141,7 @@ int test__PERF_RECORD(int subtest __maybe_unused)
         err = perf_evlist__mmap(evlist, opts.mmap_pages, false);
         if (err < 0) {
                 pr_debug("perf_evlist__mmap: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/sdt.c b/tools/perf/tests/sdt.c
new file mode 100644
index 000000000000..f59d210e1baf
--- /dev/null
+++ b/tools/perf/tests/sdt.c
@@ -0,0 +1,115 @@
+#include <stdio.h>
+#include <sys/epoll.h>
+#include <util/util.h>
+#include <util/evlist.h>
+#include <linux/filter.h>
+#include "tests.h"
+#include "debug.h"
+#include "probe-file.h"
+#include "build-id.h"
+
+/* To test SDT event, we need libelf support to scan elf binary */
+#if defined(HAVE_SDT_EVENT) && defined(HAVE_LIBELF_SUPPORT)
+
+#include <sys/sdt.h>
+
+static int target_function(void)
+{
+        DTRACE_PROBE(perf, test_target);
+        return TEST_OK;
+}
+
+/* Copied from builtin-buildid-cache.c */
+static int build_id_cache__add_file(const char *filename)
+{
+        char sbuild_id[SBUILD_ID_SIZE];
+        u8 build_id[BUILD_ID_SIZE];
+        int err;
+
+        err = filename__read_build_id(filename, &build_id, sizeof(build_id));
+        if (err < 0) {
+                pr_debug("Failed to read build id of %s\n", filename);
+                return err;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__add_s(sbuild_id, filename, false, false);
+        if (err < 0)
+                pr_debug("Failed to add build id cache of %s\n", filename);
+        return err;
+}
+
+static char *get_self_path(void)
+{
+        char *buf = calloc(PATH_MAX, sizeof(char));
+
+        if (buf && readlink("/proc/self/exe", buf, PATH_MAX) < 0) {
+                pr_debug("Failed to get correct path of perf\n");
+                free(buf);
+                return NULL;
+        }
+        return buf;
+}
+
+static int search_cached_probe(const char *target,
+                               const char *group, const char *event)
+{
+        struct probe_cache *cache = probe_cache__new(target);
+        int ret = 0;
+
+        if (!cache) {
+                pr_debug("Failed to open probe cache of %s\n", target);
+                return -EINVAL;
+        }
+
+        if (!probe_cache__find_by_name(cache, group, event)) {
+                pr_debug("Failed to find %s:%s in the cache\n", group, event);
+                ret = -ENOENT;
+        }
+        probe_cache__delete(cache);
+
+        return ret;
+}
+
+int test__sdt_event(int subtests __maybe_unused)
+{
+        int ret = TEST_FAIL;
+        char __tempdir[] = "./test-buildid-XXXXXX";
+        char *tempdir = NULL, *myself = get_self_path();
+
+        if (myself == NULL || mkdtemp(__tempdir) == NULL) {
+                pr_debug("Failed to make a tempdir for build-id cache\n");
+                goto error;
+        }
+        /* Note that buildid_dir must be an absolute path */
+        tempdir = realpath(__tempdir, NULL);
+
+        /* At first, scan itself */
+        set_buildid_dir(tempdir);
+        if (build_id_cache__add_file(myself) < 0)
+                goto error_rmdir;
+
+        /* Open a cache and make sure the SDT is stored */
+        if (search_cached_probe(myself, "sdt_perf", "test_target") < 0)
+                goto error_rmdir;
+
+        /* TBD: probing on the SDT event and collect logs */
+
+        /* Call the target and get an event */
+        ret = target_function();
+
+error_rmdir:
+        /* Cleanup temporary buildid dir */
+        rm_rf(tempdir);
+error:
+        free(tempdir);
+        free(myself);
+        return ret;
+}
+#else
+int test__sdt_event(int subtests __maybe_unused)
+{
+        pr_debug("Skip SDT event test because SDT support is not compiled\n");
+        return TEST_SKIP;
+}
+#endif
diff --git a/tools/perf/tests/sw-clock.c b/tools/perf/tests/sw-clock.c
index 36e8ce1550e3..4c9fd046d57b 100644
--- a/tools/perf/tests/sw-clock.c
+++ b/tools/perf/tests/sw-clock.c
@@ -70,7 +70,7 @@ static int __test__sw_clock_freq(enum perf_sw_ids clock_id)
 
                 err = -errno;
                 pr_debug("Couldn't open evlist: %s\nHint: check %s, using %" PRIu64 " in this test.\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)),
+                         str_error_r(errno, sbuf, sizeof(sbuf)),
                          knob, (u64)attr.sample_freq);
                 goto out_delete_evlist;
         }
@@ -78,7 +78,7 @@ static int __test__sw_clock_freq(enum perf_sw_ids clock_id)
         err = perf_evlist__mmap(evlist, 128, true);
         if (err < 0) {
                 pr_debug("failed to mmap event: %d (%s)\n", errno,
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/switch-tracking.c b/tools/perf/tests/switch-tracking.c
index 39a689bf7574..7ddbe267d0ac 100644
--- a/tools/perf/tests/switch-tracking.c
+++ b/tools/perf/tests/switch-tracking.c
@@ -432,7 +432,7 @@ int test__switch_tracking(int subtest __maybe_unused)
         }
 
         /* Check non-tracking events are not tracking */
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel != tracking_evsel) {
                         if (evsel->attr.mmap || evsel->attr.comm) {
                                 pr_debug("Non-tracking event is tracking\n");
diff --git a/tools/perf/tests/task-exit.c b/tools/perf/tests/task-exit.c
index 2dfff7ac8ef3..01a5ba2788c6 100644
--- a/tools/perf/tests/task-exit.c
+++ b/tools/perf/tests/task-exit.c
@@ -91,13 +91,13 @@ int test__task_exit(int subtest __maybe_unused)
         err = perf_evlist__open(evlist);
         if (err < 0) {
                 pr_debug("Couldn't open the evlist: %s\n",
-                         strerror_r(-err, sbuf, sizeof(sbuf)));
+                         str_error_r(-err, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
         if (perf_evlist__mmap(evlist, 128, true) < 0) {
                 pr_debug("failed to mmap events: %d (%s)\n", errno,
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 goto out_delete_evlist;
         }
 
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index c57e72c826d2..7c196c585472 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -87,6 +87,10 @@ int test__synthesize_stat_round(int subtest);
 int test__event_update(int subtest);
 int test__event_times(int subtest);
 int test__backward_ring_buffer(int subtest);
+int test__cpu_map_print(int subtest);
+int test__sdt_event(int subtest);
+int test__is_printable_array(int subtest);
+int test__bitmap_print(int subtest);
 
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/tests/thread-map.c b/tools/perf/tests/thread-map.c
index fccde848fe9c..cee2a2cdc933 100644
--- a/tools/perf/tests/thread-map.c
+++ b/tools/perf/tests/thread-map.c
@@ -1,13 +1,20 @@
 #include <sys/types.h>
 #include <unistd.h>
+#include <sys/prctl.h>
 #include "tests.h"
 #include "thread_map.h"
 #include "debug.h"
 
+#define NAME    (const char *) "perf"
+#define NAMEUL  (unsigned long) NAME
+
 int test__thread_map(int subtest __maybe_unused)
 {
         struct thread_map *map;
 
+        TEST_ASSERT_VAL("failed to set process name",
+                        !prctl(PR_SET_NAME, NAMEUL, 0, 0, 0));
+
         /* test map on current pid */
         map = thread_map__new_by_pid(getpid());
         TEST_ASSERT_VAL("failed to alloc map", map);
@@ -19,7 +26,7 @@ int test__thread_map(int subtest __maybe_unused)
                         thread_map__pid(map, 0) == getpid());
         TEST_ASSERT_VAL("wrong comm",
                         thread_map__comm(map, 0) &&
-                        !strcmp(thread_map__comm(map, 0), "perf"));
+                        !strcmp(thread_map__comm(map, 0), NAME));
         TEST_ASSERT_VAL("wrong refcnt",
                         atomic_read(&map->refcnt) == 1);
         thread_map__put(map);
@@ -51,7 +58,7 @@ static int process_event(struct perf_tool *tool __maybe_unused,
 
         TEST_ASSERT_VAL("wrong nr",   map->nr == 1);
         TEST_ASSERT_VAL("wrong pid",  map->entries[0].pid == (u64) getpid());
-        TEST_ASSERT_VAL("wrong comm", !strcmp(map->entries[0].comm, "perf"));
+        TEST_ASSERT_VAL("wrong comm", !strcmp(map->entries[0].comm, NAME));
 
         threads = thread_map__new_event(&event->thread_map);
         TEST_ASSERT_VAL("failed to alloc map", threads);
@@ -61,7 +68,7 @@ static int process_event(struct perf_tool *tool __maybe_unused,
                         thread_map__pid(threads, 0) == getpid());
         TEST_ASSERT_VAL("wrong comm",
                         thread_map__comm(threads, 0) &&
-                        !strcmp(thread_map__comm(threads, 0), "perf"));
+                        !strcmp(thread_map__comm(threads, 0), NAME));
         TEST_ASSERT_VAL("wrong refcnt",
                         atomic_read(&threads->refcnt) == 1);
         thread_map__put(threads);
@@ -72,6 +79,9 @@ int test__thread_map_synthesize(int subtest __maybe_unused)
 {
         struct thread_map *threads;
 
+        TEST_ASSERT_VAL("failed to set process name",
+                        !prctl(PR_SET_NAME, NAMEUL, 0, 0, 0));
+
         /* test map on current pid */
         threads = thread_map__new_by_pid(getpid());
         TEST_ASSERT_VAL("failed to alloc map", threads);
diff --git a/tools/perf/tests/vmlinux-kallsyms.c b/tools/perf/tests/vmlinux-kallsyms.c
index e63abab7d5a1..a5082331f246 100644
--- a/tools/perf/tests/vmlinux-kallsyms.c
+++ b/tools/perf/tests/vmlinux-kallsyms.c
@@ -8,14 +8,6 @@
 #include "debug.h"
 #include "machine.h"
 
-static int vmlinux_matches_kallsyms_filter(struct map *map __maybe_unused,
-                                           struct symbol *sym)
-{
-        bool *visited = symbol__priv(sym);
-        *visited = true;
-        return 0;
-}
-
 #define UM(x) kallsyms_map->unmap_ip(kallsyms_map, (x))
 
 int test__vmlinux_matches_kallsyms(int subtest __maybe_unused)
@@ -28,6 +20,7 @@ int test__vmlinux_matches_kallsyms(int subtest __maybe_unused)
         enum map_type type = MAP__FUNCTION;
         struct maps *maps = &vmlinux.kmaps.maps[type];
         u64 mem_start, mem_end;
+        bool header_printed;
 
         /*
          * Step 1:
@@ -61,7 +54,7 @@ int test__vmlinux_matches_kallsyms(int subtest __maybe_unused)
          * be compacted against the list of modules found in the "vmlinux"
          * code and with the one got from /proc/modules from the "kallsyms" code.
          */
-        if (__machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, true, NULL) <= 0) {
+        if (__machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, true) <= 0) {
                 pr_debug("dso__load_kallsyms ");
                 goto out;
         }
@@ -99,8 +92,7 @@ int test__vmlinux_matches_kallsyms(int subtest __maybe_unused)
          * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines
          * to fixup the symbols.
          */
-        if (machine__load_vmlinux_path(&vmlinux, type,
-                                       vmlinux_matches_kallsyms_filter) <= 0) {
+        if (machine__load_vmlinux_path(&vmlinux, type) <= 0) {
                 pr_debug("Couldn't find a vmlinux that matches the kernel running on this machine, skipping test\n");
                 err = TEST_SKIP;
                 goto out;
@@ -126,7 +118,7 @@ int test__vmlinux_matches_kallsyms(int subtest __maybe_unused)
                 mem_end = vmlinux_map->unmap_ip(vmlinux_map, sym->end);
 
                 first_pair = machine__find_kernel_symbol(&kallsyms, type,
-                                                         mem_start, NULL, NULL);
+                                                         mem_start, NULL);
                 pair = first_pair;
 
                 if (pair && UM(pair->start) == mem_start) {
@@ -143,7 +135,7 @@ next_pair:
                                  */
                                 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",
+                                        pr_debug("WARN: %#" PRIx64 ": diff end addr for %s v: %#" PRIx64 " k: %#" PRIx64 "\n",
                                                  mem_start, sym->name, mem_end,
                                                  UM(pair->end));
 
@@ -154,22 +146,23 @@ next_pair:
                                  * kallsyms.
                                  */
                                 continue;
-
                         } else {
-                                pair = machine__find_kernel_symbol_by_name(&kallsyms, type, sym->name, NULL, NULL);
+                                pair = machine__find_kernel_symbol_by_name(&kallsyms, type, sym->name, NULL);
                                 if (pair) {
                                         if (UM(pair->start) == mem_start)
                                                 goto next_pair;
 
-                                        pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
+                                        pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
                                                  mem_start, sym->name, pair->name);
                                 } else {
-                                        pr_debug("%#" PRIx64 ": diff name v: %s k: %s\n",
+                                        pr_debug("WARN: %#" PRIx64 ": diff name v: %s k: %s\n",
                                                  mem_start, sym->name, first_pair->name);
                                 }
+
+                                continue;
                         }
                 } else
-                        pr_debug("%#" PRIx64 ": %s not on kallsyms\n",
+                        pr_debug("ERR : %#" PRIx64 ": %s not on kallsyms\n",
                                  mem_start, sym->name);
 
                 err = -1;
@@ -178,7 +171,7 @@ next_pair:
         if (!verbose)
                 goto out;
 
-        pr_info("Maps only in vmlinux:\n");
+        header_printed = false;
 
         for (map = maps__first(maps); map; map = map__next(map)) {
                 struct map *
@@ -192,13 +185,18 @@ next_pair:
                                                 (map->dso->kernel ?
                                                         map->dso->short_name :
                                                         map->dso->name));
-                if (pair)
+                if (pair) {
                         pair->priv = 1;
-                else
+                } else {
+                        if (!header_printed) {
+                                pr_info("WARN: Maps only in vmlinux:\n");
+                                header_printed = true;
+                        }
                         map__fprintf(map, stderr);
+                }
         }
 
-        pr_info("Maps in vmlinux with a different name in kallsyms:\n");
+        header_printed = false;
 
         for (map = maps__first(maps); map; map = map__next(map)) {
                 struct map *pair;
@@ -211,24 +209,33 @@ next_pair:
                         continue;
 
                 if (pair->start == mem_start) {
-                        pair->priv = 1;
-                        pr_info(" %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
+                        if (!header_printed) {
+                                pr_info("WARN: Maps in vmlinux with a different name in kallsyms:\n");
+                                header_printed = true;
+                        }
+
+                        pr_info("WARN: %" PRIx64 "-%" PRIx64 " %" PRIx64 " %s in kallsyms as",
                                 map->start, map->end, map->pgoff, map->dso->name);
                         if (mem_end != pair->end)
-                                pr_info(":\n*%" PRIx64 "-%" PRIx64 " %" PRIx64,
+                                pr_info(":\nWARN: *%" PRIx64 "-%" PRIx64 " %" PRIx64,
                                         pair->start, pair->end, pair->pgoff);
                         pr_info(" %s\n", pair->dso->name);
                         pair->priv = 1;
                 }
         }
 
-        pr_info("Maps only in kallsyms:\n");
+        header_printed = false;
 
         maps = &kallsyms.kmaps.maps[type];
 
         for (map = maps__first(maps); map; map = map__next(map)) {
-                if (!map->priv)
+                if (!map->priv) {
+                        if (!header_printed) {
+                                pr_info("WARN: Maps only in kallsyms:\n");
+                                header_printed = true;
+                        }
                         map__fprintf(map, stderr);
+                }
         }
 out:
         machine__exit(&kallsyms);
diff --git a/tools/perf/trace/beauty/eventfd.c b/tools/perf/trace/beauty/eventfd.c
index d64f4a9128a1..b08f21eb6f4d 100644
--- a/tools/perf/trace/beauty/eventfd.c
+++ b/tools/perf/trace/beauty/eventfd.c
@@ -1,5 +1,3 @@
-#include <sys/eventfd.h>
-
 #ifndef EFD_SEMAPHORE
 #define EFD_SEMAPHORE           1
 #endif
diff --git a/tools/perf/trace/beauty/flock.c b/tools/perf/trace/beauty/flock.c
index 021bb48c6336..74613703a14e 100644
--- a/tools/perf/trace/beauty/flock.c
+++ b/tools/perf/trace/beauty/flock.c
@@ -1,3 +1,20 @@
+#include <fcntl.h>
+
+#ifndef LOCK_MAND
+#define LOCK_MAND        32
+#endif
+
+#ifndef LOCK_READ
+#define LOCK_READ        64
+#endif
+
+#ifndef LOCK_WRITE
+#define LOCK_WRITE      128
+#endif
+
+#ifndef LOCK_RW
+#define LOCK_RW         192
+#endif
 
 static size_t syscall_arg__scnprintf_flock(char *bf, size_t size,
                                            struct syscall_arg *arg)
diff --git a/tools/perf/trace/beauty/futex_op.c b/tools/perf/trace/beauty/futex_op.c
index e2476211f22d..bfd3359b09b6 100644
--- a/tools/perf/trace/beauty/futex_op.c
+++ b/tools/perf/trace/beauty/futex_op.c
@@ -1,5 +1,21 @@
 #include <linux/futex.h>
 
+#ifndef FUTEX_WAIT_BITSET
+#define FUTEX_WAIT_BITSET         9
+#endif
+#ifndef FUTEX_WAKE_BITSET
+#define FUTEX_WAKE_BITSET        10
+#endif
+#ifndef FUTEX_WAIT_REQUEUE_PI
+#define FUTEX_WAIT_REQUEUE_PI    11
+#endif
+#ifndef FUTEX_CMP_REQUEUE_PI
+#define FUTEX_CMP_REQUEUE_PI     12
+#endif
+#ifndef FUTEX_CLOCK_REALTIME
+#define FUTEX_CLOCK_REALTIME    256
+#endif
+
 static size_t syscall_arg__scnprintf_futex_op(char *bf, size_t size, struct syscall_arg *arg)
 {
         enum syscall_futex_args {
diff --git a/tools/perf/trace/beauty/mmap.c b/tools/perf/trace/beauty/mmap.c
index 3444a4d5382d..fd710ab33684 100644
--- a/tools/perf/trace/beauty/mmap.c
+++ b/tools/perf/trace/beauty/mmap.c
@@ -1,4 +1,4 @@
-#include <sys/mman.h>
+#include <uapi/linux/mman.h>
 
 static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
                                                struct syscall_arg *arg)
@@ -16,9 +16,7 @@ static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
         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
@@ -31,10 +29,6 @@ static size_t syscall_arg__scnprintf_mmap_prot(char *bf, size_t size,
 
 #define SCA_MMAP_PROT syscall_arg__scnprintf_mmap_prot
 
-#ifndef MAP_STACK
-# define MAP_STACK              0x20000
-#endif
-
 static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
                                                 struct syscall_arg *arg)
 {
@@ -48,26 +42,20 @@ static size_t syscall_arg__scnprintf_mmap_flags(char *bf, size_t size,
 
         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)
@@ -90,9 +78,7 @@ static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
         }
 
         P_MREMAP_FLAG(MAYMOVE);
-#ifdef MREMAP_FIXED
         P_MREMAP_FLAG(FIXED);
-#endif
 #undef P_MREMAP_FLAG
 
         if (flags)
@@ -103,18 +89,6 @@ static size_t syscall_arg__scnprintf_mremap_flags(char *bf, size_t size,
 
 #define SCA_MREMAP_FLAGS syscall_arg__scnprintf_mremap_flags
 
-#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_madvise_behavior(char *bf, size_t size,
                                                       struct syscall_arg *arg)
 {
@@ -127,28 +101,19 @@ static size_t syscall_arg__scnprintf_madvise_behavior(char *bf, size_t size,
         P_MADV_BHV(SEQUENTIAL);
         P_MADV_BHV(WILLNEED);
         P_MADV_BHV(DONTNEED);
+        P_MADV_BHV(FREE);
         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
+#undef P_MADV_BHV
         default: break;
         }
 
diff --git a/tools/perf/trace/beauty/msg_flags.c b/tools/perf/trace/beauty/msg_flags.c
index 07fa8a0acad6..1106c8960cc4 100644
--- a/tools/perf/trace/beauty/msg_flags.c
+++ b/tools/perf/trace/beauty/msg_flags.c
@@ -33,7 +33,6 @@ static size_t syscall_arg__scnprintf_msg_flags(char *bf, size_t size,
         P_MSG_FLAG(OOB);
         P_MSG_FLAG(PEEK);
         P_MSG_FLAG(DONTROUTE);
-        P_MSG_FLAG(TRYHARD);
         P_MSG_FLAG(CTRUNC);
         P_MSG_FLAG(PROBE);
         P_MSG_FLAG(TRUNC);
diff --git a/tools/perf/trace/beauty/open_flags.c b/tools/perf/trace/beauty/open_flags.c
index 0f3679e0cdcf..f55a4597fc38 100644
--- a/tools/perf/trace/beauty/open_flags.c
+++ b/tools/perf/trace/beauty/open_flags.c
@@ -1,3 +1,18 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#ifndef O_DIRECT
+#define O_DIRECT        00040000
+#endif
+
+#ifndef O_DIRECTORY
+#define O_DIRECTORY     00200000
+#endif
+
+#ifndef O_NOATIME
+#define O_NOATIME       01000000
+#endif
 
 static size_t syscall_arg__scnprintf_open_flags(char *bf, size_t size,
                                                struct syscall_arg *arg)
diff --git a/tools/perf/trace/beauty/sched_policy.c b/tools/perf/trace/beauty/sched_policy.c
index c205bc608b3c..34775295b9b3 100644
--- a/tools/perf/trace/beauty/sched_policy.c
+++ b/tools/perf/trace/beauty/sched_policy.c
@@ -9,6 +9,9 @@
 #ifndef SCHED_DEADLINE
 #define SCHED_DEADLINE 6
 #endif
+#ifndef SCHED_RESET_ON_FORK
+#define SCHED_RESET_ON_FORK 0x40000000
+#endif
 
 static size_t syscall_arg__scnprintf_sched_policy(char *bf, size_t size,
                                                   struct syscall_arg *arg)
diff --git a/tools/perf/trace/beauty/seccomp.c b/tools/perf/trace/beauty/seccomp.c
index 213c5a7e3e92..356441bce27d 100644
--- a/tools/perf/trace/beauty/seccomp.c
+++ b/tools/perf/trace/beauty/seccomp.c
@@ -1,5 +1,3 @@
-#include <linux/seccomp.h>
-
 #ifndef SECCOMP_SET_MODE_STRICT
 #define SECCOMP_SET_MODE_STRICT 0
 #endif
diff --git a/tools/perf/ui/browser.c b/tools/perf/ui/browser.c
index af68a9d488bf..3eb3edb307a4 100644
--- a/tools/perf/ui/browser.c
+++ b/tools/perf/ui/browser.c
@@ -1,5 +1,5 @@
 #include "../util.h"
-#include "../cache.h"
+#include "../config.h"
 #include "../../perf.h"
 #include "libslang.h"
 #include "ui.h"
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 4fc208e82c6f..4c18271c71c9 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -8,6 +8,7 @@
 #include "../../util/sort.h"
 #include "../../util/symbol.h"
 #include "../../util/evsel.h"
+#include "../../util/config.h"
 #include <pthread.h>
 
 struct disasm_line_samples {
@@ -222,16 +223,14 @@ static void annotate_browser__write(struct ui_browser *browser, void *entry, int
                         } else if (ins__is_call(dl->ins)) {
                                 ui_browser__write_graph(browser, SLSMG_RARROW_CHAR);
                                 SLsmg_write_char(' ');
+                        } else if (ins__is_ret(dl->ins)) {
+                                ui_browser__write_graph(browser, SLSMG_LARROW_CHAR);
+                                SLsmg_write_char(' ');
                         } else {
                                 ui_browser__write_nstring(browser, " ", 2);
                         }
                 } else {
-                        if (strcmp(dl->name, "retq")) {
-                                ui_browser__write_nstring(browser, " ", 2);
-                        } else {
-                                ui_browser__write_graph(browser, SLSMG_LARROW_CHAR);
-                                SLsmg_write_char(' ');
-                        }
+                        ui_browser__write_nstring(browser, " ", 2);
                 }
 
                 disasm_line__scnprintf(dl, bf, sizeof(bf), !annotate_browser__opts.use_offset);
@@ -496,7 +495,7 @@ static bool annotate_browser__callq(struct annotate_browser *browser,
         if (!ins__is_call(dl->ins))
                 return false;
 
-        if (map_groups__find_ams(&target, NULL) ||
+        if (map_groups__find_ams(&target) ||
             map__rip_2objdump(target.map, target.map->map_ip(target.map,
                                                              target.addr)) !=
             dl->ops.target.addr) {
@@ -842,14 +841,14 @@ show_help:
                                 ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
                         else if (browser->selection->offset == -1)
                                 ui_helpline__puts("Actions are only available for assembly lines.");
-                        else if (!browser->selection->ins) {
-                                if (strcmp(browser->selection->name, "retq"))
-                                        goto show_sup_ins;
+                        else if (!browser->selection->ins)
+                                goto show_sup_ins;
+                        else if (ins__is_ret(browser->selection->ins))
                                 goto out;
-                        } else if (!(annotate_browser__jump(browser) ||
+                        else if (!(annotate_browser__jump(browser) ||
                                      annotate_browser__callq(browser, evsel, hbt))) {
 show_sup_ins:
-                                ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions.");
+                                ui_helpline__puts("Actions are only available for function call/return & jump/branch instructions.");
                         }
                         continue;
                 case 't':
@@ -1027,7 +1026,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map,
                         .use_navkeypressed = true,
                 },
         };
-        int ret = -1;
+        int ret = -1, err;
         int nr_pcnt = 1;
         size_t sizeof_bdl = sizeof(struct browser_disasm_line);
 
@@ -1051,8 +1050,11 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map,
                   (nr_pcnt - 1);
         }
 
-        if (symbol__annotate(sym, map, sizeof_bdl) < 0) {
-                ui__error("%s", ui_helpline__last_msg);
+        err = symbol__disassemble(sym, map, sizeof_bdl);
+        if (err) {
+                char msg[BUFSIZ];
+                symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
+                ui__error("Couldn't annotate %s:\n%s", sym->name, msg);
                 goto out_free_offsets;
         }
 
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 538bae880bfe..fb8e42c7507a 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -12,35 +12,17 @@
 #include "../../util/top.h"
 #include "../../arch/common.h"
 
-#include "../browser.h"
+#include "../browsers/hists.h"
 #include "../helpline.h"
 #include "../util.h"
 #include "../ui.h"
 #include "map.h"
 #include "annotate.h"
 
-struct hist_browser {
-        struct ui_browser   b;
-        struct hists        *hists;
-        struct hist_entry   *he_selection;
-        struct map_symbol   *selection;
-        struct hist_browser_timer *hbt;
-        struct pstack       *pstack;
-        struct perf_env *env;
-        int                  print_seq;
-        bool                 show_dso;
-        bool                 show_headers;
-        float                min_pcnt;
-        u64                  nr_non_filtered_entries;
-        u64                  nr_hierarchy_entries;
-        u64                  nr_callchain_rows;
-};
-
 extern void hist_browser__init_hpp(void);
 
-static int hists__browser_title(struct hists *hists,
-                                struct hist_browser_timer *hbt,
-                                char *bf, size_t size);
+static int perf_evsel_browser_title(struct hist_browser *browser,
+                                    char *bf, size_t size);
 static void hist_browser__update_nr_entries(struct hist_browser *hb);
 
 static struct rb_node *hists__filter_entries(struct rb_node *nd,
@@ -87,8 +69,11 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb)
 static void hist_browser__update_rows(struct hist_browser *hb)
 {
         struct ui_browser *browser = &hb->b;
-        u16 header_offset = hb->show_headers ? 1 : 0, index_row;
+        struct hists *hists = hb->hists;
+        struct perf_hpp_list *hpp_list = hists->hpp_list;
+        u16 header_offset, index_row;
 
+        header_offset = hb->show_headers ? hpp_list->nr_header_lines : 0;
         browser->rows = browser->height - header_offset;
         /*
          * Verify if we were at the last line and that line isn't
@@ -117,8 +102,11 @@ static void hist_browser__refresh_dimensions(struct ui_browser *browser)
 
 static void hist_browser__gotorc(struct hist_browser *browser, int row, int column)
 {
-        u16 header_offset = browser->show_headers ? 1 : 0;
+        struct hists *hists = browser->hists;
+        struct perf_hpp_list *hpp_list = hists->hpp_list;
+        u16 header_offset;
 
+        header_offset = browser->show_headers ? hpp_list->nr_header_lines : 0;
         ui_browser__gotorc(&browser->b, row + header_offset, column);
 }
 
@@ -585,7 +573,12 @@ static void ui_browser__warn_lost_events(struct ui_browser *browser)
                 "Or reduce the sampling frequency.");
 }
 
-static int hist_browser__run(struct hist_browser *browser, const char *help)
+static int hist_browser__title(struct hist_browser *browser, char *bf, size_t size)
+{
+        return browser->title ? browser->title(browser, bf, size) : 0;
+}
+
+int hist_browser__run(struct hist_browser *browser, const char *help)
 {
         int key;
         char title[160];
@@ -595,7 +588,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *help)
         browser->b.entries = &browser->hists->entries;
         browser->b.nr_entries = hist_browser__nr_entries(browser);
 
-        hists__browser_title(browser->hists, hbt, title, sizeof(title));
+        hist_browser__title(browser, title, sizeof(title));
 
         if (ui_browser__show(&browser->b, title, "%s", help) < 0)
                 return -1;
@@ -621,8 +614,7 @@ static int hist_browser__run(struct hist_browser *browser, const char *help)
                                 ui_browser__warn_lost_events(&browser->b);
                         }
 
-                        hists__browser_title(browser->hists,
-                                             hbt, title, sizeof(title));
+                        hist_browser__title(browser, title, sizeof(title));
                         ui_browser__show_title(&browser->b, title);
                         continue;
                 }
@@ -1088,7 +1080,7 @@ struct hpp_arg {
         bool current_entry;
 };
 
-static int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
+int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
 {
         struct hpp_arg *arg = hpp->ptr;
         int ret, len;
@@ -1105,7 +1097,6 @@ static int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...)
         ret = scnprintf(hpp->buf, hpp->size, fmt, len, percent);
         ui_browser__printf(arg->b, "%s", hpp->buf);
 
-        advance_hpp(hpp, ret);
         return ret;
 }
 
@@ -1470,7 +1461,7 @@ static int hist_browser__show_no_entry(struct hist_browser *browser,
                     column++ < browser->b.horiz_scroll)
                         continue;
 
-                ret = fmt->width(fmt, NULL, hists_to_evsel(browser->hists));
+                ret = fmt->width(fmt, NULL, browser->hists);
 
                 if (first) {
                         /* for folded sign */
@@ -1510,7 +1501,9 @@ static int advance_hpp_check(struct perf_hpp *hpp, int inc)
         return hpp->size <= 0;
 }
 
-static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *buf, size_t size)
+static int
+hists_browser__scnprintf_headers(struct hist_browser *browser, char *buf,
+                                 size_t size, int line)
 {
         struct hists *hists = browser->hists;
         struct perf_hpp dummy_hpp = {
@@ -1520,6 +1513,7 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *
         struct perf_hpp_fmt *fmt;
         size_t ret = 0;
         int column = 0;
+        int span = 0;
 
         if (symbol_conf.use_callchain) {
                 ret = scnprintf(buf, size, "  ");
@@ -1531,10 +1525,13 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *
                 if (perf_hpp__should_skip(fmt, hists)  || column++ < browser->b.horiz_scroll)
                         continue;
 
-                ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
+                ret = fmt->header(fmt, &dummy_hpp, hists, line, &span);
                 if (advance_hpp_check(&dummy_hpp, ret))
                         break;
 
+                if (span)
+                        continue;
+
                 ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
                 if (advance_hpp_check(&dummy_hpp, ret))
                         break;
@@ -1568,7 +1565,7 @@ static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *brows
                 if (column++ < browser->b.horiz_scroll)
                         continue;
 
-                ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
+                ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
                 if (advance_hpp_check(&dummy_hpp, ret))
                         break;
 
@@ -1605,7 +1602,7 @@ static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *brows
                         }
                         first_col = false;
 
-                        ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
+                        ret = fmt->header(fmt, &dummy_hpp, hists, 0, NULL);
                         dummy_hpp.buf[ret] = '\0';
 
                         start = trim(dummy_hpp.buf);
@@ -1622,21 +1619,45 @@ static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *brows
         return ret;
 }
 
-static void hist_browser__show_headers(struct hist_browser *browser)
+static void hists_browser__hierarchy_headers(struct hist_browser *browser)
 {
         char headers[1024];
 
-        if (symbol_conf.report_hierarchy)
-                hists_browser__scnprintf_hierarchy_headers(browser, headers,
-                                                           sizeof(headers));
-        else
-                hists_browser__scnprintf_headers(browser, headers,
-                                                 sizeof(headers));
+        hists_browser__scnprintf_hierarchy_headers(browser, headers,
+                                                   sizeof(headers));
+
         ui_browser__gotorc(&browser->b, 0, 0);
         ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
         ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
 }
 
+static void hists_browser__headers(struct hist_browser *browser)
+{
+        struct hists *hists = browser->hists;
+        struct perf_hpp_list *hpp_list = hists->hpp_list;
+
+        int line;
+
+        for (line = 0; line < hpp_list->nr_header_lines; line++) {
+                char headers[1024];
+
+                hists_browser__scnprintf_headers(browser, headers,
+                                                 sizeof(headers), line);
+
+                ui_browser__gotorc(&browser->b, line, 0);
+                ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
+                ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
+        }
+}
+
+static void hist_browser__show_headers(struct hist_browser *browser)
+{
+        if (symbol_conf.report_hierarchy)
+                hists_browser__hierarchy_headers(browser);
+        else
+                hists_browser__headers(browser);
+}
+
 static void ui_browser__hists_init_top(struct ui_browser *browser)
 {
         if (browser->top == NULL) {
@@ -1653,10 +1674,13 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
         u16 header_offset = 0;
         struct rb_node *nd;
         struct hist_browser *hb = container_of(browser, struct hist_browser, b);
+        struct hists *hists = hb->hists;
 
         if (hb->show_headers) {
+                struct perf_hpp_list *hpp_list = hists->hpp_list;
+
                 hist_browser__show_headers(hb);
-                header_offset = 1;
+                header_offset = hpp_list->nr_header_lines;
         }
 
         ui_browser__hists_init_top(browser);
@@ -2026,7 +2050,7 @@ static int hist_browser__dump(struct hist_browser *browser)
         fp = fopen(filename, "w");
         if (fp == NULL) {
                 char bf[64];
-                const char *err = strerror_r(errno, bf, sizeof(bf));
+                const char *err = str_error_r(errno, bf, sizeof(bf));
                 ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
                 return -1;
         }
@@ -2039,27 +2063,50 @@ static int hist_browser__dump(struct hist_browser *browser)
         return 0;
 }
 
-static struct hist_browser *hist_browser__new(struct hists *hists,
-                                              struct hist_browser_timer *hbt,
-                                              struct perf_env *env)
+void hist_browser__init(struct hist_browser *browser,
+                        struct hists *hists)
+{
+        struct perf_hpp_fmt *fmt;
+
+        browser->hists                  = hists;
+        browser->b.refresh              = hist_browser__refresh;
+        browser->b.refresh_dimensions   = hist_browser__refresh_dimensions;
+        browser->b.seek                 = ui_browser__hists_seek;
+        browser->b.use_navkeypressed    = true;
+        browser->show_headers           = symbol_conf.show_hist_headers;
+
+        hists__for_each_format(hists, fmt)
+                ++browser->b.columns;
+
+        hists__reset_column_width(hists);
+}
+
+struct hist_browser *hist_browser__new(struct hists *hists)
 {
         struct hist_browser *browser = zalloc(sizeof(*browser));
 
+        if (browser)
+                hist_browser__init(browser, hists);
+
+        return browser;
+}
+
+static struct hist_browser *
+perf_evsel_browser__new(struct perf_evsel *evsel,
+                        struct hist_browser_timer *hbt,
+                        struct perf_env *env)
+{
+        struct hist_browser *browser = hist_browser__new(evsel__hists(evsel));
+
         if (browser) {
-                browser->hists = hists;
-                browser->b.refresh = hist_browser__refresh;
-                browser->b.refresh_dimensions = hist_browser__refresh_dimensions;
-                browser->b.seek = ui_browser__hists_seek;
-                browser->b.use_navkeypressed = true;
-                browser->show_headers = symbol_conf.show_hist_headers;
-                browser->hbt = hbt;
-                browser->env = env;
+                browser->hbt   = hbt;
+                browser->env   = env;
+                browser->title = perf_evsel_browser_title;
         }
-
         return browser;
 }
 
-static void hist_browser__delete(struct hist_browser *browser)
+void hist_browser__delete(struct hist_browser *browser)
 {
         free(browser);
 }
@@ -2080,10 +2127,11 @@ static inline bool is_report_browser(void *timer)
         return timer == NULL;
 }
 
-static int hists__browser_title(struct hists *hists,
-                                struct hist_browser_timer *hbt,
+static int perf_evsel_browser_title(struct hist_browser *browser,
                                 char *bf, size_t size)
 {
+        struct hist_browser_timer *hbt = browser->hbt;
+        struct hists *hists = browser->hists;
         char unit;
         int printed;
         const struct dso *dso = hists->dso_filter;
@@ -2391,8 +2439,6 @@ do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
                 browser->hists->dso_filter = NULL;
                 ui_helpline__pop();
         } else {
-                if (map == NULL)
-                        return 0;
                 ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s DSO\"",
                                    __map__is_kernel(map) ? "the Kernel" : map->dso->short_name);
                 browser->hists->dso_filter = map->dso;
@@ -2640,7 +2686,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     struct perf_env *env)
 {
         struct hists *hists = evsel__hists(evsel);
-        struct hist_browser *browser = hist_browser__new(hists, hbt, env);
+        struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env);
         struct branch_info *bi;
 #define MAX_OPTIONS  16
         char *options[MAX_OPTIONS];
@@ -2649,7 +2695,6 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         int key = -1;
         char buf[64];
         int delay_secs = hbt ? hbt->refresh : 0;
-        struct perf_hpp_fmt *fmt;
 
 #define HIST_BROWSER_HELP_COMMON                                        \
         "h/?/F1        Show this window\n"                              \
@@ -2708,18 +2753,6 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         memset(options, 0, sizeof(options));
         memset(actions, 0, sizeof(actions));
 
-        hists__for_each_format(browser->hists, fmt) {
-                perf_hpp__reset_width(fmt, hists);
-                /*
-                 * This is done just once, and activates the horizontal scrolling
-                 * code in the ui_browser code, it would be better to have a the
-                 * counter in the perf_hpp code, but I couldn't find doing it here
-                 * works, FIXME by setting this in hist_browser__new, for now, be
-                 * clever 8-)
-                 */
-                ++browser->b.columns;
-        }
-
         if (symbol_conf.col_width_list_str)
                 perf_hpp__set_user_width(symbol_conf.col_width_list_str);
 
@@ -3185,7 +3218,7 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
 
         ui_helpline__push("Press ESC to exit");
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 const char *ev_name = perf_evsel__name(pos);
                 size_t line_len = strlen(ev_name) + 7;
 
@@ -3216,7 +3249,7 @@ single_entry:
                 struct perf_evsel *pos;
 
                 nr_entries = 0;
-                evlist__for_each(evlist, pos) {
+                evlist__for_each_entry(evlist, pos) {
                         if (perf_evsel__is_group_leader(pos))
                                 nr_entries++;
                 }
diff --git a/tools/perf/ui/browsers/hists.h b/tools/perf/ui/browsers/hists.h
new file mode 100644
index 000000000000..39bd0f28f211
--- /dev/null
+++ b/tools/perf/ui/browsers/hists.h
@@ -0,0 +1,32 @@
+#ifndef _PERF_UI_BROWSER_HISTS_H_
+#define _PERF_UI_BROWSER_HISTS_H_ 1
+
+#include "ui/browser.h"
+
+struct hist_browser {
+        struct ui_browser   b;
+        struct hists        *hists;
+        struct hist_entry   *he_selection;
+        struct map_symbol   *selection;
+        struct hist_browser_timer *hbt;
+        struct pstack       *pstack;
+        struct perf_env     *env;
+        int                  print_seq;
+        bool                 show_dso;
+        bool                 show_headers;
+        float                min_pcnt;
+        u64                  nr_non_filtered_entries;
+        u64                  nr_hierarchy_entries;
+        u64                  nr_callchain_rows;
+
+        /* Get title string. */
+        int                  (*title)(struct hist_browser *browser,
+                             char *bf, size_t size);
+};
+
+struct hist_browser *hist_browser__new(struct hists *hists);
+void hist_browser__delete(struct hist_browser *browser);
+int hist_browser__run(struct hist_browser *browser, const char *help);
+void hist_browser__init(struct hist_browser *browser,
+                        struct hists *hists);
+#endif /* _PERF_UI_BROWSER_HISTS_H_ */
diff --git a/tools/perf/ui/browsers/map.c b/tools/perf/ui/browsers/map.c
index 80912778bb6d..98a34664bb7e 100644
--- a/tools/perf/ui/browsers/map.c
+++ b/tools/perf/ui/browsers/map.c
@@ -52,9 +52,9 @@ static int map_browser__search(struct map_browser *browser)
 
         if (target[0] == '0' && tolower(target[1]) == 'x') {
                 u64 addr = strtoull(target, NULL, 16);
-                sym = map__find_symbol(browser->map, addr, NULL);
+                sym = map__find_symbol(browser->map, addr);
         } else
-                sym = map__find_symbol_by_name(browser->map, target, NULL);
+                sym = map__find_symbol_by_name(browser->map, target);
 
         if (sym != NULL) {
                 u32 *idx = symbol__browser_index(sym);
diff --git a/tools/perf/ui/gtk/annotate.c b/tools/perf/ui/gtk/annotate.c
index 9c7ff8d31b27..42d319927762 100644
--- a/tools/perf/ui/gtk/annotate.c
+++ b/tools/perf/ui/gtk/annotate.c
@@ -162,12 +162,16 @@ static int symbol__gtk_annotate(struct symbol *sym, struct map *map,
         GtkWidget *notebook;
         GtkWidget *scrolled_window;
         GtkWidget *tab_label;
+        int err;
 
         if (map->dso->annotate_warned)
                 return -1;
 
-        if (symbol__annotate(sym, map, 0) < 0) {
-                ui__error("%s", ui_helpline__current);
+        err = symbol__disassemble(sym, map, 0);
+        if (err) {
+                char msg[BUFSIZ];
+                symbol__strerror_disassemble(sym, map, err, msg, sizeof(msg));
+                ui__error("Couldn't annotate %s: %s\n", sym->name, msg);
                 return -1;
         }
 
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index 932adfaa05af..a4f02de7c1b5 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -549,7 +549,7 @@ static void perf_gtk__show_hierarchy(GtkWidget *window, struct hists *hists,
                                 strcat(buf, "+");
                         first_col = false;
 
-                        fmt->header(fmt, &hpp, hists_to_evsel(hists));
+                        fmt->header(fmt, &hpp, hists, 0, NULL);
                         strcat(buf, ltrim(rtrim(hpp.buf)));
                 }
         }
@@ -627,7 +627,7 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 
         gtk_container_add(GTK_CONTAINER(window), vbox);
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 struct hists *hists = evsel__hists(pos);
                 const char *evname = perf_evsel__name(pos);
                 GtkWidget *scrolled_window;
diff --git a/tools/perf/ui/gtk/util.c b/tools/perf/ui/gtk/util.c
index 52e7fc48af9f..00b91921edb1 100644
--- a/tools/perf/ui/gtk/util.c
+++ b/tools/perf/ui/gtk/util.c
@@ -1,4 +1,5 @@
 #include "../util.h"
+#include "../../util/util.h"
 #include "../../util/debug.h"
 #include "gtk.h"
 
diff --git a/tools/perf/ui/helpline.c b/tools/perf/ui/helpline.c
index 700fb3cfa1c7..5b74a7eba210 100644
--- a/tools/perf/ui/helpline.c
+++ b/tools/perf/ui/helpline.c
@@ -5,6 +5,7 @@
 #include "../debug.h"
 #include "helpline.h"
 #include "ui.h"
+#include "../util.h"
 
 char ui_helpline__current[512];
 
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index af07ffb129ca..37388397b5bc 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -215,9 +215,10 @@ static int __hpp__sort_acc(struct hist_entry *a, struct hist_entry *b,
 
 static int hpp__width_fn(struct perf_hpp_fmt *fmt,
                          struct perf_hpp *hpp __maybe_unused,
-                         struct perf_evsel *evsel)
+                         struct hists *hists)
 {
         int len = fmt->user_len ?: fmt->len;
+        struct perf_evsel *evsel = hists_to_evsel(hists);
 
         if (symbol_conf.event_group)
                 len = max(len, evsel->nr_members * fmt->len);
@@ -229,13 +230,14 @@ static int hpp__width_fn(struct perf_hpp_fmt *fmt,
 }
 
 static int hpp__header_fn(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                          struct perf_evsel *evsel)
+                          struct hists *hists, int line __maybe_unused,
+                          int *span __maybe_unused)
 {
-        int len = hpp__width_fn(fmt, hpp, evsel);
+        int len = hpp__width_fn(fmt, hpp, hists);
         return scnprintf(hpp->buf, hpp->size, "%*s", len, fmt->name);
 }
 
-static int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
+int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...)
 {
         va_list args;
         ssize_t ssize = hpp->size;
@@ -440,6 +442,7 @@ struct perf_hpp_fmt perf_hpp__format[] = {
 struct perf_hpp_list perf_hpp_list = {
         .fields = LIST_HEAD_INIT(perf_hpp_list.fields),
         .sorts  = LIST_HEAD_INIT(perf_hpp_list.sorts),
+        .nr_header_lines = 1,
 };
 
 #undef HPP__COLOR_PRINT_FNS
@@ -632,7 +635,7 @@ unsigned int hists__sort_list_width(struct hists *hists)
                 else
                         ret += 2;
 
-                ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
+                ret += fmt->width(fmt, &dummy_hpp, hists);
         }
 
         if (verbose && hists__has(hists, sym)) /* Addr + origin */
@@ -657,7 +660,7 @@ unsigned int hists__overhead_width(struct hists *hists)
                 else
                         ret += 2;
 
-                ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
+                ret += fmt->width(fmt, &dummy_hpp, hists);
         }
 
         return ret;
@@ -696,6 +699,21 @@ void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists)
         }
 }
 
+void hists__reset_column_width(struct hists *hists)
+{
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *node;
+
+        hists__for_each_format(hists, fmt)
+                perf_hpp__reset_width(fmt, hists);
+
+        /* hierarchy entries have their own hpp list */
+        list_for_each_entry(node, &hists->hpp_formats, list) {
+                perf_hpp_list__for_each_format(&node->hpp, fmt)
+                        perf_hpp__reset_width(fmt, hists);
+        }
+}
+
 void perf_hpp__set_user_width(const char *width_list_str)
 {
         struct perf_hpp_fmt *fmt;
@@ -765,7 +783,7 @@ int perf_hpp__setup_hists_formats(struct perf_hpp_list *list,
         if (!symbol_conf.report_hierarchy)
                 return 0;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 hists = evsel__hists(evsel);
 
                 perf_hpp_list__for_each_sort_list(list, fmt) {
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
index ba51fa8a1176..1f6b0994f4f4 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -60,6 +60,13 @@ static inline int setup_gtk_browser(void) { return -1; }
 static inline void exit_gtk_browser(bool wait_for_ok __maybe_unused) {}
 #endif
 
+int stdio__config_color(const struct option *opt __maybe_unused,
+                        const char *mode, int unset __maybe_unused)
+{
+        perf_use_color_default = perf_config_colorbool("color.ui", mode, -1);
+        return 0;
+}
+
 void setup_browser(bool fallback_to_pager)
 {
         if (use_browser < 2 && (!isatty(1) || dump_trace))
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 560eb47d56f9..89d8441f9890 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -373,7 +373,8 @@ static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
         return 0;
 }
 
-static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
+int __hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp,
+                           struct perf_hpp_list *hpp_list)
 {
         const char *sep = symbol_conf.field_sep;
         struct perf_hpp_fmt *fmt;
@@ -384,7 +385,7 @@ static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
         if (symbol_conf.exclude_other && !he->parent)
                 return 0;
 
-        hists__for_each_format(he->hists, fmt) {
+        perf_hpp_list__for_each_format(hpp_list, fmt) {
                 if (perf_hpp__should_skip(fmt, he->hists))
                         continue;
 
@@ -410,6 +411,11 @@ static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
         return hpp->buf - start;
 }
 
+static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
+{
+        return __hist_entry__snprintf(he, hpp, he->hists->hpp_list);
+}
+
 static int hist_entry__hierarchy_fprintf(struct hist_entry *he,
                                          struct perf_hpp *hpp,
                                          struct hists *hists,
@@ -492,14 +498,15 @@ out:
 }
 
 static int hist_entry__fprintf(struct hist_entry *he, size_t size,
-                               struct hists *hists,
-                               char *bf, size_t bfsz, FILE *fp)
+                               char *bf, size_t bfsz, FILE *fp,
+                               bool use_callchain)
 {
         int ret;
         struct perf_hpp hpp = {
                 .buf            = bf,
                 .size           = size,
         };
+        struct hists *hists = he->hists;
         u64 total_period = hists->stats.total_period;
 
         if (size == 0 || size > bfsz)
@@ -512,7 +519,7 @@ static int hist_entry__fprintf(struct hist_entry *he, size_t size,
 
         ret = fprintf(fp, "%s\n", bf);
 
-        if (symbol_conf.use_callchain)
+        if (use_callchain)
                 ret += hist_entry_callchain__fprintf(he, total_period, 0, fp);
 
         return ret;
@@ -527,8 +534,8 @@ static int print_hierarchy_indent(const char *sep, int indent,
         return fprintf(fp, "%-.*s", (indent - 2) * HIERARCHY_INDENT, line);
 }
 
-static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
-                                  const char *sep, FILE *fp)
+static int hists__fprintf_hierarchy_headers(struct hists *hists,
+                                            struct perf_hpp *hpp, FILE *fp)
 {
         bool first_node, first_col;
         int indent;
@@ -537,6 +544,7 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
         unsigned header_width = 0;
         struct perf_hpp_fmt *fmt;
         struct perf_hpp_list_node *fmt_node;
+        const char *sep = symbol_conf.field_sep;
 
         indent = hists->nr_hpp_node;
 
@@ -548,7 +556,7 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
                                     struct perf_hpp_list_node, list);
 
         perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
-                fmt->header(fmt, hpp, hists_to_evsel(hists));
+                fmt->header(fmt, hpp, hists, 0, NULL);
                 fprintf(fp, "%s%s", hpp->buf, sep ?: "  ");
         }
 
@@ -568,7 +576,7 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
                                 header_width += fprintf(fp, "+");
                         first_col = false;
 
-                        fmt->header(fmt, hpp, hists_to_evsel(hists));
+                        fmt->header(fmt, hpp, hists, 0, NULL);
 
                         header_width += fprintf(fp, "%s", trim(hpp->buf));
                 }
@@ -589,7 +597,7 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
                         fprintf(fp, "%s", sep ?: "..");
                 first_col = false;
 
-                width = fmt->width(fmt, hpp, hists_to_evsel(hists));
+                width = fmt->width(fmt, hpp, hists);
                 fprintf(fp, "%.*s", width, dots);
         }
 
@@ -606,7 +614,7 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
                                 width++;  /* for '+' sign between column header */
                         first_col = false;
 
-                        width += fmt->width(fmt, hpp, hists_to_evsel(hists));
+                        width += fmt->width(fmt, hpp, hists);
                 }
 
                 if (width > header_width)
@@ -622,67 +630,52 @@ static int print_hierarchy_header(struct hists *hists, struct perf_hpp *hpp,
         return 2;
 }
 
-size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
-                      int max_cols, float min_pcnt, FILE *fp)
+static void fprintf_line(struct hists *hists, struct perf_hpp *hpp,
+                         int line, FILE *fp)
 {
         struct perf_hpp_fmt *fmt;
-        struct perf_hpp_list_node *fmt_node;
-        struct rb_node *nd;
-        size_t ret = 0;
-        unsigned int width;
         const char *sep = symbol_conf.field_sep;
-        int nr_rows = 0;
-        char bf[96];
-        struct perf_hpp dummy_hpp = {
-                .buf    = bf,
-                .size   = sizeof(bf),
-        };
         bool first = true;
-        size_t linesz;
-        char *line = NULL;
-        unsigned indent;
-
-        init_rem_hits();
-
-        hists__for_each_format(hists, fmt)
-                perf_hpp__reset_width(fmt, hists);
-
-        if (symbol_conf.col_width_list_str)
-                perf_hpp__set_user_width(symbol_conf.col_width_list_str);
-
-        if (!show_header)
-                goto print_entries;
-
-        fprintf(fp, "# ");
-
-        if (symbol_conf.report_hierarchy) {
-                list_for_each_entry(fmt_node, &hists->hpp_formats, list) {
-                        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt)
-                                perf_hpp__reset_width(fmt, hists);
-                }
-                nr_rows += print_hierarchy_header(hists, &dummy_hpp, sep, fp);
-                goto print_entries;
-        }
+        int span = 0;
 
         hists__for_each_format(hists, fmt) {
                 if (perf_hpp__should_skip(fmt, hists))
                         continue;
 
-                if (!first)
+                if (!first && !span)
                         fprintf(fp, "%s", sep ?: "  ");
                 else
                         first = false;
 
-                fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
-                fprintf(fp, "%s", bf);
+                fmt->header(fmt, hpp, hists, line, &span);
+
+                if (!span)
+                        fprintf(fp, "%s", hpp->buf);
         }
+}
 
-        fprintf(fp, "\n");
-        if (max_rows && ++nr_rows >= max_rows)
-                goto out;
+static int
+hists__fprintf_standard_headers(struct hists *hists,
+                                struct perf_hpp *hpp,
+                                FILE *fp)
+{
+        struct perf_hpp_list *hpp_list = hists->hpp_list;
+        struct perf_hpp_fmt *fmt;
+        unsigned int width;
+        const char *sep = symbol_conf.field_sep;
+        bool first = true;
+        int line;
+
+        for (line = 0; line < hpp_list->nr_header_lines; line++) {
+                /* first # is displayed one level up */
+                if (line)
+                        fprintf(fp, "# ");
+                fprintf_line(hists, hpp, line, fp);
+                fprintf(fp, "\n");
+        }
 
         if (sep)
-                goto print_entries;
+                return hpp_list->nr_header_lines;
 
         first = true;
 
@@ -699,20 +692,58 @@ size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
                 else
                         first = false;
 
-                width = fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
+                width = fmt->width(fmt, hpp, hists);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
 
         fprintf(fp, "\n");
-        if (max_rows && ++nr_rows >= max_rows)
-                goto out;
-
         fprintf(fp, "#\n");
-        if (max_rows && ++nr_rows >= max_rows)
+        return hpp_list->nr_header_lines + 2;
+}
+
+int hists__fprintf_headers(struct hists *hists, FILE *fp)
+{
+        char bf[1024];
+        struct perf_hpp dummy_hpp = {
+                .buf    = bf,
+                .size   = sizeof(bf),
+        };
+
+        fprintf(fp, "# ");
+
+        if (symbol_conf.report_hierarchy)
+                return hists__fprintf_hierarchy_headers(hists, &dummy_hpp, fp);
+        else
+                return hists__fprintf_standard_headers(hists, &dummy_hpp, fp);
+
+}
+
+size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
+                      int max_cols, float min_pcnt, FILE *fp,
+                      bool use_callchain)
+{
+        struct rb_node *nd;
+        size_t ret = 0;
+        const char *sep = symbol_conf.field_sep;
+        int nr_rows = 0;
+        size_t linesz;
+        char *line = NULL;
+        unsigned indent;
+
+        init_rem_hits();
+
+        hists__reset_column_width(hists);
+
+        if (symbol_conf.col_width_list_str)
+                perf_hpp__set_user_width(symbol_conf.col_width_list_str);
+
+        if (show_header)
+                nr_rows += hists__fprintf_headers(hists, fp);
+
+        if (max_rows && nr_rows >= max_rows)
                 goto out;
 
-print_entries:
         linesz = hists__sort_list_width(hists) + 3 + 1;
         linesz += perf_hpp__color_overhead();
         line = malloc(linesz);
@@ -734,7 +765,7 @@ print_entries:
                 if (percent < min_pcnt)
                         continue;
 
-                ret += hist_entry__fprintf(h, max_cols, hists, line, linesz, fp);
+                ret += hist_entry__fprintf(h, max_cols, line, linesz, fp, use_callchain);
 
                 if (max_rows && ++nr_rows >= max_rows)
                         break;
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index 7dfeba0a91f3..4ea2ba861fc2 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -1,3 +1,4 @@
+#include <errno.h>
 #include <signal.h>
 #include <stdbool.h>
 #ifdef HAVE_BACKTRACE_SUPPORT
@@ -6,6 +7,7 @@
 
 #include "../../util/cache.h"
 #include "../../util/debug.h"
+#include "../../util/util.h"
 #include "../browser.h"
 #include "../helpline.h"
 #include "../ui.h"
diff --git a/tools/perf/ui/ui.h b/tools/perf/ui/ui.h
index ab88383f8be8..4b6fb6c7a542 100644
--- a/tools/perf/ui/ui.h
+++ b/tools/perf/ui/ui.h
@@ -26,4 +26,8 @@ static inline void ui__exit(bool wait_for_ok __maybe_unused) {}
 
 void ui__refresh_dimensions(bool force);
 
+struct option;
+
+int stdio__config_color(const struct option *opt, const char *mode, int unset);
+
 #endif /* _PERF_UI_H_ */
diff --git a/tools/perf/util/Build b/tools/perf/util/Build
index 8c6c8a0ca642..eb60e613d795 100644
--- a/tools/perf/util/Build
+++ b/tools/perf/util/Build
@@ -1,5 +1,6 @@
 libperf-y += alias.o
 libperf-y += annotate.o
+libperf-y += block-range.o
 libperf-y += build-id.o
 libperf-y += config.o
 libperf-y += ctype.o
@@ -84,6 +85,8 @@ libperf-y += parse-regs-options.o
 libperf-y += term.o
 libperf-y += help-unknown-cmd.o
 libperf-y += mem-events.o
+libperf-y += vsprintf.o
+libperf-y += drv_configs.o
 
 libperf-$(CONFIG_LIBBPF) += bpf-loader.o
 libperf-$(CONFIG_BPF_PROLOGUE) += bpf-prologue.o
@@ -97,9 +100,13 @@ endif
 
 libperf-$(CONFIG_DWARF) += probe-finder.o
 libperf-$(CONFIG_DWARF) += dwarf-aux.o
+libperf-$(CONFIG_DWARF) += dwarf-regs.o
 
 libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
+libperf-$(CONFIG_LOCAL_LIBUNWIND)    += unwind-libunwind-local.o
 libperf-$(CONFIG_LIBUNWIND)          += unwind-libunwind.o
+libperf-$(CONFIG_LIBUNWIND_X86)      += libunwind/x86_32.o
+libperf-$(CONFIG_LIBUNWIND_AARCH64)  += libunwind/arm64.o
 
 libperf-$(CONFIG_LIBBABELTRACE) += data-convert-bt.o
 
@@ -108,6 +115,7 @@ libperf-y += scripting-engines/
 libperf-$(CONFIG_ZLIB) += zlib.o
 libperf-$(CONFIG_LZMA) += lzma.o
 libperf-y += demangle-java.o
+libperf-y += demangle-rust.o
 
 ifdef CONFIG_JITDUMP
 libperf-$(CONFIG_LIBELF) += jitdump.o
@@ -173,3 +181,7 @@ $(OUTPUT)util/libstring.o: ../lib/string.c FORCE
 $(OUTPUT)util/hweight.o: ../lib/hweight.c FORCE
         $(call rule_mkdir)
         $(call if_changed_dep,cc_o_c)
+
+$(OUTPUT)util/vsprintf.o: ../lib/vsprintf.c FORCE
+        $(call rule_mkdir)
+        $(call if_changed_dep,cc_o_c)
diff --git a/tools/perf/util/alias.c b/tools/perf/util/alias.c
index c0b43ee40d95..6455471d9cd1 100644
--- a/tools/perf/util/alias.c
+++ b/tools/perf/util/alias.c
@@ -1,4 +1,6 @@
 #include "cache.h"
+#include "util.h"
+#include "config.h"
 
 static const char *alias_key;
 static char *alias_val;
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 7e5a1e8874ce..aeb5a441bd74 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -17,6 +17,7 @@
 #include "debug.h"
 #include "annotate.h"
 #include "evsel.h"
+#include "block-range.h"
 #include <regex.h>
 #include <pthread.h>
 #include <linux/bitops.h>
@@ -53,7 +54,7 @@ int ins__scnprintf(struct ins *ins, char *bf, size_t size,
         return ins__raw_scnprintf(ins, bf, size, ops);
 }
 
-static int call__parse(struct ins_operands *ops)
+static int call__parse(struct ins_operands *ops, struct map *map)
 {
         char *endptr, *tok, *name;
 
@@ -81,16 +82,16 @@ static int call__parse(struct ins_operands *ops)
         return ops->target.name == NULL ? -1 : 0;
 
 indirect_call:
-        tok = strchr(endptr, '(');
-        if (tok != NULL) {
-                ops->target.addr = 0;
+        tok = strchr(endptr, '*');
+        if (tok == NULL) {
+                struct symbol *sym = map__find_symbol(map, map->map_ip(map, ops->target.addr));
+                if (sym != NULL)
+                        ops->target.name = strdup(sym->name);
+                else
+                        ops->target.addr = 0;
                 return 0;
         }
 
-        tok = strchr(endptr, '*');
-        if (tok == NULL)
-                return -1;
-
         ops->target.addr = strtoull(tok + 1, NULL, 16);
         return 0;
 }
@@ -117,7 +118,7 @@ bool ins__is_call(const struct ins *ins)
         return ins->ops == &call_ops;
 }
 
-static int jump__parse(struct ins_operands *ops)
+static int jump__parse(struct ins_operands *ops, struct map *map __maybe_unused)
 {
         const char *s = strchr(ops->raw, '+');
 
@@ -172,7 +173,7 @@ static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
         return 0;
 }
 
-static int lock__parse(struct ins_operands *ops)
+static int lock__parse(struct ins_operands *ops, struct map *map)
 {
         char *name;
 
@@ -193,7 +194,7 @@ static int lock__parse(struct ins_operands *ops)
                 return 0;
 
         if (ops->locked.ins->ops->parse &&
-            ops->locked.ins->ops->parse(ops->locked.ops) < 0)
+            ops->locked.ins->ops->parse(ops->locked.ops, map) < 0)
                 goto out_free_ops;
 
         return 0;
@@ -236,7 +237,7 @@ static struct ins_ops lock_ops = {
         .scnprintf = lock__scnprintf,
 };
 
-static int mov__parse(struct ins_operands *ops)
+static int mov__parse(struct ins_operands *ops, struct map *map __maybe_unused)
 {
         char *s = strchr(ops->raw, ','), *target, *comment, prev;
 
@@ -303,7 +304,7 @@ static struct ins_ops mov_ops = {
         .scnprintf = mov__scnprintf,
 };
 
-static int dec__parse(struct ins_operands *ops)
+static int dec__parse(struct ins_operands *ops, struct map *map __maybe_unused)
 {
         char *target, *comment, *s, prev;
 
@@ -354,6 +355,15 @@ static struct ins_ops nop_ops = {
         .scnprintf = nop__scnprintf,
 };
 
+static struct ins_ops ret_ops = {
+        .scnprintf = ins__raw_scnprintf,
+};
+
+bool ins__is_ret(const struct ins *ins)
+{
+        return ins->ops == &ret_ops;
+}
+
 static struct ins instructions[] = {
         { .name = "add",   .ops  = &mov_ops, },
         { .name = "addl",  .ops  = &mov_ops, },
@@ -444,6 +454,7 @@ static struct ins instructions[] = {
         { .name = "xadd",  .ops  = &mov_ops, },
         { .name = "xbeginl", .ops  = &jump_ops, },
         { .name = "xbeginq", .ops  = &jump_ops, },
+        { .name = "retq",  .ops  = &ret_ops, },
 };
 
 static int ins__key_cmp(const void *name, const void *insp)
@@ -481,13 +492,6 @@ static struct ins *ins__find(const char *name)
         return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__key_cmp);
 }
 
-int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym)
-{
-        struct annotation *notes = symbol__annotation(sym);
-        pthread_mutex_init(&notes->lock, NULL);
-        return 0;
-}
-
 int symbol__alloc_hist(struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
@@ -705,7 +709,7 @@ int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
         return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
 }
 
-static void disasm_line__init_ins(struct disasm_line *dl)
+static void disasm_line__init_ins(struct disasm_line *dl, struct map *map)
 {
         dl->ins = ins__find(dl->name);
 
@@ -715,7 +719,7 @@ static void disasm_line__init_ins(struct disasm_line *dl)
         if (!dl->ins->ops)
                 return;
 
-        if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops) < 0)
+        if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops, map) < 0)
                 dl->ins = NULL;
 }
 
@@ -757,7 +761,8 @@ out_free_name:
 }
 
 static struct disasm_line *disasm_line__new(s64 offset, char *line,
-                                        size_t privsize, int line_nr)
+                                            size_t privsize, int line_nr,
+                                            struct map *map)
 {
         struct disasm_line *dl = zalloc(sizeof(*dl) + privsize);
 
@@ -772,7 +777,7 @@ static struct disasm_line *disasm_line__new(s64 offset, char *line,
                         if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0)
                                 goto out_free_line;
 
-                        disasm_line__init_ins(dl);
+                        disasm_line__init_ins(dl, map);
                 }
         }
 
@@ -856,6 +861,89 @@ double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
         return percent;
 }
 
+static const char *annotate__address_color(struct block_range *br)
+{
+        double cov = block_range__coverage(br);
+
+        if (cov >= 0) {
+                /* mark red for >75% coverage */
+                if (cov > 0.75)
+                        return PERF_COLOR_RED;
+
+                /* mark dull for <1% coverage */
+                if (cov < 0.01)
+                        return PERF_COLOR_NORMAL;
+        }
+
+        return PERF_COLOR_MAGENTA;
+}
+
+static const char *annotate__asm_color(struct block_range *br)
+{
+        double cov = block_range__coverage(br);
+
+        if (cov >= 0) {
+                /* mark dull for <1% coverage */
+                if (cov < 0.01)
+                        return PERF_COLOR_NORMAL;
+        }
+
+        return PERF_COLOR_BLUE;
+}
+
+static void annotate__branch_printf(struct block_range *br, u64 addr)
+{
+        bool emit_comment = true;
+
+        if (!br)
+                return;
+
+#if 1
+        if (br->is_target && br->start == addr) {
+                struct block_range *branch = br;
+                double p;
+
+                /*
+                 * Find matching branch to our target.
+                 */
+                while (!branch->is_branch)
+                        branch = block_range__next(branch);
+
+                p = 100 *(double)br->entry / branch->coverage;
+
+                if (p > 0.1) {
+                        if (emit_comment) {
+                                emit_comment = false;
+                                printf("\t#");
+                        }
+
+                        /*
+                         * The percentage of coverage joined at this target in relation
+                         * to the next branch.
+                         */
+                        printf(" +%.2f%%", p);
+                }
+        }
+#endif
+        if (br->is_branch && br->end == addr) {
+                double p = 100*(double)br->taken / br->coverage;
+
+                if (p > 0.1) {
+                        if (emit_comment) {
+                                emit_comment = false;
+                                printf("\t#");
+                        }
+
+                        /*
+                         * The percentage of coverage leaving at this branch, and
+                         * its prediction ratio.
+                         */
+                        printf(" -%.2f%% (p:%.2f%%)", p, 100*(double)br->pred  / br->taken);
+                }
+        }
+}
+
+
 static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
                       struct perf_evsel *evsel, u64 len, int min_pcnt, int printed,
                       int max_lines, struct disasm_line *queue)
@@ -875,6 +963,7 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                 s64 offset = dl->offset;
                 const u64 addr = start + offset;
                 struct disasm_line *next;
+                struct block_range *br;
 
                 next = disasm__get_next_ip_line(&notes->src->source, dl);
 
@@ -944,8 +1033,12 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
                 }
 
                 printf(" :      ");
-                color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
-                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
+
+                br = block_range__find(addr);
+                color_fprintf(stdout, annotate__address_color(br), "  %" PRIx64 ":", addr);
+                color_fprintf(stdout, annotate__asm_color(br), "%s", dl->line);
+                annotate__branch_printf(br, addr);
+                printf("\n");
 
                 if (ppercents != &percent)
                         free(ppercents);
@@ -1056,7 +1149,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                         parsed_line = tmp2 + 1;
         }
 
-        dl = disasm_line__new(offset, parsed_line, privsize, *line_nr);
+        dl = disasm_line__new(offset, parsed_line, privsize, *line_nr, map);
         free(line);
         (*line_nr)++;
 
@@ -1074,7 +1167,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                         .addr = dl->ops.target.addr,
                 };
 
-                if (!map_groups__find_ams(&target, NULL) &&
+                if (!map_groups__find_ams(&target) &&
                     target.sym->start == target.al_addr)
                         dl->ops.target.name = strdup(target.sym->name);
         }
@@ -1113,75 +1206,99 @@ static void delete_last_nop(struct symbol *sym)
         }
 }
 
-int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize)
+int symbol__strerror_disassemble(struct symbol *sym __maybe_unused, struct map *map,
+                              int errnum, char *buf, size_t buflen)
 {
         struct dso *dso = map->dso;
-        char *filename = dso__build_id_filename(dso, NULL, 0);
-        bool free_filename = true;
-        char command[PATH_MAX * 2];
-        FILE *file;
-        int err = 0;
-        char symfs_filename[PATH_MAX];
-        struct kcore_extract kce;
-        bool delete_extract = false;
-        int lineno = 0;
-        int nline;
 
-        if (filename)
-                symbol__join_symfs(symfs_filename, filename);
+        BUG_ON(buflen == 0);
+
+        if (errnum >= 0) {
+                str_error_r(errnum, buf, buflen);
+                return 0;
+        }
+
+        switch (errnum) {
+        case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: {
+                char bf[SBUILD_ID_SIZE + 15] = " with build id ";
+                char *build_id_msg = NULL;
 
-        if (filename == NULL) {
                 if (dso->has_build_id) {
-                        pr_err("Can't annotate %s: not enough memory\n",
-                               sym->name);
-                        return -ENOMEM;
+                        build_id__sprintf(dso->build_id,
+                                          sizeof(dso->build_id), bf + 15);
+                        build_id_msg = bf;
                 }
+                scnprintf(buf, buflen,
+                          "No vmlinux file%s\nwas found in the path.\n\n"
+                          "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n"
+                          "Please use:\n\n"
+                          "  perf buildid-cache -vu vmlinux\n\n"
+                          "or:\n\n"
+                          "  --vmlinux vmlinux\n", build_id_msg ?: "");
+        }
+                break;
+        default:
+                scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum);
+                break;
+        }
+
+        return 0;
+}
+
+static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size)
+{
+        char linkname[PATH_MAX];
+        char *build_id_filename;
+
+        if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
+            !dso__is_kcore(dso))
+                return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX;
+
+        build_id_filename = dso__build_id_filename(dso, NULL, 0);
+        if (build_id_filename) {
+                __symbol__join_symfs(filename, filename_size, build_id_filename);
+                free(build_id_filename);
+        } else {
+                if (dso->has_build_id)
+                        return ENOMEM;
                 goto fallback;
-        } else if (dso__is_kcore(dso)) {
-                goto fallback;
-        } else if (readlink(symfs_filename, command, sizeof(command)) < 0 ||
-                   strstr(command, DSO__NAME_KALLSYMS) ||
-                   access(symfs_filename, R_OK)) {
-                free(filename);
+        }
+
+        if (dso__is_kcore(dso) ||
+            readlink(filename, linkname, sizeof(linkname)) < 0 ||
+            strstr(linkname, DSO__NAME_KALLSYMS) ||
+            access(filename, R_OK)) {
 fallback:
                 /*
                  * If we don't have build-ids or the build-id file isn't in the
                  * cache, or is just a kallsyms file, well, lets hope that this
                  * DSO is the same as when 'perf record' ran.
                  */
-                filename = (char *)dso->long_name;
-                symbol__join_symfs(symfs_filename, filename);
-                free_filename = false;
+                __symbol__join_symfs(filename, filename_size, dso->long_name);
         }
 
-        if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
-            !dso__is_kcore(dso)) {
-                char bf[SBUILD_ID_SIZE + 15] = " with build id ";
-                char *build_id_msg = NULL;
+        return 0;
+}
 
-                if (dso->annotate_warned)
-                        goto out_free_filename;
+int symbol__disassemble(struct symbol *sym, struct map *map, size_t privsize)
+{
+        struct dso *dso = map->dso;
+        char command[PATH_MAX * 2];
+        FILE *file;
+        char symfs_filename[PATH_MAX];
+        struct kcore_extract kce;
+        bool delete_extract = false;
+        int stdout_fd[2];
+        int lineno = 0;
+        int nline;
+        pid_t pid;
+        int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename));
 
-                if (dso->has_build_id) {
-                        build_id__sprintf(dso->build_id,
-                                          sizeof(dso->build_id), bf + 15);
-                        build_id_msg = bf;
-                }
-                err = -ENOENT;
-                dso->annotate_warned = 1;
-                pr_err("Can't annotate %s:\n\n"
-                       "No vmlinux file%s\nwas found in the path.\n\n"
-                       "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n"
-                       "Please use:\n\n"
-                       "  perf buildid-cache -vu vmlinux\n\n"
-                       "or:\n\n"
-                       "  --vmlinux vmlinux\n",
-                       sym->name, build_id_msg ?: "");
-                goto out_free_filename;
-        }
+        if (err)
+                return err;
 
         pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
-                 filename, sym->name, map->unmap_ip(map, sym->start),
+                 symfs_filename, sym->name, map->unmap_ip(map, sym->start),
                  map->unmap_ip(map, sym->end));
 
         pr_debug("annotating [%p] %30s : [%p] %30s\n",
@@ -1196,11 +1313,6 @@ fallback:
                         delete_extract = true;
                         strlcpy(symfs_filename, kce.extract_filename,
                                 sizeof(symfs_filename));
-                        if (free_filename) {
-                                free(filename);
-                                free_filename = false;
-                        }
-                        filename = symfs_filename;
                 }
         } else if (dso__needs_decompress(dso)) {
                 char tmp[PATH_MAX];
@@ -1209,14 +1321,14 @@ fallback:
                 bool ret;
 
                 if (kmod_path__parse_ext(&m, symfs_filename))
-                        goto out_free_filename;
+                        goto out;
 
                 snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
 
                 fd = mkstemp(tmp);
                 if (fd < 0) {
                         free(m.ext);
-                        goto out_free_filename;
+                        goto out;
                 }
 
                 ret = decompress_to_file(m.ext, symfs_filename, fd);
@@ -1228,7 +1340,7 @@ fallback:
                 close(fd);
 
                 if (!ret)
-                        goto out_free_filename;
+                        goto out;
 
                 strcpy(symfs_filename, tmp);
         }
@@ -1244,13 +1356,36 @@ fallback:
                  map__rip_2objdump(map, sym->end),
                  symbol_conf.annotate_asm_raw ? "" : "--no-show-raw",
                  symbol_conf.annotate_src ? "-S" : "",
-                 symfs_filename, filename);
+                 symfs_filename, symfs_filename);
 
         pr_debug("Executing: %s\n", command);
 
-        file = popen(command, "r");
+        err = -1;
+        if (pipe(stdout_fd) < 0) {
+                pr_err("Failure creating the pipe to run %s\n", command);
+                goto out_remove_tmp;
+        }
+
+        pid = fork();
+        if (pid < 0) {
+                pr_err("Failure forking to run %s\n", command);
+                goto out_close_stdout;
+        }
+
+        if (pid == 0) {
+                close(stdout_fd[0]);
+                dup2(stdout_fd[1], 1);
+                close(stdout_fd[1]);
+                execl("/bin/sh", "sh", "-c", command, NULL);
+                perror(command);
+                exit(-1);
+        }
+
+        close(stdout_fd[1]);
+
+        file = fdopen(stdout_fd[0], "r");
         if (!file) {
-                pr_err("Failure running %s\n", command);
+                pr_err("Failure creating FILE stream for %s\n", command);
                 /*
                  * If we were using debug info should retry with
                  * original binary.
@@ -1276,17 +1411,22 @@ fallback:
         if (dso__is_kcore(dso))
                 delete_last_nop(sym);
 
-        pclose(file);
-
+        fclose(file);
+        err = 0;
 out_remove_tmp:
+        close(stdout_fd[0]);
+
         if (dso__needs_decompress(dso))
                 unlink(symfs_filename);
-out_free_filename:
+
         if (delete_extract)
                 kcore_extract__delete(&kce);
-        if (free_filename)
-                free(filename);
+out:
         return err;
+
+out_close_stdout:
+        close(stdout_fd[1]);
+        goto out_remove_tmp;
 }
 
 static void insert_source_line(struct rb_root *root, struct source_line *src_line)
@@ -1512,13 +1652,14 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
         const char *d_filename;
         const char *evsel_name = perf_evsel__name(evsel);
         struct annotation *notes = symbol__annotation(sym);
+        struct sym_hist *h = annotation__histogram(notes, evsel->idx);
         struct disasm_line *pos, *queue = NULL;
         u64 start = map__rip_2objdump(map, sym->start);
         int printed = 2, queue_len = 0;
         int more = 0;
         u64 len;
         int width = 8;
-        int namelen, evsel_name_len, graph_dotted_len;
+        int graph_dotted_len;
 
         filename = strdup(dso->long_name);
         if (!filename)
@@ -1530,17 +1671,14 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map,
                 d_filename = basename(filename);
 
         len = symbol__size(sym);
-        namelen = strlen(d_filename);
-        evsel_name_len = strlen(evsel_name);
 
         if (perf_evsel__is_group_event(evsel))
                 width *= evsel->nr_members;
 
-        printf(" %-*.*s|        Source code & Disassembly of %s for %s\n",
-               width, width, "Percent", d_filename, evsel_name);
+        graph_dotted_len = printf(" %-*.*s|     Source code & Disassembly of %s for %s (%" PRIu64 " samples)\n",
+               width, width, "Percent", d_filename, evsel_name, h->sum);
 
-        graph_dotted_len = width + namelen + evsel_name_len;
-        printf("-%-*.*s-----------------------------------------\n",
+        printf("%-*.*s----\n",
                graph_dotted_len, graph_dotted_len, graph_dotted_line);
 
         if (verbose)
@@ -1655,7 +1793,7 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
         struct rb_root source_line = RB_ROOT;
         u64 len;
 
-        if (symbol__annotate(sym, map, 0) < 0)
+        if (symbol__disassemble(sym, map, 0) < 0)
                 return -1;
 
         len = symbol__size(sym);
@@ -1676,11 +1814,6 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
         return 0;
 }
 
-int hist_entry__annotate(struct hist_entry *he, size_t privsize)
-{
-        return symbol__annotate(he->ms.sym, he->ms.map, privsize);
-}
-
 bool ui__has_annotation(void)
 {
         return use_browser == 1 && perf_hpp_list.sym;
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 9241f8c2b7e1..5bbcec173b82 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -36,7 +36,7 @@ struct ins_operands {
 
 struct ins_ops {
         void (*free)(struct ins_operands *ops);
-        int (*parse)(struct ins_operands *ops);
+        int (*parse)(struct ins_operands *ops, struct map *map);
         int (*scnprintf)(struct ins *ins, char *bf, size_t size,
                          struct ins_operands *ops);
 };
@@ -48,6 +48,7 @@ struct ins {
 
 bool ins__is_jump(const struct ins *ins);
 bool ins__is_call(const struct ins *ins);
+bool ins__is_ret(const struct ins *ins);
 int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops);
 
 struct annotation;
@@ -129,6 +130,7 @@ struct annotated_source {
 
 struct annotation {
         pthread_mutex_t         lock;
+        u64                     max_coverage;
         struct annotated_source *src;
 };
 
@@ -154,11 +156,28 @@ int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 addr);
 int symbol__alloc_hist(struct symbol *sym);
 void symbol__annotate_zero_histograms(struct symbol *sym);
 
-int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
+int symbol__disassemble(struct symbol *sym, struct map *map, size_t privsize);
 
-int hist_entry__annotate(struct hist_entry *he, size_t privsize);
+enum symbol_disassemble_errno {
+        SYMBOL_ANNOTATE_ERRNO__SUCCESS          = 0,
+
+        /*
+         * Choose an arbitrary negative big number not to clash with standard
+         * errno since SUS requires the errno has distinct positive values.
+         * See 'Issue 6' in the link below.
+         *
+         * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
+         */
+        __SYMBOL_ANNOTATE_ERRNO__START          = -10000,
+
+        SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX       = __SYMBOL_ANNOTATE_ERRNO__START,
+
+        __SYMBOL_ANNOTATE_ERRNO__END,
+};
+
+int symbol__strerror_disassemble(struct symbol *sym, struct map *map,
+                                 int errnum, char *buf, size_t buflen);
 
-int symbol__annotate_init(struct map *map, struct symbol *sym);
 int symbol__annotate_printf(struct symbol *sym, struct map *map,
                             struct perf_evsel *evsel, bool full_paths,
                             int min_pcnt, int max_lines, int context);
diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c
index c9169011e55e..c5a6e0b12452 100644
--- a/tools/perf/util/auxtrace.c
+++ b/tools/perf/util/auxtrace.c
@@ -16,6 +16,10 @@
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <stdbool.h>
+#include <ctype.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
 
 #include <linux/kernel.h>
 #include <linux/perf_event.h>
@@ -35,9 +39,14 @@
 #include "../perf.h"
 #include "util.h"
 #include "evlist.h"
+#include "dso.h"
+#include "map.h"
+#include "pmu.h"
+#include "evsel.h"
 #include "cpumap.h"
 #include "thread_map.h"
 #include "asm/bug.h"
+#include "symbol/kallsyms.h"
 #include "auxtrace.h"
 
 #include <linux/hash.h>
@@ -892,6 +901,7 @@ int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused,
                 return intel_pt_process_auxtrace_info(event, session);
         case PERF_AUXTRACE_INTEL_BTS:
                 return intel_bts_process_auxtrace_info(event, session);
+        case PERF_AUXTRACE_CS_ETM:
         case PERF_AUXTRACE_UNKNOWN:
         default:
                 return -EINVAL;
@@ -1398,3 +1408,731 @@ void *auxtrace_cache__lookup(struct auxtrace_cache *c, u32 key)
 
         return NULL;
 }
+
+static void addr_filter__free_str(struct addr_filter *filt)
+{
+        free(filt->str);
+        filt->action   = NULL;
+        filt->sym_from = NULL;
+        filt->sym_to   = NULL;
+        filt->filename = NULL;
+        filt->str      = NULL;
+}
+
+static struct addr_filter *addr_filter__new(void)
+{
+        struct addr_filter *filt = zalloc(sizeof(*filt));
+
+        if (filt)
+                INIT_LIST_HEAD(&filt->list);
+
+        return filt;
+}
+
+static void addr_filter__free(struct addr_filter *filt)
+{
+        if (filt)
+                addr_filter__free_str(filt);
+        free(filt);
+}
+
+static void addr_filters__add(struct addr_filters *filts,
+                              struct addr_filter *filt)
+{
+        list_add_tail(&filt->list, &filts->head);
+        filts->cnt += 1;
+}
+
+static void addr_filters__del(struct addr_filters *filts,
+                              struct addr_filter *filt)
+{
+        list_del_init(&filt->list);
+        filts->cnt -= 1;
+}
+
+void addr_filters__init(struct addr_filters *filts)
+{
+        INIT_LIST_HEAD(&filts->head);
+        filts->cnt = 0;
+}
+
+void addr_filters__exit(struct addr_filters *filts)
+{
+        struct addr_filter *filt, *n;
+
+        list_for_each_entry_safe(filt, n, &filts->head, list) {
+                addr_filters__del(filts, filt);
+                addr_filter__free(filt);
+        }
+}
+
+static int parse_num_or_str(char **inp, u64 *num, const char **str,
+                            const char *str_delim)
+{
+        *inp += strspn(*inp, " ");
+
+        if (isdigit(**inp)) {
+                char *endptr;
+
+                if (!num)
+                        return -EINVAL;
+                errno = 0;
+                *num = strtoull(*inp, &endptr, 0);
+                if (errno)
+                        return -errno;
+                if (endptr == *inp)
+                        return -EINVAL;
+                *inp = endptr;
+        } else {
+                size_t n;
+
+                if (!str)
+                        return -EINVAL;
+                *inp += strspn(*inp, " ");
+                *str = *inp;
+                n = strcspn(*inp, str_delim);
+                if (!n)
+                        return -EINVAL;
+                *inp += n;
+                if (**inp) {
+                        **inp = '\0';
+                        *inp += 1;
+                }
+        }
+        return 0;
+}
+
+static int parse_action(struct addr_filter *filt)
+{
+        if (!strcmp(filt->action, "filter")) {
+                filt->start = true;
+                filt->range = true;
+        } else if (!strcmp(filt->action, "start")) {
+                filt->start = true;
+        } else if (!strcmp(filt->action, "stop")) {
+                filt->start = false;
+        } else if (!strcmp(filt->action, "tracestop")) {
+                filt->start = false;
+                filt->range = true;
+                filt->action += 5; /* Change 'tracestop' to 'stop' */
+        } else {
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int parse_sym_idx(char **inp, int *idx)
+{
+        *idx = -1;
+
+        *inp += strspn(*inp, " ");
+
+        if (**inp != '#')
+                return 0;
+
+        *inp += 1;
+
+        if (**inp == 'g' || **inp == 'G') {
+                *inp += 1;
+                *idx = 0;
+        } else {
+                unsigned long num;
+                char *endptr;
+
+                errno = 0;
+                num = strtoul(*inp, &endptr, 0);
+                if (errno)
+                        return -errno;
+                if (endptr == *inp || num > INT_MAX)
+                        return -EINVAL;
+                *inp = endptr;
+                *idx = num;
+        }
+
+        return 0;
+}
+
+static int parse_addr_size(char **inp, u64 *num, const char **str, int *idx)
+{
+        int err = parse_num_or_str(inp, num, str, " ");
+
+        if (!err && *str)
+                err = parse_sym_idx(inp, idx);
+
+        return err;
+}
+
+static int parse_one_filter(struct addr_filter *filt, const char **filter_inp)
+{
+        char *fstr;
+        int err;
+
+        filt->str = fstr = strdup(*filter_inp);
+        if (!fstr)
+                return -ENOMEM;
+
+        err = parse_num_or_str(&fstr, NULL, &filt->action, " ");
+        if (err)
+                goto out_err;
+
+        err = parse_action(filt);
+        if (err)
+                goto out_err;
+
+        err = parse_addr_size(&fstr, &filt->addr, &filt->sym_from,
+                              &filt->sym_from_idx);
+        if (err)
+                goto out_err;
+
+        fstr += strspn(fstr, " ");
+
+        if (*fstr == '/') {
+                fstr += 1;
+                err = parse_addr_size(&fstr, &filt->size, &filt->sym_to,
+                                      &filt->sym_to_idx);
+                if (err)
+                        goto out_err;
+                filt->range = true;
+        }
+
+        fstr += strspn(fstr, " ");
+
+        if (*fstr == '@') {
+                fstr += 1;
+                err = parse_num_or_str(&fstr, NULL, &filt->filename, " ,");
+                if (err)
+                        goto out_err;
+        }
+
+        fstr += strspn(fstr, " ,");
+
+        *filter_inp += fstr - filt->str;
+
+        return 0;
+
+out_err:
+        addr_filter__free_str(filt);
+
+        return err;
+}
+
+int addr_filters__parse_bare_filter(struct addr_filters *filts,
+                                    const char *filter)
+{
+        struct addr_filter *filt;
+        const char *fstr = filter;
+        int err;
+
+        while (*fstr) {
+                filt = addr_filter__new();
+                err = parse_one_filter(filt, &fstr);
+                if (err) {
+                        addr_filter__free(filt);
+                        addr_filters__exit(filts);
+                        return err;
+                }
+                addr_filters__add(filts, filt);
+        }
+
+        return 0;
+}
+
+struct sym_args {
+        const char      *name;
+        u64             start;
+        u64             size;
+        int             idx;
+        int             cnt;
+        bool            started;
+        bool            global;
+        bool            selected;
+        bool            duplicate;
+        bool            near;
+};
+
+static bool kern_sym_match(struct sym_args *args, const char *name, char type)
+{
+        /* A function with the same name, and global or the n'th found or any */
+        return symbol_type__is_a(type, MAP__FUNCTION) &&
+               !strcmp(name, args->name) &&
+               ((args->global && isupper(type)) ||
+                (args->selected && ++(args->cnt) == args->idx) ||
+                (!args->global && !args->selected));
+}
+
+static int find_kern_sym_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct sym_args *args = arg;
+
+        if (args->started) {
+                if (!args->size)
+                        args->size = start - args->start;
+                if (args->selected) {
+                        if (args->size)
+                                return 1;
+                } else if (kern_sym_match(args, name, type)) {
+                        args->duplicate = true;
+                        return 1;
+                }
+        } else if (kern_sym_match(args, name, type)) {
+                args->started = true;
+                args->start = start;
+        }
+
+        return 0;
+}
+
+static int print_kern_sym_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct sym_args *args = arg;
+
+        if (kern_sym_match(args, name, type)) {
+                pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
+                       ++args->cnt, start, type, name);
+                args->near = true;
+        } else if (args->near) {
+                args->near = false;
+                pr_err("\t\twhich is near\t\t%s\n", name);
+        }
+
+        return 0;
+}
+
+static int sym_not_found_error(const char *sym_name, int idx)
+{
+        if (idx > 0) {
+                pr_err("N'th occurrence (N=%d) of symbol '%s' not found.\n",
+                       idx, sym_name);
+        } else if (!idx) {
+                pr_err("Global symbol '%s' not found.\n", sym_name);
+        } else {
+                pr_err("Symbol '%s' not found.\n", sym_name);
+        }
+        pr_err("Note that symbols must be functions.\n");
+
+        return -EINVAL;
+}
+
+static int find_kern_sym(const char *sym_name, u64 *start, u64 *size, int idx)
+{
+        struct sym_args args = {
+                .name = sym_name,
+                .idx = idx,
+                .global = !idx,
+                .selected = idx > 0,
+        };
+        int err;
+
+        *start = 0;
+        *size = 0;
+
+        err = kallsyms__parse("/proc/kallsyms", &args, find_kern_sym_cb);
+        if (err < 0) {
+                pr_err("Failed to parse /proc/kallsyms\n");
+                return err;
+        }
+
+        if (args.duplicate) {
+                pr_err("Multiple kernel symbols with name '%s'\n", sym_name);
+                args.cnt = 0;
+                kallsyms__parse("/proc/kallsyms", &args, print_kern_sym_cb);
+                pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
+                       sym_name);
+                pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
+                return -EINVAL;
+        }
+
+        if (!args.started) {
+                pr_err("Kernel symbol lookup: ");
+                return sym_not_found_error(sym_name, idx);
+        }
+
+        *start = args.start;
+        *size = args.size;
+
+        return 0;
+}
+
+static int find_entire_kern_cb(void *arg, const char *name __maybe_unused,
+                               char type, u64 start)
+{
+        struct sym_args *args = arg;
+
+        if (!symbol_type__is_a(type, MAP__FUNCTION))
+                return 0;
+
+        if (!args->started) {
+                args->started = true;
+                args->start = start;
+        }
+        /* Don't know exactly where the kernel ends, so we add a page */
+        args->size = round_up(start, page_size) + page_size - args->start;
+
+        return 0;
+}
+
+static int addr_filter__entire_kernel(struct addr_filter *filt)
+{
+        struct sym_args args = { .started = false };
+        int err;
+
+        err = kallsyms__parse("/proc/kallsyms", &args, find_entire_kern_cb);
+        if (err < 0 || !args.started) {
+                pr_err("Failed to parse /proc/kallsyms\n");
+                return err;
+        }
+
+        filt->addr = args.start;
+        filt->size = args.size;
+
+        return 0;
+}
+
+static int check_end_after_start(struct addr_filter *filt, u64 start, u64 size)
+{
+        if (start + size >= filt->addr)
+                return 0;
+
+        if (filt->sym_from) {
+                pr_err("Symbol '%s' (0x%"PRIx64") comes before '%s' (0x%"PRIx64")\n",
+                       filt->sym_to, start, filt->sym_from, filt->addr);
+        } else {
+                pr_err("Symbol '%s' (0x%"PRIx64") comes before address 0x%"PRIx64")\n",
+                       filt->sym_to, start, filt->addr);
+        }
+
+        return -EINVAL;
+}
+
+static int addr_filter__resolve_kernel_syms(struct addr_filter *filt)
+{
+        bool no_size = false;
+        u64 start, size;
+        int err;
+
+        if (symbol_conf.kptr_restrict) {
+                pr_err("Kernel addresses are restricted. Unable to resolve kernel symbols.\n");
+                return -EINVAL;
+        }
+
+        if (filt->sym_from && !strcmp(filt->sym_from, "*"))
+                return addr_filter__entire_kernel(filt);
+
+        if (filt->sym_from) {
+                err = find_kern_sym(filt->sym_from, &start, &size,
+                                    filt->sym_from_idx);
+                if (err)
+                        return err;
+                filt->addr = start;
+                if (filt->range && !filt->size && !filt->sym_to) {
+                        filt->size = size;
+                        no_size = !!size;
+                }
+        }
+
+        if (filt->sym_to) {
+                err = find_kern_sym(filt->sym_to, &start, &size,
+                                    filt->sym_to_idx);
+                if (err)
+                        return err;
+
+                err = check_end_after_start(filt, start, size);
+                if (err)
+                        return err;
+                filt->size = start + size - filt->addr;
+                no_size = !!size;
+        }
+
+        /* The very last symbol in kallsyms does not imply a particular size */
+        if (no_size) {
+                pr_err("Cannot determine size of symbol '%s'\n",
+                       filt->sym_to ? filt->sym_to : filt->sym_from);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct dso *load_dso(const char *name)
+{
+        struct map *map;
+        struct dso *dso;
+
+        map = dso__new_map(name);
+        if (!map)
+                return NULL;
+
+        map__load(map);
+
+        dso = dso__get(map->dso);
+
+        map__put(map);
+
+        return dso;
+}
+
+static bool dso_sym_match(struct symbol *sym, const char *name, int *cnt,
+                          int idx)
+{
+        /* Same name, and global or the n'th found or any */
+        return !arch__compare_symbol_names(name, sym->name) &&
+               ((!idx && sym->binding == STB_GLOBAL) ||
+                (idx > 0 && ++*cnt == idx) ||
+                idx < 0);
+}
+
+static void print_duplicate_syms(struct dso *dso, const char *sym_name)
+{
+        struct symbol *sym;
+        bool near = false;
+        int cnt = 0;
+
+        pr_err("Multiple symbols with name '%s'\n", sym_name);
+
+        sym = dso__first_symbol(dso, MAP__FUNCTION);
+        while (sym) {
+                if (dso_sym_match(sym, sym_name, &cnt, -1)) {
+                        pr_err("#%d\t0x%"PRIx64"\t%c\t%s\n",
+                               ++cnt, sym->start,
+                               sym->binding == STB_GLOBAL ? 'g' :
+                               sym->binding == STB_LOCAL  ? 'l' : 'w',
+                               sym->name);
+                        near = true;
+                } else if (near) {
+                        near = false;
+                        pr_err("\t\twhich is near\t\t%s\n", sym->name);
+                }
+                sym = dso__next_symbol(sym);
+        }
+
+        pr_err("Disambiguate symbol name by inserting #n after the name e.g. %s #2\n",
+               sym_name);
+        pr_err("Or select a global symbol by inserting #0 or #g or #G\n");
+}
+
+static int find_dso_sym(struct dso *dso, const char *sym_name, u64 *start,
+                        u64 *size, int idx)
+{
+        struct symbol *sym;
+        int cnt = 0;
+
+        *start = 0;
+        *size = 0;
+
+        sym = dso__first_symbol(dso, MAP__FUNCTION);
+        while (sym) {
+                if (*start) {
+                        if (!*size)
+                                *size = sym->start - *start;
+                        if (idx > 0) {
+                                if (*size)
+                                        return 1;
+                        } else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
+                                print_duplicate_syms(dso, sym_name);
+                                return -EINVAL;
+                        }
+                } else if (dso_sym_match(sym, sym_name, &cnt, idx)) {
+                        *start = sym->start;
+                        *size = sym->end - sym->start;
+                }
+                sym = dso__next_symbol(sym);
+        }
+
+        if (!*start)
+                return sym_not_found_error(sym_name, idx);
+
+        return 0;
+}
+
+static int addr_filter__entire_dso(struct addr_filter *filt, struct dso *dso)
+{
+        struct symbol *first_sym = dso__first_symbol(dso, MAP__FUNCTION);
+        struct symbol *last_sym = dso__last_symbol(dso, MAP__FUNCTION);
+
+        if (!first_sym || !last_sym) {
+                pr_err("Failed to determine filter for %s\nNo symbols found.\n",
+                       filt->filename);
+                return -EINVAL;
+        }
+
+        filt->addr = first_sym->start;
+        filt->size = last_sym->end - first_sym->start;
+
+        return 0;
+}
+
+static int addr_filter__resolve_syms(struct addr_filter *filt)
+{
+        u64 start, size;
+        struct dso *dso;
+        int err = 0;
+
+        if (!filt->sym_from && !filt->sym_to)
+                return 0;
+
+        if (!filt->filename)
+                return addr_filter__resolve_kernel_syms(filt);
+
+        dso = load_dso(filt->filename);
+        if (!dso) {
+                pr_err("Failed to load symbols from: %s\n", filt->filename);
+                return -EINVAL;
+        }
+
+        if (filt->sym_from && !strcmp(filt->sym_from, "*")) {
+                err = addr_filter__entire_dso(filt, dso);
+                goto put_dso;
+        }
+
+        if (filt->sym_from) {
+                err = find_dso_sym(dso, filt->sym_from, &start, &size,
+                                   filt->sym_from_idx);
+                if (err)
+                        goto put_dso;
+                filt->addr = start;
+                if (filt->range && !filt->size && !filt->sym_to)
+                        filt->size = size;
+        }
+
+        if (filt->sym_to) {
+                err = find_dso_sym(dso, filt->sym_to, &start, &size,
+                                   filt->sym_to_idx);
+                if (err)
+                        goto put_dso;
+
+                err = check_end_after_start(filt, start, size);
+                if (err)
+                        return err;
+
+                filt->size = start + size - filt->addr;
+        }
+
+put_dso:
+        dso__put(dso);
+
+        return err;
+}
+
+static char *addr_filter__to_str(struct addr_filter *filt)
+{
+        char filename_buf[PATH_MAX];
+        const char *at = "";
+        const char *fn = "";
+        char *filter;
+        int err;
+
+        if (filt->filename) {
+                at = "@";
+                fn = realpath(filt->filename, filename_buf);
+                if (!fn)
+                        return NULL;
+        }
+
+        if (filt->range) {
+                err = asprintf(&filter, "%s 0x%"PRIx64"/0x%"PRIx64"%s%s",
+                               filt->action, filt->addr, filt->size, at, fn);
+        } else {
+                err = asprintf(&filter, "%s 0x%"PRIx64"%s%s",
+                               filt->action, filt->addr, at, fn);
+        }
+
+        return err < 0 ? NULL : filter;
+}
+
+static int parse_addr_filter(struct perf_evsel *evsel, const char *filter,
+                             int max_nr)
+{
+        struct addr_filters filts;
+        struct addr_filter *filt;
+        int err;
+
+        addr_filters__init(&filts);
+
+        err = addr_filters__parse_bare_filter(&filts, filter);
+        if (err)
+                goto out_exit;
+
+        if (filts.cnt > max_nr) {
+                pr_err("Error: number of address filters (%d) exceeds maximum (%d)\n",
+                       filts.cnt, max_nr);
+                err = -EINVAL;
+                goto out_exit;
+        }
+
+        list_for_each_entry(filt, &filts.head, list) {
+                char *new_filter;
+
+                err = addr_filter__resolve_syms(filt);
+                if (err)
+                        goto out_exit;
+
+                new_filter = addr_filter__to_str(filt);
+                if (!new_filter) {
+                        err = -ENOMEM;
+                        goto out_exit;
+                }
+
+                if (perf_evsel__append_addr_filter(evsel, new_filter)) {
+                        err = -ENOMEM;
+                        goto out_exit;
+                }
+        }
+
+out_exit:
+        addr_filters__exit(&filts);
+
+        if (err) {
+                pr_err("Failed to parse address filter: '%s'\n", filter);
+                pr_err("Filter format is: filter|start|stop|tracestop <start symbol or address> [/ <end symbol or size>] [@<file name>]\n");
+                pr_err("Where multiple filters are separated by space or comma.\n");
+        }
+
+        return err;
+}
+
+static struct perf_pmu *perf_evsel__find_pmu(struct perf_evsel *evsel)
+{
+        struct perf_pmu *pmu = NULL;
+
+        while ((pmu = perf_pmu__scan(pmu)) != NULL) {
+                if (pmu->type == evsel->attr.type)
+                        break;
+        }
+
+        return pmu;
+}
+
+static int perf_evsel__nr_addr_filter(struct perf_evsel *evsel)
+{
+        struct perf_pmu *pmu = perf_evsel__find_pmu(evsel);
+        int nr_addr_filters = 0;
+
+        if (!pmu)
+                return 0;
+
+        perf_pmu__scan_file(pmu, "nr_addr_filters", "%d", &nr_addr_filters);
+
+        return nr_addr_filters;
+}
+
+int auxtrace_parse_filters(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+        char *filter;
+        int err, max_nr;
+
+        evlist__for_each_entry(evlist, evsel) {
+                filter = evsel->filter;
+                max_nr = perf_evsel__nr_addr_filter(evsel);
+                if (!filter || !max_nr)
+                        continue;
+                evsel->filter = NULL;
+                err = parse_addr_filter(evsel, filter, max_nr);
+                free(filter);
+                if (err)
+                        return err;
+                pr_debug("Address filter: %s\n", evsel->filter);
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 767989e0e312..26fb1ee5746a 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -41,6 +41,7 @@ enum auxtrace_type {
         PERF_AUXTRACE_UNKNOWN,
         PERF_AUXTRACE_INTEL_PT,
         PERF_AUXTRACE_INTEL_BTS,
+        PERF_AUXTRACE_CS_ETM,
 };
 
 enum itrace_period_type {
@@ -63,6 +64,7 @@ enum itrace_period_type {
  * @calls: limit branch samples to calls (can be combined with @returns)
  * @returns: limit branch samples to returns (can be combined with @calls)
  * @callchain: add callchain to 'instructions' events
+ * @thread_stack: feed branches to the thread_stack
  * @last_branch: add branch context to 'instruction' events
  * @callchain_sz: maximum callchain size
  * @last_branch_sz: branch context size
@@ -82,6 +84,7 @@ struct itrace_synth_opts {
         bool                    calls;
         bool                    returns;
         bool                    callchain;
+        bool                    thread_stack;
         bool                    last_branch;
         unsigned int            callchain_sz;
         unsigned int            last_branch_sz;
@@ -315,6 +318,48 @@ struct auxtrace_record {
         unsigned int alignment;
 };
 
+/**
+ * struct addr_filter - address filter.
+ * @list: list node
+ * @range: true if it is a range filter
+ * @start: true if action is 'filter' or 'start'
+ * @action: 'filter', 'start' or 'stop' ('tracestop' is accepted but converted
+ *          to 'stop')
+ * @sym_from: symbol name for the filter address
+ * @sym_to: symbol name that determines the filter size
+ * @sym_from_idx: selects n'th from symbols with the same name (0 means global
+ *                and less than 0 means symbol must be unique)
+ * @sym_to_idx: same as @sym_from_idx but for @sym_to
+ * @addr: filter address
+ * @size: filter region size (for range filters)
+ * @filename: DSO file name or NULL for the kernel
+ * @str: allocated string that contains the other string members
+ */
+struct addr_filter {
+        struct list_head        list;
+        bool                    range;
+        bool                    start;
+        const char              *action;
+        const char              *sym_from;
+        const char              *sym_to;
+        int                     sym_from_idx;
+        int                     sym_to_idx;
+        u64                     addr;
+        u64                     size;
+        const char              *filename;
+        char                    *str;
+};
+
+/**
+ * struct addr_filters - list of address filters.
+ * @head: list of address filters
+ * @cnt: number of address filters
+ */
+struct addr_filters {
+        struct list_head        head;
+        int                     cnt;
+};
+
 #ifdef HAVE_AUXTRACE_SUPPORT
 
 /*
@@ -479,6 +524,12 @@ void perf_session__auxtrace_error_inc(struct perf_session *session,
                                       union perf_event *event);
 void events_stats__auxtrace_error_warn(const struct events_stats *stats);
 
+void addr_filters__init(struct addr_filters *filts);
+void addr_filters__exit(struct addr_filters *filts);
+int addr_filters__parse_bare_filter(struct addr_filters *filts,
+                                    const char *filter);
+int auxtrace_parse_filters(struct perf_evlist *evlist);
+
 static inline int auxtrace__process_event(struct perf_session *session,
                                           union perf_event *event,
                                           struct perf_sample *sample,
@@ -637,6 +688,12 @@ void auxtrace_index__free(struct list_head *head __maybe_unused)
 {
 }
 
+static inline
+int auxtrace_parse_filters(struct perf_evlist *evlist __maybe_unused)
+{
+        return 0;
+}
+
 int auxtrace_mmap__mmap(struct auxtrace_mmap *mm,
                         struct auxtrace_mmap_params *mp,
                         void *userpg, int fd);
diff --git a/tools/perf/util/block-range.c b/tools/perf/util/block-range.c
new file mode 100644
index 000000000000..7b3e1d75d803
--- /dev/null
+++ b/tools/perf/util/block-range.c
@@ -0,0 +1,328 @@
+#include "block-range.h"
+#include "annotate.h"
+
+struct {
+        struct rb_root root;
+        u64 blocks;
+} block_ranges;
+
+static void block_range__debug(void)
+{
+        /*
+         * XXX still paranoid for now; see if we can make this depend on
+         * DEBUG=1 builds.
+         */
+#if 1
+        struct rb_node *rb;
+        u64 old = 0; /* NULL isn't executable */
+
+        for (rb = rb_first(&block_ranges.root); rb; rb = rb_next(rb)) {
+                struct block_range *entry = rb_entry(rb, struct block_range, node);
+
+                assert(old < entry->start);
+                assert(entry->start <= entry->end); /* single instruction block; jump to a jump */
+
+                old = entry->end;
+        }
+#endif
+}
+
+struct block_range *block_range__find(u64 addr)
+{
+        struct rb_node **p = &block_ranges.root.rb_node;
+        struct rb_node *parent = NULL;
+        struct block_range *entry;
+
+        while (*p != NULL) {
+                parent = *p;
+                entry = rb_entry(parent, struct block_range, node);
+
+                if (addr < entry->start)
+                        p = &parent->rb_left;
+                else if (addr > entry->end)
+                        p = &parent->rb_right;
+                else
+                        return entry;
+        }
+
+        return NULL;
+}
+
+static inline void rb_link_left_of_node(struct rb_node *left, struct rb_node *node)
+{
+        struct rb_node **p = &node->rb_left;
+        while (*p) {
+                node = *p;
+                p = &node->rb_right;
+        }
+        rb_link_node(left, node, p);
+}
+
+static inline void rb_link_right_of_node(struct rb_node *right, struct rb_node *node)
+{
+        struct rb_node **p = &node->rb_right;
+        while (*p) {
+                node = *p;
+                p = &node->rb_left;
+        }
+        rb_link_node(right, node, p);
+}
+
+/**
+ * block_range__create
+ * @start: branch target starting this basic block
+ * @end:   branch ending this basic block
+ *
+ * Create all the required block ranges to precisely span the given range.
+ */
+struct block_range_iter block_range__create(u64 start, u64 end)
+{
+        struct rb_node **p = &block_ranges.root.rb_node;
+        struct rb_node *n, *parent = NULL;
+        struct block_range *next, *entry = NULL;
+        struct block_range_iter iter = { NULL, NULL };
+
+        while (*p != NULL) {
+                parent = *p;
+                entry = rb_entry(parent, struct block_range, node);
+
+                if (start < entry->start)
+                        p = &parent->rb_left;
+                else if (start > entry->end)
+                        p = &parent->rb_right;
+                else
+                        break;
+        }
+
+        /*
+         * Didn't find anything.. there's a hole at @start, however @end might
+         * be inside/behind the next range.
+         */
+        if (!*p) {
+                if (!entry) /* tree empty */
+                        goto do_whole;
+
+                /*
+                 * If the last node is before, advance one to find the next.
+                 */
+                n = parent;
+                if (entry->end < start) {
+                        n = rb_next(n);
+                        if (!n)
+                                goto do_whole;
+                }
+                next = rb_entry(n, struct block_range, node);
+
+                if (next->start <= end) { /* add head: [start...][n->start...] */
+                        struct block_range *head = malloc(sizeof(struct block_range));
+                        if (!head)
+                                return iter;
+
+                        *head = (struct block_range){
+                                .start          = start,
+                                .end            = next->start - 1,
+                                .is_target      = 1,
+                                .is_branch      = 0,
+                        };
+
+                        rb_link_left_of_node(&head->node, &next->node);
+                        rb_insert_color(&head->node, &block_ranges.root);
+                        block_range__debug();
+
+                        iter.start = head;
+                        goto do_tail;
+                }
+
+do_whole:
+                /*
+                 * The whole [start..end] range is non-overlapping.
+                 */
+                entry = malloc(sizeof(struct block_range));
+                if (!entry)
+                        return iter;
+
+                *entry = (struct block_range){
+                        .start          = start,
+                        .end            = end,
+                        .is_target      = 1,
+                        .is_branch      = 1,
+                };
+
+                rb_link_node(&entry->node, parent, p);
+                rb_insert_color(&entry->node, &block_ranges.root);
+                block_range__debug();
+
+                iter.start = entry;
+                iter.end   = entry;
+                goto done;
+        }
+
+        /*
+         * We found a range that overlapped with ours, split if needed.
+         */
+        if (entry->start < start) { /* split: [e->start...][start...] */
+                struct block_range *head = malloc(sizeof(struct block_range));
+                if (!head)
+                        return iter;
+
+                *head = (struct block_range){
+                        .start          = entry->start,
+                        .end            = start - 1,
+                        .is_target      = entry->is_target,
+                        .is_branch      = 0,
+
+                        .coverage       = entry->coverage,
+                        .entry          = entry->entry,
+                };
+
+                entry->start            = start;
+                entry->is_target        = 1;
+                entry->entry            = 0;
+
+                rb_link_left_of_node(&head->node, &entry->node);
+                rb_insert_color(&head->node, &block_ranges.root);
+                block_range__debug();
+
+        } else if (entry->start == start)
+                entry->is_target = 1;
+
+        iter.start = entry;
+
+do_tail:
+        /*
+         * At this point we've got: @iter.start = [@start...] but @end can still be
+         * inside or beyond it.
+         */
+        entry = iter.start;
+        for (;;) {
+                /*
+                 * If @end is inside @entry, split.
+                 */
+                if (end < entry->end) { /* split: [...end][...e->end] */
+                        struct block_range *tail = malloc(sizeof(struct block_range));
+                        if (!tail)
+                                return iter;
+
+                        *tail = (struct block_range){
+                                .start          = end + 1,
+                                .end            = entry->end,
+                                .is_target      = 0,
+                                .is_branch      = entry->is_branch,
+
+                                .coverage       = entry->coverage,
+                                .taken          = entry->taken,
+                                .pred           = entry->pred,
+                        };
+
+                        entry->end              = end;
+                        entry->is_branch        = 1;
+                        entry->taken            = 0;
+                        entry->pred             = 0;
+
+                        rb_link_right_of_node(&tail->node, &entry->node);
+                        rb_insert_color(&tail->node, &block_ranges.root);
+                        block_range__debug();
+
+                        iter.end = entry;
+                        goto done;
+                }
+
+                /*
+                 * If @end matches @entry, done
+                 */
+                if (end == entry->end) {
+                        entry->is_branch = 1;
+                        iter.end = entry;
+                        goto done;
+                }
+
+                next = block_range__next(entry);
+                if (!next)
+                        goto add_tail;
+
+                /*
+                 * If @end is in beyond @entry but not inside @next, add tail.
+                 */
+                if (end < next->start) { /* add tail: [...e->end][...end] */
+                        struct block_range *tail;
+add_tail:
+                        tail = malloc(sizeof(struct block_range));
+                        if (!tail)
+                                return iter;
+
+                        *tail = (struct block_range){
+                                .start          = entry->end + 1,
+                                .end            = end,
+                                .is_target      = 0,
+                                .is_branch      = 1,
+                        };
+
+                        rb_link_right_of_node(&tail->node, &entry->node);
+                        rb_insert_color(&tail->node, &block_ranges.root);
+                        block_range__debug();
+
+                        iter.end = tail;
+                        goto done;
+                }
+
+                /*
+                 * If there is a hole between @entry and @next, fill it.
+                 */
+                if (entry->end + 1 != next->start) {
+                        struct block_range *hole = malloc(sizeof(struct block_range));
+                        if (!hole)
+                                return iter;
+
+                        *hole = (struct block_range){
+                                .start          = entry->end + 1,
+                                .end            = next->start - 1,
+                                .is_target      = 0,
+                                .is_branch      = 0,
+                        };
+
+                        rb_link_left_of_node(&hole->node, &next->node);
+                        rb_insert_color(&hole->node, &block_ranges.root);
+                        block_range__debug();
+                }
+
+                entry = next;
+        }
+
+done:
+        assert(iter.start->start == start && iter.start->is_target);
+        assert(iter.end->end == end && iter.end->is_branch);
+
+        block_ranges.blocks++;
+
+        return iter;
+}
+
+
+/*
+ * Compute coverage as:
+ *
+ *    br->coverage / br->sym->max_coverage
+ *
+ * This ensures each symbol has a 100% spot, to reflect that each symbol has a
+ * most covered section.
+ *
+ * Returns [0-1] for coverage and -1 if we had no data what so ever or the
+ * symbol does not exist.
+ */
+double block_range__coverage(struct block_range *br)
+{
+        struct symbol *sym;
+
+        if (!br) {
+                if (block_ranges.blocks)
+                        return 0;
+
+                return -1;
+        }
+
+        sym = br->sym;
+        if (!sym)
+                return -1;
+
+        return (double)br->coverage / symbol__annotation(sym)->max_coverage;
+}
diff --git a/tools/perf/util/block-range.h b/tools/perf/util/block-range.h
new file mode 100644
index 000000000000..a8c841381131
--- /dev/null
+++ b/tools/perf/util/block-range.h
@@ -0,0 +1,71 @@
+#ifndef __PERF_BLOCK_RANGE_H
+#define __PERF_BLOCK_RANGE_H
+
+#include "symbol.h"
+
+/*
+ * struct block_range - non-overlapping parts of basic blocks
+ * @node:       treenode
+ * @start:      inclusive start of range
+ * @end:        inclusive end of range
+ * @is_target:  @start is a jump target
+ * @is_branch:  @end is a branch instruction
+ * @coverage:   number of blocks that cover this range
+ * @taken:      number of times the branch is taken (requires @is_branch)
+ * @pred:       number of times the taken branch was predicted
+ */
+struct block_range {
+        struct rb_node node;
+
+        struct symbol *sym;
+
+        u64 start;
+        u64 end;
+
+        int is_target, is_branch;
+
+        u64 coverage;
+        u64 entry;
+        u64 taken;
+        u64 pred;
+};
+
+static inline struct block_range *block_range__next(struct block_range *br)
+{
+        struct rb_node *n = rb_next(&br->node);
+        if (!n)
+                return NULL;
+        return rb_entry(n, struct block_range, node);
+}
+
+struct block_range_iter {
+        struct block_range *start;
+        struct block_range *end;
+};
+
+static inline struct block_range *block_range_iter(struct block_range_iter *iter)
+{
+        return iter->start;
+}
+
+static inline bool block_range_iter__next(struct block_range_iter *iter)
+{
+        if (iter->start == iter->end)
+                return false;
+
+        iter->start = block_range__next(iter->start);
+        return true;
+}
+
+static inline bool block_range_iter__valid(struct block_range_iter *iter)
+{
+        if (!iter->start || !iter->end)
+                return false;
+        return true;
+}
+
+extern struct block_range *block_range__find(u64 addr);
+extern struct block_range_iter block_range__create(u64 start, u64 end);
+extern double block_range__coverage(struct block_range *br);
+
+#endif /* __PERF_BLOCK_RANGE_H */
diff --git a/tools/perf/util/bpf-loader.c b/tools/perf/util/bpf-loader.c
index 493307d1414c..2b2c9b82f5ab 100644
--- a/tools/perf/util/bpf-loader.c
+++ b/tools/perf/util/bpf-loader.c
@@ -37,6 +37,9 @@ DEFINE_PRINT_FN(info, 1)
 DEFINE_PRINT_FN(debug, 1)
 
 struct bpf_prog_priv {
+        bool is_tp;
+        char *sys_name;
+        char *evt_name;
         struct perf_probe_event pev;
         bool need_prologue;
         struct bpf_insn *insns_buf;
@@ -118,6 +121,8 @@ clear_prog_priv(struct bpf_program *prog __maybe_unused,
         cleanup_perf_probe_events(&priv->pev, 1);
         zfree(&priv->insns_buf);
         zfree(&priv->type_mapping);
+        zfree(&priv->sys_name);
+        zfree(&priv->evt_name);
         free(priv);
 }
 
@@ -269,7 +274,8 @@ nextline:
 }
 
 static int
-parse_prog_config(const char *config_str, struct perf_probe_event *pev)
+parse_prog_config(const char *config_str, const char **p_main_str,
+                  bool *is_tp, struct perf_probe_event *pev)
 {
         int err;
         const char *main_str = parse_prog_config_kvpair(config_str, pev);
@@ -277,6 +283,22 @@ parse_prog_config(const char *config_str, struct perf_probe_event *pev)
         if (IS_ERR(main_str))
                 return PTR_ERR(main_str);
 
+        *p_main_str = main_str;
+        if (!strchr(main_str, '=')) {
+                /* Is a tracepoint event? */
+                const char *s = strchr(main_str, ':');
+
+                if (!s) {
+                        pr_debug("bpf: '%s' is not a valid tracepoint\n",
+                                 config_str);
+                        return -BPF_LOADER_ERRNO__CONFIG;
+                }
+
+                *is_tp = true;
+                return 0;
+        }
+
+        *is_tp = false;
         err = parse_perf_probe_command(main_str, pev);
         if (err < 0) {
                 pr_debug("bpf: '%s' is not a valid config string\n",
@@ -292,7 +314,8 @@ config_bpf_program(struct bpf_program *prog)
 {
         struct perf_probe_event *pev = NULL;
         struct bpf_prog_priv *priv = NULL;
-        const char *config_str;
+        const char *config_str, *main_str;
+        bool is_tp = false;
         int err;
 
         /* Initialize per-program probing setting */
@@ -313,10 +336,19 @@ config_bpf_program(struct bpf_program *prog)
         pev = &priv->pev;
 
         pr_debug("bpf: config program '%s'\n", config_str);
-        err = parse_prog_config(config_str, pev);
+        err = parse_prog_config(config_str, &main_str, &is_tp, pev);
         if (err)
                 goto errout;
 
+        if (is_tp) {
+                char *s = strchr(main_str, ':');
+
+                priv->is_tp = true;
+                priv->sys_name = strndup(main_str, s - main_str);
+                priv->evt_name = strdup(s + 1);
+                goto set_priv;
+        }
+
         if (pev->group && strcmp(pev->group, PERF_BPF_PROBE_GROUP)) {
                 pr_debug("bpf: '%s': group for event is set and not '%s'.\n",
                          config_str, PERF_BPF_PROBE_GROUP);
@@ -339,7 +371,8 @@ config_bpf_program(struct bpf_program *prog)
         }
         pr_debug("bpf: config '%s' is ok\n", config_str);
 
-        err = bpf_program__set_private(prog, priv, clear_prog_priv);
+set_priv:
+        err = bpf_program__set_priv(prog, priv, clear_prog_priv);
         if (err) {
                 pr_debug("Failed to set priv for program '%s'\n", config_str);
                 goto errout;
@@ -380,15 +413,14 @@ preproc_gen_prologue(struct bpf_program *prog, int n,
                      struct bpf_insn *orig_insns, int orig_insns_cnt,
                      struct bpf_prog_prep_result *res)
 {
+        struct bpf_prog_priv *priv = bpf_program__priv(prog);
         struct probe_trace_event *tev;
         struct perf_probe_event *pev;
-        struct bpf_prog_priv *priv;
         struct bpf_insn *buf;
         size_t prologue_cnt = 0;
         int i, err;
 
-        err = bpf_program__get_private(prog, (void **)&priv);
-        if (err || !priv)
+        if (IS_ERR(priv) || !priv || priv->is_tp)
                 goto errout;
 
         pev = &priv->pev;
@@ -499,7 +531,7 @@ static int map_prologue(struct perf_probe_event *pev, int *mapping,
 
         ptevs = malloc(array_sz);
         if (!ptevs) {
-                pr_debug("No ehough memory: alloc ptevs failed\n");
+                pr_debug("No enough memory: alloc ptevs failed\n");
                 return -ENOMEM;
         }
 
@@ -535,17 +567,21 @@ static int map_prologue(struct perf_probe_event *pev, int *mapping,
 
 static int hook_load_preprocessor(struct bpf_program *prog)
 {
+        struct bpf_prog_priv *priv = bpf_program__priv(prog);
         struct perf_probe_event *pev;
-        struct bpf_prog_priv *priv;
         bool need_prologue = false;
         int err, i;
 
-        err = bpf_program__get_private(prog, (void **)&priv);
-        if (err || !priv) {
+        if (IS_ERR(priv) || !priv) {
                 pr_debug("Internal error when hook preprocessor\n");
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
 
+        if (priv->is_tp) {
+                priv->need_prologue = false;
+                return 0;
+        }
+
         pev = &priv->pev;
         for (i = 0; i < pev->ntevs; i++) {
                 struct probe_trace_event *tev = &pev->tevs[i];
@@ -607,9 +643,18 @@ int bpf__probe(struct bpf_object *obj)
                 if (err)
                         goto out;
 
-                err = bpf_program__get_private(prog, (void **)&priv);
-                if (err || !priv)
+                priv = bpf_program__priv(prog);
+                if (IS_ERR(priv) || !priv) {
+                        err = PTR_ERR(priv);
                         goto out;
+                }
+
+                if (priv->is_tp) {
+                        bpf_program__set_tracepoint(prog);
+                        continue;
+                }
+
+                bpf_program__set_kprobe(prog);
                 pev = &priv->pev;
 
                 err = convert_perf_probe_events(pev, 1);
@@ -645,13 +690,12 @@ int bpf__unprobe(struct bpf_object *obj)
 {
         int err, ret = 0;
         struct bpf_program *prog;
-        struct bpf_prog_priv *priv;
 
         bpf_object__for_each_program(prog, obj) {
+                struct bpf_prog_priv *priv = bpf_program__priv(prog);
                 int i;
 
-                err = bpf_program__get_private(prog, (void **)&priv);
-                if (err || !priv)
+                if (IS_ERR(priv) || !priv || priv->is_tp)
                         continue;
 
                 for (i = 0; i < priv->pev.ntevs; i++) {
@@ -694,26 +738,34 @@ int bpf__load(struct bpf_object *obj)
         return 0;
 }
 
-int bpf__foreach_tev(struct bpf_object *obj,
-                     bpf_prog_iter_callback_t func,
-                     void *arg)
+int bpf__foreach_event(struct bpf_object *obj,
+                       bpf_prog_iter_callback_t func,
+                       void *arg)
 {
         struct bpf_program *prog;
         int err;
 
         bpf_object__for_each_program(prog, obj) {
+                struct bpf_prog_priv *priv = bpf_program__priv(prog);
                 struct probe_trace_event *tev;
                 struct perf_probe_event *pev;
-                struct bpf_prog_priv *priv;
                 int i, fd;
 
-                err = bpf_program__get_private(prog,
-                                (void **)&priv);
-                if (err || !priv) {
+                if (IS_ERR(priv) || !priv) {
                         pr_debug("bpf: failed to get private field\n");
                         return -BPF_LOADER_ERRNO__INTERNAL;
                 }
 
+                if (priv->is_tp) {
+                        fd = bpf_program__fd(prog);
+                        err = (*func)(priv->sys_name, priv->evt_name, fd, arg);
+                        if (err) {
+                                pr_debug("bpf: tracepoint call back failed, stop iterate\n");
+                                return err;
+                        }
+                        continue;
+                }
+
                 pev = &priv->pev;
                 for (i = 0; i < pev->ntevs; i++) {
                         tev = &pev->tevs[i];
@@ -731,7 +783,7 @@ int bpf__foreach_tev(struct bpf_object *obj,
                                 return fd;
                         }
 
-                        err = (*func)(tev, fd, arg);
+                        err = (*func)(tev->group, tev->event, fd, arg);
                         if (err) {
                                 pr_debug("bpf: call back failed, stop iterate\n");
                                 return err;
@@ -897,15 +949,12 @@ bpf_map_priv__clone(struct bpf_map_priv *priv)
 static int
 bpf_map__add_op(struct bpf_map *map, struct bpf_map_op *op)
 {
-        struct bpf_map_priv *priv;
-        const char *map_name;
-        int err;
+        const char *map_name = bpf_map__name(map);
+        struct bpf_map_priv *priv = bpf_map__priv(map);
 
-        map_name = bpf_map__get_name(map);
-        err = bpf_map__get_private(map, (void **)&priv);
-        if (err) {
+        if (IS_ERR(priv)) {
                 pr_debug("Failed to get private from map %s\n", map_name);
-                return err;
+                return PTR_ERR(priv);
         }
 
         if (!priv) {
@@ -916,7 +965,7 @@ bpf_map__add_op(struct bpf_map *map, struct bpf_map_op *op)
                 }
                 INIT_LIST_HEAD(&priv->ops_list);
 
-                if (bpf_map__set_private(map, priv, bpf_map_priv__clear)) {
+                if (bpf_map__set_priv(map, priv, bpf_map_priv__clear)) {
                         free(priv);
                         return -BPF_LOADER_ERRNO__INTERNAL;
                 }
@@ -948,30 +997,26 @@ static int
 __bpf_map__config_value(struct bpf_map *map,
                         struct parse_events_term *term)
 {
-        struct bpf_map_def def;
         struct bpf_map_op *op;
-        const char *map_name;
-        int err;
+        const char *map_name = bpf_map__name(map);
+        const struct bpf_map_def *def = bpf_map__def(map);
 
-        map_name = bpf_map__get_name(map);
-
-        err = bpf_map__get_def(map, &def);
-        if (err) {
+        if (IS_ERR(def)) {
                 pr_debug("Unable to get map definition from '%s'\n",
                          map_name);
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
 
-        if (def.type != BPF_MAP_TYPE_ARRAY) {
+        if (def->type != BPF_MAP_TYPE_ARRAY) {
                 pr_debug("Map %s type is not BPF_MAP_TYPE_ARRAY\n",
                          map_name);
                 return -BPF_LOADER_ERRNO__OBJCONF_MAP_TYPE;
         }
-        if (def.key_size < sizeof(unsigned int)) {
+        if (def->key_size < sizeof(unsigned int)) {
                 pr_debug("Map %s has incorrect key size\n", map_name);
                 return -BPF_LOADER_ERRNO__OBJCONF_MAP_KEYSIZE;
         }
-        switch (def.value_size) {
+        switch (def->value_size) {
         case 1:
         case 2:
         case 4:
@@ -1014,12 +1059,10 @@ __bpf_map__config_event(struct bpf_map *map,
                         struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
-        struct bpf_map_def def;
+        const struct bpf_map_def *def;
         struct bpf_map_op *op;
-        const char *map_name;
-        int err;
+        const char *map_name = bpf_map__name(map);
 
-        map_name = bpf_map__get_name(map);
         evsel = perf_evlist__find_evsel_by_str(evlist, term->val.str);
         if (!evsel) {
                 pr_debug("Event (for '%s') '%s' doesn't exist\n",
@@ -1027,18 +1070,18 @@ __bpf_map__config_event(struct bpf_map *map,
                 return -BPF_LOADER_ERRNO__OBJCONF_MAP_NOEVT;
         }
 
-        err = bpf_map__get_def(map, &def);
-        if (err) {
+        def = bpf_map__def(map);
+        if (IS_ERR(def)) {
                 pr_debug("Unable to get map definition from '%s'\n",
                          map_name);
-                return err;
+                return PTR_ERR(def);
         }
 
         /*
          * No need to check key_size and value_size:
          * kernel has already checked them.
          */
-        if (def.type != BPF_MAP_TYPE_PERF_EVENT_ARRAY) {
+        if (def->type != BPF_MAP_TYPE_PERF_EVENT_ARRAY) {
                 pr_debug("Map %s type is not BPF_MAP_TYPE_PERF_EVENT_ARRAY\n",
                          map_name);
                 return -BPF_LOADER_ERRNO__OBJCONF_MAP_TYPE;
@@ -1087,9 +1130,8 @@ config_map_indices_range_check(struct parse_events_term *term,
                                const char *map_name)
 {
         struct parse_events_array *array = &term->array;
-        struct bpf_map_def def;
+        const struct bpf_map_def *def;
         unsigned int i;
-        int err;
 
         if (!array->nr_ranges)
                 return 0;
@@ -1099,8 +1141,8 @@ config_map_indices_range_check(struct parse_events_term *term,
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
 
-        err = bpf_map__get_def(map, &def);
-        if (err) {
+        def = bpf_map__def(map);
+        if (IS_ERR(def)) {
                 pr_debug("ERROR: Unable to get map definition from '%s'\n",
                          map_name);
                 return -BPF_LOADER_ERRNO__INTERNAL;
@@ -1111,7 +1153,7 @@ config_map_indices_range_check(struct parse_events_term *term,
                 size_t length = array->ranges[i].length;
                 unsigned int idx = start + length - 1;
 
-                if (idx >= def.max_entries) {
+                if (idx >= def->max_entries) {
                         pr_debug("ERROR: index %d too large\n", idx);
                         return -BPF_LOADER_ERRNO__OBJCONF_MAP_IDX2BIG;
                 }
@@ -1147,7 +1189,7 @@ bpf__obj_config_map(struct bpf_object *obj,
                 goto out;
         }
 
-        map = bpf_object__get_map_by_name(obj, map_name);
+        map = bpf_object__find_map_by_name(obj, map_name);
         if (!map) {
                 pr_debug("ERROR: Map %s doesn't exist\n", map_name);
                 err = -BPF_LOADER_ERRNO__OBJCONF_MAP_NOTEXIST;
@@ -1204,14 +1246,14 @@ out:
 }
 
 typedef int (*map_config_func_t)(const char *name, int map_fd,
-                                 struct bpf_map_def *pdef,
+                                 const struct bpf_map_def *pdef,
                                  struct bpf_map_op *op,
                                  void *pkey, void *arg);
 
 static int
 foreach_key_array_all(map_config_func_t func,
                       void *arg, const char *name,
-                      int map_fd, struct bpf_map_def *pdef,
+                      int map_fd, const struct bpf_map_def *pdef,
                       struct bpf_map_op *op)
 {
         unsigned int i;
@@ -1231,7 +1273,7 @@ foreach_key_array_all(map_config_func_t func,
 static int
 foreach_key_array_ranges(map_config_func_t func, void *arg,
                          const char *name, int map_fd,
-                         struct bpf_map_def *pdef,
+                         const struct bpf_map_def *pdef,
                          struct bpf_map_op *op)
 {
         unsigned int i, j;
@@ -1261,15 +1303,12 @@ bpf_map_config_foreach_key(struct bpf_map *map,
                            void *arg)
 {
         int err, map_fd;
-        const char *name;
         struct bpf_map_op *op;
-        struct bpf_map_def def;
-        struct bpf_map_priv *priv;
+        const struct bpf_map_def *def;
+        const char *name = bpf_map__name(map);
+        struct bpf_map_priv *priv = bpf_map__priv(map);
 
-        name = bpf_map__get_name(map);
-
-        err = bpf_map__get_private(map, (void **)&priv);
-        if (err) {
+        if (IS_ERR(priv)) {
                 pr_debug("ERROR: failed to get private from map %s\n", name);
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
@@ -1278,29 +1317,29 @@ bpf_map_config_foreach_key(struct bpf_map *map,
                 return 0;
         }
 
-        err = bpf_map__get_def(map, &def);
-        if (err) {
+        def = bpf_map__def(map);
+        if (IS_ERR(def)) {
                 pr_debug("ERROR: failed to get definition from map %s\n", name);
                 return -BPF_LOADER_ERRNO__INTERNAL;
         }
-        map_fd = bpf_map__get_fd(map);
+        map_fd = bpf_map__fd(map);
         if (map_fd < 0) {
                 pr_debug("ERROR: failed to get fd from map %s\n", name);
                 return map_fd;
         }
 
         list_for_each_entry(op, &priv->ops_list, list) {
-                switch (def.type) {
+                switch (def->type) {
                 case BPF_MAP_TYPE_ARRAY:
                 case BPF_MAP_TYPE_PERF_EVENT_ARRAY:
                         switch (op->key_type) {
                         case BPF_MAP_KEY_ALL:
                                 err = foreach_key_array_all(func, arg, name,
-                                                            map_fd, &def, op);
+                                                            map_fd, def, op);
                                 break;
                         case BPF_MAP_KEY_RANGES:
                                 err = foreach_key_array_ranges(func, arg, name,
-                                                               map_fd, &def,
+                                                               map_fd, def,
                                                                op);
                                 break;
                         default:
@@ -1410,7 +1449,7 @@ apply_config_evsel_for_key(const char *name, int map_fd, void *pkey,
 
 static int
 apply_obj_config_map_for_key(const char *name, int map_fd,
-                             struct bpf_map_def *pdef __maybe_unused,
+                             const struct bpf_map_def *pdef,
                              struct bpf_map_op *op,
                              void *pkey, void *arg __maybe_unused)
 {
@@ -1475,9 +1514,9 @@ int bpf__apply_obj_config(void)
 
 #define bpf__for_each_stdout_map(pos, obj, objtmp)      \
         bpf__for_each_map(pos, obj, objtmp)             \
-                if (bpf_map__get_name(pos) &&           \
+                if (bpf_map__name(pos) &&               \
                         (strcmp("__bpf_stdout__",       \
-                                bpf_map__get_name(pos)) == 0))
+                                bpf_map__name(pos)) == 0))
 
 int bpf__setup_stdout(struct perf_evlist *evlist __maybe_unused)
 {
@@ -1489,10 +1528,9 @@ int bpf__setup_stdout(struct perf_evlist *evlist __maybe_unused)
         bool need_init = false;
 
         bpf__for_each_stdout_map(map, obj, tmp) {
-                struct bpf_map_priv *priv;
+                struct bpf_map_priv *priv = bpf_map__priv(map);
 
-                err = bpf_map__get_private(map, (void **)&priv);
-                if (err)
+                if (IS_ERR(priv))
                         return -BPF_LOADER_ERRNO__INTERNAL;
 
                 /*
@@ -1520,10 +1558,9 @@ int bpf__setup_stdout(struct perf_evlist *evlist __maybe_unused)
         }
 
         bpf__for_each_stdout_map(map, obj, tmp) {
-                struct bpf_map_priv *priv;
+                struct bpf_map_priv *priv = bpf_map__priv(map);
 
-                err = bpf_map__get_private(map, (void **)&priv);
-                if (err)
+                if (IS_ERR(priv))
                         return -BPF_LOADER_ERRNO__INTERNAL;
                 if (priv)
                         continue;
@@ -1533,7 +1570,7 @@ int bpf__setup_stdout(struct perf_evlist *evlist __maybe_unused)
                         if (!priv)
                                 return -ENOMEM;
 
-                        err = bpf_map__set_private(map, priv, bpf_map_priv__clear);
+                        err = bpf_map__set_priv(map, priv, bpf_map_priv__clear);
                         if (err) {
                                 bpf_map_priv__clear(map, priv);
                                 return err;
@@ -1607,7 +1644,7 @@ bpf_loader_strerror(int err, char *buf, size_t size)
                 snprintf(buf, size, "Unknown bpf loader error %d", err);
         else
                 snprintf(buf, size, "%s",
-                         strerror_r(err, sbuf, sizeof(sbuf)));
+                         str_error_r(err, sbuf, sizeof(sbuf)));
 
         buf[size - 1] = '\0';
         return -1;
@@ -1677,7 +1714,7 @@ int bpf__strerror_load(struct bpf_object *obj,
 {
         bpf__strerror_head(err, buf, size);
         case LIBBPF_ERRNO__KVER: {
-                unsigned int obj_kver = bpf_object__get_kversion(obj);
+                unsigned int obj_kver = bpf_object__kversion(obj);
                 unsigned int real_kver;
 
                 if (fetch_kernel_version(&real_kver, NULL, 0)) {
diff --git a/tools/perf/util/bpf-loader.h b/tools/perf/util/bpf-loader.h
index 941e17275aa7..f2b737b225f2 100644
--- a/tools/perf/util/bpf-loader.h
+++ b/tools/perf/util/bpf-loader.h
@@ -46,7 +46,7 @@ struct bpf_object;
 struct parse_events_term;
 #define PERF_BPF_PROBE_GROUP "perf_bpf_probe"
 
-typedef int (*bpf_prog_iter_callback_t)(struct probe_trace_event *tev,
+typedef int (*bpf_prog_iter_callback_t)(const char *group, const char *event,
                                         int fd, void *arg);
 
 #ifdef HAVE_LIBBPF_SUPPORT
@@ -67,8 +67,8 @@ int bpf__strerror_probe(struct bpf_object *obj, int err,
 int bpf__load(struct bpf_object *obj);
 int bpf__strerror_load(struct bpf_object *obj, int err,
                        char *buf, size_t size);
-int bpf__foreach_tev(struct bpf_object *obj,
-                     bpf_prog_iter_callback_t func, void *arg);
+int bpf__foreach_event(struct bpf_object *obj,
+                       bpf_prog_iter_callback_t func, void *arg);
 
 int bpf__config_obj(struct bpf_object *obj, struct parse_events_term *term,
                     struct perf_evlist *evlist, int *error_pos);
@@ -107,9 +107,9 @@ static inline int bpf__unprobe(struct bpf_object *obj __maybe_unused) { return 0
 static inline int bpf__load(struct bpf_object *obj __maybe_unused) { return 0; }
 
 static inline int
-bpf__foreach_tev(struct bpf_object *obj __maybe_unused,
-                 bpf_prog_iter_callback_t func __maybe_unused,
-                 void *arg __maybe_unused)
+bpf__foreach_event(struct bpf_object *obj __maybe_unused,
+                   bpf_prog_iter_callback_t func __maybe_unused,
+                   void *arg __maybe_unused)
 {
         return 0;
 }
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 67e5966503b2..e528c40739cc 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -17,6 +17,7 @@
 #include "tool.h"
 #include "header.h"
 #include "vdso.h"
+#include "probe-file.h"
 
 
 static bool no_buildid_cache;
@@ -144,7 +145,28 @@ static int asnprintf(char **strp, size_t size, const char *fmt, ...)
         return ret;
 }
 
-static char *build_id__filename(const char *sbuild_id, char *bf, size_t size)
+char *build_id_cache__kallsyms_path(const char *sbuild_id, char *bf,
+                                    size_t size)
+{
+        bool retry_old = true;
+
+        snprintf(bf, size, "%s/%s/%s/kallsyms",
+                 buildid_dir, DSO__NAME_KALLSYMS, sbuild_id);
+retry:
+        if (!access(bf, F_OK))
+                return bf;
+        if (retry_old) {
+                /* Try old style kallsyms cache */
+                snprintf(bf, size, "%s/%s/%s",
+                         buildid_dir, DSO__NAME_KALLSYMS, sbuild_id);
+                retry_old = false;
+                goto retry;
+        }
+
+        return NULL;
+}
+
+char *build_id_cache__linkname(const char *sbuild_id, char *bf, size_t size)
 {
         char *tmp = bf;
         int ret = asnprintf(&bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
@@ -154,23 +176,107 @@ static char *build_id__filename(const char *sbuild_id, char *bf, size_t size)
         return bf;
 }
 
+char *build_id_cache__origname(const char *sbuild_id)
+{
+        char *linkname;
+        char buf[PATH_MAX];
+        char *ret = NULL, *p;
+        size_t offs = 5;        /* == strlen("../..") */
+
+        linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
+        if (!linkname)
+                return NULL;
+
+        if (readlink(linkname, buf, PATH_MAX) < 0)
+                goto out;
+        /* The link should be "../..<origpath>/<sbuild_id>" */
+        p = strrchr(buf, '/');  /* Cut off the "/<sbuild_id>" */
+        if (p && (p > buf + offs)) {
+                *p = '\0';
+                if (buf[offs + 1] == '[')
+                        offs++; /*
+                                 * This is a DSO name, like [kernel.kallsyms].
+                                 * Skip the first '/', since this is not the
+                                 * cache of a regular file.
+                                 */
+                ret = strdup(buf + offs);       /* Skip "../..[/]" */
+        }
+out:
+        free(linkname);
+        return ret;
+}
+
+/* Check if the given build_id cache is valid on current running system */
+static bool build_id_cache__valid_id(char *sbuild_id)
+{
+        char real_sbuild_id[SBUILD_ID_SIZE] = "";
+        char *pathname;
+        int ret = 0;
+        bool result = false;
+
+        pathname = build_id_cache__origname(sbuild_id);
+        if (!pathname)
+                return false;
+
+        if (!strcmp(pathname, DSO__NAME_KALLSYMS))
+                ret = sysfs__sprintf_build_id("/", real_sbuild_id);
+        else if (pathname[0] == '/')
+                ret = filename__sprintf_build_id(pathname, real_sbuild_id);
+        else
+                ret = -EINVAL;  /* Should we support other special DSO cache? */
+        if (ret >= 0)
+                result = (strcmp(sbuild_id, real_sbuild_id) == 0);
+        free(pathname);
+
+        return result;
+}
+
+static const char *build_id_cache__basename(bool is_kallsyms, bool is_vdso)
+{
+        return is_kallsyms ? "kallsyms" : (is_vdso ? "vdso" : "elf");
+}
+
 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size)
 {
-        char build_id_hex[SBUILD_ID_SIZE];
+        bool is_kallsyms = dso__is_kallsyms((struct dso *)dso);
+        bool is_vdso = dso__is_vdso((struct dso *)dso);
+        char sbuild_id[SBUILD_ID_SIZE];
+        char *linkname;
+        bool alloc = (bf == NULL);
+        int ret;
 
         if (!dso->has_build_id)
                 return NULL;
 
-        build_id__sprintf(dso->build_id, sizeof(dso->build_id), build_id_hex);
-        return build_id__filename(build_id_hex, bf, size);
+        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
+        linkname = build_id_cache__linkname(sbuild_id, NULL, 0);
+        if (!linkname)
+                return NULL;
+
+        /* Check if old style build_id cache */
+        if (is_regular_file(linkname))
+                ret = asnprintf(&bf, size, "%s", linkname);
+        else
+                ret = asnprintf(&bf, size, "%s/%s", linkname,
+                         build_id_cache__basename(is_kallsyms, is_vdso));
+        if (ret < 0 || (!alloc && size < (unsigned int)ret))
+                bf = NULL;
+        free(linkname);
+
+        return bf;
 }
 
 bool dso__build_id_is_kmod(const struct dso *dso, char *bf, size_t size)
 {
-        char *id_name, *ch;
+        char *id_name = NULL, *ch;
         struct stat sb;
+        char sbuild_id[SBUILD_ID_SIZE];
 
-        id_name = dso__build_id_filename(dso, bf, size);
+        if (!dso->has_build_id)
+                goto err;
+
+        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
+        id_name = build_id_cache__linkname(sbuild_id, NULL, 0);
         if (!id_name)
                 goto err;
         if (access(id_name, F_OK))
@@ -194,18 +300,14 @@ bool dso__build_id_is_kmod(const struct dso *dso, char *bf, size_t size)
         if (ch - 3 < bf)
                 goto err;
 
+        free(id_name);
         return strncmp(".ko", ch - 3, 3) == 0;
 err:
-        /*
-         * If dso__build_id_filename work, get id_name again,
-         * because id_name points to bf and is broken.
-         */
-        if (id_name)
-                id_name = dso__build_id_filename(dso, bf, size);
         pr_err("Invalid build id: %s\n", id_name ? :
                                          dso->long_name ? :
                                          dso->short_name ? :
                                          "[unknown]");
+        free(id_name);
         return false;
 }
 
@@ -340,8 +442,132 @@ void disable_buildid_cache(void)
         no_buildid_cache = true;
 }
 
-static char *build_id_cache__dirname_from_path(const char *name,
-                                               bool is_kallsyms, bool is_vdso)
+static bool lsdir_bid_head_filter(const char *name __maybe_unused,
+                                  struct dirent *d __maybe_unused)
+{
+        return (strlen(d->d_name) == 2) &&
+                isxdigit(d->d_name[0]) && isxdigit(d->d_name[1]);
+}
+
+static bool lsdir_bid_tail_filter(const char *name __maybe_unused,
+                                  struct dirent *d __maybe_unused)
+{
+        int i = 0;
+        while (isxdigit(d->d_name[i]) && i < SBUILD_ID_SIZE - 3)
+                i++;
+        return (i == SBUILD_ID_SIZE - 3) && (d->d_name[i] == '\0');
+}
+
+struct strlist *build_id_cache__list_all(bool validonly)
+{
+        struct strlist *toplist, *linklist = NULL, *bidlist;
+        struct str_node *nd, *nd2;
+        char *topdir, *linkdir = NULL;
+        char sbuild_id[SBUILD_ID_SIZE];
+
+        /* for filename__ functions */
+        if (validonly)
+                symbol__init(NULL);
+
+        /* Open the top-level directory */
+        if (asprintf(&topdir, "%s/.build-id/", buildid_dir) < 0)
+                return NULL;
+
+        bidlist = strlist__new(NULL, NULL);
+        if (!bidlist)
+                goto out;
+
+        toplist = lsdir(topdir, lsdir_bid_head_filter);
+        if (!toplist) {
+                pr_debug("Error in lsdir(%s): %d\n", topdir, errno);
+                /* If there is no buildid cache, return an empty list */
+                if (errno == ENOENT)
+                        goto out;
+                goto err_out;
+        }
+
+        strlist__for_each_entry(nd, toplist) {
+                if (asprintf(&linkdir, "%s/%s", topdir, nd->s) < 0)
+                        goto err_out;
+                /* Open the lower-level directory */
+                linklist = lsdir(linkdir, lsdir_bid_tail_filter);
+                if (!linklist) {
+                        pr_debug("Error in lsdir(%s): %d\n", linkdir, errno);
+                        goto err_out;
+                }
+                strlist__for_each_entry(nd2, linklist) {
+                        if (snprintf(sbuild_id, SBUILD_ID_SIZE, "%s%s",
+                                     nd->s, nd2->s) != SBUILD_ID_SIZE - 1)
+                                goto err_out;
+                        if (validonly && !build_id_cache__valid_id(sbuild_id))
+                                continue;
+                        if (strlist__add(bidlist, sbuild_id) < 0)
+                                goto err_out;
+                }
+                strlist__delete(linklist);
+                zfree(&linkdir);
+        }
+
+out_free:
+        strlist__delete(toplist);
+out:
+        free(topdir);
+
+        return bidlist;
+
+err_out:
+        strlist__delete(linklist);
+        zfree(&linkdir);
+        strlist__delete(bidlist);
+        bidlist = NULL;
+        goto out_free;
+}
+
+static bool str_is_build_id(const char *maybe_sbuild_id, size_t len)
+{
+        size_t i;
+
+        for (i = 0; i < len; i++) {
+                if (!isxdigit(maybe_sbuild_id[i]))
+                        return false;
+        }
+        return true;
+}
+
+/* Return the valid complete build-id */
+char *build_id_cache__complement(const char *incomplete_sbuild_id)
+{
+        struct strlist *bidlist;
+        struct str_node *nd, *cand = NULL;
+        char *sbuild_id = NULL;
+        size_t len = strlen(incomplete_sbuild_id);
+
+        if (len >= SBUILD_ID_SIZE ||
+            !str_is_build_id(incomplete_sbuild_id, len))
+                return NULL;
+
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist)
+                return NULL;
+
+        strlist__for_each_entry(nd, bidlist) {
+                if (strncmp(nd->s, incomplete_sbuild_id, len) != 0)
+                        continue;
+                if (cand) {     /* Error: There are more than 2 candidates. */
+                        cand = NULL;
+                        break;
+                }
+                cand = nd;
+        }
+        if (cand)
+                sbuild_id = strdup(cand->s);
+        strlist__delete(bidlist);
+
+        return sbuild_id;
+}
+
+char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
+                               bool is_kallsyms, bool is_vdso)
 {
         char *realname = (char *)name, *filename;
         bool slash = is_kallsyms || is_vdso;
@@ -352,8 +578,9 @@ static char *build_id_cache__dirname_from_path(const char *name,
                         return NULL;
         }
 
-        if (asprintf(&filename, "%s%s%s", buildid_dir, slash ? "/" : "",
-                     is_vdso ? DSO__NAME_VDSO : realname) < 0)
+        if (asprintf(&filename, "%s%s%s%s%s", buildid_dir, slash ? "/" : "",
+                     is_vdso ? DSO__NAME_VDSO : realname,
+                     sbuild_id ? "/" : "", sbuild_id ?: "") < 0)
                 filename = NULL;
 
         if (!slash)
@@ -368,7 +595,7 @@ int build_id_cache__list_build_ids(const char *pathname,
         char *dir_name;
         int ret = 0;
 
-        dir_name = build_id_cache__dirname_from_path(pathname, false, false);
+        dir_name = build_id_cache__cachedir(NULL, pathname, false, false);
         if (!dir_name)
                 return -ENOMEM;
 
@@ -380,12 +607,36 @@ int build_id_cache__list_build_ids(const char *pathname,
         return ret;
 }
 
+#if defined(HAVE_LIBELF_SUPPORT) && defined(HAVE_GELF_GETNOTE_SUPPORT)
+static int build_id_cache__add_sdt_cache(const char *sbuild_id,
+                                          const char *realname)
+{
+        struct probe_cache *cache;
+        int ret;
+
+        cache = probe_cache__new(sbuild_id);
+        if (!cache)
+                return -1;
+
+        ret = probe_cache__scan_sdt(cache, realname);
+        if (ret >= 0) {
+                pr_debug4("Found %d SDTs in %s\n", ret, realname);
+                if (probe_cache__commit(cache) < 0)
+                        ret = -1;
+        }
+        probe_cache__delete(cache);
+        return ret;
+}
+#else
+#define build_id_cache__add_sdt_cache(sbuild_id, realname) (0)
+#endif
+
 int build_id_cache__add_s(const char *sbuild_id, const char *name,
                           bool is_kallsyms, bool is_vdso)
 {
         const size_t size = PATH_MAX;
         char *realname = NULL, *filename = NULL, *dir_name = NULL,
-             *linkname = zalloc(size), *targetname, *tmp;
+             *linkname = zalloc(size), *tmp;
         int err = -1;
 
         if (!is_kallsyms) {
@@ -394,14 +645,22 @@ int build_id_cache__add_s(const char *sbuild_id, const char *name,
                         goto out_free;
         }
 
-        dir_name = build_id_cache__dirname_from_path(name, is_kallsyms, is_vdso);
+        dir_name = build_id_cache__cachedir(sbuild_id, name,
+                                            is_kallsyms, is_vdso);
         if (!dir_name)
                 goto out_free;
 
+        /* Remove old style build-id cache */
+        if (is_regular_file(dir_name))
+                if (unlink(dir_name))
+                        goto out_free;
+
         if (mkdir_p(dir_name, 0755))
                 goto out_free;
 
-        if (asprintf(&filename, "%s/%s", dir_name, sbuild_id) < 0) {
+        /* Save the allocated buildid dirname */
+        if (asprintf(&filename, "%s/%s", dir_name,
+                     build_id_cache__basename(is_kallsyms, is_vdso)) < 0) {
                 filename = NULL;
                 goto out_free;
         }
@@ -415,7 +674,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *name,
                         goto out_free;
         }
 
-        if (!build_id__filename(sbuild_id, linkname, size))
+        if (!build_id_cache__linkname(sbuild_id, linkname, size))
                 goto out_free;
         tmp = strrchr(linkname, '/');
         *tmp = '\0';
@@ -424,11 +683,16 @@ int build_id_cache__add_s(const char *sbuild_id, const char *name,
                 goto out_free;
 
         *tmp = '/';
-        targetname = filename + strlen(buildid_dir) - 5;
-        memcpy(targetname, "../..", 5);
+        tmp = dir_name + strlen(buildid_dir) - 5;
+        memcpy(tmp, "../..", 5);
 
-        if (symlink(targetname, linkname) == 0)
+        if (symlink(tmp, linkname) == 0)
                 err = 0;
+
+        /* Update SDT cache : error is just warned */
+        if (build_id_cache__add_sdt_cache(sbuild_id, realname) < 0)
+                pr_debug4("Failed to update/scan SDT cache for %s\n", realname);
+
 out_free:
         if (!is_kallsyms)
                 free(realname);
@@ -452,7 +716,7 @@ static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
 bool build_id_cache__cached(const char *sbuild_id)
 {
         bool ret = false;
-        char *filename = build_id__filename(sbuild_id, NULL, 0);
+        char *filename = build_id_cache__linkname(sbuild_id, NULL, 0);
 
         if (filename && !access(filename, F_OK))
                 ret = true;
@@ -471,7 +735,7 @@ int build_id_cache__remove_s(const char *sbuild_id)
         if (filename == NULL || linkname == NULL)
                 goto out_free;
 
-        if (!build_id__filename(sbuild_id, linkname, size))
+        if (!build_id_cache__linkname(sbuild_id, linkname, size))
                 goto out_free;
 
         if (access(linkname, F_OK))
@@ -489,7 +753,7 @@ int build_id_cache__remove_s(const char *sbuild_id)
         tmp = strrchr(linkname, '/') + 1;
         snprintf(tmp, size - (tmp - linkname), "%s", filename);
 
-        if (unlink(linkname))
+        if (rm_rf(linkname))
                 goto out_free;
 
         err = 0;
@@ -501,7 +765,7 @@ out_free:
 
 static int dso__cache_build_id(struct dso *dso, struct machine *machine)
 {
-        bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
+        bool is_kallsyms = dso__is_kallsyms(dso);
         bool is_vdso = dso__is_vdso(dso);
         const char *name = dso->long_name;
         char nm[PATH_MAX];
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 64af3e20610d..d27990610f9f 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -14,6 +14,8 @@ struct dso;
 int build_id__sprintf(const u8 *build_id, int len, char *bf);
 int sysfs__sprintf_build_id(const char *root_dir, char *sbuild_id);
 int filename__sprintf_build_id(const char *pathname, char *sbuild_id);
+char *build_id_cache__kallsyms_path(const char *sbuild_id, char *bf,
+                                    size_t size);
 
 char *dso__build_id_filename(const struct dso *dso, char *bf, size_t size);
 bool dso__build_id_is_kmod(const struct dso *dso, char *bf, size_t size);
@@ -28,6 +30,12 @@ bool perf_session__read_build_ids(struct perf_session *session, bool with_hits);
 int perf_session__write_buildid_table(struct perf_session *session, int fd);
 int perf_session__cache_build_ids(struct perf_session *session);
 
+char *build_id_cache__origname(const char *sbuild_id);
+char *build_id_cache__linkname(const char *sbuild_id, char *bf, size_t size);
+char *build_id_cache__cachedir(const char *sbuild_id, const char *name,
+                               bool is_kallsyms, bool is_vdso);
+struct strlist *build_id_cache__list_all(bool validonly);
+char *build_id_cache__complement(const char *incomplete_sbuild_id);
 int build_id_cache__list_build_ids(const char *pathname,
                                    struct strlist **result);
 bool build_id_cache__cached(const char *sbuild_id);
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 0d814bb74661..512c0c83fbc6 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,40 +1,20 @@
 #ifndef __PERF_CACHE_H
 #define __PERF_CACHE_H
 
-#include <stdbool.h>
-#include "util.h"
 #include "strbuf.h"
 #include <subcmd/pager.h>
-#include "../perf.h"
 #include "../ui/ui.h"
 
 #include <linux/string.h>
 
 #define CMD_EXEC_PATH "--exec-path"
-#define CMD_PERF_DIR "--perf-dir="
-#define CMD_WORK_TREE "--work-tree="
 #define CMD_DEBUGFS_DIR "--debugfs-dir="
 
-#define PERF_DIR_ENVIRONMENT "PERF_DIR"
-#define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
 #define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
-#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
 #define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
 #define PERF_PAGER_ENVIRONMENT "PERF_PAGER"
 
-extern const char *config_exclusive_filename;
-
-typedef int (*config_fn_t)(const char *, const char *, void *);
-int perf_default_config(const char *, const char *, void *);
-int perf_config(config_fn_t fn, void *);
-int perf_config_int(const char *, const char *);
-u64 perf_config_u64(const char *, const char *);
-int perf_config_bool(const char *, const char *);
-int config_error_nonbool(const char *);
-const char *perf_config_dirname(const char *, const char *);
-const char *perf_etc_perfconfig(void);
-
 char *alias_lookup(const char *alias);
 int split_cmdline(char *cmdline, const char ***argv);
 
@@ -45,9 +25,6 @@ static inline int is_absolute_path(const char *path)
         return path[0] == '/';
 }
 
-char *strip_path_suffix(const char *path, const char *suffix);
-
 char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
-char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
 
 #endif /* __PERF_CACHE_H */
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 65e2a4f7cb4e..13e75549c440 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -94,6 +94,7 @@ struct callchain_param {
         enum perf_call_graph_mode record_mode;
         u32                     dump_size;
         enum chain_mode         mode;
+        u16                     max_stack;
         u32                     print_limit;
         double                  min_percent;
         sort_chain_func_t       sort;
@@ -105,6 +106,7 @@ struct callchain_param {
 };
 
 extern struct callchain_param callchain_param;
+extern struct callchain_param callchain_param_default;
 
 struct callchain_list {
         u64                     ip;
diff --git a/tools/perf/util/cgroup.c b/tools/perf/util/cgroup.c
index 90aa1b46b2e5..8fdee24725a7 100644
--- a/tools/perf/util/cgroup.c
+++ b/tools/perf/util/cgroup.c
@@ -81,7 +81,7 @@ static int add_cgroup(struct perf_evlist *evlist, char *str)
         /*
          * check if cgrp is already defined, if so we reuse it
          */
-        evlist__for_each(evlist, counter) {
+        evlist__for_each_entry(evlist, counter) {
                 cgrp = counter->cgrp;
                 if (!cgrp)
                         continue;
@@ -110,7 +110,7 @@ static int add_cgroup(struct perf_evlist *evlist, char *str)
          * if add cgroup N, then need to find event N
          */
         n = 0;
-        evlist__for_each(evlist, counter) {
+        evlist__for_each_entry(evlist, counter) {
                 if (n == nr_cgroups)
                         goto found;
                 n++;
diff --git a/tools/perf/util/cloexec.c b/tools/perf/util/cloexec.c
index 2babddaa2481..f0dcd0ee0afa 100644
--- a/tools/perf/util/cloexec.c
+++ b/tools/perf/util/cloexec.c
@@ -4,18 +4,24 @@
 #include "cloexec.h"
 #include "asm/bug.h"
 #include "debug.h"
+#include <unistd.h>
+#include <asm/unistd.h>
+#include <sys/syscall.h>
 
 static unsigned long flag = PERF_FLAG_FD_CLOEXEC;
 
-#ifdef __GLIBC_PREREQ
-#if !__GLIBC_PREREQ(2, 6)
 int __weak sched_getcpu(void)
 {
+#ifdef __NR_getcpu
+        unsigned cpu;
+        int err = syscall(__NR_getcpu, &cpu, NULL, NULL);
+        if (!err)
+                return cpu;
+#else
         errno = ENOSYS;
+#endif
         return -1;
 }
-#endif
-#endif
 
 static int perf_flag_probe(void)
 {
@@ -58,7 +64,7 @@ static int perf_flag_probe(void)
 
         WARN_ONCE(err != EINVAL && err != EBUSY,
                   "perf_event_open(..., PERF_FLAG_FD_CLOEXEC) failed with unexpected error %d (%s)\n",
-                  err, strerror_r(err, sbuf, sizeof(sbuf)));
+                  err, str_error_r(err, sbuf, sizeof(sbuf)));
 
         /* not supported, confirm error related to PERF_FLAG_FD_CLOEXEC */
         while (1) {
@@ -76,7 +82,7 @@ static int perf_flag_probe(void)
 
         if (WARN_ONCE(fd < 0 && err != EBUSY,
                       "perf_event_open(..., 0) failed unexpectedly with error %d (%s)\n",
-                      err, strerror_r(err, sbuf, sizeof(sbuf))))
+                      err, str_error_r(err, sbuf, sizeof(sbuf))))
                 return -1;
 
         return 0;
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index 43e84aa27e4a..dbbf89b050a5 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -1,7 +1,11 @@
 #include <linux/kernel.h>
 #include "cache.h"
+#include "config.h"
+#include <stdlib.h>
+#include <stdio.h>
 #include "color.h"
 #include <math.h>
+#include <unistd.h>
 
 int perf_use_color_default = -1;
 
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index dad7d8272168..18dae745034f 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -26,6 +26,7 @@ static FILE *config_file;
 static const char *config_file_name;
 static int config_linenr;
 static int config_file_eof;
+static struct perf_config_set *config_set;
 
 const char *config_exclusive_filename;
 
@@ -275,7 +276,8 @@ static int perf_parse_file(config_fn_t fn, void *data)
                         break;
                 }
         }
-        die("bad config file line %d in %s", config_linenr, config_file_name);
+        pr_err("bad config file line %d in %s\n", config_linenr, config_file_name);
+        return -1;
 }
 
 static int parse_unit_factor(const char *end, unsigned long *val)
@@ -371,7 +373,7 @@ int perf_config_bool(const char *name, const char *value)
         return !!perf_config_bool_or_int(name, value, &discard);
 }
 
-const char *perf_config_dirname(const char *name, const char *value)
+static const char *perf_config_dirname(const char *name, const char *value)
 {
         if (!name)
                 return NULL;
@@ -477,54 +479,6 @@ static int perf_config_global(void)
         return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
 }
 
-int perf_config(config_fn_t fn, void *data)
-{
-        int ret = 0, found = 0;
-        const char *home = NULL;
-
-        /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
-        if (config_exclusive_filename)
-                return perf_config_from_file(fn, config_exclusive_filename, data);
-        if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
-                ret += perf_config_from_file(fn, perf_etc_perfconfig(),
-                                            data);
-                found += 1;
-        }
-
-        home = getenv("HOME");
-        if (perf_config_global() && home) {
-                char *user_config = strdup(mkpath("%s/.perfconfig", home));
-                struct stat st;
-
-                if (user_config == NULL) {
-                        warning("Not enough memory to process %s/.perfconfig, "
-                                "ignoring it.", home);
-                        goto out;
-                }
-
-                if (stat(user_config, &st) < 0)
-                        goto out_free;
-
-                if (st.st_uid && (st.st_uid != geteuid())) {
-                        warning("File %s not owned by current user or root, "
-                                "ignoring it.", user_config);
-                        goto out_free;
-                }
-
-                if (!st.st_size)
-                        goto out_free;
-
-                ret += perf_config_from_file(fn, user_config, data);
-                found += 1;
-out_free:
-                free(user_config);
-        }
-out:
-        if (found == 0)
-                return -1;
-        return ret;
-}
-
 static struct perf_config_section *find_section(struct list_head *sections,
                                                 const char *section_name)
 {
@@ -609,8 +563,12 @@ static int collect_config(const char *var, const char *value,
         struct perf_config_section *section = NULL;
         struct perf_config_item *item = NULL;
         struct perf_config_set *set = perf_config_set;
-        struct list_head *sections = &set->sections;
+        struct list_head *sections;
+
+        if (set == NULL)
+                return -1;
 
+        sections = &set->sections;
         key = ptr = strdup(var);
         if (!key) {
                 pr_debug("%s: strdup failed\n", __func__);
@@ -641,22 +599,115 @@ static int collect_config(const char *var, const char *value,
 
 out_free:
         free(key);
-        perf_config_set__delete(set);
         return -1;
 }
 
+static int perf_config_set__init(struct perf_config_set *set)
+{
+        int ret = -1;
+        const char *home = NULL;
+
+        /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
+        if (config_exclusive_filename)
+                return perf_config_from_file(collect_config, config_exclusive_filename, set);
+        if (perf_config_system() && !access(perf_etc_perfconfig(), R_OK)) {
+                if (perf_config_from_file(collect_config, perf_etc_perfconfig(), set) < 0)
+                        goto out;
+        }
+
+        home = getenv("HOME");
+        if (perf_config_global() && home) {
+                char *user_config = strdup(mkpath("%s/.perfconfig", home));
+                struct stat st;
+
+                if (user_config == NULL) {
+                        warning("Not enough memory to process %s/.perfconfig, "
+                                "ignoring it.", home);
+                        goto out;
+                }
+
+                if (stat(user_config, &st) < 0)
+                        goto out_free;
+
+                if (st.st_uid && (st.st_uid != geteuid())) {
+                        warning("File %s not owned by current user or root, "
+                                "ignoring it.", user_config);
+                        goto out_free;
+                }
+
+                if (!st.st_size)
+                        goto out_free;
+
+                ret = perf_config_from_file(collect_config, user_config, set);
+
+out_free:
+                free(user_config);
+        }
+out:
+        return ret;
+}
+
 struct perf_config_set *perf_config_set__new(void)
 {
         struct perf_config_set *set = zalloc(sizeof(*set));
 
         if (set) {
                 INIT_LIST_HEAD(&set->sections);
-                perf_config(collect_config, set);
+                if (perf_config_set__init(set) < 0) {
+                        perf_config_set__delete(set);
+                        set = NULL;
+                }
         }
 
         return set;
 }
 
+int perf_config(config_fn_t fn, void *data)
+{
+        int ret = 0;
+        char key[BUFSIZ];
+        struct perf_config_section *section;
+        struct perf_config_item *item;
+
+        if (config_set == NULL)
+                return -1;
+
+        perf_config_set__for_each_entry(config_set, section, item) {
+                char *value = item->value;
+
+                if (value) {
+                        scnprintf(key, sizeof(key), "%s.%s",
+                                  section->name, item->name);
+                        ret = fn(key, value, data);
+                        if (ret < 0) {
+                                pr_err("Error: wrong config key-value pair %s=%s\n",
+                                       key, value);
+                                break;
+                        }
+                }
+        }
+
+        return ret;
+}
+
+void perf_config__init(void)
+{
+        if (config_set == NULL)
+                config_set = perf_config_set__new();
+}
+
+void perf_config__exit(void)
+{
+        perf_config_set__delete(config_set);
+        config_set = NULL;
+}
+
+void perf_config__refresh(void)
+{
+        perf_config__exit();
+        perf_config__init();
+}
+
 static void perf_config_item__delete(struct perf_config_item *item)
 {
         zfree(&item->name);
@@ -693,6 +744,9 @@ static void perf_config_set__purge(struct perf_config_set *set)
 
 void perf_config_set__delete(struct perf_config_set *set)
 {
+        if (set == NULL)
+                return;
+
         perf_config_set__purge(set);
         free(set);
 }
diff --git a/tools/perf/util/config.h b/tools/perf/util/config.h
index 22ec626ac718..6f813d46045e 100644
--- a/tools/perf/util/config.h
+++ b/tools/perf/util/config.h
@@ -20,7 +20,47 @@ struct perf_config_set {
         struct list_head sections;
 };
 
+extern const char *config_exclusive_filename;
+
+typedef int (*config_fn_t)(const char *, const char *, void *);
+int perf_default_config(const char *, const char *, void *);
+int perf_config(config_fn_t fn, void *);
+int perf_config_int(const char *, const char *);
+u64 perf_config_u64(const char *, const char *);
+int perf_config_bool(const char *, const char *);
+int config_error_nonbool(const char *);
+const char *perf_etc_perfconfig(void);
+
 struct perf_config_set *perf_config_set__new(void);
 void perf_config_set__delete(struct perf_config_set *set);
+void perf_config__init(void);
+void perf_config__exit(void);
+void perf_config__refresh(void);
+
+/**
+ * perf_config_sections__for_each - iterate thru all the sections
+ * @list: list_head instance to iterate
+ * @section: struct perf_config_section iterator
+ */
+#define perf_config_sections__for_each_entry(list, section)     \
+        list_for_each_entry(section, list, node)
+
+/**
+ * perf_config_items__for_each - iterate thru all the items
+ * @list: list_head instance to iterate
+ * @item: struct perf_config_item iterator
+ */
+#define perf_config_items__for_each_entry(list, item)   \
+        list_for_each_entry(item, list, node)
+
+/**
+ * perf_config_set__for_each - iterate thru all the config section-item pairs
+ * @set: evlist instance to iterate
+ * @section: struct perf_config_section iterator
+ * @item: struct perf_config_item iterator
+ */
+#define perf_config_set__for_each_entry(set, section, item)                     \
+        perf_config_sections__for_each_entry(&set->sections, section)           \
+        perf_config_items__for_each_entry(&section->items, item)
 
 #endif /* __PERF_CONFIG_H */
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 02d801670f30..2c0b52264a46 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -236,13 +236,12 @@ struct cpu_map *cpu_map__new_data(struct cpu_map_data *data)
 
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp)
 {
-        int i;
-        size_t printed = fprintf(fp, "%d cpu%s: ",
-                                 map->nr, map->nr > 1 ? "s" : "");
-        for (i = 0; i < map->nr; ++i)
-                printed += fprintf(fp, "%s%d", i ? ", " : "", map->map[i]);
+#define BUFSIZE 1024
+        char buf[BUFSIZE];
 
-        return printed + fprintf(fp, "\n");
+        cpu_map__snprint(map, buf, sizeof(buf));
+        return fprintf(fp, "%s\n", buf);
+#undef BUFSIZE
 }
 
 struct cpu_map *cpu_map__dummy_new(void)
@@ -590,12 +589,65 @@ int cpu__setup_cpunode_map(void)
 
 bool cpu_map__has(struct cpu_map *cpus, int cpu)
 {
+        return cpu_map__idx(cpus, cpu) != -1;
+}
+
+int cpu_map__idx(struct cpu_map *cpus, int cpu)
+{
         int i;
 
         for (i = 0; i < cpus->nr; ++i) {
                 if (cpus->map[i] == cpu)
-                        return true;
+                        return i;
+        }
+
+        return -1;
+}
+
+int cpu_map__cpu(struct cpu_map *cpus, int idx)
+{
+        return cpus->map[idx];
+}
+
+size_t cpu_map__snprint(struct cpu_map *map, char *buf, size_t size)
+{
+        int i, cpu, start = -1;
+        bool first = true;
+        size_t ret = 0;
+
+#define COMMA first ? "" : ","
+
+        for (i = 0; i < map->nr + 1; i++) {
+                bool last = i == map->nr;
+
+                cpu = last ? INT_MAX : map->map[i];
+
+                if (start == -1) {
+                        start = i;
+                        if (last) {
+                                ret += snprintf(buf + ret, size - ret,
+                                                "%s%d", COMMA,
+                                                map->map[i]);
+                        }
+                } else if (((i - start) != (cpu - map->map[start])) || last) {
+                        int end = i - 1;
+
+                        if (start == end) {
+                                ret += snprintf(buf + ret, size - ret,
+                                                "%s%d", COMMA,
+                                                map->map[start]);
+                        } else {
+                                ret += snprintf(buf + ret, size - ret,
+                                                "%s%d-%d", COMMA,
+                                                map->map[start], map->map[end]);
+                        }
+                        first = false;
+                        start = i;
+                }
         }
 
-        return false;
+#undef COMMA
+
+        pr_debug("cpumask list: %s\n", buf);
+        return ret;
 }
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 1a0a35073ce1..06bd689f5989 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -19,6 +19,7 @@ struct cpu_map *cpu_map__empty_new(int nr);
 struct cpu_map *cpu_map__dummy_new(void);
 struct cpu_map *cpu_map__new_data(struct cpu_map_data *data);
 struct cpu_map *cpu_map__read(FILE *file);
+size_t cpu_map__snprint(struct cpu_map *map, char *buf, size_t size);
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
 int cpu_map__get_socket_id(int cpu);
 int cpu_map__get_socket(struct cpu_map *map, int idx, void *data);
@@ -67,5 +68,7 @@ int cpu_map__build_map(struct cpu_map *cpus, struct cpu_map **res,
                        int (*f)(struct cpu_map *map, int cpu, void *data),
                        void *data);
 
+int cpu_map__cpu(struct cpu_map *cpus, int idx);
 bool cpu_map__has(struct cpu_map *cpus, int cpu);
+int cpu_map__idx(struct cpu_map *cpus, int cpu);
 #endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h
new file mode 100644
index 000000000000..3cc6bc3263fe
--- /dev/null
+++ b/tools/perf/util/cs-etm.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright(C) 2015 Linaro Limited. All rights reserved.
+ * Author: Mathieu Poirier <mathieu.poirier@linaro.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * 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 General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDE__UTIL_PERF_CS_ETM_H__
+#define INCLUDE__UTIL_PERF_CS_ETM_H__
+
+/* Versionning header in case things need tro change in the future.  That way
+ * decoding of old snapshot is still possible.
+ */
+enum {
+        /* Starting with 0x0 */
+        CS_HEADER_VERSION_0,
+        /* PMU->type (32 bit), total # of CPUs (32 bit) */
+        CS_PMU_TYPE_CPUS,
+        CS_ETM_SNAPSHOT,
+        CS_HEADER_VERSION_0_MAX,
+};
+
+/* Beginning of header common to both ETMv3 and V4 */
+enum {
+        CS_ETM_MAGIC,
+        CS_ETM_CPU,
+};
+
+/* ETMv3/PTM metadata */
+enum {
+        /* Dynamic, configurable parameters */
+        CS_ETM_ETMCR = CS_ETM_CPU + 1,
+        CS_ETM_ETMTRACEIDR,
+        /* RO, taken from sysFS */
+        CS_ETM_ETMCCER,
+        CS_ETM_ETMIDR,
+        CS_ETM_PRIV_MAX,
+};
+
+/* ETMv4 metadata */
+enum {
+        /* Dynamic, configurable parameters */
+        CS_ETMV4_TRCCONFIGR = CS_ETM_CPU + 1,
+        CS_ETMV4_TRCTRACEIDR,
+        /* RO, taken from sysFS */
+        CS_ETMV4_TRCIDR0,
+        CS_ETMV4_TRCIDR1,
+        CS_ETMV4_TRCIDR2,
+        CS_ETMV4_TRCIDR8,
+        CS_ETMV4_TRCAUTHSTATUS,
+        CS_ETMV4_PRIV_MAX,
+};
+
+#define KiB(x) ((x) * 1024)
+#define MiB(x) ((x) * 1024 * 1024)
+
+#define CS_ETM_HEADER_SIZE (CS_HEADER_VERSION_0_MAX * sizeof(u64))
+
+static const u64 __perf_cs_etmv3_magic   = 0x3030303030303030ULL;
+static const u64 __perf_cs_etmv4_magic   = 0x4040404040404040ULL;
+#define CS_ETMV3_PRIV_SIZE (CS_ETM_PRIV_MAX * sizeof(u64))
+#define CS_ETMV4_PRIV_SIZE (CS_ETMV4_PRIV_MAX * sizeof(u64))
+
+#endif
diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-convert-bt.c
index bbf69d248ec5..7123f4de32cc 100644
--- a/tools/perf/util/data-convert-bt.c
+++ b/tools/perf/util/data-convert-bt.c
@@ -26,6 +26,7 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "machine.h"
+#include "config.h"
 
 #define pr_N(n, fmt, ...) \
         eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
@@ -68,6 +69,9 @@ struct ctf_writer {
                 };
                 struct bt_ctf_field_type *array[6];
         } data;
+        struct bt_ctf_event_class       *comm_class;
+        struct bt_ctf_event_class       *exit_class;
+        struct bt_ctf_event_class       *fork_class;
 };
 
 struct convert {
@@ -76,6 +80,7 @@ struct convert {
 
         u64                     events_size;
         u64                     events_count;
+        u64                     non_sample_count;
 
         /* Ordered events configured queue size. */
         u64                     queue_size;
@@ -140,6 +145,36 @@ FUNC_VALUE_SET(s64)
 FUNC_VALUE_SET(u64)
 __FUNC_VALUE_SET(u64_hex, u64)
 
+static int string_set_value(struct bt_ctf_field *field, const char *string);
+static __maybe_unused int
+value_set_string(struct ctf_writer *cw, struct bt_ctf_event *event,
+                 const char *name, const char *string)
+{
+        struct bt_ctf_field_type *type = cw->data.string;
+        struct bt_ctf_field *field;
+        int ret = 0;
+
+        field = bt_ctf_field_create(type);
+        if (!field) {
+                pr_err("failed to create a field %s\n", name);
+                return -1;
+        }
+
+        ret = string_set_value(field, string);
+        if (ret) {
+                pr_err("failed to set value %s\n", name);
+                goto err_put_field;
+        }
+
+        ret = bt_ctf_event_set_payload(event, name, field);
+        if (ret)
+                pr_err("failed to set payload %s\n", name);
+
+err_put_field:
+        bt_ctf_field_put(field);
+        return ret;
+}
+
 static struct bt_ctf_field_type*
 get_tracepoint_field_type(struct ctf_writer *cw, struct format_field *field)
 {
@@ -204,6 +239,44 @@ static unsigned long long adjust_signedness(unsigned long long value_int, int si
         return (value_int & value_mask) | ~value_mask;
 }
 
+static int string_set_value(struct bt_ctf_field *field, const char *string)
+{
+        char *buffer = NULL;
+        size_t len = strlen(string), i, p;
+        int err;
+
+        for (i = p = 0; i < len; i++, p++) {
+                if (isprint(string[i])) {
+                        if (!buffer)
+                                continue;
+                        buffer[p] = string[i];
+                } else {
+                        char numstr[5];
+
+                        snprintf(numstr, sizeof(numstr), "\\x%02x",
+                                 (unsigned int)(string[i]) & 0xff);
+
+                        if (!buffer) {
+                                buffer = zalloc(i + (len - i) * 4 + 2);
+                                if (!buffer) {
+                                        pr_err("failed to set unprintable string '%s'\n", string);
+                                        return bt_ctf_field_string_set_value(field, "UNPRINTABLE-STRING");
+                                }
+                                if (i > 0)
+                                        strncpy(buffer, string, i);
+                        }
+                        strncat(buffer + p, numstr, 4);
+                        p += 3;
+                }
+        }
+
+        if (!buffer)
+                return bt_ctf_field_string_set_value(field, string);
+        err = bt_ctf_field_string_set_value(field, buffer);
+        free(buffer);
+        return err;
+}
+
 static int add_tracepoint_field_value(struct ctf_writer *cw,
                                       struct bt_ctf_event_class *event_class,
                                       struct bt_ctf_event *event,
@@ -270,8 +343,7 @@ static int add_tracepoint_field_value(struct ctf_writer *cw,
                 }
 
                 if (flags & FIELD_IS_STRING)
-                        ret = bt_ctf_field_string_set_value(field,
-                                        data + offset + i * len);
+                        ret = string_set_value(field, data + offset + i * len);
                 else {
                         unsigned long long value_int;
 
@@ -365,7 +437,7 @@ add_bpf_output_values(struct bt_ctf_event_class *event_class,
         int ret;
 
         if (nr_elements * sizeof(u32) != raw_size)
-                pr_warning("Incorrect raw_size (%u) in bpf output event, skip %lu bytes\n",
+                pr_warning("Incorrect raw_size (%u) in bpf output event, skip %zu bytes\n",
                            raw_size, nr_elements * sizeof(u32) - raw_size);
 
         len_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_len");
@@ -694,6 +766,72 @@ static int process_sample_event(struct perf_tool *tool,
         return cs ? 0 : -1;
 }
 
+#define __NON_SAMPLE_SET_FIELD(_name, _type, _field)    \
+do {                                                    \
+        ret = value_set_##_type(cw, event, #_field, _event->_name._field);\
+        if (ret)                                        \
+                return -1;                              \
+} while(0)
+
+#define __FUNC_PROCESS_NON_SAMPLE(_name, body)  \
+static int process_##_name##_event(struct perf_tool *tool,      \
+                                   union perf_event *_event,    \
+                                   struct perf_sample *sample,  \
+                                   struct machine *machine)     \
+{                                                               \
+        struct convert *c = container_of(tool, struct convert, tool);\
+        struct ctf_writer *cw = &c->writer;                     \
+        struct bt_ctf_event_class *event_class = cw->_name##_class;\
+        struct bt_ctf_event *event;                             \
+        struct ctf_stream *cs;                                  \
+        int ret;                                                \
+                                                                \
+        c->non_sample_count++;                                  \
+        c->events_size += _event->header.size;                  \
+        event = bt_ctf_event_create(event_class);               \
+        if (!event) {                                           \
+                pr_err("Failed to create an CTF event\n");      \
+                return -1;                                      \
+        }                                                       \
+                                                                \
+        bt_ctf_clock_set_time(cw->clock, sample->time);         \
+        body                                                    \
+        cs = ctf_stream(cw, 0);                                 \
+        if (cs) {                                               \
+                if (is_flush_needed(cs))                        \
+                        ctf_stream__flush(cs);                  \
+                                                                \
+                cs->count++;                                    \
+                bt_ctf_stream_append_event(cs->stream, event);  \
+        }                                                       \
+        bt_ctf_event_put(event);                                \
+                                                                \
+        return perf_event__process_##_name(tool, _event, sample, machine);\
+}
+
+__FUNC_PROCESS_NON_SAMPLE(comm,
+        __NON_SAMPLE_SET_FIELD(comm, u32, pid);
+        __NON_SAMPLE_SET_FIELD(comm, u32, tid);
+        __NON_SAMPLE_SET_FIELD(comm, string, comm);
+)
+__FUNC_PROCESS_NON_SAMPLE(fork,
+        __NON_SAMPLE_SET_FIELD(fork, u32, pid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, tid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
+        __NON_SAMPLE_SET_FIELD(fork, u64, time);
+)
+
+__FUNC_PROCESS_NON_SAMPLE(exit,
+        __NON_SAMPLE_SET_FIELD(fork, u32, pid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, ppid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, tid);
+        __NON_SAMPLE_SET_FIELD(fork, u32, ptid);
+        __NON_SAMPLE_SET_FIELD(fork, u64, time);
+)
+#undef __NON_SAMPLE_SET_FIELD
+#undef __FUNC_PROCESS_NON_SAMPLE
+
 /* If dup < 0, add a prefix. Else, add _dupl_X suffix. */
 static char *change_name(char *name, char *orig_name, int dup)
 {
@@ -960,7 +1098,7 @@ static int setup_events(struct ctf_writer *cw, struct perf_session *session)
         struct perf_evsel *evsel;
         int ret;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 ret = add_event(cw, evsel);
                 if (ret)
                         return ret;
@@ -968,12 +1106,86 @@ static int setup_events(struct ctf_writer *cw, struct perf_session *session)
         return 0;
 }
 
+#define __NON_SAMPLE_ADD_FIELD(t, n)                                            \
+        do {                                                    \
+                pr2("  field '%s'\n", #n);                      \
+                if (bt_ctf_event_class_add_field(event_class, cw->data.t, #n)) {\
+                        pr_err("Failed to add field '%s';\n", #n);\
+                        return -1;                              \
+                }                                               \
+        } while(0)
+
+#define __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(_name, body)          \
+static int add_##_name##_event(struct ctf_writer *cw)           \
+{                                                               \
+        struct bt_ctf_event_class *event_class;                 \
+        int ret;                                                \
+                                                                \
+        pr("Adding "#_name" event\n");                          \
+        event_class = bt_ctf_event_class_create("perf_" #_name);\
+        if (!event_class)                                       \
+                return -1;                                      \
+        body                                                    \
+                                                                \
+        ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);\
+        if (ret) {                                              \
+                pr("Failed to add event class '"#_name"' into stream.\n");\
+                return ret;                                     \
+        }                                                       \
+                                                                \
+        cw->_name##_class = event_class;                        \
+        bt_ctf_event_class_put(event_class);                    \
+        return 0;                                               \
+}
+
+__FUNC_ADD_NON_SAMPLE_EVENT_CLASS(comm,
+        __NON_SAMPLE_ADD_FIELD(u32, pid);
+        __NON_SAMPLE_ADD_FIELD(u32, tid);
+        __NON_SAMPLE_ADD_FIELD(string, comm);
+)
+
+__FUNC_ADD_NON_SAMPLE_EVENT_CLASS(fork,
+        __NON_SAMPLE_ADD_FIELD(u32, pid);
+        __NON_SAMPLE_ADD_FIELD(u32, ppid);
+        __NON_SAMPLE_ADD_FIELD(u32, tid);
+        __NON_SAMPLE_ADD_FIELD(u32, ptid);
+        __NON_SAMPLE_ADD_FIELD(u64, time);
+)
+
+__FUNC_ADD_NON_SAMPLE_EVENT_CLASS(exit,
+        __NON_SAMPLE_ADD_FIELD(u32, pid);
+        __NON_SAMPLE_ADD_FIELD(u32, ppid);
+        __NON_SAMPLE_ADD_FIELD(u32, tid);
+        __NON_SAMPLE_ADD_FIELD(u32, ptid);
+        __NON_SAMPLE_ADD_FIELD(u64, time);
+)
+
+#undef __NON_SAMPLE_ADD_FIELD
+#undef __FUNC_ADD_NON_SAMPLE_EVENT_CLASS
+
+static int setup_non_sample_events(struct ctf_writer *cw,
+                                   struct perf_session *session __maybe_unused)
+{
+        int ret;
+
+        ret = add_comm_event(cw);
+        if (ret)
+                return ret;
+        ret = add_exit_event(cw);
+        if (ret)
+                return ret;
+        ret = add_fork_event(cw);
+        if (ret)
+                return ret;
+        return 0;
+}
+
 static void cleanup_events(struct perf_session *session)
 {
         struct perf_evlist *evlist = session->evlist;
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 struct evsel_priv *priv;
 
                 priv = evsel->priv;
@@ -1236,13 +1448,14 @@ static int convert__config(const char *var, const char *value, void *cb)
         return 0;
 }
 
-int bt_convert__perf2ctf(const char *input, const char *path, bool force)
+int bt_convert__perf2ctf(const char *input, const char *path,
+                         struct perf_data_convert_opts *opts)
 {
         struct perf_session *session;
         struct perf_data_file file = {
                 .path = input,
                 .mode = PERF_DATA_MODE_READ,
-                .force = force,
+                .force = opts->force,
         };
         struct convert c = {
                 .tool = {
@@ -1262,6 +1475,12 @@ int bt_convert__perf2ctf(const char *input, const char *path, bool force)
         struct ctf_writer *cw = &c.writer;
         int err = -1;
 
+        if (opts->all) {
+                c.tool.comm = process_comm_event;
+                c.tool.exit = process_exit_event;
+                c.tool.fork = process_fork_event;
+        }
+
         perf_config(convert__config, &c);
 
         /* CTF writer */
@@ -1286,6 +1505,9 @@ int bt_convert__perf2ctf(const char *input, const char *path, bool force)
         if (setup_events(cw, session))
                 goto free_session;
 
+        if (opts->all && setup_non_sample_events(cw, session))
+                goto free_session;
+
         if (setup_streams(cw, session))
                 goto free_session;
 
@@ -1300,10 +1522,15 @@ int bt_convert__perf2ctf(const char *input, const char *path, bool force)
                 file.path, path);
 
         fprintf(stderr,
-                "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples) ]\n",
+                "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples",
                 (double) c.events_size / 1024.0 / 1024.0,
                 c.events_count);
 
+        if (!c.non_sample_count)
+                fprintf(stderr, ") ]\n");
+        else
+                fprintf(stderr, ", %" PRIu64 " non-samples) ]\n", c.non_sample_count);
+
         cleanup_events(session);
         perf_session__delete(session);
         ctf_writer__cleanup(cw);
diff --git a/tools/perf/util/data-convert-bt.h b/tools/perf/util/data-convert-bt.h
index 4c204342a9d8..9a3b587f76c1 100644
--- a/tools/perf/util/data-convert-bt.h
+++ b/tools/perf/util/data-convert-bt.h
@@ -1,8 +1,10 @@
 #ifndef __DATA_CONVERT_BT_H
 #define __DATA_CONVERT_BT_H
+#include "data-convert.h"
 #ifdef HAVE_LIBBABELTRACE_SUPPORT
 
-int bt_convert__perf2ctf(const char *input_name, const char *to_ctf, bool force);
+int bt_convert__perf2ctf(const char *input_name, const char *to_ctf,
+                         struct perf_data_convert_opts *opts);
 
 #endif /* HAVE_LIBBABELTRACE_SUPPORT */
 #endif /* __DATA_CONVERT_BT_H */
diff --git a/tools/perf/util/data-convert.h b/tools/perf/util/data-convert.h
new file mode 100644
index 000000000000..5314962fe95b
--- /dev/null
+++ b/tools/perf/util/data-convert.h
@@ -0,0 +1,9 @@
+#ifndef __DATA_CONVERT_H
+#define __DATA_CONVERT_H
+
+struct perf_data_convert_opts {
+        bool force;
+        bool all;
+};
+
+#endif /* __DATA_CONVERT_H */
diff --git a/tools/perf/util/data.c b/tools/perf/util/data.c
index be83516155ee..60bfc9ca1e22 100644
--- a/tools/perf/util/data.c
+++ b/tools/perf/util/data.c
@@ -57,7 +57,7 @@ static int open_file_read(struct perf_data_file *file)
                 int err = errno;
 
                 pr_err("failed to open %s: %s", file->path,
-                        strerror_r(err, sbuf, sizeof(sbuf)));
+                        str_error_r(err, sbuf, sizeof(sbuf)));
                 if (err == ENOENT && !strcmp(file->path, "perf.data"))
                         pr_err("  (try 'perf record' first)");
                 pr_err("\n");
@@ -99,7 +99,7 @@ static int open_file_write(struct perf_data_file *file)
 
         if (fd < 0)
                 pr_err("failed to open %s : %s\n", file->path,
-                        strerror_r(errno, sbuf, sizeof(sbuf)));
+                        str_error_r(errno, sbuf, sizeof(sbuf)));
 
         return fd;
 }
diff --git a/tools/perf/util/db-export.c b/tools/perf/util/db-export.c
index c9a6dc173e74..b0c2b5c5d337 100644
--- a/tools/perf/util/db-export.c
+++ b/tools/perf/util/db-export.c
@@ -233,17 +233,6 @@ int db_export__symbol(struct db_export *dbe, struct symbol *sym,
         return 0;
 }
 
-static struct thread *get_main_thread(struct machine *machine, struct thread *thread)
-{
-        if (thread->pid_ == thread->tid)
-                return thread__get(thread);
-
-        if (thread->pid_ == -1)
-                return NULL;
-
-        return machine__find_thread(machine, thread->pid_, thread->pid_);
-}
-
 static int db_ids_from_al(struct db_export *dbe, struct addr_location *al,
                           u64 *dso_db_id, u64 *sym_db_id, u64 *offset)
 {
@@ -382,7 +371,7 @@ int db_export__sample(struct db_export *dbe, union perf_event *event,
         if (err)
                 return err;
 
-        main_thread = get_main_thread(al->machine, thread);
+        main_thread = thread__main_thread(al->machine, thread);
         if (main_thread)
                 comm = machine__thread_exec_comm(al->machine, main_thread);
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 8c4212abd19b..c1838b643108 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -6,6 +6,7 @@
 #include <stdarg.h>
 #include <stdio.h>
 #include <api/debug.h>
+#include <linux/time64.h>
 
 #include "cache.h"
 #include "color.h"
@@ -14,9 +15,6 @@
 #include "util.h"
 #include "target.h"
 
-#define NSECS_PER_SEC  1000000000ULL
-#define NSECS_PER_USEC 1000ULL
-
 int verbose;
 bool dump_trace = false, quiet = false;
 int debug_ordered_events;
@@ -54,9 +52,9 @@ static int veprintf_time(u64 t, const char *fmt, va_list args)
         int ret = 0;
         u64 secs, usecs, nsecs = t;
 
-        secs   = nsecs / NSECS_PER_SEC;
-        nsecs -= secs  * NSECS_PER_SEC;
-        usecs  = nsecs / NSECS_PER_USEC;
+        secs   = nsecs / NSEC_PER_SEC;
+        nsecs -= secs  * NSEC_PER_SEC;
+        usecs  = nsecs / NSEC_PER_USEC;
 
         ret = fprintf(stderr, "[%13" PRIu64 ".%06" PRIu64 "] ",
                       secs, usecs);
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 14bafda79eda..d242adc3d5a2 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -38,7 +38,7 @@ extern int debug_data_convert;
 #define pr_oe_time(t, fmt, ...)  pr_time_N(1, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_oe_time2(t, fmt, ...) pr_time_N(2, debug_ordered_events, t, pr_fmt(fmt), ##__VA_ARGS__)
 
-#define STRERR_BUFSIZE  128     /* For the buffer size of strerror_r */
+#define STRERR_BUFSIZE  128     /* For the buffer size of str_error_r */
 
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(union perf_event *event);
diff --git a/tools/perf/util/demangle-rust.c b/tools/perf/util/demangle-rust.c
new file mode 100644
index 000000000000..f9dafa888c06
--- /dev/null
+++ b/tools/perf/util/demangle-rust.c
@@ -0,0 +1,269 @@
+#include <string.h>
+#include "util.h"
+#include "debug.h"
+
+#include "demangle-rust.h"
+
+/*
+ * Mangled Rust symbols look like this:
+ *
+ *     _$LT$std..sys..fd..FileDesc$u20$as$u20$core..ops..Drop$GT$::drop::hc68340e1baa4987a
+ *
+ * The original symbol is:
+ *
+ *     <std::sys::fd::FileDesc as core::ops::Drop>::drop
+ *
+ * The last component of the path is a 64-bit hash in lowercase hex, prefixed
+ * with "h". Rust does not have a global namespace between crates, an illusion
+ * which Rust maintains by using the hash to distinguish things that would
+ * otherwise have the same symbol.
+ *
+ * Any path component not starting with a XID_Start character is prefixed with
+ * "_".
+ *
+ * The following escape sequences are used:
+ *
+ *     ","  =>  $C$
+ *     "@"  =>  $SP$
+ *     "*"  =>  $BP$
+ *     "&"  =>  $RF$
+ *     "<"  =>  $LT$
+ *     ">"  =>  $GT$
+ *     "("  =>  $LP$
+ *     ")"  =>  $RP$
+ *     " "  =>  $u20$
+ *     "'"  =>  $u27$
+ *     "["  =>  $u5b$
+ *     "]"  =>  $u5d$
+ *     "~"  =>  $u7e$
+ *
+ * A double ".." means "::" and a single "." means "-".
+ *
+ * The only characters allowed in the mangled symbol are a-zA-Z0-9 and _.:$
+ */
+
+static const char *hash_prefix = "::h";
+static const size_t hash_prefix_len = 3;
+static const size_t hash_len = 16;
+
+static bool is_prefixed_hash(const char *start);
+static bool looks_like_rust(const char *sym, size_t len);
+static bool unescape(const char **in, char **out, const char *seq, char value);
+
+/*
+ * INPUT:
+ *     sym: symbol that has been through BFD-demangling
+ *
+ * This function looks for the following indicators:
+ *
+ *  1. The hash must consist of "h" followed by 16 lowercase hex digits.
+ *
+ *  2. As a sanity check, the hash must use between 5 and 15 of the 16 possible
+ *     hex digits. This is true of 99.9998% of hashes so once in your life you
+ *     may see a false negative. The point is to notice path components that
+ *     could be Rust hashes but are probably not, like "haaaaaaaaaaaaaaaa". In
+ *     this case a false positive (non-Rust symbol has an important path
+ *     component removed because it looks like a Rust hash) is worse than a
+ *     false negative (the rare Rust symbol is not demangled) so this sets the
+ *     balance in favor of false negatives.
+ *
+ *  3. There must be no characters other than a-zA-Z0-9 and _.:$
+ *
+ *  4. There must be no unrecognized $-sign sequences.
+ *
+ *  5. There must be no sequence of three or more dots in a row ("...").
+ */
+bool
+rust_is_mangled(const char *sym)
+{
+        size_t len, len_without_hash;
+
+        if (!sym)
+                return false;
+
+        len = strlen(sym);
+        if (len <= hash_prefix_len + hash_len)
+                /* Not long enough to contain "::h" + hash + something else */
+                return false;
+
+        len_without_hash = len - (hash_prefix_len + hash_len);
+        if (!is_prefixed_hash(sym + len_without_hash))
+                return false;
+
+        return looks_like_rust(sym, len_without_hash);
+}
+
+/*
+ * A hash is the prefix "::h" followed by 16 lowercase hex digits. The hex
+ * digits must comprise between 5 and 15 (inclusive) distinct digits.
+ */
+static bool is_prefixed_hash(const char *str)
+{
+        const char *end;
+        bool seen[16];
+        size_t i;
+        int count;
+
+        if (strncmp(str, hash_prefix, hash_prefix_len))
+                return false;
+        str += hash_prefix_len;
+
+        memset(seen, false, sizeof(seen));
+        for (end = str + hash_len; str < end; str++)
+                if (*str >= '0' && *str <= '9')
+                        seen[*str - '0'] = true;
+                else if (*str >= 'a' && *str <= 'f')
+                        seen[*str - 'a' + 10] = true;
+                else
+                        return false;
+
+        /* Count how many distinct digits seen */
+        count = 0;
+        for (i = 0; i < 16; i++)
+                if (seen[i])
+                        count++;
+
+        return count >= 5 && count <= 15;
+}
+
+static bool looks_like_rust(const char *str, size_t len)
+{
+        const char *end = str + len;
+
+        while (str < end)
+                switch (*str) {
+                case '$':
+                        if (!strncmp(str, "$C$", 3))
+                                str += 3;
+                        else if (!strncmp(str, "$SP$", 4)
+                                        || !strncmp(str, "$BP$", 4)
+                                        || !strncmp(str, "$RF$", 4)
+                                        || !strncmp(str, "$LT$", 4)
+                                        || !strncmp(str, "$GT$", 4)
+                                        || !strncmp(str, "$LP$", 4)
+                                        || !strncmp(str, "$RP$", 4))
+                                str += 4;
+                        else if (!strncmp(str, "$u20$", 5)
+                                        || !strncmp(str, "$u27$", 5)
+                                        || !strncmp(str, "$u5b$", 5)
+                                        || !strncmp(str, "$u5d$", 5)
+                                        || !strncmp(str, "$u7e$", 5))
+                                str += 5;
+                        else
+                                return false;
+                        break;
+                case '.':
+                        /* Do not allow three or more consecutive dots */
+                        if (!strncmp(str, "...", 3))
+                                return false;
+                        /* Fall through */
+                case 'a' ... 'z':
+                case 'A' ... 'Z':
+                case '0' ... '9':
+                case '_':
+                case ':':
+                        str++;
+                        break;
+                default:
+                        return false;
+                }
+
+        return true;
+}
+
+/*
+ * INPUT:
+ *     sym: symbol for which rust_is_mangled(sym) returns true
+ *
+ * The input is demangled in-place because the mangled name is always longer
+ * than the demangled one.
+ */
+void
+rust_demangle_sym(char *sym)
+{
+        const char *in;
+        char *out;
+        const char *end;
+
+        if (!sym)
+                return;
+
+        in = sym;
+        out = sym;
+        end = sym + strlen(sym) - (hash_prefix_len + hash_len);
+
+        while (in < end)
+                switch (*in) {
+                case '$':
+                        if (!(unescape(&in, &out, "$C$", ',')
+                                        || unescape(&in, &out, "$SP$", '@')
+                                        || unescape(&in, &out, "$BP$", '*')
+                                        || unescape(&in, &out, "$RF$", '&')
+                                        || unescape(&in, &out, "$LT$", '<')
+                                        || unescape(&in, &out, "$GT$", '>')
+                                        || unescape(&in, &out, "$LP$", '(')
+                                        || unescape(&in, &out, "$RP$", ')')
+                                        || unescape(&in, &out, "$u20$", ' ')
+                                        || unescape(&in, &out, "$u27$", '\'')
+                                        || unescape(&in, &out, "$u5b$", '[')
+                                        || unescape(&in, &out, "$u5d$", ']')
+                                        || unescape(&in, &out, "$u7e$", '~'))) {
+                                pr_err("demangle-rust: unexpected escape sequence");
+                                goto done;
+                        }
+                        break;
+                case '_':
+                        /*
+                         * If this is the start of a path component and the next
+                         * character is an escape sequence, ignore the
+                         * underscore. The mangler inserts an underscore to make
+                         * sure the path component begins with a XID_Start
+                         * character.
+                         */
+                        if ((in == sym || in[-1] == ':') && in[1] == '$')
+                                in++;
+                        else
+                                *out++ = *in++;
+                        break;
+                case '.':
+                        if (in[1] == '.') {
+                                /* ".." becomes "::" */
+                                *out++ = ':';
+                                *out++ = ':';
+                                in += 2;
+                        } else {
+                                /* "." becomes "-" */
+                                *out++ = '-';
+                                in++;
+                        }
+                        break;
+                case 'a' ... 'z':
+                case 'A' ... 'Z':
+                case '0' ... '9':
+                case ':':
+                        *out++ = *in++;
+                        break;
+                default:
+                        pr_err("demangle-rust: unexpected character '%c' in symbol\n",
+                                *in);
+                        goto done;
+                }
+
+done:
+        *out = '\0';
+}
+
+static bool unescape(const char **in, char **out, const char *seq, char value)
+{
+        size_t len = strlen(seq);
+
+        if (strncmp(*in, seq, len))
+                return false;
+
+        **out = value;
+
+        *in += len;
+        *out += 1;
+
+        return true;
+}
diff --git a/tools/perf/util/demangle-rust.h b/tools/perf/util/demangle-rust.h
new file mode 100644
index 000000000000..7b41ead7e0dd
--- /dev/null
+++ b/tools/perf/util/demangle-rust.h
@@ -0,0 +1,7 @@
+#ifndef __PERF_DEMANGLE_RUST
+#define __PERF_DEMANGLE_RUST 1
+
+bool rust_is_mangled(const char *str);
+void rust_demangle_sym(char *str);
+
+#endif /* __PERF_DEMANGLE_RUST */
diff --git a/tools/perf/util/drv_configs.c b/tools/perf/util/drv_configs.c
new file mode 100644
index 000000000000..1647f285c629
--- /dev/null
+++ b/tools/perf/util/drv_configs.c
@@ -0,0 +1,77 @@
+/*
+ * drv_configs.h: Interface to apply PMU specific configuration
+ * Copyright (c) 2016-2018, Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ */
+
+#include "drv_configs.h"
+#include "evlist.h"
+#include "evsel.h"
+#include "pmu.h"
+
+static int
+perf_evsel__apply_drv_configs(struct perf_evsel *evsel,
+                              struct perf_evsel_config_term **err_term)
+{
+        bool found = false;
+        int err = 0;
+        struct perf_evsel_config_term *term;
+        struct perf_pmu *pmu = NULL;
+
+        while ((pmu = perf_pmu__scan(pmu)) != NULL)
+                if (pmu->type == evsel->attr.type) {
+                        found = true;
+                        break;
+                }
+
+        list_for_each_entry(term, &evsel->config_terms, list) {
+                if (term->type != PERF_EVSEL__CONFIG_TERM_DRV_CFG)
+                        continue;
+
+                /*
+                 * We have a configuration term, report an error if we
+                 * can't find the PMU or if the PMU driver doesn't support
+                 * cmd line driver configuration.
+                 */
+                if (!found || !pmu->set_drv_config) {
+                        err = -EINVAL;
+                        *err_term = term;
+                        break;
+                }
+
+                err = pmu->set_drv_config(term);
+                if (err) {
+                        *err_term = term;
+                        break;
+                }
+        }
+
+        return err;
+}
+
+int perf_evlist__apply_drv_configs(struct perf_evlist *evlist,
+                                   struct perf_evsel **err_evsel,
+                                   struct perf_evsel_config_term **err_term)
+{
+        struct perf_evsel *evsel;
+        int err = 0;
+
+        evlist__for_each_entry(evlist, evsel) {
+                err = perf_evsel__apply_drv_configs(evsel, err_term);
+                if (err) {
+                        *err_evsel = evsel;
+                        break;
+                }
+        }
+
+        return err;
+}
diff --git a/tools/perf/util/drv_configs.h b/tools/perf/util/drv_configs.h
new file mode 100644
index 000000000000..32bc9babc2e0
--- /dev/null
+++ b/tools/perf/util/drv_configs.h
@@ -0,0 +1,26 @@
+/*
+ * drv_configs.h: Interface to apply PMU specific configuration
+ * Copyright (c) 2016-2018, Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ */
+
+#ifndef __PERF_DRV_CONFIGS_H
+#define __PERF_DRV_CONFIGS_H
+
+#include "drv_configs.h"
+#include "evlist.h"
+#include "evsel.h"
+
+int perf_evlist__apply_drv_configs(struct perf_evlist *evlist,
+                                   struct perf_evsel **err_evsel,
+                                   struct perf_evsel_config_term **term);
+#endif
diff --git a/tools/perf/util/dso.c b/tools/perf/util/dso.c
index 5d286f5d7906..d2c6cdd9d42b 100644
--- a/tools/perf/util/dso.c
+++ b/tools/perf/util/dso.c
@@ -335,7 +335,7 @@ static int do_open(char *name)
                         return fd;
 
                 pr_debug("dso open failed: %s\n",
-                         strerror_r(errno, sbuf, sizeof(sbuf)));
+                         str_error_r(errno, sbuf, sizeof(sbuf)));
                 if (!dso__data_open_cnt || errno != EMFILE)
                         break;
 
@@ -363,6 +363,9 @@ static int __open_dso(struct dso *dso, struct machine *machine)
                 return -EINVAL;
         }
 
+        if (!is_regular_file(name))
+                return -EINVAL;
+
         fd = do_open(name);
         free(name);
         return fd;
@@ -442,17 +445,27 @@ static rlim_t get_fd_limit(void)
         return limit;
 }
 
-static bool may_cache_fd(void)
+static rlim_t fd_limit;
+
+/*
+ * Used only by tests/dso-data.c to reset the environment
+ * for tests. I dont expect we should change this during
+ * standard runtime.
+ */
+void reset_fd_limit(void)
 {
-        static rlim_t limit;
+        fd_limit = 0;
+}
 
-        if (!limit)
-                limit = get_fd_limit();
+static bool may_cache_fd(void)
+{
+        if (!fd_limit)
+                fd_limit = get_fd_limit();
 
-        if (limit == RLIM_INFINITY)
+        if (fd_limit == RLIM_INFINITY)
                 return true;
 
-        return limit > (rlim_t) dso__data_open_cnt;
+        return fd_limit > (rlim_t) dso__data_open_cnt;
 }
 
 /*
@@ -776,7 +789,7 @@ static int data_file_size(struct dso *dso, struct machine *machine)
         if (fstat(dso->data.fd, &st) < 0) {
                 ret = -errno;
                 pr_err("dso cache fstat failed: %s\n",
-                       strerror_r(errno, sbuf, sizeof(sbuf)));
+                       str_error_r(errno, sbuf, sizeof(sbuf)));
                 dso->data.status = DSO_DATA_STATUS_ERROR;
                 goto out;
         }
@@ -1356,7 +1369,7 @@ int dso__strerror_load(struct dso *dso, char *buf, size_t buflen)
         BUG_ON(buflen == 0);
 
         if (errnum >= 0) {
-                const char *err = strerror_r(errnum, buf, buflen);
+                const char *err = str_error_r(errnum, buf, buflen);
 
                 if (err != buf)
                         scnprintf(buf, buflen, "%s", err);
diff --git a/tools/perf/util/dso.h b/tools/perf/util/dso.h
index 0953280629cf..ecc4bbd3f82e 100644
--- a/tools/perf/util/dso.h
+++ b/tools/perf/util/dso.h
@@ -4,6 +4,7 @@
 #include <linux/atomic.h>
 #include <linux/types.h>
 #include <linux/rbtree.h>
+#include <sys/types.h>
 #include <stdbool.h>
 #include <pthread.h>
 #include <linux/types.h>
@@ -349,10 +350,17 @@ static inline bool dso__is_kcore(struct dso *dso)
                dso->binary_type == DSO_BINARY_TYPE__GUEST_KCORE;
 }
 
+static inline bool dso__is_kallsyms(struct dso *dso)
+{
+        return dso->kernel && dso->long_name[0] != '/';
+}
+
 void dso__free_a2l(struct dso *dso);
 
 enum dso_type dso__type(struct dso *dso, struct machine *machine);
 
 int dso__strerror_load(struct dso *dso, char *buf, size_t buflen);
 
+void reset_fd_limit(void);
+
 #endif /* __PERF_DSO */
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index a347b19c961a..41e068e94349 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -130,6 +130,22 @@ int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
 }
 
 /**
+ * die_get_linkage_name - Get the linkage name of the object
+ * @dw_die: A DIE of the object
+ *
+ * Get the linkage name attiribute of given @dw_die.
+ * For C++ binary, the linkage name will be the mangled symbol.
+ */
+const char *die_get_linkage_name(Dwarf_Die *dw_die)
+{
+        Dwarf_Attribute attr;
+
+        if (dwarf_attr_integrate(dw_die, DW_AT_linkage_name, &attr) == NULL)
+                return NULL;
+        return dwarf_formstring(&attr);
+}
+
+/**
  * die_compare_name - Compare diename and tname
  * @dw_die: a DIE
  * @tname: a string of target name
@@ -145,18 +161,26 @@ bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 }
 
 /**
- * die_match_name - Match diename and glob
+ * die_match_name - Match diename/linkage name and glob
  * @dw_die: a DIE
  * @glob: a string of target glob pattern
  *
  * Glob matching the name of @dw_die and @glob. Return false if matching fail.
+ * This also match linkage name.
  */
 bool die_match_name(Dwarf_Die *dw_die, const char *glob)
 {
         const char *name;
 
         name = dwarf_diename(dw_die);
-        return name ? strglobmatch(name, glob) : false;
+        if (name && strglobmatch(name, glob))
+                return true;
+        /* fall back to check linkage name */
+        name = die_get_linkage_name(dw_die);
+        if (name && strglobmatch(name, glob))
+                return true;
+
+        return false;
 }
 
 /**
@@ -1085,3 +1109,182 @@ int die_get_var_range(Dwarf_Die *sp_die __maybe_unused,
         return -ENOTSUP;
 }
 #endif
+
+/*
+ * die_has_loclist - Check if DW_AT_location of @vr_die is a location list
+ * @vr_die: a variable DIE
+ */
+static bool die_has_loclist(Dwarf_Die *vr_die)
+{
+        Dwarf_Attribute loc;
+        int tag = dwarf_tag(vr_die);
+
+        if (tag != DW_TAG_formal_parameter &&
+            tag != DW_TAG_variable)
+                return false;
+
+        return (dwarf_attr_integrate(vr_die, DW_AT_location, &loc) &&
+                dwarf_whatform(&loc) == DW_FORM_sec_offset);
+}
+
+/*
+ * die_is_optimized_target - Check if target program is compiled with
+ * optimization
+ * @cu_die: a CU DIE
+ *
+ * For any object in given CU whose DW_AT_location is a location list,
+ * target program is compiled with optimization. This is applicable to
+ * clang as well.
+ */
+bool die_is_optimized_target(Dwarf_Die *cu_die)
+{
+        Dwarf_Die tmp_die;
+
+        if (die_has_loclist(cu_die))
+                return true;
+
+        if (!dwarf_child(cu_die, &tmp_die) &&
+            die_is_optimized_target(&tmp_die))
+                return true;
+
+        if (!dwarf_siblingof(cu_die, &tmp_die) &&
+            die_is_optimized_target(&tmp_die))
+                return true;
+
+        return false;
+}
+
+/*
+ * die_search_idx - Search index of given line address
+ * @lines: Line records of single CU
+ * @nr_lines: Number of @lines
+ * @addr: address we are looking for
+ * @idx: index to be set by this function (return value)
+ *
+ * Search for @addr by looping over every lines of CU. If address
+ * matches, set index of that line in @idx. Note that single source
+ * line can have multiple line records. i.e. single source line can
+ * have multiple index.
+ */
+static bool die_search_idx(Dwarf_Lines *lines, unsigned long nr_lines,
+                           Dwarf_Addr addr, unsigned long *idx)
+{
+        unsigned long i;
+        Dwarf_Addr tmp;
+
+        for (i = 0; i < nr_lines; i++) {
+                if (dwarf_lineaddr(dwarf_onesrcline(lines, i), &tmp))
+                        return false;
+
+                if (tmp == addr) {
+                        *idx = i;
+                        return true;
+                }
+        }
+        return false;
+}
+
+/*
+ * die_get_postprologue_addr - Search next address after function prologue
+ * @entrypc_idx: entrypc index
+ * @lines: Line records of single CU
+ * @nr_lines: Number of @lines
+ * @hignpc: high PC address of function
+ * @postprologue_addr: Next address after function prologue (return value)
+ *
+ * Look for prologue-end marker. If there is no explicit marker, return
+ * address of next line record or next source line.
+ */
+static bool die_get_postprologue_addr(unsigned long entrypc_idx,
+                                      Dwarf_Lines *lines,
+                                      unsigned long nr_lines,
+                                      Dwarf_Addr highpc,
+                                      Dwarf_Addr *postprologue_addr)
+{
+        unsigned long i;
+        int entrypc_lno, lno;
+        Dwarf_Line *line;
+        Dwarf_Addr addr;
+        bool p_end;
+
+        /* entrypc_lno is actual source line number */
+        line = dwarf_onesrcline(lines, entrypc_idx);
+        if (dwarf_lineno(line, &entrypc_lno))
+                return false;
+
+        for (i = entrypc_idx; i < nr_lines; i++) {
+                line = dwarf_onesrcline(lines, i);
+
+                if (dwarf_lineaddr(line, &addr) ||
+                    dwarf_lineno(line, &lno)    ||
+                    dwarf_lineprologueend(line, &p_end))
+                        return false;
+
+                /* highpc is exclusive. [entrypc,highpc) */
+                if (addr >= highpc)
+                        break;
+
+                /* clang supports prologue-end marker */
+                if (p_end)
+                        break;
+
+                /* Actual next line in source */
+                if (lno != entrypc_lno)
+                        break;
+
+                /*
+                 * Single source line can have multiple line records.
+                 * For Example,
+                 *     void foo() { printf("hello\n"); }
+                 * contains two line records. One points to declaration and
+                 * other points to printf() line. Variable 'lno' won't get
+                 * incremented in this case but 'i' will.
+                 */
+                if (i != entrypc_idx)
+                        break;
+        }
+
+        dwarf_lineaddr(line, postprologue_addr);
+        if (*postprologue_addr >= highpc)
+                dwarf_lineaddr(dwarf_onesrcline(lines, i - 1),
+                               postprologue_addr);
+
+        return true;
+}
+
+/*
+ * die_skip_prologue - Use next address after prologue as probe location
+ * @sp_die: a subprogram DIE
+ * @cu_die: a CU DIE
+ * @entrypc: entrypc of the function
+ *
+ * Function prologue prepares stack and registers before executing function
+ * logic. When target program is compiled without optimization, function
+ * parameter information is only valid after prologue. When we probe entrypc
+ * of the function, and try to record function parameter, it contains
+ * garbage value.
+ */
+void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
+                       Dwarf_Addr *entrypc)
+{
+        size_t nr_lines = 0;
+        unsigned long entrypc_idx = 0;
+        Dwarf_Lines *lines = NULL;
+        Dwarf_Addr postprologue_addr;
+        Dwarf_Addr highpc;
+
+        if (dwarf_highpc(sp_die, &highpc))
+                return;
+
+        if (dwarf_getsrclines(cu_die, &lines, &nr_lines))
+                return;
+
+        if (!die_search_idx(lines, nr_lines, *entrypc, &entrypc_idx))
+                return;
+
+        if (!die_get_postprologue_addr(entrypc_idx, lines, nr_lines,
+                                       highpc, &postprologue_addr))
+                return;
+
+        *entrypc = postprologue_addr;
+}
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index dc0ce1adb075..8ac53bf1ec4e 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -38,6 +38,9 @@ int cu_find_lineinfo(Dwarf_Die *cudie, unsigned long addr,
 int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
                          int (*callback)(Dwarf_Die *, void *), void *data);
 
+/* Get DW_AT_linkage_name (should be NULL for C binary) */
+const char *die_get_linkage_name(Dwarf_Die *dw_die);
+
 /* Ensure that this DIE is a subprogram and definition (not declaration) */
 bool die_is_func_def(Dwarf_Die *dw_die);
 
@@ -125,4 +128,12 @@ int die_get_typename(Dwarf_Die *vr_die, struct strbuf *buf);
 /* Get the name and type of given variable DIE, stored as "type\tname" */
 int die_get_varname(Dwarf_Die *vr_die, struct strbuf *buf);
 int die_get_var_range(Dwarf_Die *sp_die, Dwarf_Die *vr_die, struct strbuf *buf);
+
+/* Check if target program is compiled with optimization */
+bool die_is_optimized_target(Dwarf_Die *cu_die);
+
+/* Use next address after prologue as probe location */
+void die_skip_prologue(Dwarf_Die *sp_die, Dwarf_Die *cu_die,
+                       Dwarf_Addr *entrypc);
+
 #endif
diff --git a/tools/perf/util/dwarf-regs.c b/tools/perf/util/dwarf-regs.c
new file mode 100644
index 000000000000..62bc4a86a970
--- /dev/null
+++ b/tools/perf/util/dwarf-regs.c
@@ -0,0 +1,59 @@
+/*
+ * dwarf-regs.c : Mapping of DWARF debug register numbers into register names.
+ *
+ * Written by: Masami Hiramatsu <mhiramat@kernel.org>
+ */
+
+#include <util.h>
+#include <debug.h>
+#include <dwarf-regs.h>
+#include <elf.h>
+
+#ifndef EM_AARCH64
+#define EM_AARCH64      183  /* ARM 64 bit */
+#endif
+
+/* Define const char * {arch}_register_tbl[] */
+#define DEFINE_DWARF_REGSTR_TABLE
+#include "../arch/x86/include/dwarf-regs-table.h"
+#include "../arch/arm/include/dwarf-regs-table.h"
+#include "../arch/arm64/include/dwarf-regs-table.h"
+#include "../arch/sh/include/dwarf-regs-table.h"
+#include "../arch/powerpc/include/dwarf-regs-table.h"
+#include "../arch/s390/include/dwarf-regs-table.h"
+#include "../arch/sparc/include/dwarf-regs-table.h"
+#include "../arch/xtensa/include/dwarf-regs-table.h"
+
+#define __get_dwarf_regstr(tbl, n) (((n) < ARRAY_SIZE(tbl)) ? (tbl)[(n)] : NULL)
+
+/* Return architecture dependent register string (for kprobe-tracer) */
+const char *get_dwarf_regstr(unsigned int n, unsigned int machine)
+{
+        switch (machine) {
+        case EM_NONE:   /* Generic arch - use host arch */
+                return get_arch_regstr(n);
+        case EM_386:
+                return __get_dwarf_regstr(x86_32_regstr_tbl, n);
+        case EM_X86_64:
+                return __get_dwarf_regstr(x86_64_regstr_tbl, n);
+        case EM_ARM:
+                return __get_dwarf_regstr(arm_regstr_tbl, n);
+        case EM_AARCH64:
+                return __get_dwarf_regstr(aarch64_regstr_tbl, n);
+        case EM_SH:
+                return __get_dwarf_regstr(sh_regstr_tbl, n);
+        case EM_S390:
+                return __get_dwarf_regstr(s390_regstr_tbl, n);
+        case EM_PPC:
+        case EM_PPC64:
+                return __get_dwarf_regstr(powerpc_regstr_tbl, n);
+        case EM_SPARC:
+        case EM_SPARCV9:
+                return __get_dwarf_regstr(sparc_regstr_tbl, n);
+        case EM_XTENSA:
+                return __get_dwarf_regstr(xtensa_regstr_tbl, n);
+        default:
+                pr_err("ELF MACHINE %x is not supported.\n", machine);
+        }
+        return NULL;
+}
diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c
index 49a11d9d8b8f..bb964e86b09d 100644
--- a/tools/perf/util/env.c
+++ b/tools/perf/util/env.c
@@ -18,10 +18,13 @@ void perf_env__exit(struct perf_env *env)
         zfree(&env->cmdline_argv);
         zfree(&env->sibling_cores);
         zfree(&env->sibling_threads);
-        zfree(&env->numa_nodes);
         zfree(&env->pmu_mappings);
         zfree(&env->cpu);
 
+        for (i = 0; i < env->nr_numa_nodes; i++)
+                cpu_map__put(env->numa_nodes[i].map);
+        zfree(&env->numa_nodes);
+
         for (i = 0; i < env->caches_cnt; i++)
                 cpu_cache_level__free(&env->caches[i]);
         zfree(&env->caches);
diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h
index 56cffb60a0b4..b164dfd2dcbf 100644
--- a/tools/perf/util/env.h
+++ b/tools/perf/util/env.h
@@ -2,6 +2,7 @@
 #define __PERF_ENV_H
 
 #include <linux/types.h>
+#include "cpumap.h"
 
 struct cpu_topology_map {
         int     socket_id;
@@ -18,6 +19,13 @@ struct cpu_cache_level {
         char    *map;
 };
 
+struct numa_node {
+        u32              node;
+        u64              mem_total;
+        u64              mem_free;
+        struct cpu_map  *map;
+};
+
 struct perf_env {
         char                    *hostname;
         char                    *os_release;
@@ -40,11 +48,11 @@ struct perf_env {
         const char              **cmdline_argv;
         char                    *sibling_cores;
         char                    *sibling_threads;
-        char                    *numa_nodes;
         char                    *pmu_mappings;
         struct cpu_topology_map *cpu;
         struct cpu_cache_level  *caches;
         int                      caches_cnt;
+        struct numa_node        *numa_nodes;
 };
 
 extern struct perf_env perf_env;
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index f6fcc6832949..8ab0d7da956b 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -1,5 +1,6 @@
 #include <linux/types.h>
-#include <sys/mman.h>
+#include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
+#include <api/fs/fs.h>
 #include "event.h"
 #include "debug.h"
 #include "hist.h"
@@ -248,6 +249,8 @@ int perf_event__synthesize_mmap_events(struct perf_tool *tool,
         bool truncation = false;
         unsigned long long timeout = proc_map_timeout * 1000000ULL;
         int rc = 0;
+        const char *hugetlbfs_mnt = hugetlbfs__mountpoint();
+        int hugetlbfs_mnt_len = hugetlbfs_mnt ? strlen(hugetlbfs_mnt) : 0;
 
         if (machine__is_default_guest(machine))
                 return 0;
@@ -343,6 +346,12 @@ out:
                 if (!strcmp(execname, ""))
                         strcpy(execname, anonstr);
 
+                if (hugetlbfs_mnt_len &&
+                    !strncmp(execname, hugetlbfs_mnt, hugetlbfs_mnt_len)) {
+                        strcpy(execname, anonstr);
+                        event->mmap2.flags |= MAP_HUGETLB;
+                }
+
                 size = strlen(execname) + 1;
                 memcpy(event->mmap2.filename, execname, size);
                 size = PERF_ALIGN(size, sizeof(u64));
@@ -673,6 +682,8 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
         int err;
         union perf_event *event;
 
+        if (symbol_conf.kptr_restrict)
+                return -1;
         if (map == NULL)
                 return -1;
 
@@ -1090,7 +1101,7 @@ size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp)
         struct cpu_map *cpus = cpu_map__new_data(&event->cpu_map.data);
         size_t ret;
 
-        ret = fprintf(fp, " nr: ");
+        ret = fprintf(fp, ": ");
 
         if (cpus)
                 ret += cpu_map__fprintf(cpus, fp);
@@ -1284,7 +1295,7 @@ try_again:
                  * must be done prior to using kernel maps.
                  */
                 if (load_map)
-                        map__load(al->map, machine->symbol_filter);
+                        map__load(al->map);
                 al->addr = al->map->map_ip(al->map, al->addr);
         }
 }
@@ -1295,8 +1306,7 @@ void thread__find_addr_location(struct thread *thread,
 {
         thread__find_addr_map(thread, cpumode, type, addr, al);
         if (al->map != NULL)
-                al->sym = map__find_symbol(al->map, al->addr,
-                                           thread->mg->machine->symbol_filter);
+                al->sym = map__find_symbol(al->map, al->addr);
         else
                 al->sym = NULL;
 }
@@ -1357,8 +1367,7 @@ int machine__resolve(struct machine *machine, struct addr_location *al,
                         al->filtered |= (1 << HIST_FILTER__DSO);
                 }
 
-                al->sym = map__find_symbol(al->map, al->addr,
-                                           machine->symbol_filter);
+                al->sym = map__find_symbol(al->map, al->addr);
         }
 
         if (symbol_conf.sym_list &&
@@ -1414,5 +1423,5 @@ void thread__resolve(struct thread *thread, struct addr_location *al,
         al->sym = NULL;
 
         if (al->map)
-                al->sym = map__find_symbol(al->map, al->addr, NULL);
+                al->sym = map__find_symbol(al->map, al->addr);
 }
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index e82ba90cc969..d92e02006fb8 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -15,6 +15,7 @@
 #include "evlist.h"
 #include "evsel.h"
 #include "debug.h"
+#include "asm/bug.h"
 #include <unistd.h>
 
 #include "parse-events.h"
@@ -27,8 +28,8 @@
 #include <linux/log2.h>
 #include <linux/err.h>
 
-static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx);
-static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx);
+static void perf_mmap__munmap(struct perf_mmap *map);
+static void perf_mmap__put(struct perf_mmap *map);
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 #define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
@@ -44,7 +45,7 @@ void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
         perf_evlist__set_maps(evlist, cpus, threads);
         fdarray__init(&evlist->pollfd, 64);
         evlist->workload.pid = -1;
-        evlist->backward = false;
+        evlist->bkw_mmap_state = BKW_MMAP_NOTREADY;
 }
 
 struct perf_evlist *perf_evlist__new(void)
@@ -100,7 +101,7 @@ static void perf_evlist__update_id_pos(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 perf_evsel__calc_id_pos(evsel);
 
         perf_evlist__set_id_pos(evlist);
@@ -110,7 +111,7 @@ static void perf_evlist__purge(struct perf_evlist *evlist)
 {
         struct perf_evsel *pos, *n;
 
-        evlist__for_each_safe(evlist, n, pos) {
+        evlist__for_each_entry_safe(evlist, n, pos) {
                 list_del_init(&pos->node);
                 pos->evlist = NULL;
                 perf_evsel__delete(pos);
@@ -122,11 +123,15 @@ static void perf_evlist__purge(struct perf_evlist *evlist)
 void perf_evlist__exit(struct perf_evlist *evlist)
 {
         zfree(&evlist->mmap);
+        zfree(&evlist->backward_mmap);
         fdarray__exit(&evlist->pollfd);
 }
 
 void perf_evlist__delete(struct perf_evlist *evlist)
 {
+        if (evlist == NULL)
+                return;
+
         perf_evlist__munmap(evlist);
         perf_evlist__close(evlist);
         cpu_map__put(evlist->cpus);
@@ -161,7 +166,7 @@ static void perf_evlist__propagate_maps(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 __perf_evlist__propagate_maps(evlist, evsel);
 }
 
@@ -190,7 +195,7 @@ void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
 {
         struct perf_evsel *evsel, *temp;
 
-        __evlist__for_each_safe(list, temp, evsel) {
+        __evlist__for_each_entry_safe(list, temp, evsel) {
                 list_del_init(&evsel->node);
                 perf_evlist__add(evlist, evsel);
         }
@@ -205,7 +210,7 @@ void __perf_evlist__set_leader(struct list_head *list)
 
         leader->nr_members = evsel->idx - leader->idx + 1;
 
-        __evlist__for_each(list, evsel) {
+        __evlist__for_each_entry(list, evsel) {
                 evsel->leader = leader;
         }
 }
@@ -234,31 +239,13 @@ void perf_event_attr__set_max_precise_ip(struct perf_event_attr *attr)
 
 int perf_evlist__add_default(struct perf_evlist *evlist)
 {
-        struct perf_event_attr attr = {
-                .type = PERF_TYPE_HARDWARE,
-                .config = PERF_COUNT_HW_CPU_CYCLES,
-        };
-        struct perf_evsel *evsel;
-
-        event_attr_init(&attr);
+        struct perf_evsel *evsel = perf_evsel__new_cycles();
 
-        perf_event_attr__set_max_precise_ip(&attr);
-
-        evsel = perf_evsel__new(&attr);
         if (evsel == NULL)
-                goto error;
-
-        /* use asprintf() because free(evsel) assumes name is allocated */
-        if (asprintf(&evsel->name, "cycles%.*s",
-                     attr.precise_ip ? attr.precise_ip + 1 : 0, ":ppp") < 0)
-                goto error_free;
+                return -ENOMEM;
 
         perf_evlist__add(evlist, evsel);
         return 0;
-error_free:
-        perf_evsel__delete(evsel);
-error:
-        return -ENOMEM;
 }
 
 int perf_evlist__add_dummy(struct perf_evlist *evlist)
@@ -296,7 +283,7 @@ static int perf_evlist__add_attrs(struct perf_evlist *evlist,
         return 0;
 
 out_delete_partial_list:
-        __evlist__for_each_safe(&head, n, evsel)
+        __evlist__for_each_entry_safe(&head, n, evsel)
                 perf_evsel__delete(evsel);
         return -1;
 }
@@ -317,7 +304,7 @@ perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type   == PERF_TYPE_TRACEPOINT &&
                     (int)evsel->attr.config == id)
                         return evsel;
@@ -332,7 +319,7 @@ perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist,
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) &&
                     (strcmp(evsel->name, name) == 0))
                         return evsel;
@@ -367,7 +354,7 @@ void perf_evlist__disable(struct perf_evlist *evlist)
 {
         struct perf_evsel *pos;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                         continue;
                 perf_evsel__disable(pos);
@@ -380,7 +367,7 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 {
         struct perf_evsel *pos;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (!perf_evsel__is_group_leader(pos) || !pos->fd)
                         continue;
                 perf_evsel__enable(pos);
@@ -397,15 +384,14 @@ void perf_evlist__toggle_enable(struct perf_evlist *evlist)
 static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist,
                                          struct perf_evsel *evsel, int cpu)
 {
-        int thread, err;
+        int thread;
         int nr_threads = perf_evlist__nr_threads(evlist, evsel);
 
         if (!evsel->fd)
                 return -EINVAL;
 
         for (thread = 0; thread < nr_threads; thread++) {
-                err = ioctl(FD(evsel, cpu, thread),
-                            PERF_EVENT_IOC_ENABLE, 0);
+                int err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
                 if (err)
                         return err;
         }
@@ -416,14 +402,14 @@ static int perf_evlist__enable_event_thread(struct perf_evlist *evlist,
                                             struct perf_evsel *evsel,
                                             int thread)
 {
-        int cpu, err;
+        int cpu;
         int nr_cpus = cpu_map__nr(evlist->cpus);
 
         if (!evsel->fd)
                 return -EINVAL;
 
         for (cpu = 0; cpu < nr_cpus; cpu++) {
-                err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
+                int err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0);
                 if (err)
                         return err;
         }
@@ -448,7 +434,7 @@ int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
         int nfds = 0;
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->system_wide)
                         nfds += nr_cpus;
                 else
@@ -462,15 +448,16 @@ int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
         return 0;
 }
 
-static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx)
+static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd,
+                                     struct perf_mmap *map, short revent)
 {
-        int pos = fdarray__add(&evlist->pollfd, fd, POLLIN | POLLERR | POLLHUP);
+        int pos = fdarray__add(&evlist->pollfd, fd, revent | POLLERR | POLLHUP);
         /*
          * Save the idx so that when we filter out fds POLLHUP'ed we can
          * close the associated evlist->mmap[] entry.
          */
         if (pos >= 0) {
-                evlist->pollfd.priv[pos].idx = idx;
+                evlist->pollfd.priv[pos].ptr = map;
 
                 fcntl(fd, F_SETFL, O_NONBLOCK);
         }
@@ -480,20 +467,22 @@ static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx
 
 int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
 {
-        return __perf_evlist__add_pollfd(evlist, fd, -1);
+        return __perf_evlist__add_pollfd(evlist, fd, NULL, POLLIN);
 }
 
-static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd)
+static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd,
+                                         void *arg __maybe_unused)
 {
-        struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd);
+        struct perf_mmap *map = fda->priv[fd].ptr;
 
-        perf_evlist__mmap_put(evlist, fda->priv[fd].idx);
+        if (map)
+                perf_mmap__put(map);
 }
 
 int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask)
 {
         return fdarray__filter(&evlist->pollfd, revents_and_mask,
-                               perf_evlist__munmap_filtered);
+                               perf_evlist__munmap_filtered, NULL);
 }
 
 int perf_evlist__poll(struct perf_evlist *evlist, int timeout)
@@ -647,8 +636,8 @@ static int perf_evlist__event2id(struct perf_evlist *evlist,
         return 0;
 }
 
-static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
-                                                   union perf_event *event)
+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;
@@ -684,8 +673,11 @@ static int perf_evlist__set_paused(struct perf_evlist *evlist, bool value)
 {
         int i;
 
+        if (!evlist->backward_mmap)
+                return 0;
+
         for (i = 0; i < evlist->nr_mmaps; i++) {
-                int fd = evlist->mmap[i].fd;
+                int fd = evlist->backward_mmap[i].fd;
                 int err;
 
                 if (fd < 0)
@@ -697,12 +689,12 @@ static int perf_evlist__set_paused(struct perf_evlist *evlist, bool value)
         return 0;
 }
 
-int perf_evlist__pause(struct perf_evlist *evlist)
+static int perf_evlist__pause(struct perf_evlist *evlist)
 {
         return perf_evlist__set_paused(evlist, true);
 }
 
-int perf_evlist__resume(struct perf_evlist *evlist)
+static int perf_evlist__resume(struct perf_evlist *evlist)
 {
         return perf_evlist__set_paused(evlist, false);
 }
@@ -777,9 +769,8 @@ broken_event:
         return event;
 }
 
-union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
+union perf_event *perf_mmap__read_forward(struct perf_mmap *md, bool check_messup)
 {
-        struct perf_mmap *md = &evlist->mmap[idx];
         u64 head;
         u64 old = md->prev;
 
@@ -791,13 +782,12 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
 
         head = perf_mmap__read_head(md);
 
-        return perf_mmap__read(md, evlist->overwrite, old, head, &md->prev);
+        return perf_mmap__read(md, check_messup, old, head, &md->prev);
 }
 
 union perf_event *
-perf_evlist__mmap_read_backward(struct perf_evlist *evlist, int idx)
+perf_mmap__read_backward(struct perf_mmap *md)
 {
-        struct perf_mmap *md = &evlist->mmap[idx];
         u64 head, end;
         u64 start = md->prev;
 
@@ -832,9 +822,38 @@ perf_evlist__mmap_read_backward(struct perf_evlist *evlist, int idx)
         return perf_mmap__read(md, false, start, end, &md->prev);
 }
 
-void perf_evlist__mmap_read_catchup(struct perf_evlist *evlist, int idx)
+union perf_event *perf_evlist__mmap_read_forward(struct perf_evlist *evlist, int idx)
 {
         struct perf_mmap *md = &evlist->mmap[idx];
+
+        /*
+         * Check messup is required for forward overwritable ring buffer:
+         * memory pointed by md->prev can be overwritten in this case.
+         * No need for read-write ring buffer: kernel stop outputting when
+         * it hit md->prev (perf_mmap__consume()).
+         */
+        return perf_mmap__read_forward(md, evlist->overwrite);
+}
+
+union perf_event *perf_evlist__mmap_read_backward(struct perf_evlist *evlist, int idx)
+{
+        struct perf_mmap *md = &evlist->mmap[idx];
+
+        /*
+         * No need to check messup for backward ring buffer:
+         * We can always read arbitrary long data from a backward
+         * ring buffer unless we forget to pause it before reading.
+         */
+        return perf_mmap__read_backward(md);
+}
+
+union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
+{
+        return perf_evlist__mmap_read_forward(evlist, idx);
+}
+
+void perf_mmap__read_catchup(struct perf_mmap *md)
+{
         u64 head;
 
         if (!atomic_read(&md->refcnt))
@@ -844,36 +863,44 @@ void perf_evlist__mmap_read_catchup(struct perf_evlist *evlist, int idx)
         md->prev = head;
 }
 
+void perf_evlist__mmap_read_catchup(struct perf_evlist *evlist, int idx)
+{
+        perf_mmap__read_catchup(&evlist->mmap[idx]);
+}
+
 static bool perf_mmap__empty(struct perf_mmap *md)
 {
         return perf_mmap__read_head(md) == md->prev && !md->auxtrace_mmap.base;
 }
 
-static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx)
+static void perf_mmap__get(struct perf_mmap *map)
 {
-        atomic_inc(&evlist->mmap[idx].refcnt);
+        atomic_inc(&map->refcnt);
 }
 
-static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx)
+static void perf_mmap__put(struct perf_mmap *md)
 {
-        BUG_ON(atomic_read(&evlist->mmap[idx].refcnt) == 0);
+        BUG_ON(md->base && atomic_read(&md->refcnt) == 0);
 
-        if (atomic_dec_and_test(&evlist->mmap[idx].refcnt))
-                __perf_evlist__munmap(evlist, idx);
+        if (atomic_dec_and_test(&md->refcnt))
+                perf_mmap__munmap(md);
 }
 
-void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
+void perf_mmap__consume(struct perf_mmap *md, bool overwrite)
 {
-        struct perf_mmap *md = &evlist->mmap[idx];
-
-        if (!evlist->overwrite) {
+        if (!overwrite) {
                 u64 old = md->prev;
 
                 perf_mmap__write_tail(md, old);
         }
 
         if (atomic_read(&md->refcnt) == 1 && perf_mmap__empty(md))
-                perf_evlist__mmap_put(evlist, idx);
+                perf_mmap__put(md);
+}
+
+void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx)
+{
+        perf_mmap__consume(&evlist->mmap[idx], evlist->overwrite);
 }
 
 int __weak auxtrace_mmap__mmap(struct auxtrace_mmap *mm __maybe_unused,
@@ -904,41 +931,52 @@ void __weak auxtrace_mmap_params__set_idx(
 {
 }
 
-static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx)
+static void perf_mmap__munmap(struct perf_mmap *map)
 {
-        if (evlist->mmap[idx].base != NULL) {
-                munmap(evlist->mmap[idx].base, evlist->mmap_len);
-                evlist->mmap[idx].base = NULL;
-                evlist->mmap[idx].fd = -1;
-                atomic_set(&evlist->mmap[idx].refcnt, 0);
+        if (map->base != NULL) {
+                munmap(map->base, perf_mmap__mmap_len(map));
+                map->base = NULL;
+                map->fd = -1;
+                atomic_set(&map->refcnt, 0);
         }
-        auxtrace_mmap__munmap(&evlist->mmap[idx].auxtrace_mmap);
+        auxtrace_mmap__munmap(&map->auxtrace_mmap);
 }
 
-void perf_evlist__munmap(struct perf_evlist *evlist)
+static void perf_evlist__munmap_nofree(struct perf_evlist *evlist)
 {
         int i;
 
-        if (evlist->mmap == NULL)
-                return;
+        if (evlist->mmap)
+                for (i = 0; i < evlist->nr_mmaps; i++)
+                        perf_mmap__munmap(&evlist->mmap[i]);
 
-        for (i = 0; i < evlist->nr_mmaps; i++)
-                __perf_evlist__munmap(evlist, i);
+        if (evlist->backward_mmap)
+                for (i = 0; i < evlist->nr_mmaps; i++)
+                        perf_mmap__munmap(&evlist->backward_mmap[i]);
+}
 
+void perf_evlist__munmap(struct perf_evlist *evlist)
+{
+        perf_evlist__munmap_nofree(evlist);
         zfree(&evlist->mmap);
+        zfree(&evlist->backward_mmap);
 }
 
-static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
+static struct perf_mmap *perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
         int i;
+        struct perf_mmap *map;
 
         evlist->nr_mmaps = cpu_map__nr(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));
+        map = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
+        if (!map)
+                return NULL;
+
         for (i = 0; i < evlist->nr_mmaps; i++)
-                evlist->mmap[i].fd = -1;
-        return evlist->mmap != NULL ? 0 : -ENOMEM;
+                map[i].fd = -1;
+        return map;
 }
 
 struct mmap_params {
@@ -947,8 +985,8 @@ struct mmap_params {
         struct auxtrace_mmap_params auxtrace_mp;
 };
 
-static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
-                               struct mmap_params *mp, int fd)
+static int perf_mmap__mmap(struct perf_mmap *map,
+                           struct mmap_params *mp, int fd)
 {
         /*
          * The last one will be done at perf_evlist__mmap_consume(), so that we
@@ -963,51 +1001,86 @@ static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx,
          * evlist layer can't just drop it when filtering events in
          * perf_evlist__filter_pollfd().
          */
-        atomic_set(&evlist->mmap[idx].refcnt, 2);
-        evlist->mmap[idx].prev = 0;
-        evlist->mmap[idx].mask = mp->mask;
-        evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot,
-                                      MAP_SHARED, fd, 0);
-        if (evlist->mmap[idx].base == MAP_FAILED) {
+        atomic_set(&map->refcnt, 2);
+        map->prev = 0;
+        map->mask = mp->mask;
+        map->base = mmap(NULL, perf_mmap__mmap_len(map), mp->prot,
+                         MAP_SHARED, fd, 0);
+        if (map->base == MAP_FAILED) {
                 pr_debug2("failed to mmap perf event ring buffer, error %d\n",
                           errno);
-                evlist->mmap[idx].base = NULL;
+                map->base = NULL;
                 return -1;
         }
-        evlist->mmap[idx].fd = fd;
+        map->fd = fd;
 
-        if (auxtrace_mmap__mmap(&evlist->mmap[idx].auxtrace_mmap,
-                                &mp->auxtrace_mp, evlist->mmap[idx].base, fd))
+        if (auxtrace_mmap__mmap(&map->auxtrace_mmap,
+                                &mp->auxtrace_mp, map->base, fd))
                 return -1;
 
         return 0;
 }
 
+static bool
+perf_evlist__should_poll(struct perf_evlist *evlist __maybe_unused,
+                         struct perf_evsel *evsel)
+{
+        if (evsel->attr.write_backward)
+                return false;
+        return true;
+}
+
 static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
-                                       struct mmap_params *mp, int cpu,
-                                       int thread, int *output)
+                                       struct mmap_params *mp, int cpu_idx,
+                                       int thread, int *_output, int *_output_backward)
 {
         struct perf_evsel *evsel;
+        int revent;
+        int evlist_cpu = cpu_map__cpu(evlist->cpus, cpu_idx);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
+                struct perf_mmap *maps = evlist->mmap;
+                int *output = _output;
                 int fd;
+                int cpu;
+
+                if (evsel->attr.write_backward) {
+                        output = _output_backward;
+                        maps = evlist->backward_mmap;
+
+                        if (!maps) {
+                                maps = perf_evlist__alloc_mmap(evlist);
+                                if (!maps)
+                                        return -1;
+                                evlist->backward_mmap = maps;
+                                if (evlist->bkw_mmap_state == BKW_MMAP_NOTREADY)
+                                        perf_evlist__toggle_bkw_mmap(evlist, BKW_MMAP_RUNNING);
+                        }
+                }
 
                 if (evsel->system_wide && thread)
                         continue;
 
+                cpu = cpu_map__idx(evsel->cpus, evlist_cpu);
+                if (cpu == -1)
+                        continue;
+
                 fd = FD(evsel, cpu, thread);
 
                 if (*output == -1) {
                         *output = fd;
-                        if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0)
+
+                        if (perf_mmap__mmap(&maps[idx], mp, *output)  < 0)
                                 return -1;
                 } else {
                         if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0)
                                 return -1;
 
-                        perf_evlist__mmap_get(evlist, idx);
+                        perf_mmap__get(&maps[idx]);
                 }
 
+                revent = perf_evlist__should_poll(evlist, evsel) ? POLLIN : 0;
+
                 /*
                  * The system_wide flag causes a selected event to be opened
                  * always without a pid.  Consequently it will never get a
@@ -1016,8 +1089,8 @@ static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx,
                  * Therefore don't add it for polling.
                  */
                 if (!evsel->system_wide &&
-                    __perf_evlist__add_pollfd(evlist, fd, idx) < 0) {
-                        perf_evlist__mmap_put(evlist, idx);
+                    __perf_evlist__add_pollfd(evlist, fd, &maps[idx], revent) < 0) {
+                        perf_mmap__put(&maps[idx]);
                         return -1;
                 }
 
@@ -1043,13 +1116,14 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
         pr_debug2("perf event ring buffer mmapped per cpu\n");
         for (cpu = 0; cpu < nr_cpus; cpu++) {
                 int output = -1;
+                int output_backward = -1;
 
                 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, cpu,
                                               true);
 
                 for (thread = 0; thread < nr_threads; thread++) {
                         if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu,
-                                                        thread, &output))
+                                                        thread, &output, &output_backward))
                                 goto out_unmap;
                 }
         }
@@ -1057,8 +1131,7 @@ static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist,
         return 0;
 
 out_unmap:
-        for (cpu = 0; cpu < nr_cpus; cpu++)
-                __perf_evlist__munmap(evlist, cpu);
+        perf_evlist__munmap_nofree(evlist);
         return -1;
 }
 
@@ -1071,20 +1144,20 @@ static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist,
         pr_debug2("perf event ring buffer mmapped per thread\n");
         for (thread = 0; thread < nr_threads; thread++) {
                 int output = -1;
+                int output_backward = -1;
 
                 auxtrace_mmap_params__set_idx(&mp->auxtrace_mp, evlist, thread,
                                               false);
 
                 if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread,
-                                                &output))
+                                                &output, &output_backward))
                         goto out_unmap;
         }
 
         return 0;
 
 out_unmap:
-        for (thread = 0; thread < nr_threads; thread++)
-                __perf_evlist__munmap(evlist, thread);
+        perf_evlist__munmap_nofree(evlist);
         return -1;
 }
 
@@ -1217,7 +1290,9 @@ int perf_evlist__mmap_ex(struct perf_evlist *evlist, unsigned int pages,
                 .prot = PROT_READ | (overwrite ? 0 : PROT_WRITE),
         };
 
-        if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0)
+        if (!evlist->mmap)
+                evlist->mmap = perf_evlist__alloc_mmap(evlist);
+        if (!evlist->mmap)
                 return -ENOMEM;
 
         if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0)
@@ -1231,7 +1306,7 @@ int perf_evlist__mmap_ex(struct perf_evlist *evlist, unsigned int pages,
         auxtrace_mmap_params__init(&mp.auxtrace_mp, evlist->mmap_len,
                                    auxtrace_pages, auxtrace_overwrite);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
                     evsel->sample_id == NULL &&
                     perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
@@ -1307,7 +1382,7 @@ void __perf_evlist__set_sample_bit(struct perf_evlist *evlist,
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 __perf_evsel__set_sample_bit(evsel, bit);
 }
 
@@ -1316,7 +1391,7 @@ void __perf_evlist__reset_sample_bit(struct perf_evlist *evlist,
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 __perf_evsel__reset_sample_bit(evsel, bit);
 }
 
@@ -1327,7 +1402,7 @@ int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **e
         const int ncpus = cpu_map__nr(evlist->cpus),
                   nthreads = thread_map__nr(evlist->threads);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->filter == NULL)
                         continue;
 
@@ -1350,7 +1425,7 @@ int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
         struct perf_evsel *evsel;
         int err = 0;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
                         continue;
 
@@ -1404,7 +1479,7 @@ bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
         if (evlist->id_pos < 0 || evlist->is_pos < 0)
                 return false;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (pos->id_pos != evlist->id_pos ||
                     pos->is_pos != evlist->is_pos)
                         return false;
@@ -1420,7 +1495,7 @@ u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
         if (evlist->combined_sample_type)
                 return evlist->combined_sample_type;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 evlist->combined_sample_type |= evsel->attr.sample_type;
 
         return evlist->combined_sample_type;
@@ -1437,7 +1512,7 @@ u64 perf_evlist__combined_branch_type(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         u64 branch_type = 0;
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 branch_type |= evsel->attr.branch_sample_type;
         return branch_type;
 }
@@ -1448,7 +1523,7 @@ bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
         u64 read_format = first->attr.read_format;
         u64 sample_type = first->attr.sample_type;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (read_format != pos->attr.read_format)
                         return false;
         }
@@ -1505,7 +1580,7 @@ bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
 {
         struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 
-        evlist__for_each_continue(evlist, pos) {
+        evlist__for_each_entry_continue(evlist, pos) {
                 if (first->attr.sample_id_all != pos->attr.sample_id_all)
                         return false;
         }
@@ -1530,10 +1605,9 @@ void perf_evlist__close(struct perf_evlist *evlist)
         struct perf_evsel *evsel;
         int ncpus = cpu_map__nr(evlist->cpus);
         int nthreads = thread_map__nr(evlist->threads);
-        int n;
 
-        evlist__for_each_reverse(evlist, evsel) {
-                n = evsel->cpus ? evsel->cpus->nr : ncpus;
+        evlist__for_each_entry_reverse(evlist, evsel) {
+                int n = evsel->cpus ? evsel->cpus->nr : ncpus;
                 perf_evsel__close(evsel, n, nthreads);
         }
 }
@@ -1586,7 +1660,7 @@ int perf_evlist__open(struct perf_evlist *evlist)
 
         perf_evlist__update_id_pos(evlist);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 err = perf_evsel__open(evsel, evsel->cpus, evsel->threads);
                 if (err < 0)
                         goto out_err;
@@ -1747,7 +1821,7 @@ size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
         struct perf_evsel *evsel;
         size_t printed = 0;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
                                    perf_evsel__name(evsel));
         }
@@ -1759,7 +1833,7 @@ int perf_evlist__strerror_open(struct perf_evlist *evlist,
                                int err, char *buf, size_t size)
 {
         int printed, value;
-        char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
+        char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));
 
         switch (err) {
         case EACCES:
@@ -1811,7 +1885,7 @@ out_default:
 
 int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size)
 {
-        char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf));
+        char sbuf[STRERR_BUFSIZE], *emsg = str_error_r(err, sbuf, sizeof(sbuf));
         int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0;
 
         switch (err) {
@@ -1849,7 +1923,7 @@ void perf_evlist__to_front(struct perf_evlist *evlist,
         if (move_evsel == perf_evlist__first(evlist))
                 return;
 
-        evlist__for_each_safe(evlist, n, evsel) {
+        evlist__for_each_entry_safe(evlist, n, evsel) {
                 if (evsel->leader == move_evsel->leader)
                         list_move_tail(&evsel->node, &move);
         }
@@ -1865,7 +1939,7 @@ void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
         if (tracking_evsel->tracking)
                 return;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel != tracking_evsel)
                         evsel->tracking = false;
         }
@@ -1879,7 +1953,7 @@ perf_evlist__find_evsel_by_str(struct perf_evlist *evlist,
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (!evsel->name)
                         continue;
                 if (strcmp(str, evsel->name) == 0)
@@ -1888,3 +1962,61 @@ perf_evlist__find_evsel_by_str(struct perf_evlist *evlist,
 
         return NULL;
 }
+
+void perf_evlist__toggle_bkw_mmap(struct perf_evlist *evlist,
+                                  enum bkw_mmap_state state)
+{
+        enum bkw_mmap_state old_state = evlist->bkw_mmap_state;
+        enum action {
+                NONE,
+                PAUSE,
+                RESUME,
+        } action = NONE;
+
+        if (!evlist->backward_mmap)
+                return;
+
+        switch (old_state) {
+        case BKW_MMAP_NOTREADY: {
+                if (state != BKW_MMAP_RUNNING)
+                        goto state_err;;
+                break;
+        }
+        case BKW_MMAP_RUNNING: {
+                if (state != BKW_MMAP_DATA_PENDING)
+                        goto state_err;
+                action = PAUSE;
+                break;
+        }
+        case BKW_MMAP_DATA_PENDING: {
+                if (state != BKW_MMAP_EMPTY)
+                        goto state_err;
+                break;
+        }
+        case BKW_MMAP_EMPTY: {
+                if (state != BKW_MMAP_RUNNING)
+                        goto state_err;
+                action = RESUME;
+                break;
+        }
+        default:
+                WARN_ONCE(1, "Shouldn't get there\n");
+        }
+
+        evlist->bkw_mmap_state = state;
+
+        switch (action) {
+        case PAUSE:
+                perf_evlist__pause(evlist);
+                break;
+        case RESUME:
+                perf_evlist__resume(evlist);
+                break;
+        case NONE:
+        default:
+                break;
+        }
+
+state_err:
+        return;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index d740fb877ab6..4fd034f22d2f 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -35,6 +35,40 @@ struct perf_mmap {
         char             event_copy[PERF_SAMPLE_MAX_SIZE] __attribute__((aligned(8)));
 };
 
+static inline size_t
+perf_mmap__mmap_len(struct perf_mmap *map)
+{
+        return map->mask + 1 + page_size;
+}
+
+/*
+ * State machine of bkw_mmap_state:
+ *
+ *                     .________________(forbid)_____________.
+ *                     |                                     V
+ * NOTREADY --(0)--> RUNNING --(1)--> DATA_PENDING --(2)--> EMPTY
+ *                     ^  ^              |   ^               |
+ *                     |  |__(forbid)____/   |___(forbid)___/|
+ *                     |                                     |
+ *                      \_________________(3)_______________/
+ *
+ * NOTREADY     : Backward ring buffers are not ready
+ * RUNNING      : Backward ring buffers are recording
+ * DATA_PENDING : We are required to collect data from backward ring buffers
+ * EMPTY        : We have collected data from backward ring buffers.
+ *
+ * (0): Setup backward ring buffer
+ * (1): Pause ring buffers for reading
+ * (2): Read from ring buffers
+ * (3): Resume ring buffers for recording
+ */
+enum bkw_mmap_state {
+        BKW_MMAP_NOTREADY,
+        BKW_MMAP_RUNNING,
+        BKW_MMAP_DATA_PENDING,
+        BKW_MMAP_EMPTY,
+};
+
 struct perf_evlist {
         struct list_head entries;
         struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
@@ -44,17 +78,18 @@ struct perf_evlist {
         bool             overwrite;
         bool             enabled;
         bool             has_user_cpus;
-        bool             backward;
         size_t           mmap_len;
         int              id_pos;
         int              is_pos;
         u64              combined_sample_type;
+        enum bkw_mmap_state bkw_mmap_state;
         struct {
                 int     cork_fd;
                 pid_t   pid;
         } workload;
         struct fdarray   pollfd;
         struct perf_mmap *mmap;
+        struct perf_mmap *backward_mmap;
         struct thread_map *threads;
         struct cpu_map    *cpus;
         struct perf_evsel *selected;
@@ -129,16 +164,24 @@ struct perf_evsel *perf_evlist__id2evsel_strict(struct perf_evlist *evlist,
 
 struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id);
 
+void perf_evlist__toggle_bkw_mmap(struct perf_evlist *evlist, enum bkw_mmap_state state);
+
+union perf_event *perf_mmap__read_forward(struct perf_mmap *map, bool check_messup);
+union perf_event *perf_mmap__read_backward(struct perf_mmap *map);
+
+void perf_mmap__read_catchup(struct perf_mmap *md);
+void perf_mmap__consume(struct perf_mmap *md, bool overwrite);
+
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx);
 
+union perf_event *perf_evlist__mmap_read_forward(struct perf_evlist *evlist,
+                                                 int idx);
 union perf_event *perf_evlist__mmap_read_backward(struct perf_evlist *evlist,
                                                   int idx);
 void perf_evlist__mmap_read_catchup(struct perf_evlist *evlist, int idx);
 
 void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx);
 
-int perf_evlist__pause(struct perf_evlist *evlist);
-int perf_evlist__resume(struct perf_evlist *evlist);
 int perf_evlist__open(struct perf_evlist *evlist);
 void perf_evlist__close(struct perf_evlist *evlist);
 
@@ -249,70 +292,70 @@ void perf_evlist__to_front(struct perf_evlist *evlist,
                            struct perf_evsel *move_evsel);
 
 /**
- * __evlist__for_each - iterate thru all the evsels
+ * __evlist__for_each_entry - iterate thru all the evsels
  * @list: list_head instance to iterate
  * @evsel: struct evsel iterator
  */
-#define __evlist__for_each(list, evsel) \
+#define __evlist__for_each_entry(list, evsel) \
         list_for_each_entry(evsel, list, node)
 
 /**
- * evlist__for_each - iterate thru all the evsels
+ * evlist__for_each_entry - iterate thru all the evsels
  * @evlist: evlist instance to iterate
  * @evsel: struct evsel iterator
  */
-#define evlist__for_each(evlist, evsel) \
-        __evlist__for_each(&(evlist)->entries, evsel)
+#define evlist__for_each_entry(evlist, evsel) \
+        __evlist__for_each_entry(&(evlist)->entries, evsel)
 
 /**
- * __evlist__for_each_continue - continue iteration thru all the evsels
+ * __evlist__for_each_entry_continue - continue iteration thru all the evsels
  * @list: list_head instance to iterate
  * @evsel: struct evsel iterator
  */
-#define __evlist__for_each_continue(list, evsel) \
+#define __evlist__for_each_entry_continue(list, evsel) \
         list_for_each_entry_continue(evsel, list, node)
 
 /**
- * evlist__for_each_continue - continue iteration thru all the evsels
+ * evlist__for_each_entry_continue - continue iteration thru all the evsels
  * @evlist: evlist instance to iterate
  * @evsel: struct evsel iterator
  */
-#define evlist__for_each_continue(evlist, evsel) \
-        __evlist__for_each_continue(&(evlist)->entries, evsel)
+#define evlist__for_each_entry_continue(evlist, evsel) \
+        __evlist__for_each_entry_continue(&(evlist)->entries, evsel)
 
 /**
- * __evlist__for_each_reverse - iterate thru all the evsels in reverse order
+ * __evlist__for_each_entry_reverse - iterate thru all the evsels in reverse order
  * @list: list_head instance to iterate
  * @evsel: struct evsel iterator
  */
-#define __evlist__for_each_reverse(list, evsel) \
+#define __evlist__for_each_entry_reverse(list, evsel) \
         list_for_each_entry_reverse(evsel, list, node)
 
 /**
- * evlist__for_each_reverse - iterate thru all the evsels in reverse order
+ * evlist__for_each_entry_reverse - iterate thru all the evsels in reverse order
  * @evlist: evlist instance to iterate
  * @evsel: struct evsel iterator
  */
-#define evlist__for_each_reverse(evlist, evsel) \
-        __evlist__for_each_reverse(&(evlist)->entries, evsel)
+#define evlist__for_each_entry_reverse(evlist, evsel) \
+        __evlist__for_each_entry_reverse(&(evlist)->entries, evsel)
 
 /**
- * __evlist__for_each_safe - safely iterate thru all the evsels
+ * __evlist__for_each_entry_safe - safely iterate thru all the evsels
  * @list: list_head instance to iterate
  * @tmp: struct evsel temp iterator
  * @evsel: struct evsel iterator
  */
-#define __evlist__for_each_safe(list, tmp, evsel) \
+#define __evlist__for_each_entry_safe(list, tmp, evsel) \
         list_for_each_entry_safe(evsel, tmp, list, node)
 
 /**
- * evlist__for_each_safe - safely iterate thru all the evsels
+ * evlist__for_each_entry_safe - safely iterate thru all the evsels
  * @evlist: evlist instance to iterate
  * @evsel: struct evsel iterator
  * @tmp: struct evsel temp iterator
  */
-#define evlist__for_each_safe(evlist, tmp, evsel) \
-        __evlist__for_each_safe(&(evlist)->entries, tmp, evsel)
+#define evlist__for_each_entry_safe(evlist, tmp, evsel) \
+        __evlist__for_each_entry_safe(&(evlist)->entries, tmp, evsel)
 
 void perf_evlist__set_tracking_event(struct perf_evlist *evlist,
                                      struct perf_evsel *tracking_evsel);
@@ -321,4 +364,7 @@ void perf_event_attr__set_max_precise_ip(struct perf_event_attr *attr);
 
 struct perf_evsel *
 perf_evlist__find_evsel_by_str(struct perf_evlist *evlist, const char *str);
+
+struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
+                                            union perf_event *event);
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 5d7037ef7d3b..8bc271141d9d 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -200,6 +200,24 @@ void perf_evsel__set_sample_id(struct perf_evsel *evsel,
         evsel->attr.read_format |= PERF_FORMAT_ID;
 }
 
+/**
+ * perf_evsel__is_function_event - Return whether given evsel is a function
+ * trace event
+ *
+ * @evsel - evsel selector to be tested
+ *
+ * Return %true if event is function trace event
+ */
+bool perf_evsel__is_function_event(struct perf_evsel *evsel)
+{
+#define FUNCTION_EVENT "ftrace:function"
+
+        return evsel->name &&
+               !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT));
+
+#undef FUNCTION_EVENT
+}
+
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx)
 {
@@ -235,6 +253,34 @@ struct perf_evsel *perf_evsel__new_idx(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
+struct perf_evsel *perf_evsel__new_cycles(void)
+{
+        struct perf_event_attr attr = {
+                .type   = PERF_TYPE_HARDWARE,
+                .config = PERF_COUNT_HW_CPU_CYCLES,
+        };
+        struct perf_evsel *evsel;
+
+        event_attr_init(&attr);
+
+        perf_event_attr__set_max_precise_ip(&attr);
+
+        evsel = perf_evsel__new(&attr);
+        if (evsel == NULL)
+                goto out;
+
+        /* use asprintf() because free(evsel) assumes name is allocated */
+        if (asprintf(&evsel->name, "cycles%.*s",
+                     attr.precise_ip ? attr.precise_ip + 1 : 0, ":ppp") < 0)
+                goto error_free;
+out:
+        return evsel;
+error_free:
+        perf_evsel__delete(evsel);
+        evsel = NULL;
+        goto out;
+}
+
 /*
  * Returns pointer with encoded error via <linux/err.h> interface.
  */
@@ -461,17 +507,17 @@ static int __perf_evsel__hw_cache_name(u64 config, char *bf, size_t size)
         u8 op, result, type = (config >>  0) & 0xff;
         const char *err = "unknown-ext-hardware-cache-type";
 
-        if (type > PERF_COUNT_HW_CACHE_MAX)
+        if (type >= PERF_COUNT_HW_CACHE_MAX)
                 goto out_err;
 
         op = (config >>  8) & 0xff;
         err = "unknown-ext-hardware-cache-op";
-        if (op > PERF_COUNT_HW_CACHE_OP_MAX)
+        if (op >= PERF_COUNT_HW_CACHE_OP_MAX)
                 goto out_err;
 
         result = (config >> 16) & 0xff;
         err = "unknown-ext-hardware-cache-result";
-        if (result > PERF_COUNT_HW_CACHE_RESULT_MAX)
+        if (result >= PERF_COUNT_HW_CACHE_RESULT_MAX)
                 goto out_err;
 
         err = "invalid-cache";
@@ -572,6 +618,8 @@ void perf_evsel__config_callchain(struct perf_evsel *evsel,
 
         perf_evsel__set_sample_bit(evsel, CALLCHAIN);
 
+        attr->sample_max_stack = param->max_stack;
+
         if (param->record_mode == CALLCHAIN_LBR) {
                 if (!opts->branch_stack) {
                         if (attr->exclude_user) {
@@ -635,7 +683,8 @@ static void apply_config_terms(struct perf_evsel *evsel,
         struct perf_event_attr *attr = &evsel->attr;
         struct callchain_param param;
         u32 dump_size = 0;
-        char *callgraph_buf = NULL;
+        int max_stack = 0;
+        const char *callgraph_buf = NULL;
 
         /* callgraph default */
         param.record_mode = callchain_param.record_mode;
@@ -662,6 +711,9 @@ static void apply_config_terms(struct perf_evsel *evsel,
                 case PERF_EVSEL__CONFIG_TERM_STACK_USER:
                         dump_size = term->val.stack_user;
                         break;
+                case PERF_EVSEL__CONFIG_TERM_MAX_STACK:
+                        max_stack = term->val.max_stack;
+                        break;
                 case PERF_EVSEL__CONFIG_TERM_INHERIT:
                         /*
                          * attr->inherit should has already been set by
@@ -671,13 +723,21 @@ static void apply_config_terms(struct perf_evsel *evsel,
                          */
                         attr->inherit = term->val.inherit ? 1 : 0;
                         break;
+                case PERF_EVSEL__CONFIG_TERM_OVERWRITE:
+                        attr->write_backward = term->val.overwrite ? 1 : 0;
+                        break;
                 default:
                         break;
                 }
         }
 
         /* User explicitly set per-event callgraph, clear the old setting and reset. */
-        if ((callgraph_buf != NULL) || (dump_size > 0)) {
+        if ((callgraph_buf != NULL) || (dump_size > 0) || max_stack) {
+                if (max_stack) {
+                        param.max_stack = max_stack;
+                        if (callgraph_buf == NULL)
+                                callgraph_buf = "fp";
+                }
 
                 /* parse callgraph parameters */
                 if (callgraph_buf != NULL) {
@@ -747,6 +807,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
 
         attr->sample_id_all = perf_missing_features.sample_id_all ? 0 : 1;
         attr->inherit       = !opts->no_inherit;
+        attr->write_backward = opts->overwrite ? 1 : 0;
 
         perf_evsel__set_sample_bit(evsel, IP);
         perf_evsel__set_sample_bit(evsel, TID);
@@ -821,7 +882,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
                 perf_evsel__set_sample_bit(evsel, REGS_INTR);
         }
 
-        if (target__has_cpu(&opts->target))
+        if (target__has_cpu(&opts->target) || opts->sample_cpu)
                 perf_evsel__set_sample_bit(evsel, CPU);
 
         if (opts->period)
@@ -924,14 +985,13 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
 
 static int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
-        int cpu, thread;
-
         if (evsel->system_wide)
                 nthreads = 1;
 
         evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
 
         if (evsel->fd) {
+                int cpu, thread;
                 for (cpu = 0; cpu < ncpus; cpu++) {
                         for (thread = 0; thread < nthreads; thread++) {
                                 FD(evsel, cpu, thread) = -1;
@@ -984,15 +1044,15 @@ int perf_evsel__set_filter(struct perf_evsel *evsel, const char *filter)
         return -1;
 }
 
-int perf_evsel__append_filter(struct perf_evsel *evsel,
-                              const char *op, const char *filter)
+static int perf_evsel__append_filter(struct perf_evsel *evsel,
+                                     const char *fmt, const char *filter)
 {
         char *new_filter;
 
         if (evsel->filter == NULL)
                 return perf_evsel__set_filter(evsel, filter);
 
-        if (asprintf(&new_filter,"(%s) %s (%s)", evsel->filter, op, filter) > 0) {
+        if (asprintf(&new_filter, fmt, evsel->filter, filter) > 0) {
                 free(evsel->filter);
                 evsel->filter = new_filter;
                 return 0;
@@ -1001,6 +1061,16 @@ int perf_evsel__append_filter(struct perf_evsel *evsel,
         return -1;
 }
 
+int perf_evsel__append_tp_filter(struct perf_evsel *evsel, const char *filter)
+{
+        return perf_evsel__append_filter(evsel, "(%s) && (%s)", filter);
+}
+
+int perf_evsel__append_addr_filter(struct perf_evsel *evsel, const char *filter)
+{
+        return perf_evsel__append_filter(evsel, "%s,%s", filter);
+}
+
 int perf_evsel__enable(struct perf_evsel *evsel)
 {
         int nthreads = thread_map__nr(evsel->threads);
@@ -1329,6 +1399,7 @@ int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
         PRINT_ATTRf(clockid, p_signed);
         PRINT_ATTRf(sample_regs_intr, p_hex);
         PRINT_ATTRf(aux_watermark, p_unsigned);
+        PRINT_ATTRf(sample_max_stack, p_unsigned);
 
         return ret;
 }
@@ -1347,6 +1418,9 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         int pid = -1, err;
         enum { NO_CHANGE, SET_TO_MAX, INCREASED_MAX } set_rlimit = NO_CHANGE;
 
+        if (perf_missing_features.write_backward && evsel->attr.write_backward)
+                return -EINVAL;
+
         if (evsel->system_wide)
                 nthreads = 1;
         else
@@ -1377,8 +1451,6 @@ fallback_missing_features:
         if (perf_missing_features.lbr_flags)
                 evsel->attr.branch_sample_type &= ~(PERF_SAMPLE_BRANCH_NO_FLAGS |
                                      PERF_SAMPLE_BRANCH_NO_CYCLES);
-        if (perf_missing_features.write_backward)
-                evsel->attr.write_backward = false;
 retry_sample_id:
         if (perf_missing_features.sample_id_all)
                 evsel->attr.sample_id_all = 0;
@@ -1441,12 +1513,6 @@ retry_open:
                                 err = -EINVAL;
                                 goto out_close;
                         }
-
-                        if (evsel->overwrite &&
-                            perf_missing_features.write_backward) {
-                                err = -EINVAL;
-                                goto out_close;
-                        }
                 }
         }
 
@@ -1484,7 +1550,10 @@ try_fallback:
          * Must probe features in the order they were added to the
          * perf_event_attr interface.
          */
-        if (!perf_missing_features.clockid_wrong && evsel->attr.use_clockid) {
+        if (!perf_missing_features.write_backward && evsel->attr.write_backward) {
+                perf_missing_features.write_backward = true;
+                goto out_close;
+        } else if (!perf_missing_features.clockid_wrong && evsel->attr.use_clockid) {
                 perf_missing_features.clockid_wrong = true;
                 goto fallback_missing_features;
         } else if (!perf_missing_features.clockid && evsel->attr.use_clockid) {
@@ -1509,12 +1578,7 @@ try_fallback:
                           PERF_SAMPLE_BRANCH_NO_FLAGS))) {
                 perf_missing_features.lbr_flags = true;
                 goto fallback_missing_features;
-        } else if (!perf_missing_features.write_backward &&
-                        evsel->attr.write_backward) {
-                perf_missing_features.write_backward = true;
-                goto fallback_missing_features;
         }
-
 out_close:
         do {
                 while (--thread >= 0) {
@@ -1673,7 +1737,6 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         data->cpu = data->pid = data->tid = -1;
         data->stream_id = data->id = data->time = -1ULL;
         data->period = evsel->attr.sample_period;
-        data->weight = 0;
         data->cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
         if (event->header.type != PERF_RECORD_SAMPLE) {
@@ -1880,7 +1943,6 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                 }
         }
 
-        data->weight = 0;
         if (type & PERF_SAMPLE_WEIGHT) {
                 OVERFLOW_CHECK_u64(array);
                 data->weight = *array;
@@ -2239,17 +2301,11 @@ void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
         return sample->raw_data + offset;
 }
 
-u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
-                       const char *name)
+u64 format_field__intval(struct format_field *field, struct perf_sample *sample,
+                         bool needs_swap)
 {
-        struct format_field *field = perf_evsel__field(evsel, name);
-        void *ptr;
         u64 value;
-
-        if (!field)
-                return 0;
-
-        ptr = sample->raw_data + field->offset;
+        void *ptr = sample->raw_data + field->offset;
 
         switch (field->size) {
         case 1:
@@ -2267,7 +2323,7 @@ u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
                 return 0;
         }
 
-        if (!evsel->needs_swap)
+        if (!needs_swap)
                 return value;
 
         switch (field->size) {
@@ -2284,6 +2340,17 @@ u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
         return 0;
 }
 
+u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
+                       const char *name)
+{
+        struct format_field *field = perf_evsel__field(evsel, name);
+
+        if (!field)
+                return 0;
+
+        return field ? format_field__intval(field, sample, evsel->needs_swap) : 0;
+}
+
 bool perf_evsel__fallback(struct perf_evsel *evsel, int err,
                           char *msg, size_t msgsize)
 {
@@ -2372,6 +2439,9 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
          "No such device - did you specify an out-of-range profile CPU?");
                 break;
         case EOPNOTSUPP:
+                if (evsel->attr.sample_period != 0)
+                        return scnprintf(msg, size, "%s",
+        "PMU Hardware doesn't support sampling/overflow-interrupts.");
                 if (evsel->attr.precise_ip)
                         return scnprintf(msg, size, "%s",
         "\'precise\' request may not be supported. Try removing 'p' modifier.");
@@ -2389,6 +2459,8 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
         "We found oprofile daemon running, please stop it and try again.");
                 break;
         case EINVAL:
+                if (evsel->attr.write_backward && perf_missing_features.write_backward)
+                        return scnprintf(msg, size, "Reading from overwrite event is not supported by this kernel.");
                 if (perf_missing_features.clockid)
                         return scnprintf(msg, size, "clockid feature not supported.");
                 if (perf_missing_features.clockid_wrong)
@@ -2402,6 +2474,13 @@ int perf_evsel__open_strerror(struct perf_evsel *evsel, struct target *target,
         "The sys_perf_event_open() syscall returned with %d (%s) for event (%s).\n"
         "/bin/dmesg may provide additional information.\n"
         "No CONFIG_PERF_EVENTS=y kernel support configured?",
-                         err, strerror_r(err, sbuf, sizeof(sbuf)),
+                         err, str_error_r(err, sbuf, sizeof(sbuf)),
                          perf_evsel__name(evsel));
 }
+
+char *perf_evsel__env_arch(struct perf_evsel *evsel)
+{
+        if (evsel && evsel->evlist && evsel->evlist->env)
+                return evsel->evlist->env->arch;
+        return NULL;
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index c1f10159804c..b1503b0ecdff 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -44,6 +44,9 @@ enum {
         PERF_EVSEL__CONFIG_TERM_CALLGRAPH,
         PERF_EVSEL__CONFIG_TERM_STACK_USER,
         PERF_EVSEL__CONFIG_TERM_INHERIT,
+        PERF_EVSEL__CONFIG_TERM_MAX_STACK,
+        PERF_EVSEL__CONFIG_TERM_OVERWRITE,
+        PERF_EVSEL__CONFIG_TERM_DRV_CFG,
         PERF_EVSEL__CONFIG_TERM_MAX,
 };
 
@@ -55,8 +58,11 @@ struct perf_evsel_config_term {
                 u64     freq;
                 bool    time;
                 char    *callgraph;
+                char    *drv_cfg;
                 u64     stack_user;
+                int     max_stack;
                 bool    inherit;
+                bool    overwrite;
         } val;
 };
 
@@ -112,7 +118,6 @@ struct perf_evsel {
         bool                    tracking;
         bool                    per_pkg;
         bool                    precise_max;
-        bool                    overwrite;
         /* parse modifier helper */
         int                     exclude_GH;
         int                     nr_members;
@@ -172,6 +177,8 @@ static inline struct perf_evsel *perf_evsel__newtp(const char *sys, const char *
         return perf_evsel__newtp_idx(sys, name, 0);
 }
 
+struct perf_evsel *perf_evsel__new_cycles(void);
+
 struct event_format *event_format__new(const char *sys, const char *name);
 
 void perf_evsel__init(struct perf_evsel *evsel,
@@ -228,8 +235,9 @@ void perf_evsel__set_sample_id(struct perf_evsel *evsel,
                                bool use_sample_identifier);
 
 int perf_evsel__set_filter(struct perf_evsel *evsel, const char *filter);
-int perf_evsel__append_filter(struct perf_evsel *evsel,
-                              const char *op, const char *filter);
+int perf_evsel__append_tp_filter(struct perf_evsel *evsel, const char *filter);
+int perf_evsel__append_addr_filter(struct perf_evsel *evsel,
+                                   const char *filter);
 int perf_evsel__apply_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
                              const char *filter);
 int perf_evsel__enable(struct perf_evsel *evsel);
@@ -259,6 +267,8 @@ static inline char *perf_evsel__strval(struct perf_evsel *evsel,
 
 struct format_field;
 
+u64 format_field__intval(struct format_field *field, struct perf_sample *sample, bool needs_swap);
+
 struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
 
 #define perf_evsel__match(evsel, t, c)          \
@@ -351,23 +361,7 @@ static inline bool perf_evsel__is_group_event(struct perf_evsel *evsel)
         return perf_evsel__is_group_leader(evsel) && evsel->nr_members > 1;
 }
 
-/**
- * perf_evsel__is_function_event - Return whether given evsel is a function
- * trace event
- *
- * @evsel - evsel selector to be tested
- *
- * Return %true if event is function trace event
- */
-static inline bool perf_evsel__is_function_event(struct perf_evsel *evsel)
-{
-#define FUNCTION_EVENT "ftrace:function"
-
-        return evsel->name &&
-               !strncmp(FUNCTION_EVENT, evsel->name, sizeof(FUNCTION_EVENT));
-
-#undef FUNCTION_EVENT
-}
+bool perf_evsel__is_function_event(struct perf_evsel *evsel);
 
 static inline bool perf_evsel__is_bpf_output(struct perf_evsel *evsel)
 {
@@ -431,4 +425,6 @@ typedef int (*attr__fprintf_f)(FILE *, const char *, const char *, void *);
 int perf_event_attr__fprintf(FILE *fp, struct perf_event_attr *attr,
                              attr__fprintf_f attr__fprintf, void *priv);
 
+char *perf_evsel__env_arch(struct perf_evsel *evsel);
+
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/evsel_fprintf.c b/tools/perf/util/evsel_fprintf.c
index 3674e77ad640..662a0a6182e7 100644
--- a/tools/perf/util/evsel_fprintf.c
+++ b/tools/perf/util/evsel_fprintf.c
@@ -122,9 +122,6 @@ int sample__fprintf_callchain(struct perf_sample *sample, int left_alignment,
                         if (!node)
                                 break;
 
-                        if (node->sym && node->sym->ignore)
-                                goto next;
-
                         printed += fprintf(fp, "%-*.*s", left_alignment, left_alignment, " ");
 
                         if (print_ip)
@@ -158,7 +155,7 @@ int sample__fprintf_callchain(struct perf_sample *sample, int left_alignment,
 
                         if (!print_oneline)
                                 printed += fprintf(fp, "\n");
-next:
+
                         callchain_cursor_advance(cursor);
                 }
         }
@@ -181,7 +178,7 @@ int sample__fprintf_sym(struct perf_sample *sample, struct addr_location *al,
         if (cursor != NULL) {
                 printed += sample__fprintf_callchain(sample, left_alignment,
                                                      print_opts, cursor, fp);
-        } else if (!(al->sym && al->sym->ignore)) {
+        } else {
                 printed += fprintf(fp, "%-*.*s", left_alignment, left_alignment, " ");
 
                 if (print_ip)
diff --git a/tools/perf/util/group.h b/tools/perf/util/group.h
new file mode 100644
index 000000000000..116debe7a995
--- /dev/null
+++ b/tools/perf/util/group.h
@@ -0,0 +1,7 @@
+#ifndef GROUP_H
+#define GROUP_H 1
+
+bool arch_topdown_check_group(bool *warn);
+void arch_topdown_group_warn(void);
+
+#endif
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 08852dde1378..85dd0db0a127 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -336,7 +336,7 @@ static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
         if (ret < 0)
                 return ret;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 ret = do_write(fd, &evsel->attr, sz);
                 if (ret < 0)
                         return ret;
@@ -801,7 +801,7 @@ static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
         if (ret < 0)
                 return ret;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (perf_evsel__is_group_leader(evsel) &&
                     evsel->nr_members > 1) {
                         const char *name = evsel->group_name ?: "{anon_group}";
@@ -828,8 +828,7 @@ static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
  * default get_cpuid(): nothing gets recorded
  * actual implementation must be in arch/$(ARCH)/util/header.c
  */
-int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused,
-                                     size_t sz __maybe_unused)
+int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused)
 {
         return -1;
 }
@@ -1306,42 +1305,19 @@ static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
 static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
                                 FILE *fp)
 {
-        u32 nr, c, i;
-        char *str, *tmp;
-        uint64_t mem_total, mem_free;
-
-        /* nr nodes */
-        nr = ph->env.nr_numa_nodes;
-        str = ph->env.numa_nodes;
-
-        for (i = 0; i < nr; i++) {
-                /* node number */
-                c = strtoul(str, &tmp, 0);
-                if (*tmp != ':')
-                        goto error;
-
-                str = tmp + 1;
-                mem_total = strtoull(str, &tmp, 0);
-                if (*tmp != ':')
-                        goto error;
+        int i;
+        struct numa_node *n;
 
-                str = tmp + 1;
-                mem_free = strtoull(str, &tmp, 0);
-                if (*tmp != ':')
-                        goto error;
+        for (i = 0; i < ph->env.nr_numa_nodes; i++) {
+                n = &ph->env.numa_nodes[i];
 
                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
                             " free = %"PRIu64" kB\n",
-                        c, mem_total, mem_free);
+                        n->node, n->mem_total, n->mem_free);
 
-                str = tmp + 1;
-                fprintf(fp, "# node%u cpu list : %s\n", c, str);
-
-                str += strlen(str) + 1;
+                fprintf(fp, "# node%u cpu list : ", n->node);
+                cpu_map__fprintf(n->map, fp);
         }
-        return;
-error:
-        fprintf(fp, "# numa topology : not available\n");
 }
 
 static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
@@ -1425,7 +1401,7 @@ static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
 
         session = container_of(ph, struct perf_session, header);
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (perf_evsel__is_group_leader(evsel) &&
                     evsel->nr_members > 1) {
                         fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
@@ -1703,7 +1679,7 @@ perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->idx == idx)
                         return evsel;
         }
@@ -1906,11 +1882,10 @@ static int process_numa_topology(struct perf_file_section *section __maybe_unuse
                                  struct perf_header *ph, int fd,
                                  void *data __maybe_unused)
 {
+        struct numa_node *nodes, *n;
         ssize_t ret;
-        u32 nr, node, i;
+        u32 nr, i;
         char *str;
-        uint64_t mem_total, mem_free;
-        struct strbuf sb;
 
         /* nr nodes */
         ret = readn(fd, &nr, sizeof(nr));
@@ -1921,47 +1896,47 @@ static int process_numa_topology(struct perf_file_section *section __maybe_unuse
                 nr = bswap_32(nr);
 
         ph->env.nr_numa_nodes = nr;
-        if (strbuf_init(&sb, 256) < 0)
-                return -1;
+        nodes = zalloc(sizeof(*nodes) * nr);
+        if (!nodes)
+                return -ENOMEM;
 
         for (i = 0; i < nr; i++) {
+                n = &nodes[i];
+
                 /* node number */
-                ret = readn(fd, &node, sizeof(node));
-                if (ret != sizeof(node))
+                ret = readn(fd, &n->node, sizeof(u32));
+                if (ret != sizeof(n->node))
                         goto error;
 
-                ret = readn(fd, &mem_total, sizeof(u64));
+                ret = readn(fd, &n->mem_total, sizeof(u64));
                 if (ret != sizeof(u64))
                         goto error;
 
-                ret = readn(fd, &mem_free, sizeof(u64));
+                ret = readn(fd, &n->mem_free, sizeof(u64));
                 if (ret != sizeof(u64))
                         goto error;
 
                 if (ph->needs_swap) {
-                        node = bswap_32(node);
-                        mem_total = bswap_64(mem_total);
-                        mem_free = bswap_64(mem_free);
+                        n->node      = bswap_32(n->node);
+                        n->mem_total = bswap_64(n->mem_total);
+                        n->mem_free  = bswap_64(n->mem_free);
                 }
 
-                if (strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
-                                node, mem_total, mem_free) < 0)
-                        goto error;
-
                 str = do_read_string(fd, ph);
                 if (!str)
                         goto error;
 
-                /* include a NULL character at the end */
-                if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
+                n->map = cpu_map__new(str);
+                if (!n->map)
                         goto error;
+
                 free(str);
         }
-        ph->env.numa_nodes = strbuf_detach(&sb, NULL);
+        ph->env.numa_nodes = nodes;
         return 0;
 
 error:
-        strbuf_release(&sb);
+        free(nodes);
         return -1;
 }
 
@@ -2075,7 +2050,7 @@ static int process_group_desc(struct perf_file_section *section __maybe_unused,
         session->evlist->nr_groups = nr_groups;
 
         i = nr = 0;
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (evsel->idx == (int) desc[i].leader_idx) {
                         evsel->leader = evsel;
                         /* {anon_group} is a dummy name */
@@ -2383,7 +2358,7 @@ int perf_session__write_header(struct perf_session *session,
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
                 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
                 if (err < 0) {
@@ -2394,7 +2369,7 @@ int perf_session__write_header(struct perf_session *session,
 
         attr_offset = lseek(fd, 0, SEEK_CUR);
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 f_attr = (struct perf_file_attr){
                         .attr = evsel->attr,
                         .ids  = {
@@ -2828,7 +2803,7 @@ static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
 {
         struct perf_evsel *pos;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
                     perf_evsel__prepare_tracepoint_event(pos, pevent))
                         return -1;
@@ -3127,7 +3102,7 @@ int perf_event__synthesize_attrs(struct perf_tool *tool,
         struct perf_evsel *evsel;
         int err = 0;
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
                                                   evsel->id, process);
                 if (err) {
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index d306ca118449..d30109b421ee 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -151,4 +151,5 @@ int write_padded(int fd, const void *bf, size_t count, size_t count_aligned);
  */
 int get_cpuid(char *buffer, size_t sz);
 
+char *get_cpuid_str(void);
 #endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/help-unknown-cmd.c b/tools/perf/util/help-unknown-cmd.c
index d62ccaeeadd6..2821f8d77e52 100644
--- a/tools/perf/util/help-unknown-cmd.c
+++ b/tools/perf/util/help-unknown-cmd.c
@@ -1,4 +1,6 @@
 #include "cache.h"
+#include "config.h"
+#include <stdio.h>
 #include <subcmd/help.h>
 #include "../builtin.h"
 #include "levenshtein.h"
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index d1f19e0012d4..b02992efb513 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -79,7 +79,7 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 
         len = thread__comm_len(h->thread);
         if (hists__new_col_len(hists, HISTC_COMM, len))
-                hists__set_col_len(hists, HISTC_THREAD, len + 6);
+                hists__set_col_len(hists, HISTC_THREAD, len + 8);
 
         if (h->ms.map) {
                 len = dso__name_len(h->ms.map->dso);
@@ -177,8 +177,10 @@ void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         hists__new_col_len(hists, HISTC_LOCAL_WEIGHT, 12);
         hists__new_col_len(hists, HISTC_GLOBAL_WEIGHT, 12);
 
-        if (h->srcline)
-                hists__new_col_len(hists, HISTC_SRCLINE, strlen(h->srcline));
+        if (h->srcline) {
+                len = MAX(strlen(h->srcline), strlen(sort_srcline.se_header));
+                hists__new_col_len(hists, HISTC_SRCLINE, len);
+        }
 
         if (h->srcfile)
                 hists__new_col_len(hists, HISTC_SRCFILE, strlen(h->srcfile));
@@ -352,86 +354,116 @@ void hists__delete_entries(struct hists *hists)
  * histogram, sorted on item, collects periods
  */
 
-static struct hist_entry *hist_entry__new(struct hist_entry *template,
-                                          bool sample_self)
+static int hist_entry__init(struct hist_entry *he,
+                            struct hist_entry *template,
+                            bool sample_self)
 {
-        size_t callchain_size = 0;
-        struct hist_entry *he;
+        *he = *template;
 
-        if (symbol_conf.use_callchain)
-                callchain_size = sizeof(struct callchain_root);
+        if (symbol_conf.cumulate_callchain) {
+                he->stat_acc = malloc(sizeof(he->stat));
+                if (he->stat_acc == NULL)
+                        return -ENOMEM;
+                memcpy(he->stat_acc, &he->stat, sizeof(he->stat));
+                if (!sample_self)
+                        memset(&he->stat, 0, sizeof(he->stat));
+        }
+
+        map__get(he->ms.map);
+
+        if (he->branch_info) {
+                /*
+                 * This branch info is (a part of) allocated from
+                 * sample__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) {
+                        map__zput(he->ms.map);
+                        free(he->stat_acc);
+                        return -ENOMEM;
+                }
+
+                memcpy(he->branch_info, template->branch_info,
+                       sizeof(*he->branch_info));
+
+                map__get(he->branch_info->from.map);
+                map__get(he->branch_info->to.map);
+        }
+
+        if (he->mem_info) {
+                map__get(he->mem_info->iaddr.map);
+                map__get(he->mem_info->daddr.map);
+        }
 
-        he = zalloc(sizeof(*he) + callchain_size);
+        if (symbol_conf.use_callchain)
+                callchain_init(he->callchain);
 
-        if (he != NULL) {
-                *he = *template;
+        if (he->raw_data) {
+                he->raw_data = memdup(he->raw_data, he->raw_size);
 
-                if (symbol_conf.cumulate_callchain) {
-                        he->stat_acc = malloc(sizeof(he->stat));
-                        if (he->stat_acc == NULL) {
-                                free(he);
-                                return NULL;
+                if (he->raw_data == NULL) {
+                        map__put(he->ms.map);
+                        if (he->branch_info) {
+                                map__put(he->branch_info->from.map);
+                                map__put(he->branch_info->to.map);
+                                free(he->branch_info);
+                        }
+                        if (he->mem_info) {
+                                map__put(he->mem_info->iaddr.map);
+                                map__put(he->mem_info->daddr.map);
                         }
-                        memcpy(he->stat_acc, &he->stat, sizeof(he->stat));
-                        if (!sample_self)
-                                memset(&he->stat, 0, sizeof(he->stat));
+                        free(he->stat_acc);
+                        return -ENOMEM;
                 }
+        }
+        INIT_LIST_HEAD(&he->pairs.node);
+        thread__get(he->thread);
+        he->hroot_in  = RB_ROOT;
+        he->hroot_out = RB_ROOT;
 
-                map__get(he->ms.map);
+        if (!symbol_conf.report_hierarchy)
+                he->leaf = true;
 
-                if (he->branch_info) {
-                        /*
-                         * This branch info is (a part of) allocated from
-                         * sample__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) {
-                                map__zput(he->ms.map);
-                                free(he->stat_acc);
-                                free(he);
-                                return NULL;
-                        }
+        return 0;
+}
 
-                        memcpy(he->branch_info, template->branch_info,
-                               sizeof(*he->branch_info));
+static void *hist_entry__zalloc(size_t size)
+{
+        return zalloc(size + sizeof(struct hist_entry));
+}
 
-                        map__get(he->branch_info->from.map);
-                        map__get(he->branch_info->to.map);
-                }
+static void hist_entry__free(void *ptr)
+{
+        free(ptr);
+}
 
-                if (he->mem_info) {
-                        map__get(he->mem_info->iaddr.map);
-                        map__get(he->mem_info->daddr.map);
-                }
+static struct hist_entry_ops default_ops = {
+        .new    = hist_entry__zalloc,
+        .free   = hist_entry__free,
+};
 
-                if (symbol_conf.use_callchain)
-                        callchain_init(he->callchain);
+static struct hist_entry *hist_entry__new(struct hist_entry *template,
+                                          bool sample_self)
+{
+        struct hist_entry_ops *ops = template->ops;
+        size_t callchain_size = 0;
+        struct hist_entry *he;
+        int err = 0;
 
-                if (he->raw_data) {
-                        he->raw_data = memdup(he->raw_data, he->raw_size);
+        if (!ops)
+                ops = template->ops = &default_ops;
 
-                        if (he->raw_data == NULL) {
-                                map__put(he->ms.map);
-                                if (he->branch_info) {
-                                        map__put(he->branch_info->from.map);
-                                        map__put(he->branch_info->to.map);
-                                        free(he->branch_info);
-                                }
-                                if (he->mem_info) {
-                                        map__put(he->mem_info->iaddr.map);
-                                        map__put(he->mem_info->daddr.map);
-                                }
-                                free(he->stat_acc);
-                                free(he);
-                                return NULL;
-                        }
-                }
-                INIT_LIST_HEAD(&he->pairs.node);
-                thread__get(he->thread);
+        if (symbol_conf.use_callchain)
+                callchain_size = sizeof(struct callchain_root);
 
-                if (!symbol_conf.report_hierarchy)
-                        he->leaf = true;
+        he = ops->new(callchain_size);
+        if (he) {
+                err = hist_entry__init(he, template, sample_self);
+                if (err) {
+                        ops->free(he);
+                        he = NULL;
+                }
         }
 
         return he;
@@ -531,13 +563,15 @@ out:
         return he;
 }
 
-struct hist_entry *__hists__add_entry(struct hists *hists,
-                                      struct addr_location *al,
-                                      struct symbol *sym_parent,
-                                      struct branch_info *bi,
-                                      struct mem_info *mi,
-                                      struct perf_sample *sample,
-                                      bool sample_self)
+static struct hist_entry*
+__hists__add_entry(struct hists *hists,
+                   struct addr_location *al,
+                   struct symbol *sym_parent,
+                   struct branch_info *bi,
+                   struct mem_info *mi,
+                   struct perf_sample *sample,
+                   bool sample_self,
+                   struct hist_entry_ops *ops)
 {
         struct hist_entry entry = {
                 .thread = al->thread,
@@ -564,11 +598,37 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
                 .transaction = sample->transaction,
                 .raw_data = sample->raw_data,
                 .raw_size = sample->raw_size,
+                .ops = ops,
         };
 
         return hists__findnew_entry(hists, &entry, al, sample_self);
 }
 
+struct hist_entry *hists__add_entry(struct hists *hists,
+                                    struct addr_location *al,
+                                    struct symbol *sym_parent,
+                                    struct branch_info *bi,
+                                    struct mem_info *mi,
+                                    struct perf_sample *sample,
+                                    bool sample_self)
+{
+        return __hists__add_entry(hists, al, sym_parent, bi, mi,
+                                  sample, sample_self, NULL);
+}
+
+struct hist_entry *hists__add_entry_ops(struct hists *hists,
+                                        struct hist_entry_ops *ops,
+                                        struct addr_location *al,
+                                        struct symbol *sym_parent,
+                                        struct branch_info *bi,
+                                        struct mem_info *mi,
+                                        struct perf_sample *sample,
+                                        bool sample_self)
+{
+        return __hists__add_entry(hists, al, sym_parent, bi, mi,
+                                  sample, sample_self, ops);
+}
+
 static int
 iter_next_nop_entry(struct hist_entry_iter *iter __maybe_unused,
                     struct addr_location *al __maybe_unused)
@@ -622,8 +682,8 @@ iter_add_single_mem_entry(struct hist_entry_iter *iter, struct addr_location *al
          */
         sample->period = cost;
 
-        he = __hists__add_entry(hists, al, iter->parent, NULL, mi,
-                                sample, true);
+        he = hists__add_entry(hists, al, iter->parent, NULL, mi,
+                              sample, true);
         if (!he)
                 return -ENOMEM;
 
@@ -727,8 +787,8 @@ iter_add_next_branch_entry(struct hist_entry_iter *iter, struct addr_location *a
         sample->period = 1;
         sample->weight = bi->flags.cycles ? bi->flags.cycles : 1;
 
-        he = __hists__add_entry(hists, al, iter->parent, &bi[i], NULL,
-                                sample, true);
+        he = hists__add_entry(hists, al, iter->parent, &bi[i], NULL,
+                              sample, true);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -764,8 +824,8 @@ iter_add_single_normal_entry(struct hist_entry_iter *iter, struct addr_location
         struct perf_sample *sample = iter->sample;
         struct hist_entry *he;
 
-        he = __hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,
-                                sample, true);
+        he = hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,
+                              sample, true);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -825,8 +885,8 @@ iter_add_single_cumulative_entry(struct hist_entry_iter *iter,
         struct hist_entry *he;
         int err = 0;
 
-        he = __hists__add_entry(hists, al, iter->parent, NULL, NULL,
-                                sample, true);
+        he = hists__add_entry(hists, al, iter->parent, NULL, NULL,
+                              sample, true);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -900,8 +960,8 @@ iter_add_next_cumulative_entry(struct hist_entry_iter *iter,
                 }
         }
 
-        he = __hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,
-                                sample, false);
+        he = hists__add_entry(evsel__hists(evsel), al, iter->parent, NULL, NULL,
+                              sample, false);
         if (he == NULL)
                 return -ENOMEM;
 
@@ -1043,6 +1103,8 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
 
 void hist_entry__delete(struct hist_entry *he)
 {
+        struct hist_entry_ops *ops = he->ops;
+
         thread__zput(he->thread);
         map__zput(he->ms.map);
 
@@ -1067,7 +1129,7 @@ void hist_entry__delete(struct hist_entry *he)
         free_callchain(he->callchain);
         free(he->trace_output);
         free(he->raw_data);
-        free(he);
+        ops->free(he);
 }
 
 /*
@@ -1081,7 +1143,7 @@ int hist_entry__snprintf_alignment(struct hist_entry *he, struct perf_hpp *hpp,
                                    struct perf_hpp_fmt *fmt, int printed)
 {
         if (!list_is_last(&fmt->list, &he->hists->hpp_list->fields)) {
-                const int width = fmt->width(fmt, hpp, hists_to_evsel(he->hists));
+                const int width = fmt->width(fmt, hpp, he->hists);
                 if (printed < width) {
                         advance_hpp(hpp, printed);
                         printed = scnprintf(hpp->buf, hpp->size, "%-*s", width - printed, " ");
@@ -1614,7 +1676,7 @@ static void __hists__insert_output_entry(struct rb_root *entries,
 }
 
 static void output_resort(struct hists *hists, struct ui_progress *prog,
-                          bool use_callchain)
+                          bool use_callchain, hists__resort_cb_t cb)
 {
         struct rb_root *root;
         struct rb_node *next;
@@ -1653,6 +1715,9 @@ static void output_resort(struct hists *hists, struct ui_progress *prog,
                 n = rb_entry(next, struct hist_entry, rb_node_in);
                 next = rb_next(&n->rb_node_in);
 
+                if (cb && cb(n))
+                        continue;
+
                 __hists__insert_output_entry(&hists->entries, n, min_callchain_hits, use_callchain);
                 hists__inc_stats(hists, n);
 
@@ -1673,12 +1738,18 @@ void perf_evsel__output_resort(struct perf_evsel *evsel, struct ui_progress *pro
         else
                 use_callchain = symbol_conf.use_callchain;
 
-        output_resort(evsel__hists(evsel), prog, use_callchain);
+        output_resort(evsel__hists(evsel), prog, use_callchain, NULL);
 }
 
 void hists__output_resort(struct hists *hists, struct ui_progress *prog)
 {
-        output_resort(hists, prog, symbol_conf.use_callchain);
+        output_resort(hists, prog, symbol_conf.use_callchain, NULL);
+}
+
+void hists__output_resort_cb(struct hists *hists, struct ui_progress *prog,
+                             hists__resort_cb_t cb)
+{
+        output_resort(hists, prog, symbol_conf.use_callchain, cb);
 }
 
 static bool can_goto_child(struct hist_entry *he, enum hierarchy_move_dir hmd)
@@ -2082,6 +2153,50 @@ out:
         return he;
 }
 
+static struct hist_entry *add_dummy_hierarchy_entry(struct hists *hists,
+                                                    struct rb_root *root,
+                                                    struct hist_entry *pair)
+{
+        struct rb_node **p;
+        struct rb_node *parent = NULL;
+        struct hist_entry *he;
+        struct perf_hpp_fmt *fmt;
+
+        p = &root->rb_node;
+        while (*p != NULL) {
+                int64_t cmp = 0;
+
+                parent = *p;
+                he = rb_entry(parent, struct hist_entry, rb_node_in);
+
+                perf_hpp_list__for_each_sort_list(he->hpp_list, fmt) {
+                        cmp = fmt->collapse(fmt, he, pair);
+                        if (cmp)
+                                break;
+                }
+                if (!cmp)
+                        goto out;
+
+                if (cmp < 0)
+                        p = &parent->rb_left;
+                else
+                        p = &parent->rb_right;
+        }
+
+        he = hist_entry__new(pair, true);
+        if (he) {
+                rb_link_node(&he->rb_node_in, parent, p);
+                rb_insert_color(&he->rb_node_in, root);
+
+                he->dummy = true;
+                he->hists = hists;
+                memset(&he->stat, 0, sizeof(he->stat));
+                hists__inc_stats(hists, he);
+        }
+out:
+        return he;
+}
+
 static struct hist_entry *hists__find_entry(struct hists *hists,
                                             struct hist_entry *he)
 {
@@ -2107,6 +2222,51 @@ static struct hist_entry *hists__find_entry(struct hists *hists,
         return NULL;
 }
 
+static struct hist_entry *hists__find_hierarchy_entry(struct rb_root *root,
+                                                      struct hist_entry *he)
+{
+        struct rb_node *n = root->rb_node;
+
+        while (n) {
+                struct hist_entry *iter;
+                struct perf_hpp_fmt *fmt;
+                int64_t cmp = 0;
+
+                iter = rb_entry(n, struct hist_entry, rb_node_in);
+                perf_hpp_list__for_each_sort_list(he->hpp_list, fmt) {
+                        cmp = fmt->collapse(fmt, iter, he);
+                        if (cmp)
+                                break;
+                }
+
+                if (cmp < 0)
+                        n = n->rb_left;
+                else if (cmp > 0)
+                        n = n->rb_right;
+                else
+                        return iter;
+        }
+
+        return NULL;
+}
+
+static void hists__match_hierarchy(struct rb_root *leader_root,
+                                   struct rb_root *other_root)
+{
+        struct rb_node *nd;
+        struct hist_entry *pos, *pair;
+
+        for (nd = rb_first(leader_root); nd; nd = rb_next(nd)) {
+                pos  = rb_entry(nd, struct hist_entry, rb_node_in);
+                pair = hists__find_hierarchy_entry(other_root, pos);
+
+                if (pair) {
+                        hist_entry__add_pair(pair, pos);
+                        hists__match_hierarchy(&pos->hroot_in, &pair->hroot_in);
+                }
+        }
+}
+
 /*
  * Look for pairs to link to the leader buckets (hist_entries):
  */
@@ -2116,6 +2276,12 @@ void hists__match(struct hists *leader, struct hists *other)
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
+        if (symbol_conf.report_hierarchy) {
+                /* hierarchy report always collapses entries */
+                return hists__match_hierarchy(&leader->entries_collapsed,
+                                              &other->entries_collapsed);
+        }
+
         if (hists__has(leader, need_collapse))
                 root = &leader->entries_collapsed;
         else
@@ -2130,6 +2296,50 @@ void hists__match(struct hists *leader, struct hists *other)
         }
 }
 
+static int hists__link_hierarchy(struct hists *leader_hists,
+                                 struct hist_entry *parent,
+                                 struct rb_root *leader_root,
+                                 struct rb_root *other_root)
+{
+        struct rb_node *nd;
+        struct hist_entry *pos, *leader;
+
+        for (nd = rb_first(other_root); nd; nd = rb_next(nd)) {
+                pos = rb_entry(nd, struct hist_entry, rb_node_in);
+
+                if (hist_entry__has_pairs(pos)) {
+                        bool found = false;
+
+                        list_for_each_entry(leader, &pos->pairs.head, pairs.node) {
+                                if (leader->hists == leader_hists) {
+                                        found = true;
+                                        break;
+                                }
+                        }
+                        if (!found)
+                                return -1;
+                } else {
+                        leader = add_dummy_hierarchy_entry(leader_hists,
+                                                           leader_root, pos);
+                        if (leader == NULL)
+                                return -1;
+
+                        /* do not point parent in the pos */
+                        leader->parent_he = parent;
+
+                        hist_entry__add_pair(pos, leader);
+                }
+
+                if (!pos->leaf) {
+                        if (hists__link_hierarchy(leader_hists, leader,
+                                                  &leader->hroot_in,
+                                                  &pos->hroot_in) < 0)
+                                return -1;
+                }
+        }
+        return 0;
+}
+
 /*
  * Look for entries in the other hists that are not present in the leader, if
  * we find them, just add a dummy entry on the leader hists, with period=0,
@@ -2141,6 +2351,13 @@ int hists__link(struct hists *leader, struct hists *other)
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
+        if (symbol_conf.report_hierarchy) {
+                /* hierarchy report always collapses entries */
+                return hists__link_hierarchy(leader, NULL,
+                                             &leader->entries_collapsed,
+                                             &other->entries_collapsed);
+        }
+
         if (hists__has(other, need_collapse))
                 root = &other->entries_collapsed;
         else
@@ -2199,7 +2416,7 @@ size_t perf_evlist__fprintf_nr_events(struct perf_evlist *evlist, FILE *fp)
         struct perf_evsel *pos;
         size_t ret = 0;
 
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
                 ret += events_stats__fprintf(&evsel__hists(pos)->stats, fp);
         }
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 7b54ccf1b737..9928fed8bc59 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -10,6 +10,7 @@
 #include "ui/progress.h"
 
 struct hist_entry;
+struct hist_entry_ops;
 struct addr_location;
 struct symbol;
 
@@ -120,13 +121,23 @@ extern const struct hist_iter_ops hist_iter_branch;
 extern const struct hist_iter_ops hist_iter_mem;
 extern const struct hist_iter_ops hist_iter_cumulative;
 
-struct hist_entry *__hists__add_entry(struct hists *hists,
-                                      struct addr_location *al,
-                                      struct symbol *parent,
-                                      struct branch_info *bi,
-                                      struct mem_info *mi,
-                                      struct perf_sample *sample,
-                                      bool sample_self);
+struct hist_entry *hists__add_entry(struct hists *hists,
+                                    struct addr_location *al,
+                                    struct symbol *parent,
+                                    struct branch_info *bi,
+                                    struct mem_info *mi,
+                                    struct perf_sample *sample,
+                                    bool sample_self);
+
+struct hist_entry *hists__add_entry_ops(struct hists *hists,
+                                        struct hist_entry_ops *ops,
+                                        struct addr_location *al,
+                                        struct symbol *sym_parent,
+                                        struct branch_info *bi,
+                                        struct mem_info *mi,
+                                        struct perf_sample *sample,
+                                        bool sample_self);
+
 int hist_entry_iter__add(struct hist_entry_iter *iter, struct addr_location *al,
                          int max_stack_depth, void *arg);
 
@@ -142,8 +153,12 @@ int hist_entry__snprintf_alignment(struct hist_entry *he, struct perf_hpp *hpp,
                                    struct perf_hpp_fmt *fmt, int printed);
 void hist_entry__delete(struct hist_entry *he);
 
+typedef int (*hists__resort_cb_t)(struct hist_entry *he);
+
 void perf_evsel__output_resort(struct perf_evsel *evsel, struct ui_progress *prog);
 void hists__output_resort(struct hists *hists, struct ui_progress *prog);
+void hists__output_resort_cb(struct hists *hists, struct ui_progress *prog,
+                             hists__resort_cb_t cb);
 int hists__collapse_resort(struct hists *hists, struct ui_progress *prog);
 
 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
@@ -159,7 +174,8 @@ 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 *hists, bool show_header, int max_rows,
-                      int max_cols, float min_pcnt, FILE *fp);
+                      int max_cols, float min_pcnt, FILE *fp,
+                      bool use_callchain);
 size_t perf_evlist__fprintf_nr_events(struct perf_evlist *evlist, FILE *fp);
 
 void hists__filter_by_dso(struct hists *hists);
@@ -214,9 +230,9 @@ struct perf_hpp {
 struct perf_hpp_fmt {
         const char *name;
         int (*header)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                      struct perf_evsel *evsel);
+                      struct hists *hists, int line, int *span);
         int (*width)(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                     struct perf_evsel *evsel);
+                     struct hists *hists);
         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,
@@ -243,6 +259,7 @@ struct perf_hpp_list {
         struct list_head fields;
         struct list_head sorts;
 
+        int nr_header_lines;
         int need_collapse;
         int parent;
         int sym;
@@ -351,6 +368,7 @@ static inline bool perf_hpp__should_skip(struct perf_hpp_fmt *format,
 void perf_hpp__reset_width(struct perf_hpp_fmt *fmt, struct hists *hists);
 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists);
 void perf_hpp__set_user_width(const char *width_list_str);
+void hists__reset_column_width(struct hists *hists);
 
 typedef u64 (*hpp_field_fn)(struct hist_entry *he);
 typedef int (*hpp_callback_fn)(struct perf_hpp *hpp, bool front);
@@ -467,5 +485,10 @@ static inline struct rb_node *rb_hierarchy_next(struct rb_node *node)
 #define HIERARCHY_INDENT  3
 
 bool hist_entry__has_hierarchy_children(struct hist_entry *he, float limit);
+int hpp_color_scnprintf(struct perf_hpp *hpp, const char *fmt, ...);
+int __hpp__slsmg_color_printf(struct perf_hpp *hpp, const char *fmt, ...);
+int __hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp,
+                           struct perf_hpp_list *hpp_list);
+int hists__fprintf_headers(struct hists *hists, FILE *fp);
 
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/asm/byteorder.h b/tools/perf/util/include/asm/byteorder.h
deleted file mode 100644
index 2a9bdc066307..000000000000
--- a/tools/perf/util/include/asm/byteorder.h
+++ /dev/null
@@ -1,2 +0,0 @@
-#include <asm/types.h>
-#include "../../../../include/uapi/linux/swab.h"
diff --git a/tools/perf/util/include/asm/unistd_32.h b/tools/perf/util/include/asm/unistd_32.h
deleted file mode 100644
index 8b137891791f..000000000000
--- a/tools/perf/util/include/asm/unistd_32.h
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tools/perf/util/include/asm/unistd_64.h b/tools/perf/util/include/asm/unistd_64.h
deleted file mode 100644
index 8b137891791f..000000000000
--- a/tools/perf/util/include/asm/unistd_64.h
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/tools/perf/util/include/dwarf-regs.h b/tools/perf/util/include/dwarf-regs.h
index 07c644ed64c4..43bfd8da7919 100644
--- a/tools/perf/util/include/dwarf-regs.h
+++ b/tools/perf/util/include/dwarf-regs.h
@@ -3,6 +3,12 @@
 
 #ifdef HAVE_DWARF_SUPPORT
 const char *get_arch_regstr(unsigned int n);
+/*
+ * get_dwarf_regstr - Returns ftrace register string from DWARF regnum
+ * n: DWARF register number
+ * machine: ELF machine signature (EM_*)
+ */
+const char *get_dwarf_regstr(unsigned int n, unsigned int machine);
 #endif
 
 #ifdef HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET
diff --git a/tools/perf/util/include/linux/const.h b/tools/perf/util/include/linux/const.h
deleted file mode 100644
index c10a35e1afb8..000000000000
--- a/tools/perf/util/include/linux/const.h
+++ /dev/null
@@ -1 +0,0 @@
-#include "../../../../include/uapi/linux/const.h"
diff --git a/tools/perf/util/intel-bts.c b/tools/perf/util/intel-bts.c
index 9df996085563..f545ec1e758a 100644
--- a/tools/perf/util/intel-bts.c
+++ b/tools/perf/util/intel-bts.c
@@ -346,7 +346,7 @@ static int intel_bts_get_next_insn(struct intel_bts_queue *btsq, u64 ip)
                 goto out_put;
 
         /* Load maps to ensure dso->is_64_bit has been updated */
-        map__load(al.map, machine->symbol_filter);
+        map__load(al.map);
 
         x86_64 = al.map->dso->is_64_bit;
 
@@ -422,7 +422,8 @@ static int intel_bts_get_branch_type(struct intel_bts_queue *btsq,
 }
 
 static int intel_bts_process_buffer(struct intel_bts_queue *btsq,
-                                    struct auxtrace_buffer *buffer)
+                                    struct auxtrace_buffer *buffer,
+                                    struct thread *thread)
 {
         struct branch *branch;
         size_t sz, bsz = sizeof(struct branch);
@@ -444,6 +445,12 @@ static int intel_bts_process_buffer(struct intel_bts_queue *btsq,
                 if (!branch->from && !branch->to)
                         continue;
                 intel_bts_get_branch_type(btsq, branch);
+                if (btsq->bts->synth_opts.thread_stack)
+                        thread_stack__event(thread, btsq->sample_flags,
+                                            le64_to_cpu(branch->from),
+                                            le64_to_cpu(branch->to),
+                                            btsq->intel_pt_insn.length,
+                                            buffer->buffer_nr + 1);
                 if (filter && !(filter & btsq->sample_flags))
                         continue;
                 err = intel_bts_synth_branch_sample(btsq, branch);
@@ -507,12 +514,13 @@ static int intel_bts_process_queue(struct intel_bts_queue *btsq, u64 *timestamp)
                 goto out_put;
         }
 
-        if (!btsq->bts->synth_opts.callchain && thread &&
+        if (!btsq->bts->synth_opts.callchain &&
+            !btsq->bts->synth_opts.thread_stack && thread &&
             (!old_buffer || btsq->bts->sampling_mode ||
              (btsq->bts->snapshot_mode && !buffer->consecutive)))
                 thread_stack__set_trace_nr(thread, buffer->buffer_nr + 1);
 
-        err = intel_bts_process_buffer(btsq, buffer);
+        err = intel_bts_process_buffer(btsq, buffer, thread);
 
         auxtrace_buffer__drop_data(buffer);
 
@@ -777,7 +785,7 @@ static int intel_bts_synth_events(struct intel_bts *bts,
         u64 id;
         int err;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type == bts->pmu_type && evsel->ids) {
                         found = true;
                         break;
@@ -905,10 +913,14 @@ int intel_bts_process_auxtrace_info(union perf_event *event,
         if (dump_trace)
                 return 0;
 
-        if (session->itrace_synth_opts && session->itrace_synth_opts->set)
+        if (session->itrace_synth_opts && session->itrace_synth_opts->set) {
                 bts->synth_opts = *session->itrace_synth_opts;
-        else
+        } else {
                 itrace_synth_opts__set_default(&bts->synth_opts);
+                if (session->itrace_synth_opts)
+                        bts->synth_opts.thread_stack =
+                                session->itrace_synth_opts->thread_stack;
+        }
 
         if (bts->synth_opts.calls)
                 bts->branches_filter |= PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC |
diff --git a/tools/perf/util/intel-pt-decoder/Build b/tools/perf/util/intel-pt-decoder/Build
index 0611d619a42e..9b742ea8bfe8 100644
--- a/tools/perf/util/intel-pt-decoder/Build
+++ b/tools/perf/util/intel-pt-decoder/Build
@@ -7,8 +7,11 @@ $(OUTPUT)util/intel-pt-decoder/inat-tables.c: $(inat_tables_script) $(inat_table
         $(call rule_mkdir)
         @$(call echo-cmd,gen)$(AWK) -f $(inat_tables_script) $(inat_tables_maps) > $@ || rm -f $@
 
+# Busybox's diff doesn't have -I, avoid warning in the case
+
 $(OUTPUT)util/intel-pt-decoder/intel-pt-insn-decoder.o: util/intel-pt-decoder/intel-pt-insn-decoder.c util/intel-pt-decoder/inat.c $(OUTPUT)util/intel-pt-decoder/inat-tables.c
-        @(test -d ../../kernel -a -d ../../tools -a -d ../perf && (( \
+        @(diff -I 2>&1 | grep -q 'option requires an argument' && \
+        test -d ../../kernel -a -d ../../tools -a -d ../perf && (( \
         diff -B -I'^#include' util/intel-pt-decoder/insn.c ../../arch/x86/lib/insn.c >/dev/null && \
         diff -B -I'^#include' util/intel-pt-decoder/inat.c ../../arch/x86/lib/inat.c >/dev/null && \
         diff -B util/intel-pt-decoder/x86-opcode-map.txt ../../arch/x86/lib/x86-opcode-map.txt >/dev/null && \
diff --git a/tools/perf/util/intel-pt-decoder/gen-insn-attr-x86.awk b/tools/perf/util/intel-pt-decoder/gen-insn-attr-x86.awk
index 517567347aac..54e961659514 100644
--- a/tools/perf/util/intel-pt-decoder/gen-insn-attr-x86.awk
+++ b/tools/perf/util/intel-pt-decoder/gen-insn-attr-x86.awk
@@ -72,12 +72,14 @@ BEGIN {
         lprefix_expr = "\\((66|F2|F3)\\)"
         max_lprefix = 4
 
-        # All opcodes starting with lower-case 'v' or with (v1) superscript
+        # All opcodes starting with lower-case 'v', 'k' or with (v1) superscript
         # accepts VEX prefix
-        vexok_opcode_expr = "^v.*"
+        vexok_opcode_expr = "^[vk].*"
         vexok_expr = "\\(v1\\)"
         # All opcodes with (v) superscript supports *only* VEX prefix
         vexonly_expr = "\\(v\\)"
+        # All opcodes with (ev) superscript supports *only* EVEX prefix
+        evexonly_expr = "\\(ev\\)"
 
         prefix_expr = "\\(Prefix\\)"
         prefix_num["Operand-Size"] = "INAT_PFX_OPNDSZ"
@@ -95,6 +97,7 @@ BEGIN {
         prefix_num["Address-Size"] = "INAT_PFX_ADDRSZ"
         prefix_num["VEX+1byte"] = "INAT_PFX_VEX2"
         prefix_num["VEX+2byte"] = "INAT_PFX_VEX3"
+        prefix_num["EVEX"] = "INAT_PFX_EVEX"
 
         clear_vars()
 }
@@ -319,7 +322,9 @@ function convert_operands(count,opnd,       i,j,imm,mod)
                         flags = add_flags(flags, "INAT_MODRM")
 
                 # check VEX codes
-                if (match(ext, vexonly_expr))
+                if (match(ext, evexonly_expr))
+                        flags = add_flags(flags, "INAT_VEXOK | INAT_EVEXONLY")
+                else if (match(ext, vexonly_expr))
                         flags = add_flags(flags, "INAT_VEXOK | INAT_VEXONLY")
                 else if (match(ext, vexok_expr) || match(opcode, vexok_opcode_expr))
                         flags = add_flags(flags, "INAT_VEXOK")
diff --git a/tools/perf/util/intel-pt-decoder/inat.h b/tools/perf/util/intel-pt-decoder/inat.h
index 611645e903a8..125ecd2a300d 100644
--- a/tools/perf/util/intel-pt-decoder/inat.h
+++ b/tools/perf/util/intel-pt-decoder/inat.h
@@ -48,6 +48,7 @@
 /* AVX VEX prefixes */
 #define INAT_PFX_VEX2   13      /* 2-bytes VEX prefix */
 #define INAT_PFX_VEX3   14      /* 3-bytes VEX prefix */
+#define INAT_PFX_EVEX   15      /* EVEX prefix */
 
 #define INAT_LSTPFX_MAX 3
 #define INAT_LGCPFX_MAX 11
@@ -89,6 +90,7 @@
 #define INAT_VARIANT    (1 << (INAT_FLAG_OFFS + 4))
 #define INAT_VEXOK      (1 << (INAT_FLAG_OFFS + 5))
 #define INAT_VEXONLY    (1 << (INAT_FLAG_OFFS + 6))
+#define INAT_EVEXONLY   (1 << (INAT_FLAG_OFFS + 7))
 /* Attribute making macros for attribute tables */
 #define INAT_MAKE_PREFIX(pfx)   (pfx << INAT_PFX_OFFS)
 #define INAT_MAKE_ESCAPE(esc)   (esc << INAT_ESC_OFFS)
@@ -141,7 +143,13 @@ static inline int inat_last_prefix_id(insn_attr_t attr)
 static inline int inat_is_vex_prefix(insn_attr_t attr)
 {
         attr &= INAT_PFX_MASK;
-        return attr == INAT_PFX_VEX2 || attr == INAT_PFX_VEX3;
+        return attr == INAT_PFX_VEX2 || attr == INAT_PFX_VEX3 ||
+               attr == INAT_PFX_EVEX;
+}
+
+static inline int inat_is_evex_prefix(insn_attr_t attr)
+{
+        return (attr & INAT_PFX_MASK) == INAT_PFX_EVEX;
 }
 
 static inline int inat_is_vex3_prefix(insn_attr_t attr)
@@ -216,6 +224,11 @@ static inline int inat_accept_vex(insn_attr_t attr)
 
 static inline int inat_must_vex(insn_attr_t attr)
 {
-        return attr & INAT_VEXONLY;
+        return attr & (INAT_VEXONLY | INAT_EVEXONLY);
+}
+
+static inline int inat_must_evex(insn_attr_t attr)
+{
+        return attr & INAT_EVEXONLY;
 }
 #endif
diff --git a/tools/perf/util/intel-pt-decoder/insn.c b/tools/perf/util/intel-pt-decoder/insn.c
index 9f26eae6c9f0..ca983e2bea8b 100644
--- a/tools/perf/util/intel-pt-decoder/insn.c
+++ b/tools/perf/util/intel-pt-decoder/insn.c
@@ -155,14 +155,24 @@ found:
                         /*
                          * In 32-bits mode, if the [7:6] bits (mod bits of
                          * ModRM) on the second byte are not 11b, it is
-                         * LDS or LES.
+                         * LDS or LES or BOUND.
                          */
                         if (X86_MODRM_MOD(b2) != 3)
                                 goto vex_end;
                 }
                 insn->vex_prefix.bytes[0] = b;
                 insn->vex_prefix.bytes[1] = b2;
-                if (inat_is_vex3_prefix(attr)) {
+                if (inat_is_evex_prefix(attr)) {
+                        b2 = peek_nbyte_next(insn_byte_t, insn, 2);
+                        insn->vex_prefix.bytes[2] = b2;
+                        b2 = peek_nbyte_next(insn_byte_t, insn, 3);
+                        insn->vex_prefix.bytes[3] = b2;
+                        insn->vex_prefix.nbytes = 4;
+                        insn->next_byte += 4;
+                        if (insn->x86_64 && X86_VEX_W(b2))
+                                /* VEX.W overrides opnd_size */
+                                insn->opnd_bytes = 8;
+                } else if (inat_is_vex3_prefix(attr)) {
                         b2 = peek_nbyte_next(insn_byte_t, insn, 2);
                         insn->vex_prefix.bytes[2] = b2;
                         insn->vex_prefix.nbytes = 3;
@@ -221,7 +231,9 @@ void insn_get_opcode(struct insn *insn)
                 m = insn_vex_m_bits(insn);
                 p = insn_vex_p_bits(insn);
                 insn->attr = inat_get_avx_attribute(op, m, p);
-                if (!inat_accept_vex(insn->attr) && !inat_is_group(insn->attr))
+                if ((inat_must_evex(insn->attr) && !insn_is_evex(insn)) ||
+                    (!inat_accept_vex(insn->attr) &&
+                     !inat_is_group(insn->attr)))
                         insn->attr = 0; /* This instruction is bad */
                 goto end;       /* VEX has only 1 byte for opcode */
         }
diff --git a/tools/perf/util/intel-pt-decoder/insn.h b/tools/perf/util/intel-pt-decoder/insn.h
index dd12da0f4593..e23578c7b1be 100644
--- a/tools/perf/util/intel-pt-decoder/insn.h
+++ b/tools/perf/util/intel-pt-decoder/insn.h
@@ -91,6 +91,7 @@ struct insn {
 #define X86_VEX_B(vex)  ((vex) & 0x20)  /* VEX3 Byte1 */
 #define X86_VEX_L(vex)  ((vex) & 0x04)  /* VEX3 Byte2, VEX2 Byte1 */
 /* VEX bit fields */
+#define X86_EVEX_M(vex) ((vex) & 0x03)          /* EVEX Byte1 */
 #define X86_VEX3_M(vex) ((vex) & 0x1f)          /* VEX3 Byte1 */
 #define X86_VEX2_M      1                       /* VEX2.M always 1 */
 #define X86_VEX_V(vex)  (((vex) & 0x78) >> 3)   /* VEX3 Byte2, VEX2 Byte1 */
@@ -133,6 +134,13 @@ static inline int insn_is_avx(struct insn *insn)
         return (insn->vex_prefix.value != 0);
 }
 
+static inline int insn_is_evex(struct insn *insn)
+{
+        if (!insn->prefixes.got)
+                insn_get_prefixes(insn);
+        return (insn->vex_prefix.nbytes == 4);
+}
+
 /* Ensure this instruction is decoded completely */
 static inline int insn_complete(struct insn *insn)
 {
@@ -144,8 +152,10 @@ static inline insn_byte_t insn_vex_m_bits(struct insn *insn)
 {
         if (insn->vex_prefix.nbytes == 2)       /* 2 bytes VEX */
                 return X86_VEX2_M;
-        else
+        else if (insn->vex_prefix.nbytes == 3)  /* 3 bytes VEX */
                 return X86_VEX3_M(insn->vex_prefix.bytes[1]);
+        else                                    /* EVEX */
+                return X86_EVEX_M(insn->vex_prefix.bytes[1]);
 }
 
 static inline insn_byte_t insn_vex_p_bits(struct insn *insn)
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
index 9c8f15da86ce..16c06d3ae577 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.c
@@ -80,6 +80,7 @@ struct intel_pt_decoder {
         int (*walk_insn)(struct intel_pt_insn *intel_pt_insn,
                          uint64_t *insn_cnt_ptr, uint64_t *ip, uint64_t to_ip,
                          uint64_t max_insn_cnt, void *data);
+        bool (*pgd_ip)(uint64_t ip, void *data);
         void *data;
         struct intel_pt_state state;
         const unsigned char *buf;
@@ -89,6 +90,7 @@ struct intel_pt_decoder {
         bool pge;
         bool have_tma;
         bool have_cyc;
+        bool fixup_last_mtc;
         uint64_t pos;
         uint64_t last_ip;
         uint64_t ip;
@@ -123,8 +125,6 @@ struct intel_pt_decoder {
         bool have_calc_cyc_to_tsc;
         int exec_mode;
         unsigned int insn_bytes;
-        uint64_t sign_bit;
-        uint64_t sign_bits;
         uint64_t period;
         enum intel_pt_period_type period_type;
         uint64_t tot_insn_cnt;
@@ -188,12 +188,10 @@ struct intel_pt_decoder *intel_pt_decoder_new(struct intel_pt_params *params)
 
         decoder->get_trace          = params->get_trace;
         decoder->walk_insn          = params->walk_insn;
+        decoder->pgd_ip             = params->pgd_ip;
         decoder->data               = params->data;
         decoder->return_compression = params->return_compression;
 
-        decoder->sign_bit           = (uint64_t)1 << 47;
-        decoder->sign_bits          = ~(((uint64_t)1 << 48) - 1);
-
         decoder->period             = params->period;
         decoder->period_type        = params->period_type;
 
@@ -362,21 +360,30 @@ int intel_pt__strerror(int code, char *buf, size_t buflen)
         return 0;
 }
 
-static uint64_t intel_pt_calc_ip(struct intel_pt_decoder *decoder,
-                                 const struct intel_pt_pkt *packet,
+static uint64_t intel_pt_calc_ip(const struct intel_pt_pkt *packet,
                                  uint64_t last_ip)
 {
         uint64_t ip;
 
         switch (packet->count) {
-        case 2:
+        case 1:
                 ip = (last_ip & (uint64_t)0xffffffffffff0000ULL) |
                      packet->payload;
                 break;
-        case 4:
+        case 2:
                 ip = (last_ip & (uint64_t)0xffffffff00000000ULL) |
                      packet->payload;
                 break;
+        case 3:
+                ip = packet->payload;
+                /* Sign-extend 6-byte ip */
+                if (ip & (uint64_t)0x800000000000ULL)
+                        ip |= (uint64_t)0xffff000000000000ULL;
+                break;
+        case 4:
+                ip = (last_ip & (uint64_t)0xffff000000000000ULL) |
+                     packet->payload;
+                break;
         case 6:
                 ip = packet->payload;
                 break;
@@ -384,16 +391,12 @@ static uint64_t intel_pt_calc_ip(struct intel_pt_decoder *decoder,
                 return 0;
         }
 
-        if (ip & decoder->sign_bit)
-                return ip | decoder->sign_bits;
-
         return ip;
 }
 
 static inline void intel_pt_set_last_ip(struct intel_pt_decoder *decoder)
 {
-        decoder->last_ip = intel_pt_calc_ip(decoder, &decoder->packet,
-                                            decoder->last_ip);
+        decoder->last_ip = intel_pt_calc_ip(&decoder->packet, decoder->last_ip);
 }
 
 static inline void intel_pt_set_ip(struct intel_pt_decoder *decoder)
@@ -584,10 +587,31 @@ struct intel_pt_calc_cyc_to_tsc_info {
         uint64_t        tsc_timestamp;
         uint64_t        timestamp;
         bool            have_tma;
+        bool            fixup_last_mtc;
         bool            from_mtc;
         double          cbr_cyc_to_tsc;
 };
 
+/*
+ * MTC provides a 8-bit slice of CTC but the TMA packet only provides the lower
+ * 16 bits of CTC. If mtc_shift > 8 then some of the MTC bits are not in the CTC
+ * provided by the TMA packet. Fix-up the last_mtc calculated from the TMA
+ * packet by copying the missing bits from the current MTC assuming the least
+ * difference between the two, and that the current MTC comes after last_mtc.
+ */
+static void intel_pt_fixup_last_mtc(uint32_t mtc, int mtc_shift,
+                                    uint32_t *last_mtc)
+{
+        uint32_t first_missing_bit = 1U << (16 - mtc_shift);
+        uint32_t mask = ~(first_missing_bit - 1);
+
+        *last_mtc |= mtc & mask;
+        if (*last_mtc >= mtc) {
+                *last_mtc -= first_missing_bit;
+                *last_mtc &= 0xff;
+        }
+}
+
 static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
 {
         struct intel_pt_decoder *decoder = pkt_info->decoder;
@@ -617,6 +641,11 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
                         return 0;
 
                 mtc = pkt_info->packet.payload;
+                if (decoder->mtc_shift > 8 && data->fixup_last_mtc) {
+                        data->fixup_last_mtc = false;
+                        intel_pt_fixup_last_mtc(mtc, decoder->mtc_shift,
+                                                &data->last_mtc);
+                }
                 if (mtc > data->last_mtc)
                         mtc_delta = mtc - data->last_mtc;
                 else
@@ -685,6 +714,7 @@ static int intel_pt_calc_cyc_cb(struct intel_pt_pkt_info *pkt_info)
 
                 data->ctc_delta = 0;
                 data->have_tma = true;
+                data->fixup_last_mtc = true;
 
                 return 0;
 
@@ -751,6 +781,7 @@ static void intel_pt_calc_cyc_to_tsc(struct intel_pt_decoder *decoder,
                 .tsc_timestamp  = decoder->tsc_timestamp,
                 .timestamp      = decoder->timestamp,
                 .have_tma       = decoder->have_tma,
+                .fixup_last_mtc = decoder->fixup_last_mtc,
                 .from_mtc       = from_mtc,
                 .cbr_cyc_to_tsc = 0,
         };
@@ -1008,6 +1039,19 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
         int err;
 
         err = intel_pt_walk_insn(decoder, &intel_pt_insn, 0);
+        if (err == INTEL_PT_RETURN &&
+            decoder->pgd_ip &&
+            decoder->pkt_state == INTEL_PT_STATE_TIP_PGD &&
+            (decoder->state.type & INTEL_PT_BRANCH) &&
+            decoder->pgd_ip(decoder->state.to_ip, decoder->data)) {
+                /* Unconditional branch leaving filter region */
+                decoder->no_progress = 0;
+                decoder->pge = false;
+                decoder->continuous_period = false;
+                decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
+                decoder->state.to_ip = 0;
+                return 0;
+        }
         if (err == INTEL_PT_RETURN)
                 return 0;
         if (err)
@@ -1036,6 +1080,21 @@ static int intel_pt_walk_tip(struct intel_pt_decoder *decoder)
         }
 
         if (intel_pt_insn.branch == INTEL_PT_BR_CONDITIONAL) {
+                uint64_t to_ip = decoder->ip + intel_pt_insn.length +
+                                 intel_pt_insn.rel;
+
+                if (decoder->pgd_ip &&
+                    decoder->pkt_state == INTEL_PT_STATE_TIP_PGD &&
+                    decoder->pgd_ip(to_ip, decoder->data)) {
+                        /* Conditional branch leaving filter region */
+                        decoder->pge = false;
+                        decoder->continuous_period = false;
+                        decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
+                        decoder->ip = to_ip;
+                        decoder->state.from_ip = decoder->ip;
+                        decoder->state.to_ip = 0;
+                        return 0;
+                }
                 intel_pt_log_at("ERROR: Conditional branch when expecting indirect branch",
                                 decoder->ip);
                 decoder->pkt_state = INTEL_PT_STATE_ERR_RESYNC;
@@ -1241,6 +1300,7 @@ static void intel_pt_calc_tma(struct intel_pt_decoder *decoder)
         }
         decoder->ctc_delta = 0;
         decoder->have_tma = true;
+        decoder->fixup_last_mtc = true;
         intel_pt_log("CTC timestamp " x64_fmt " last MTC %#x  CTC rem %#x\n",
                      decoder->ctc_timestamp, decoder->last_mtc, ctc_rem);
 }
@@ -1255,6 +1315,12 @@ static void intel_pt_calc_mtc_timestamp(struct intel_pt_decoder *decoder)
 
         mtc = decoder->packet.payload;
 
+        if (decoder->mtc_shift > 8 && decoder->fixup_last_mtc) {
+                decoder->fixup_last_mtc = false;
+                intel_pt_fixup_last_mtc(mtc, decoder->mtc_shift,
+                                        &decoder->last_mtc);
+        }
+
         if (mtc > decoder->last_mtc)
                 mtc_delta = mtc - decoder->last_mtc;
         else
@@ -1323,6 +1389,8 @@ static void intel_pt_calc_cyc_timestamp(struct intel_pt_decoder *decoder)
                              timestamp, decoder->timestamp);
         else
                 decoder->timestamp = timestamp;
+
+        decoder->timestamp_insn_cnt = 0;
 }
 
 /* Walk PSB+ packets when already in sync. */
@@ -1657,6 +1725,12 @@ next:
         }
 }
 
+static inline bool intel_pt_have_ip(struct intel_pt_decoder *decoder)
+{
+        return decoder->last_ip || decoder->packet.count == 0 ||
+               decoder->packet.count == 3 || decoder->packet.count == 6;
+}
+
 /* Walk PSB+ packets to get in sync. */
 static int intel_pt_walk_psb(struct intel_pt_decoder *decoder)
 {
@@ -1677,8 +1751,7 @@ static int intel_pt_walk_psb(struct intel_pt_decoder *decoder)
 
                 case INTEL_PT_FUP:
                         decoder->pge = true;
-                        if (decoder->last_ip || decoder->packet.count == 6 ||
-                            decoder->packet.count == 0) {
+                        if (intel_pt_have_ip(decoder)) {
                                 uint64_t current_ip = decoder->ip;
 
                                 intel_pt_set_ip(decoder);
@@ -1767,8 +1840,7 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
                 case INTEL_PT_TIP_PGE:
                 case INTEL_PT_TIP:
                         decoder->pge = decoder->packet.type != INTEL_PT_TIP_PGD;
-                        if (decoder->last_ip || decoder->packet.count == 6 ||
-                            decoder->packet.count == 0)
+                        if (intel_pt_have_ip(decoder))
                                 intel_pt_set_ip(decoder);
                         if (decoder->ip)
                                 return 0;
@@ -1776,9 +1848,7 @@ static int intel_pt_walk_to_ip(struct intel_pt_decoder *decoder)
 
                 case INTEL_PT_FUP:
                         if (decoder->overflow) {
-                                if (decoder->last_ip ||
-                                    decoder->packet.count == 6 ||
-                                    decoder->packet.count == 0)
+                                if (intel_pt_have_ip(decoder))
                                         intel_pt_set_ip(decoder);
                                 if (decoder->ip)
                                         return 0;
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
index 02c38fec1c37..89399985fa4d 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-decoder.h
@@ -83,6 +83,7 @@ struct intel_pt_params {
         int (*walk_insn)(struct intel_pt_insn *intel_pt_insn,
                          uint64_t *insn_cnt_ptr, uint64_t *ip, uint64_t to_ip,
                          uint64_t max_insn_cnt, void *data);
+        bool (*pgd_ip)(uint64_t ip, void *data);
         void *data;
         bool return_compression;
         uint64_t period;
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
index b1257c816310..4f7b32020487 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
@@ -292,36 +292,46 @@ static int intel_pt_get_ip(enum intel_pt_pkt_type type, unsigned int byte,
                            const unsigned char *buf, size_t len,
                            struct intel_pt_pkt *packet)
 {
-        switch (byte >> 5) {
+        int ip_len;
+
+        packet->count = byte >> 5;
+
+        switch (packet->count) {
         case 0:
-                packet->count = 0;
+                ip_len = 0;
                 break;
         case 1:
                 if (len < 3)
                         return INTEL_PT_NEED_MORE_BYTES;
-                packet->count = 2;
+                ip_len = 2;
                 packet->payload = le16_to_cpu(*(uint16_t *)(buf + 1));
                 break;
         case 2:
                 if (len < 5)
                         return INTEL_PT_NEED_MORE_BYTES;
-                packet->count = 4;
+                ip_len = 4;
                 packet->payload = le32_to_cpu(*(uint32_t *)(buf + 1));
                 break;
         case 3:
-        case 6:
+        case 4:
                 if (len < 7)
                         return INTEL_PT_NEED_MORE_BYTES;
-                packet->count = 6;
+                ip_len = 6;
                 memcpy_le64(&packet->payload, buf + 1, 6);
                 break;
+        case 6:
+                if (len < 9)
+                        return INTEL_PT_NEED_MORE_BYTES;
+                ip_len = 8;
+                packet->payload = le64_to_cpu(*(uint64_t *)(buf + 1));
+                break;
         default:
                 return INTEL_PT_BAD_PACKET;
         }
 
         packet->type = type;
 
-        return packet->count + 1;
+        return ip_len + 1;
 }
 
 static int intel_pt_get_mode(const unsigned char *buf, size_t len,
diff --git a/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt b/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
index d388de72eaca..767be7c76034 100644
--- a/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
+++ b/tools/perf/util/intel-pt-decoder/x86-opcode-map.txt
@@ -13,12 +13,17 @@
 # opcode: escape # escaped-name
 # EndTable
 #
+# mnemonics that begin with lowercase 'v' accept a VEX or EVEX prefix
+# mnemonics that begin with lowercase 'k' accept a VEX prefix
+#
 #<group maps>
 # GrpTable: GrpXXX
 # reg:  mnemonic [operand1[,operand2...]] [(extra1)[,(extra2)...] [| 2nd-mnemonic ...]
 # EndTable
 #
 # AVX Superscripts
+#  (ev): this opcode requires EVEX prefix.
+#  (evo): this opcode is changed by EVEX prefix (EVEX opcode)
 #  (v): this opcode requires VEX prefix.
 #  (v1): this opcode only supports 128bit VEX.
 #
@@ -137,7 +142,7 @@ AVXcode:
 # 0x60 - 0x6f
 60: PUSHA/PUSHAD (i64)
 61: POPA/POPAD (i64)
-62: BOUND Gv,Ma (i64)
+62: BOUND Gv,Ma (i64) | EVEX (Prefix)
 63: ARPL Ew,Gw (i64) | MOVSXD Gv,Ev (o64)
 64: SEG=FS (Prefix)
 65: SEG=GS (Prefix)
@@ -399,17 +404,17 @@ AVXcode: 1
 3f:
 # 0x0f 0x40-0x4f
 40: CMOVO Gv,Ev
-41: CMOVNO Gv,Ev
-42: CMOVB/C/NAE Gv,Ev
+41: CMOVNO Gv,Ev | kandw/q Vk,Hk,Uk | kandb/d Vk,Hk,Uk (66)
+42: CMOVB/C/NAE Gv,Ev | kandnw/q Vk,Hk,Uk | kandnb/d Vk,Hk,Uk (66)
 43: CMOVAE/NB/NC Gv,Ev
-44: CMOVE/Z Gv,Ev
-45: CMOVNE/NZ Gv,Ev
-46: CMOVBE/NA Gv,Ev
-47: CMOVA/NBE Gv,Ev
+44: CMOVE/Z Gv,Ev | knotw/q Vk,Uk | knotb/d Vk,Uk (66)
+45: CMOVNE/NZ Gv,Ev | korw/q Vk,Hk,Uk | korb/d Vk,Hk,Uk (66)
+46: CMOVBE/NA Gv,Ev | kxnorw/q Vk,Hk,Uk | kxnorb/d Vk,Hk,Uk (66)
+47: CMOVA/NBE Gv,Ev | kxorw/q Vk,Hk,Uk | kxorb/d Vk,Hk,Uk (66)
 48: CMOVS Gv,Ev
 49: CMOVNS Gv,Ev
-4a: CMOVP/PE Gv,Ev
-4b: CMOVNP/PO Gv,Ev
+4a: CMOVP/PE Gv,Ev | kaddw/q Vk,Hk,Uk | kaddb/d Vk,Hk,Uk (66)
+4b: CMOVNP/PO Gv,Ev | kunpckbw Vk,Hk,Uk (66) | kunpckwd/dq Vk,Hk,Uk
 4c: CMOVL/NGE Gv,Ev
 4d: CMOVNL/GE Gv,Ev
 4e: CMOVLE/NG Gv,Ev
@@ -426,7 +431,7 @@ AVXcode: 1
 58: vaddps Vps,Hps,Wps | vaddpd Vpd,Hpd,Wpd (66) | vaddss Vss,Hss,Wss (F3),(v1) | vaddsd Vsd,Hsd,Wsd (F2),(v1)
 59: vmulps Vps,Hps,Wps | vmulpd Vpd,Hpd,Wpd (66) | vmulss Vss,Hss,Wss (F3),(v1) | vmulsd Vsd,Hsd,Wsd (F2),(v1)
 5a: vcvtps2pd Vpd,Wps | vcvtpd2ps Vps,Wpd (66) | vcvtss2sd Vsd,Hx,Wss (F3),(v1) | vcvtsd2ss Vss,Hx,Wsd (F2),(v1)
-5b: vcvtdq2ps Vps,Wdq | vcvtps2dq Vdq,Wps (66) | vcvttps2dq Vdq,Wps (F3)
+5b: vcvtdq2ps Vps,Wdq | vcvtqq2ps Vps,Wqq (evo) | vcvtps2dq Vdq,Wps (66) | vcvttps2dq Vdq,Wps (F3)
 5c: vsubps Vps,Hps,Wps | vsubpd Vpd,Hpd,Wpd (66) | vsubss Vss,Hss,Wss (F3),(v1) | vsubsd Vsd,Hsd,Wsd (F2),(v1)
 5d: vminps Vps,Hps,Wps | vminpd Vpd,Hpd,Wpd (66) | vminss Vss,Hss,Wss (F3),(v1) | vminsd Vsd,Hsd,Wsd (F2),(v1)
 5e: vdivps Vps,Hps,Wps | vdivpd Vpd,Hpd,Wpd (66) | vdivss Vss,Hss,Wss (F3),(v1) | vdivsd Vsd,Hsd,Wsd (F2),(v1)
@@ -447,7 +452,7 @@ AVXcode: 1
 6c: vpunpcklqdq Vx,Hx,Wx (66),(v1)
 6d: vpunpckhqdq Vx,Hx,Wx (66),(v1)
 6e: movd/q Pd,Ey | vmovd/q Vy,Ey (66),(v1)
-6f: movq Pq,Qq | vmovdqa Vx,Wx (66) | vmovdqu Vx,Wx (F3)
+6f: movq Pq,Qq | vmovdqa Vx,Wx (66) | vmovdqa32/64 Vx,Wx (66),(evo) | vmovdqu Vx,Wx (F3) | vmovdqu32/64 Vx,Wx (F3),(evo) | vmovdqu8/16 Vx,Wx (F2),(ev)
 # 0x0f 0x70-0x7f
 70: pshufw Pq,Qq,Ib | vpshufd Vx,Wx,Ib (66),(v1) | vpshufhw Vx,Wx,Ib (F3),(v1) | vpshuflw Vx,Wx,Ib (F2),(v1)
 71: Grp12 (1A)
@@ -458,14 +463,14 @@ AVXcode: 1
 76: pcmpeqd Pq,Qq | vpcmpeqd Vx,Hx,Wx (66),(v1)
 # Note: Remove (v), because vzeroall and vzeroupper becomes emms without VEX.
 77: emms | vzeroupper | vzeroall
-78: VMREAD Ey,Gy
-79: VMWRITE Gy,Ey
-7a:
-7b:
+78: VMREAD Ey,Gy | vcvttps2udq/pd2udq Vx,Wpd (evo) | vcvttsd2usi Gv,Wx (F2),(ev) | vcvttss2usi Gv,Wx (F3),(ev) | vcvttps2uqq/pd2uqq Vx,Wx (66),(ev)
+79: VMWRITE Gy,Ey | vcvtps2udq/pd2udq Vx,Wpd (evo) | vcvtsd2usi Gv,Wx (F2),(ev) | vcvtss2usi Gv,Wx (F3),(ev) | vcvtps2uqq/pd2uqq Vx,Wx (66),(ev)
+7a: vcvtudq2pd/uqq2pd Vpd,Wx (F3),(ev) | vcvtudq2ps/uqq2ps Vpd,Wx (F2),(ev) | vcvttps2qq/pd2qq Vx,Wx (66),(ev)
+7b: vcvtusi2sd Vpd,Hpd,Ev (F2),(ev) | vcvtusi2ss Vps,Hps,Ev (F3),(ev) | vcvtps2qq/pd2qq Vx,Wx (66),(ev)
 7c: vhaddpd Vpd,Hpd,Wpd (66) | vhaddps Vps,Hps,Wps (F2)
 7d: vhsubpd Vpd,Hpd,Wpd (66) | vhsubps Vps,Hps,Wps (F2)
 7e: movd/q Ey,Pd | vmovd/q Ey,Vy (66),(v1) | vmovq Vq,Wq (F3),(v1)
-7f: movq Qq,Pq | vmovdqa Wx,Vx (66) | vmovdqu Wx,Vx (F3)
+7f: movq Qq,Pq | vmovdqa Wx,Vx (66) | vmovdqa32/64 Wx,Vx (66),(evo) | vmovdqu Wx,Vx (F3) | vmovdqu32/64 Wx,Vx (F3),(evo) | vmovdqu8/16 Wx,Vx (F2),(ev)
 # 0x0f 0x80-0x8f
 # Note: "forced64" is Intel CPU behavior (see comment about CALL insn).
 80: JO Jz (f64)
@@ -485,16 +490,16 @@ AVXcode: 1
 8e: JLE/JNG Jz (f64)
 8f: JNLE/JG Jz (f64)
 # 0x0f 0x90-0x9f
-90: SETO Eb
-91: SETNO Eb
-92: SETB/C/NAE Eb
-93: SETAE/NB/NC Eb
+90: SETO Eb | kmovw/q Vk,Wk | kmovb/d Vk,Wk (66)
+91: SETNO Eb | kmovw/q Mv,Vk | kmovb/d Mv,Vk (66)
+92: SETB/C/NAE Eb | kmovw Vk,Rv | kmovb Vk,Rv (66) | kmovq/d Vk,Rv (F2)
+93: SETAE/NB/NC Eb | kmovw Gv,Uk | kmovb Gv,Uk (66) | kmovq/d Gv,Uk (F2)
 94: SETE/Z Eb
 95: SETNE/NZ Eb
 96: SETBE/NA Eb
 97: SETA/NBE Eb
-98: SETS Eb
-99: SETNS Eb
+98: SETS Eb | kortestw/q Vk,Uk | kortestb/d Vk,Uk (66)
+99: SETNS Eb | ktestw/q Vk,Uk | ktestb/d Vk,Uk (66)
 9a: SETP/PE Eb
 9b: SETNP/PO Eb
 9c: SETL/NGE Eb
@@ -564,11 +569,11 @@ d7: pmovmskb Gd,Nq | vpmovmskb Gd,Ux (66),(v1)
 d8: psubusb Pq,Qq | vpsubusb Vx,Hx,Wx (66),(v1)
 d9: psubusw Pq,Qq | vpsubusw Vx,Hx,Wx (66),(v1)
 da: pminub Pq,Qq | vpminub Vx,Hx,Wx (66),(v1)
-db: pand Pq,Qq | vpand Vx,Hx,Wx (66),(v1)
+db: pand Pq,Qq | vpand Vx,Hx,Wx (66),(v1) | vpandd/q Vx,Hx,Wx (66),(evo)
 dc: paddusb Pq,Qq | vpaddusb Vx,Hx,Wx (66),(v1)
 dd: paddusw Pq,Qq | vpaddusw Vx,Hx,Wx (66),(v1)
 de: pmaxub Pq,Qq | vpmaxub Vx,Hx,Wx (66),(v1)
-df: pandn Pq,Qq | vpandn Vx,Hx,Wx (66),(v1)
+df: pandn Pq,Qq | vpandn Vx,Hx,Wx (66),(v1) | vpandnd/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0xe0-0xef
 e0: pavgb Pq,Qq | vpavgb Vx,Hx,Wx (66),(v1)
 e1: psraw Pq,Qq | vpsraw Vx,Hx,Wx (66),(v1)
@@ -576,16 +581,16 @@ e2: psrad Pq,Qq | vpsrad Vx,Hx,Wx (66),(v1)
 e3: pavgw Pq,Qq | vpavgw Vx,Hx,Wx (66),(v1)
 e4: pmulhuw Pq,Qq | vpmulhuw Vx,Hx,Wx (66),(v1)
 e5: pmulhw Pq,Qq | vpmulhw Vx,Hx,Wx (66),(v1)
-e6: vcvttpd2dq Vx,Wpd (66) | vcvtdq2pd Vx,Wdq (F3) | vcvtpd2dq Vx,Wpd (F2)
+e6: vcvttpd2dq Vx,Wpd (66) | vcvtdq2pd Vx,Wdq (F3) | vcvtdq2pd/qq2pd Vx,Wdq (F3),(evo) | vcvtpd2dq Vx,Wpd (F2)
 e7: movntq Mq,Pq | vmovntdq Mx,Vx (66)
 e8: psubsb Pq,Qq | vpsubsb Vx,Hx,Wx (66),(v1)
 e9: psubsw Pq,Qq | vpsubsw Vx,Hx,Wx (66),(v1)
 ea: pminsw Pq,Qq | vpminsw Vx,Hx,Wx (66),(v1)
-eb: por Pq,Qq | vpor Vx,Hx,Wx (66),(v1)
+eb: por Pq,Qq | vpor Vx,Hx,Wx (66),(v1) | vpord/q Vx,Hx,Wx (66),(evo)
 ec: paddsb Pq,Qq | vpaddsb Vx,Hx,Wx (66),(v1)
 ed: paddsw Pq,Qq | vpaddsw Vx,Hx,Wx (66),(v1)
 ee: pmaxsw Pq,Qq | vpmaxsw Vx,Hx,Wx (66),(v1)
-ef: pxor Pq,Qq | vpxor Vx,Hx,Wx (66),(v1)
+ef: pxor Pq,Qq | vpxor Vx,Hx,Wx (66),(v1) | vpxord/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0xf0-0xff
 f0: vlddqu Vx,Mx (F2)
 f1: psllw Pq,Qq | vpsllw Vx,Hx,Wx (66),(v1)
@@ -626,81 +631,105 @@ AVXcode: 2
 0e: vtestps Vx,Wx (66),(v)
 0f: vtestpd Vx,Wx (66),(v)
 # 0x0f 0x38 0x10-0x1f
-10: pblendvb Vdq,Wdq (66)
-11:
-12:
-13: vcvtph2ps Vx,Wx,Ib (66),(v)
-14: blendvps Vdq,Wdq (66)
-15: blendvpd Vdq,Wdq (66)
-16: vpermps Vqq,Hqq,Wqq (66),(v)
+10: pblendvb Vdq,Wdq (66) | vpsrlvw Vx,Hx,Wx (66),(evo) | vpmovuswb Wx,Vx (F3),(ev)
+11: vpmovusdb Wx,Vd (F3),(ev) | vpsravw Vx,Hx,Wx (66),(ev)
+12: vpmovusqb Wx,Vq (F3),(ev) | vpsllvw Vx,Hx,Wx (66),(ev)
+13: vcvtph2ps Vx,Wx (66),(v) | vpmovusdw Wx,Vd (F3),(ev)
+14: blendvps Vdq,Wdq (66) | vpmovusqw Wx,Vq (F3),(ev) | vprorvd/q Vx,Hx,Wx (66),(evo)
+15: blendvpd Vdq,Wdq (66) | vpmovusqd Wx,Vq (F3),(ev) | vprolvd/q Vx,Hx,Wx (66),(evo)
+16: vpermps Vqq,Hqq,Wqq (66),(v) | vpermps/d Vqq,Hqq,Wqq (66),(evo)
 17: vptest Vx,Wx (66)
 18: vbroadcastss Vx,Wd (66),(v)
-19: vbroadcastsd Vqq,Wq (66),(v)
-1a: vbroadcastf128 Vqq,Mdq (66),(v)
-1b:
+19: vbroadcastsd Vqq,Wq (66),(v) | vbroadcastf32x2 Vqq,Wq (66),(evo)
+1a: vbroadcastf128 Vqq,Mdq (66),(v) | vbroadcastf32x4/64x2 Vqq,Wq (66),(evo)
+1b: vbroadcastf32x8/64x4 Vqq,Mdq (66),(ev)
 1c: pabsb Pq,Qq | vpabsb Vx,Wx (66),(v1)
 1d: pabsw Pq,Qq | vpabsw Vx,Wx (66),(v1)
 1e: pabsd Pq,Qq | vpabsd Vx,Wx (66),(v1)
-1f:
+1f: vpabsq Vx,Wx (66),(ev)
 # 0x0f 0x38 0x20-0x2f
-20: vpmovsxbw Vx,Ux/Mq (66),(v1)
-21: vpmovsxbd Vx,Ux/Md (66),(v1)
-22: vpmovsxbq Vx,Ux/Mw (66),(v1)
-23: vpmovsxwd Vx,Ux/Mq (66),(v1)
-24: vpmovsxwq Vx,Ux/Md (66),(v1)
-25: vpmovsxdq Vx,Ux/Mq (66),(v1)
-26:
-27:
-28: vpmuldq Vx,Hx,Wx (66),(v1)
-29: vpcmpeqq Vx,Hx,Wx (66),(v1)
-2a: vmovntdqa Vx,Mx (66),(v1)
+20: vpmovsxbw Vx,Ux/Mq (66),(v1) | vpmovswb Wx,Vx (F3),(ev)
+21: vpmovsxbd Vx,Ux/Md (66),(v1) | vpmovsdb Wx,Vd (F3),(ev)
+22: vpmovsxbq Vx,Ux/Mw (66),(v1) | vpmovsqb Wx,Vq (F3),(ev)
+23: vpmovsxwd Vx,Ux/Mq (66),(v1) | vpmovsdw Wx,Vd (F3),(ev)
+24: vpmovsxwq Vx,Ux/Md (66),(v1) | vpmovsqw Wx,Vq (F3),(ev)
+25: vpmovsxdq Vx,Ux/Mq (66),(v1) | vpmovsqd Wx,Vq (F3),(ev)
+26: vptestmb/w Vk,Hx,Wx (66),(ev) | vptestnmb/w Vk,Hx,Wx (F3),(ev)
+27: vptestmd/q Vk,Hx,Wx (66),(ev) | vptestnmd/q Vk,Hx,Wx (F3),(ev)
+28: vpmuldq Vx,Hx,Wx (66),(v1) | vpmovm2b/w Vx,Uk (F3),(ev)
+29: vpcmpeqq Vx,Hx,Wx (66),(v1) | vpmovb2m/w2m Vk,Ux (F3),(ev)
+2a: vmovntdqa Vx,Mx (66),(v1) | vpbroadcastmb2q Vx,Uk (F3),(ev)
 2b: vpackusdw Vx,Hx,Wx (66),(v1)
-2c: vmaskmovps Vx,Hx,Mx (66),(v)
-2d: vmaskmovpd Vx,Hx,Mx (66),(v)
+2c: vmaskmovps Vx,Hx,Mx (66),(v) | vscalefps/d Vx,Hx,Wx (66),(evo)
+2d: vmaskmovpd Vx,Hx,Mx (66),(v) | vscalefss/d Vx,Hx,Wx (66),(evo)
 2e: vmaskmovps Mx,Hx,Vx (66),(v)
 2f: vmaskmovpd Mx,Hx,Vx (66),(v)
 # 0x0f 0x38 0x30-0x3f
-30: vpmovzxbw Vx,Ux/Mq (66),(v1)
-31: vpmovzxbd Vx,Ux/Md (66),(v1)
-32: vpmovzxbq Vx,Ux/Mw (66),(v1)
-33: vpmovzxwd Vx,Ux/Mq (66),(v1)
-34: vpmovzxwq Vx,Ux/Md (66),(v1)
-35: vpmovzxdq Vx,Ux/Mq (66),(v1)
-36: vpermd Vqq,Hqq,Wqq (66),(v)
+30: vpmovzxbw Vx,Ux/Mq (66),(v1) | vpmovwb Wx,Vx (F3),(ev)
+31: vpmovzxbd Vx,Ux/Md (66),(v1) | vpmovdb Wx,Vd (F3),(ev)
+32: vpmovzxbq Vx,Ux/Mw (66),(v1) | vpmovqb Wx,Vq (F3),(ev)
+33: vpmovzxwd Vx,Ux/Mq (66),(v1) | vpmovdw Wx,Vd (F3),(ev)
+34: vpmovzxwq Vx,Ux/Md (66),(v1) | vpmovqw Wx,Vq (F3),(ev)
+35: vpmovzxdq Vx,Ux/Mq (66),(v1) | vpmovqd Wx,Vq (F3),(ev)
+36: vpermd Vqq,Hqq,Wqq (66),(v) | vpermd/q Vqq,Hqq,Wqq (66),(evo)
 37: vpcmpgtq Vx,Hx,Wx (66),(v1)
-38: vpminsb Vx,Hx,Wx (66),(v1)
-39: vpminsd Vx,Hx,Wx (66),(v1)
-3a: vpminuw Vx,Hx,Wx (66),(v1)
-3b: vpminud Vx,Hx,Wx (66),(v1)
+38: vpminsb Vx,Hx,Wx (66),(v1) | vpmovm2d/q Vx,Uk (F3),(ev)
+39: vpminsd Vx,Hx,Wx (66),(v1) | vpminsd/q Vx,Hx,Wx (66),(evo) | vpmovd2m/q2m Vk,Ux (F3),(ev)
+3a: vpminuw Vx,Hx,Wx (66),(v1) | vpbroadcastmw2d Vx,Uk (F3),(ev)
+3b: vpminud Vx,Hx,Wx (66),(v1) | vpminud/q Vx,Hx,Wx (66),(evo)
 3c: vpmaxsb Vx,Hx,Wx (66),(v1)
-3d: vpmaxsd Vx,Hx,Wx (66),(v1)
+3d: vpmaxsd Vx,Hx,Wx (66),(v1) | vpmaxsd/q Vx,Hx,Wx (66),(evo)
 3e: vpmaxuw Vx,Hx,Wx (66),(v1)
-3f: vpmaxud Vx,Hx,Wx (66),(v1)
+3f: vpmaxud Vx,Hx,Wx (66),(v1) | vpmaxud/q Vx,Hx,Wx (66),(evo)
 # 0x0f 0x38 0x40-0x8f
-40: vpmulld Vx,Hx,Wx (66),(v1)
+40: vpmulld Vx,Hx,Wx (66),(v1) | vpmulld/q Vx,Hx,Wx (66),(evo)
 41: vphminposuw Vdq,Wdq (66),(v1)
-42:
-43:
-44:
+42: vgetexpps/d Vx,Wx (66),(ev)
+43: vgetexpss/d Vx,Hx,Wx (66),(ev)
+44: vplzcntd/q Vx,Wx (66),(ev)
 45: vpsrlvd/q Vx,Hx,Wx (66),(v)
-46: vpsravd Vx,Hx,Wx (66),(v)
+46: vpsravd Vx,Hx,Wx (66),(v) | vpsravd/q Vx,Hx,Wx (66),(evo)
 47: vpsllvd/q Vx,Hx,Wx (66),(v)
-# Skip 0x48-0x57
+# Skip 0x48-0x4b
+4c: vrcp14ps/d Vpd,Wpd (66),(ev)
+4d: vrcp14ss/d Vsd,Hpd,Wsd (66),(ev)
+4e: vrsqrt14ps/d Vpd,Wpd (66),(ev)
+4f: vrsqrt14ss/d Vsd,Hsd,Wsd (66),(ev)
+# Skip 0x50-0x57
 58: vpbroadcastd Vx,Wx (66),(v)
-59: vpbroadcastq Vx,Wx (66),(v)
-5a: vbroadcasti128 Vqq,Mdq (66),(v)
-# Skip 0x5b-0x77
+59: vpbroadcastq Vx,Wx (66),(v) | vbroadcasti32x2 Vx,Wx (66),(evo)
+5a: vbroadcasti128 Vqq,Mdq (66),(v) | vbroadcasti32x4/64x2 Vx,Wx (66),(evo)
+5b: vbroadcasti32x8/64x4 Vqq,Mdq (66),(ev)
+# Skip 0x5c-0x63
+64: vpblendmd/q Vx,Hx,Wx (66),(ev)
+65: vblendmps/d Vx,Hx,Wx (66),(ev)
+66: vpblendmb/w Vx,Hx,Wx (66),(ev)
+# Skip 0x67-0x74
+75: vpermi2b/w Vx,Hx,Wx (66),(ev)
+76: vpermi2d/q Vx,Hx,Wx (66),(ev)
+77: vpermi2ps/d Vx,Hx,Wx (66),(ev)
 78: vpbroadcastb Vx,Wx (66),(v)
 79: vpbroadcastw Vx,Wx (66),(v)
-# Skip 0x7a-0x7f
+7a: vpbroadcastb Vx,Rv (66),(ev)
+7b: vpbroadcastw Vx,Rv (66),(ev)
+7c: vpbroadcastd/q Vx,Rv (66),(ev)
+7d: vpermt2b/w Vx,Hx,Wx (66),(ev)
+7e: vpermt2d/q Vx,Hx,Wx (66),(ev)
+7f: vpermt2ps/d Vx,Hx,Wx (66),(ev)
 80: INVEPT Gy,Mdq (66)
 81: INVPID Gy,Mdq (66)
 82: INVPCID Gy,Mdq (66)
+83: vpmultishiftqb Vx,Hx,Wx (66),(ev)
+88: vexpandps/d Vpd,Wpd (66),(ev)
+89: vpexpandd/q Vx,Wx (66),(ev)
+8a: vcompressps/d Wx,Vx (66),(ev)
+8b: vpcompressd/q Wx,Vx (66),(ev)
 8c: vpmaskmovd/q Vx,Hx,Mx (66),(v)
+8d: vpermb/w Vx,Hx,Wx (66),(ev)
 8e: vpmaskmovd/q Mx,Vx,Hx (66),(v)
 # 0x0f 0x38 0x90-0xbf (FMA)
-90: vgatherdd/q Vx,Hx,Wx (66),(v)
-91: vgatherqd/q Vx,Hx,Wx (66),(v)
+90: vgatherdd/q Vx,Hx,Wx (66),(v) | vpgatherdd/q Vx,Wx (66),(evo)
+91: vgatherqd/q Vx,Hx,Wx (66),(v) | vpgatherqd/q Vx,Wx (66),(evo)
 92: vgatherdps/d Vx,Hx,Wx (66),(v)
 93: vgatherqps/d Vx,Hx,Wx (66),(v)
 94:
@@ -715,6 +744,10 @@ AVXcode: 2
 9d: vfnmadd132ss/d Vx,Hx,Wx (66),(v),(v1)
 9e: vfnmsub132ps/d Vx,Hx,Wx (66),(v)
 9f: vfnmsub132ss/d Vx,Hx,Wx (66),(v),(v1)
+a0: vpscatterdd/q Wx,Vx (66),(ev)
+a1: vpscatterqd/q Wx,Vx (66),(ev)
+a2: vscatterdps/d Wx,Vx (66),(ev)
+a3: vscatterqps/d Wx,Vx (66),(ev)
 a6: vfmaddsub213ps/d Vx,Hx,Wx (66),(v)
 a7: vfmsubadd213ps/d Vx,Hx,Wx (66),(v)
 a8: vfmadd213ps/d Vx,Hx,Wx (66),(v)
@@ -725,6 +758,8 @@ ac: vfnmadd213ps/d Vx,Hx,Wx (66),(v)
 ad: vfnmadd213ss/d Vx,Hx,Wx (66),(v),(v1)
 ae: vfnmsub213ps/d Vx,Hx,Wx (66),(v)
 af: vfnmsub213ss/d Vx,Hx,Wx (66),(v),(v1)
+b4: vpmadd52luq Vx,Hx,Wx (66),(ev)
+b5: vpmadd52huq Vx,Hx,Wx (66),(ev)
 b6: vfmaddsub231ps/d Vx,Hx,Wx (66),(v)
 b7: vfmsubadd231ps/d Vx,Hx,Wx (66),(v)
 b8: vfmadd231ps/d Vx,Hx,Wx (66),(v)
@@ -736,12 +771,15 @@ bd: vfnmadd231ss/d Vx,Hx,Wx (66),(v),(v1)
 be: vfnmsub231ps/d Vx,Hx,Wx (66),(v)
 bf: vfnmsub231ss/d Vx,Hx,Wx (66),(v),(v1)
 # 0x0f 0x38 0xc0-0xff
-c8: sha1nexte Vdq,Wdq
+c4: vpconflictd/q Vx,Wx (66),(ev)
+c6: Grp18 (1A)
+c7: Grp19 (1A)
+c8: sha1nexte Vdq,Wdq | vexp2ps/d Vx,Wx (66),(ev)
 c9: sha1msg1 Vdq,Wdq
-ca: sha1msg2 Vdq,Wdq
-cb: sha256rnds2 Vdq,Wdq
-cc: sha256msg1 Vdq,Wdq
-cd: sha256msg2 Vdq,Wdq
+ca: sha1msg2 Vdq,Wdq | vrcp28ps/d Vx,Wx (66),(ev)
+cb: sha256rnds2 Vdq,Wdq | vrcp28ss/d Vx,Hx,Wx (66),(ev)
+cc: sha256msg1 Vdq,Wdq | vrsqrt28ps/d Vx,Wx (66),(ev)
+cd: sha256msg2 Vdq,Wdq | vrsqrt28ss/d Vx,Hx,Wx (66),(ev)
 db: VAESIMC Vdq,Wdq (66),(v1)
 dc: VAESENC Vdq,Hdq,Wdq (66),(v1)
 dd: VAESENCLAST Vdq,Hdq,Wdq (66),(v1)
@@ -763,15 +801,15 @@ AVXcode: 3
 00: vpermq Vqq,Wqq,Ib (66),(v)
 01: vpermpd Vqq,Wqq,Ib (66),(v)
 02: vpblendd Vx,Hx,Wx,Ib (66),(v)
-03:
+03: valignd/q Vx,Hx,Wx,Ib (66),(ev)
 04: vpermilps Vx,Wx,Ib (66),(v)
 05: vpermilpd Vx,Wx,Ib (66),(v)
 06: vperm2f128 Vqq,Hqq,Wqq,Ib (66),(v)
 07:
-08: vroundps Vx,Wx,Ib (66)
-09: vroundpd Vx,Wx,Ib (66)
-0a: vroundss Vss,Wss,Ib (66),(v1)
-0b: vroundsd Vsd,Wsd,Ib (66),(v1)
+08: vroundps Vx,Wx,Ib (66) | vrndscaleps Vx,Wx,Ib (66),(evo)
+09: vroundpd Vx,Wx,Ib (66) | vrndscalepd Vx,Wx,Ib (66),(evo)
+0a: vroundss Vss,Wss,Ib (66),(v1) | vrndscaless Vx,Hx,Wx,Ib (66),(evo)
+0b: vroundsd Vsd,Wsd,Ib (66),(v1) | vrndscalesd Vx,Hx,Wx,Ib (66),(evo)
 0c: vblendps Vx,Hx,Wx,Ib (66)
 0d: vblendpd Vx,Hx,Wx,Ib (66)
 0e: vpblendw Vx,Hx,Wx,Ib (66),(v1)
@@ -780,26 +818,51 @@ AVXcode: 3
 15: vpextrw Rd/Mw,Vdq,Ib (66),(v1)
 16: vpextrd/q Ey,Vdq,Ib (66),(v1)
 17: vextractps Ed,Vdq,Ib (66),(v1)
-18: vinsertf128 Vqq,Hqq,Wqq,Ib (66),(v)
-19: vextractf128 Wdq,Vqq,Ib (66),(v)
+18: vinsertf128 Vqq,Hqq,Wqq,Ib (66),(v) | vinsertf32x4/64x2 Vqq,Hqq,Wqq,Ib (66),(evo)
+19: vextractf128 Wdq,Vqq,Ib (66),(v) | vextractf32x4/64x2 Wdq,Vqq,Ib (66),(evo)
+1a: vinsertf32x8/64x4 Vqq,Hqq,Wqq,Ib (66),(ev)
+1b: vextractf32x8/64x4 Wdq,Vqq,Ib (66),(ev)
 1d: vcvtps2ph Wx,Vx,Ib (66),(v)
+1e: vpcmpud/q Vk,Hd,Wd,Ib (66),(ev)
+1f: vpcmpd/q Vk,Hd,Wd,Ib (66),(ev)
 20: vpinsrb Vdq,Hdq,Ry/Mb,Ib (66),(v1)
 21: vinsertps Vdq,Hdq,Udq/Md,Ib (66),(v1)
 22: vpinsrd/q Vdq,Hdq,Ey,Ib (66),(v1)
-38: vinserti128 Vqq,Hqq,Wqq,Ib (66),(v)
-39: vextracti128 Wdq,Vqq,Ib (66),(v)
+23: vshuff32x4/64x2 Vx,Hx,Wx,Ib (66),(ev)
+25: vpternlogd/q Vx,Hx,Wx,Ib (66),(ev)
+26: vgetmantps/d Vx,Wx,Ib (66),(ev)
+27: vgetmantss/d Vx,Hx,Wx,Ib (66),(ev)
+30: kshiftrb/w Vk,Uk,Ib (66),(v)
+31: kshiftrd/q Vk,Uk,Ib (66),(v)
+32: kshiftlb/w Vk,Uk,Ib (66),(v)
+33: kshiftld/q Vk,Uk,Ib (66),(v)
+38: vinserti128 Vqq,Hqq,Wqq,Ib (66),(v) | vinserti32x4/64x2 Vqq,Hqq,Wqq,Ib (66),(evo)
+39: vextracti128 Wdq,Vqq,Ib (66),(v) | vextracti32x4/64x2 Wdq,Vqq,Ib (66),(evo)
+3a: vinserti32x8/64x4 Vqq,Hqq,Wqq,Ib (66),(ev)
+3b: vextracti32x8/64x4 Wdq,Vqq,Ib (66),(ev)
+3e: vpcmpub/w Vk,Hk,Wx,Ib (66),(ev)
+3f: vpcmpb/w Vk,Hk,Wx,Ib (66),(ev)
 40: vdpps Vx,Hx,Wx,Ib (66)
 41: vdppd Vdq,Hdq,Wdq,Ib (66),(v1)
-42: vmpsadbw Vx,Hx,Wx,Ib (66),(v1)
+42: vmpsadbw Vx,Hx,Wx,Ib (66),(v1) | vdbpsadbw Vx,Hx,Wx,Ib (66),(evo)
+43: vshufi32x4/64x2 Vx,Hx,Wx,Ib (66),(ev)
 44: vpclmulqdq Vdq,Hdq,Wdq,Ib (66),(v1)
 46: vperm2i128 Vqq,Hqq,Wqq,Ib (66),(v)
 4a: vblendvps Vx,Hx,Wx,Lx (66),(v)
 4b: vblendvpd Vx,Hx,Wx,Lx (66),(v)
 4c: vpblendvb Vx,Hx,Wx,Lx (66),(v1)
+50: vrangeps/d Vx,Hx,Wx,Ib (66),(ev)
+51: vrangess/d Vx,Hx,Wx,Ib (66),(ev)
+54: vfixupimmps/d Vx,Hx,Wx,Ib (66),(ev)
+55: vfixupimmss/d Vx,Hx,Wx,Ib (66),(ev)
+56: vreduceps/d Vx,Wx,Ib (66),(ev)
+57: vreducess/d Vx,Hx,Wx,Ib (66),(ev)
 60: vpcmpestrm Vdq,Wdq,Ib (66),(v1)
 61: vpcmpestri Vdq,Wdq,Ib (66),(v1)
 62: vpcmpistrm Vdq,Wdq,Ib (66),(v1)
 63: vpcmpistri Vdq,Wdq,Ib (66),(v1)
+66: vfpclassps/d Vk,Wx,Ib (66),(ev)
+67: vfpclassss/d Vk,Wx,Ib (66),(ev)
 cc: sha1rnds4 Vdq,Wdq,Ib
 df: VAESKEYGEN Vdq,Wdq,Ib (66),(v1)
 f0: RORX Gy,Ey,Ib (F2),(v)
@@ -927,8 +990,10 @@ GrpTable: Grp12
 EndTable
 
 GrpTable: Grp13
+0: vprord/q Hx,Wx,Ib (66),(ev)
+1: vprold/q Hx,Wx,Ib (66),(ev)
 2: psrld Nq,Ib (11B) | vpsrld Hx,Ux,Ib (66),(11B),(v1)
-4: psrad Nq,Ib (11B) | vpsrad Hx,Ux,Ib (66),(11B),(v1)
+4: psrad Nq,Ib (11B) | vpsrad Hx,Ux,Ib (66),(11B),(v1) | vpsrad/q Hx,Ux,Ib (66),(evo)
 6: pslld Nq,Ib (11B) | vpslld Hx,Ux,Ib (66),(11B),(v1)
 EndTable
 
@@ -947,7 +1012,7 @@ GrpTable: Grp15
 4: XSAVE
 5: XRSTOR | lfence (11B)
 6: XSAVEOPT | clwb (66) | mfence (11B)
-7: clflush | clflushopt (66) | sfence (11B) | pcommit (66),(11B)
+7: clflush | clflushopt (66) | sfence (11B)
 EndTable
 
 GrpTable: Grp16
@@ -963,6 +1028,20 @@ GrpTable: Grp17
 3: BLSI By,Ey (v)
 EndTable
 
+GrpTable: Grp18
+1: vgatherpf0dps/d Wx (66),(ev)
+2: vgatherpf1dps/d Wx (66),(ev)
+5: vscatterpf0dps/d Wx (66),(ev)
+6: vscatterpf1dps/d Wx (66),(ev)
+EndTable
+
+GrpTable: Grp19
+1: vgatherpf0qps/d Wx (66),(ev)
+2: vgatherpf1qps/d Wx (66),(ev)
+5: vscatterpf0qps/d Wx (66),(ev)
+6: vscatterpf1qps/d Wx (66),(ev)
+EndTable
+
 # AMD's Prefetch Group
 GrpTable: GrpP
 0: PREFETCH
diff --git a/tools/perf/util/intel-pt.c b/tools/perf/util/intel-pt.c
index 137196990012..dc041d4368c8 100644
--- a/tools/perf/util/intel-pt.c
+++ b/tools/perf/util/intel-pt.c
@@ -39,6 +39,7 @@
 #include "auxtrace.h"
 #include "tsc.h"
 #include "intel-pt.h"
+#include "config.h"
 
 #include "intel-pt-decoder/intel-pt-log.h"
 #include "intel-pt-decoder/intel-pt-decoder.h"
@@ -102,6 +103,9 @@ struct intel_pt {
         unsigned max_non_turbo_ratio;
 
         unsigned long num_events;
+
+        char *filter;
+        struct addr_filters filts;
 };
 
 enum switch_state {
@@ -240,7 +244,7 @@ static int intel_pt_get_trace(struct intel_pt_buffer *b, void *data)
         }
 
         queue = &ptq->pt->queues.queue_array[ptq->queue_nr];
-
+next:
         buffer = auxtrace_buffer__next(queue, buffer);
         if (!buffer) {
                 if (old_buffer)
@@ -263,9 +267,6 @@ static int intel_pt_get_trace(struct intel_pt_buffer *b, void *data)
             intel_pt_do_fix_overlap(ptq->pt, old_buffer, buffer))
                 return -ENOMEM;
 
-        if (old_buffer)
-                auxtrace_buffer__drop_data(old_buffer);
-
         if (buffer->use_data) {
                 b->len = buffer->use_size;
                 b->buf = buffer->use_data;
@@ -275,6 +276,16 @@ static int intel_pt_get_trace(struct intel_pt_buffer *b, void *data)
         }
         b->ref_timestamp = buffer->reference;
 
+        /*
+         * If in snapshot mode and the buffer has no usable data, get next
+         * buffer and again check overlap against old_buffer.
+         */
+        if (ptq->pt->snapshot_mode && !b->len)
+                goto next;
+
+        if (old_buffer)
+                auxtrace_buffer__drop_data(old_buffer);
+
         if (!old_buffer || ptq->pt->sampling_mode || (ptq->pt->snapshot_mode &&
                                                       !buffer->consecutive)) {
                 b->consecutive = false;
@@ -476,7 +487,7 @@ static int intel_pt_walk_next_insn(struct intel_pt_insn *intel_pt_insn,
                 start_ip = *ip;
 
                 /* Load maps to ensure dso->is_64_bit has been updated */
-                map__load(al.map, machine->symbol_filter);
+                map__load(al.map);
 
                 x86_64 = al.map->dso->is_64_bit;
 
@@ -540,6 +551,76 @@ out_no_cache:
         return 0;
 }
 
+static bool intel_pt_match_pgd_ip(struct intel_pt *pt, uint64_t ip,
+                                  uint64_t offset, const char *filename)
+{
+        struct addr_filter *filt;
+        bool have_filter   = false;
+        bool hit_tracestop = false;
+        bool hit_filter    = false;
+
+        list_for_each_entry(filt, &pt->filts.head, list) {
+                if (filt->start)
+                        have_filter = true;
+
+                if ((filename && !filt->filename) ||
+                    (!filename && filt->filename) ||
+                    (filename && strcmp(filename, filt->filename)))
+                        continue;
+
+                if (!(offset >= filt->addr && offset < filt->addr + filt->size))
+                        continue;
+
+                intel_pt_log("TIP.PGD ip %#"PRIx64" offset %#"PRIx64" in %s hit filter: %s offset %#"PRIx64" size %#"PRIx64"\n",
+                             ip, offset, filename ? filename : "[kernel]",
+                             filt->start ? "filter" : "stop",
+                             filt->addr, filt->size);
+
+                if (filt->start)
+                        hit_filter = true;
+                else
+                        hit_tracestop = true;
+        }
+
+        if (!hit_tracestop && !hit_filter)
+                intel_pt_log("TIP.PGD ip %#"PRIx64" offset %#"PRIx64" in %s is not in a filter region\n",
+                             ip, offset, filename ? filename : "[kernel]");
+
+        return hit_tracestop || (have_filter && !hit_filter);
+}
+
+static int __intel_pt_pgd_ip(uint64_t ip, void *data)
+{
+        struct intel_pt_queue *ptq = data;
+        struct thread *thread;
+        struct addr_location al;
+        u8 cpumode;
+        u64 offset;
+
+        if (ip >= ptq->pt->kernel_start)
+                return intel_pt_match_pgd_ip(ptq->pt, ip, ip, NULL);
+
+        cpumode = PERF_RECORD_MISC_USER;
+
+        thread = ptq->thread;
+        if (!thread)
+                return -EINVAL;
+
+        thread__find_addr_map(thread, cpumode, MAP__FUNCTION, ip, &al);
+        if (!al.map || !al.map->dso)
+                return -EINVAL;
+
+        offset = al.map->map_ip(al.map, ip);
+
+        return intel_pt_match_pgd_ip(ptq->pt, ip, offset,
+                                     al.map->dso->long_name);
+}
+
+static bool intel_pt_pgd_ip(uint64_t ip, void *data)
+{
+        return __intel_pt_pgd_ip(ip, data) > 0;
+}
+
 static bool intel_pt_get_config(struct intel_pt *pt,
                                 struct perf_event_attr *attr, u64 *config)
 {
@@ -556,7 +637,7 @@ static bool intel_pt_exclude_kernel(struct intel_pt *pt)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (intel_pt_get_config(pt, &evsel->attr, NULL) &&
                     !evsel->attr.exclude_kernel)
                         return false;
@@ -572,7 +653,7 @@ static bool intel_pt_return_compression(struct intel_pt *pt)
         if (!pt->noretcomp_bit)
                 return true;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (intel_pt_get_config(pt, &evsel->attr, &config) &&
                     (config & pt->noretcomp_bit))
                         return false;
@@ -592,7 +673,7 @@ static unsigned int intel_pt_mtc_period(struct intel_pt *pt)
         for (shift = 0, config = pt->mtc_freq_bits; !(config & 1); shift++)
                 config >>= 1;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (intel_pt_get_config(pt, &evsel->attr, &config))
                         return (config & pt->mtc_freq_bits) >> shift;
         }
@@ -608,7 +689,7 @@ static bool intel_pt_timeless_decoding(struct intel_pt *pt)
         if (!pt->tsc_bit || !pt->cap_user_time_zero)
                 return true;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (!(evsel->attr.sample_type & PERF_SAMPLE_TIME))
                         return true;
                 if (intel_pt_get_config(pt, &evsel->attr, &config)) {
@@ -625,7 +706,7 @@ static bool intel_pt_tracing_kernel(struct intel_pt *pt)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (intel_pt_get_config(pt, &evsel->attr, NULL) &&
                     !evsel->attr.exclude_kernel)
                         return true;
@@ -642,7 +723,7 @@ static bool intel_pt_have_tsc(struct intel_pt *pt)
         if (!pt->tsc_bit)
                 return false;
 
-        evlist__for_each(pt->session->evlist, evsel) {
+        evlist__for_each_entry(pt->session->evlist, evsel) {
                 if (intel_pt_get_config(pt, &evsel->attr, &config)) {
                         if (config & pt->tsc_bit)
                                 have_tsc = true;
@@ -716,6 +797,9 @@ static struct intel_pt_queue *intel_pt_alloc_queue(struct intel_pt *pt,
         params.tsc_ctc_ratio_n = pt->tsc_ctc_ratio_n;
         params.tsc_ctc_ratio_d = pt->tsc_ctc_ratio_d;
 
+        if (pt->filts.cnt > 0)
+                params.pgd_ip = intel_pt_pgd_ip;
+
         if (pt->synth_opts.instructions) {
                 if (pt->synth_opts.period) {
                         switch (pt->synth_opts.period_type) {
@@ -1233,7 +1317,7 @@ static int intel_pt_sample(struct intel_pt_queue *ptq)
         if (!(state->type & INTEL_PT_BRANCH))
                 return 0;
 
-        if (pt->synth_opts.callchain)
+        if (pt->synth_opts.callchain || pt->synth_opts.thread_stack)
                 thread_stack__event(ptq->thread, ptq->flags, state->from_ip,
                                     state->to_ip, ptq->insn_len,
                                     state->trace_nr);
@@ -1293,7 +1377,7 @@ static u64 intel_pt_switch_ip(struct intel_pt *pt, u64 *ptss_ip)
         if (!map)
                 return 0;
 
-        if (map__load(map, machine->symbol_filter))
+        if (map__load(map))
                 return 0;
 
         start = dso__first_symbol(map->dso, MAP__FUNCTION);
@@ -1766,6 +1850,8 @@ static void intel_pt_free(struct perf_session *session)
         intel_pt_free_events(session);
         session->auxtrace = NULL;
         thread__put(pt->unknown_thread);
+        addr_filters__exit(&pt->filts);
+        zfree(&pt->filter);
         free(pt);
 }
 
@@ -1850,7 +1936,7 @@ static int intel_pt_synth_events(struct intel_pt *pt,
         u64 id;
         int err;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type == pt->pmu_type && evsel->ids) {
                         found = true;
                         break;
@@ -1930,7 +2016,7 @@ static int intel_pt_synth_events(struct intel_pt *pt,
                 pt->sample_transactions = true;
                 pt->transactions_id = id;
                 id += 1;
-                evlist__for_each(evlist, evsel) {
+                evlist__for_each_entry(evlist, evsel) {
                         if (evsel->id && evsel->id[0] == pt->transactions_id) {
                                 if (evsel->name)
                                         zfree(&evsel->name);
@@ -1968,7 +2054,7 @@ static struct perf_evsel *intel_pt_find_sched_switch(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each_reverse(evlist, evsel) {
+        evlist__for_each_entry_reverse(evlist, evsel) {
                 const char *name = perf_evsel__name(evsel);
 
                 if (!strcmp(name, "sched:sched_switch"))
@@ -1982,7 +2068,7 @@ static bool intel_pt_find_switch(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.context_switch)
                         return true;
         }
@@ -2015,6 +2101,8 @@ static const char * const intel_pt_info_fmts[] = {
         [INTEL_PT_TSC_CTC_N]            = "  TSC:CTC numerator   %"PRIu64"\n",
         [INTEL_PT_TSC_CTC_D]            = "  TSC:CTC denominator %"PRIu64"\n",
         [INTEL_PT_CYC_BIT]              = "  CYC bit             %#"PRIx64"\n",
+        [INTEL_PT_MAX_NONTURBO_RATIO]   = "  Max non-turbo ratio %"PRIu64"\n",
+        [INTEL_PT_FILTER_STR_LEN]       = "  Filter string len.  %"PRIu64"\n",
 };
 
 static void intel_pt_print_info(u64 *arr, int start, int finish)
@@ -2028,12 +2116,28 @@ static void intel_pt_print_info(u64 *arr, int start, int finish)
                 fprintf(stdout, intel_pt_info_fmts[i], arr[i]);
 }
 
+static void intel_pt_print_info_str(const char *name, const char *str)
+{
+        if (!dump_trace)
+                return;
+
+        fprintf(stdout, "  %-20s%s\n", name, str ? str : "");
+}
+
+static bool intel_pt_has(struct auxtrace_info_event *auxtrace_info, int pos)
+{
+        return auxtrace_info->header.size >=
+                sizeof(struct auxtrace_info_event) + (sizeof(u64) * (pos + 1));
+}
+
 int intel_pt_process_auxtrace_info(union perf_event *event,
                                    struct perf_session *session)
 {
         struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info;
         size_t min_sz = sizeof(u64) * INTEL_PT_PER_CPU_MMAPS;
         struct intel_pt *pt;
+        void *info_end;
+        u64 *info;
         int err;
 
         if (auxtrace_info->header.size < sizeof(struct auxtrace_info_event) +
@@ -2044,6 +2148,8 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
         if (!pt)
                 return -ENOMEM;
 
+        addr_filters__init(&pt->filts);
+
         perf_config(intel_pt_perf_config, pt);
 
         err = auxtrace_queues__init(&pt->queues);
@@ -2068,8 +2174,7 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
         intel_pt_print_info(&auxtrace_info->priv[0], INTEL_PT_PMU_TYPE,
                             INTEL_PT_PER_CPU_MMAPS);
 
-        if (auxtrace_info->header.size >= sizeof(struct auxtrace_info_event) +
-                                        (sizeof(u64) * INTEL_PT_CYC_BIT)) {
+        if (intel_pt_has(auxtrace_info, INTEL_PT_CYC_BIT)) {
                 pt->mtc_bit = auxtrace_info->priv[INTEL_PT_MTC_BIT];
                 pt->mtc_freq_bits = auxtrace_info->priv[INTEL_PT_MTC_FREQ_BITS];
                 pt->tsc_ctc_ratio_n = auxtrace_info->priv[INTEL_PT_TSC_CTC_N];
@@ -2079,6 +2184,54 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
                                     INTEL_PT_CYC_BIT);
         }
 
+        if (intel_pt_has(auxtrace_info, INTEL_PT_MAX_NONTURBO_RATIO)) {
+                pt->max_non_turbo_ratio =
+                        auxtrace_info->priv[INTEL_PT_MAX_NONTURBO_RATIO];
+                intel_pt_print_info(&auxtrace_info->priv[0],
+                                    INTEL_PT_MAX_NONTURBO_RATIO,
+                                    INTEL_PT_MAX_NONTURBO_RATIO);
+        }
+
+        info = &auxtrace_info->priv[INTEL_PT_FILTER_STR_LEN] + 1;
+        info_end = (void *)info + auxtrace_info->header.size;
+
+        if (intel_pt_has(auxtrace_info, INTEL_PT_FILTER_STR_LEN)) {
+                size_t len;
+
+                len = auxtrace_info->priv[INTEL_PT_FILTER_STR_LEN];
+                intel_pt_print_info(&auxtrace_info->priv[0],
+                                    INTEL_PT_FILTER_STR_LEN,
+                                    INTEL_PT_FILTER_STR_LEN);
+                if (len) {
+                        const char *filter = (const char *)info;
+
+                        len = roundup(len + 1, 8);
+                        info += len >> 3;
+                        if ((void *)info > info_end) {
+                                pr_err("%s: bad filter string length\n", __func__);
+                                err = -EINVAL;
+                                goto err_free_queues;
+                        }
+                        pt->filter = memdup(filter, len);
+                        if (!pt->filter) {
+                                err = -ENOMEM;
+                                goto err_free_queues;
+                        }
+                        if (session->header.needs_swap)
+                                mem_bswap_64(pt->filter, len);
+                        if (pt->filter[len - 1]) {
+                                pr_err("%s: filter string not null terminated\n", __func__);
+                                err = -EINVAL;
+                                goto err_free_queues;
+                        }
+                        err = addr_filters__parse_bare_filter(&pt->filts,
+                                                              filter);
+                        if (err)
+                                goto err_free_queues;
+                }
+                intel_pt_print_info_str("Filter string", pt->filter);
+        }
+
         pt->timeless_decoding = intel_pt_timeless_decoding(pt);
         pt->have_tsc = intel_pt_have_tsc(pt);
         pt->sampling_mode = false;
@@ -2120,11 +2273,13 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
                 pt->switch_evsel = intel_pt_find_sched_switch(session->evlist);
                 if (!pt->switch_evsel) {
                         pr_err("%s: missing sched_switch event\n", __func__);
+                        err = -EINVAL;
                         goto err_delete_thread;
                 }
         } else if (pt->have_sched_switch == 2 &&
                    !intel_pt_find_switch(session->evlist)) {
                 pr_err("%s: missing context_switch attribute flag\n", __func__);
+                err = -EINVAL;
                 goto err_delete_thread;
         }
 
@@ -2136,6 +2291,9 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
                         pt->synth_opts.branches = false;
                         pt->synth_opts.callchain = true;
                 }
+                if (session->itrace_synth_opts)
+                        pt->synth_opts.thread_stack =
+                                session->itrace_synth_opts->thread_stack;
         }
 
         if (pt->synth_opts.log)
@@ -2145,7 +2303,9 @@ int intel_pt_process_auxtrace_info(union perf_event *event,
         if (pt->tc.time_mult) {
                 u64 tsc_freq = intel_pt_ns_to_ticks(pt, 1000000000);
 
-                pt->max_non_turbo_ratio = (tsc_freq + 50000000) / 100000000;
+                if (!pt->max_non_turbo_ratio)
+                        pt->max_non_turbo_ratio =
+                                        (tsc_freq + 50000000) / 100000000;
                 intel_pt_log("TSC frequency %"PRIu64"\n", tsc_freq);
                 intel_pt_log("Maximum non-turbo ratio %u\n",
                              pt->max_non_turbo_ratio);
@@ -2189,6 +2349,8 @@ err_free_queues:
         auxtrace_queues__free(&pt->queues);
         session->auxtrace = NULL;
 err_free:
+        addr_filters__exit(&pt->filts);
+        zfree(&pt->filter);
         free(pt);
         return err;
 }
diff --git a/tools/perf/util/intel-pt.h b/tools/perf/util/intel-pt.h
index 0065949df693..e13b14e5a37b 100644
--- a/tools/perf/util/intel-pt.h
+++ b/tools/perf/util/intel-pt.h
@@ -34,11 +34,11 @@ enum {
         INTEL_PT_TSC_CTC_N,
         INTEL_PT_TSC_CTC_D,
         INTEL_PT_CYC_BIT,
+        INTEL_PT_MAX_NONTURBO_RATIO,
+        INTEL_PT_FILTER_STR_LEN,
         INTEL_PT_AUXTRACE_PRIV_MAX,
 };
 
-#define INTEL_PT_AUXTRACE_PRIV_SIZE (INTEL_PT_AUXTRACE_PRIV_MAX * sizeof(u64))
-
 struct auxtrace_record;
 struct perf_tool;
 union perf_event;
diff --git a/tools/perf/util/intlist.h b/tools/perf/util/intlist.h
index aa6877d36858..020b9ca1b47e 100644
--- a/tools/perf/util/intlist.h
+++ b/tools/perf/util/intlist.h
@@ -57,21 +57,21 @@ static inline struct int_node *intlist__next(struct int_node *in)
 }
 
 /**
- * intlist_for_each      - iterate over a intlist
+ * intlist__for_each_entry      - iterate over a intlist
  * @pos:        the &struct int_node to use as a loop cursor.
  * @ilist:      the &struct intlist for loop.
  */
-#define intlist__for_each(pos, ilist)   \
+#define intlist__for_each_entry(pos, ilist)     \
         for (pos = intlist__first(ilist); pos; pos = intlist__next(pos))
 
 /**
- * intlist_for_each_safe - iterate over a intlist safe against removal of
+ * intlist__for_each_entry_safe - iterate over a intlist safe against removal of
  *                         int_node
  * @pos:        the &struct int_node to use as a loop cursor.
  * @n:          another &struct int_node to use as temporary storage.
  * @ilist:      the &struct intlist for loop.
  */
-#define intlist__for_each_safe(pos, n, ilist)   \
+#define intlist__for_each_entry_safe(pos, n, ilist)     \
         for (pos = intlist__first(ilist), n = intlist__next(pos); pos;\
              pos = n, n = intlist__next(n))
 #endif /* __PERF_INTLIST_H */
diff --git a/tools/perf/util/jitdump.c b/tools/perf/util/jitdump.c
index 86afe9618bb0..95f0884aae02 100644
--- a/tools/perf/util/jitdump.c
+++ b/tools/perf/util/jitdump.c
@@ -1,3 +1,4 @@
+#include <sys/sysmacros.h>
 #include <sys/types.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -108,7 +109,7 @@ jit_validate_events(struct perf_session *session)
         /*
          * check that all events use CLOCK_MONOTONIC
          */
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (evsel->attr.use_clockid == 0 || evsel->attr.clockid != CLOCK_MONOTONIC)
                         return -1;
         }
diff --git a/tools/perf/util/levenshtein.c b/tools/perf/util/levenshtein.c
index e521d1516df6..f616e4f65b67 100644
--- a/tools/perf/util/levenshtein.c
+++ b/tools/perf/util/levenshtein.c
@@ -1,5 +1,7 @@
-#include "cache.h"
 #include "levenshtein.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
 
 /*
  * This function implements the Damerau-Levenshtein algorithm to
diff --git a/tools/perf/util/libunwind/arm64.c b/tools/perf/util/libunwind/arm64.c
new file mode 100644
index 000000000000..6559bc586643
--- /dev/null
+++ b/tools/perf/util/libunwind/arm64.c
@@ -0,0 +1,40 @@
+/*
+ * This file setups defines to compile arch specific binary from the
+ * generic one.
+ *
+ * The function 'LIBUNWIND__ARCH_REG_ID' name is set according to arch
+ * name and the defination of this function is included directly from
+ * 'arch/arm64/util/unwind-libunwind.c', to make sure that this function
+ * is defined no matter what arch the host is.
+ *
+ * Finally, the arch specific unwind methods are exported which will
+ * be assigned to each arm64 thread.
+ */
+
+#define REMOTE_UNWIND_LIBUNWIND
+
+/* Define arch specific functions & regs for libunwind, should be
+ * defined before including "unwind.h"
+ */
+#define LIBUNWIND__ARCH_REG_ID(regnum) libunwind__arm64_reg_id(regnum)
+#define LIBUNWIND__ARCH_REG_IP PERF_REG_ARM64_PC
+#define LIBUNWIND__ARCH_REG_SP PERF_REG_ARM64_SP
+
+#include "unwind.h"
+#include "debug.h"
+#include "libunwind-aarch64.h"
+#include <../../../../arch/arm64/include/uapi/asm/perf_regs.h>
+#include "../../arch/arm64/util/unwind-libunwind.c"
+
+/* NO_LIBUNWIND_DEBUG_FRAME is a feature flag for local libunwind,
+ * assign NO_LIBUNWIND_DEBUG_FRAME_AARCH64 to it for compiling arm64
+ * unwind methods.
+ */
+#undef NO_LIBUNWIND_DEBUG_FRAME
+#ifdef NO_LIBUNWIND_DEBUG_FRAME_AARCH64
+#define NO_LIBUNWIND_DEBUG_FRAME
+#endif
+#include "util/unwind-libunwind-local.c"
+
+struct unwind_libunwind_ops *
+arm64_unwind_libunwind_ops = &_unwind_libunwind_ops;
diff --git a/tools/perf/util/libunwind/x86_32.c b/tools/perf/util/libunwind/x86_32.c
new file mode 100644
index 000000000000..957ffff72428
--- /dev/null
+++ b/tools/perf/util/libunwind/x86_32.c
@@ -0,0 +1,43 @@
+/*
+ * This file setups defines to compile arch specific binary from the
+ * generic one.
+ *
+ * The function 'LIBUNWIND__ARCH_REG_ID' name is set according to arch
+ * name and the defination of this function is included directly from
+ * 'arch/x86/util/unwind-libunwind.c', to make sure that this function
+ * is defined no matter what arch the host is.
+ *
+ * Finally, the arch specific unwind methods are exported which will
+ * be assigned to each x86 thread.
+ */
+
+#define REMOTE_UNWIND_LIBUNWIND
+
+/* Define arch specific functions & regs for libunwind, should be
+ * defined before including "unwind.h"
+ */
+#define LIBUNWIND__ARCH_REG_ID(regnum) libunwind__x86_reg_id(regnum)
+#define LIBUNWIND__ARCH_REG_IP PERF_REG_X86_IP
+#define LIBUNWIND__ARCH_REG_SP PERF_REG_X86_SP
+
+#include "unwind.h"
+#include "debug.h"
+#include "libunwind-x86.h"
+#include <../../../../arch/x86/include/uapi/asm/perf_regs.h>
+
+/* HAVE_ARCH_X86_64_SUPPORT is used in'arch/x86/util/unwind-libunwind.c'
+ * for x86_32, we undef it to compile code for x86_32 only.
+ */
+#undef HAVE_ARCH_X86_64_SUPPORT
+#include "../../arch/x86/util/unwind-libunwind.c"
+
+/* Explicitly define NO_LIBUNWIND_DEBUG_FRAME, because non-ARM has no
+ * dwarf_find_debug_frame() function.
+ */
+#ifndef NO_LIBUNWIND_DEBUG_FRAME
+#define NO_LIBUNWIND_DEBUG_FRAME
+#endif
+#include "util/unwind-libunwind-local.c"
+
+struct unwind_libunwind_ops *
+x86_32_unwind_libunwind_ops = &_unwind_libunwind_ops;
diff --git a/tools/perf/util/llvm-utils.c b/tools/perf/util/llvm-utils.c
index 33071d6159bc..bf7216b8731d 100644
--- a/tools/perf/util/llvm-utils.c
+++ b/tools/perf/util/llvm-utils.c
@@ -3,11 +3,14 @@
  * Copyright (C) 2015, Huawei Inc.
  */
 
+#include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "debug.h"
 #include "llvm-utils.h"
+#include "config.h"
+#include "util.h"
 
 #define CLANG_BPF_CMD_DEFAULT_TEMPLATE                          \
                 "$CLANG_EXEC -D__KERNEL__ -D__NR_CPUS__=$NR_CPUS "\
@@ -42,6 +45,8 @@ int perf_llvm_config(const char *var, const char *value)
                 llvm_param.kbuild_dir = strdup(value);
         else if (!strcmp(var, "kbuild-opts"))
                 llvm_param.kbuild_opts = strdup(value);
+        else if (!strcmp(var, "dump-obj"))
+                llvm_param.dump_obj = !!perf_config_bool(var, value);
         else
                 return -1;
         llvm_param.user_set_param = true;
@@ -103,7 +108,7 @@ read_from_pipe(const char *cmd, void **p_buf, size_t *p_read_sz)
         file = popen(cmd, "r");
         if (!file) {
                 pr_err("ERROR: unable to popen cmd: %s\n",
-                       strerror_r(errno, serr, sizeof(serr)));
+                       str_error_r(errno, serr, sizeof(serr)));
                 return -EINVAL;
         }
 
@@ -137,7 +142,7 @@ read_from_pipe(const char *cmd, void **p_buf, size_t *p_read_sz)
 
         if (ferror(file)) {
                 pr_err("ERROR: error occurred when reading from pipe: %s\n",
-                       strerror_r(errno, serr, sizeof(serr)));
+                       str_error_r(errno, serr, sizeof(serr)));
                 err = -EIO;
                 goto errout;
         }
@@ -326,6 +331,42 @@ get_kbuild_opts(char **kbuild_dir, char **kbuild_include_opts)
         pr_debug("include option is set to %s\n", *kbuild_include_opts);
 }
 
+static void
+dump_obj(const char *path, void *obj_buf, size_t size)
+{
+        char *obj_path = strdup(path);
+        FILE *fp;
+        char *p;
+
+        if (!obj_path) {
+                pr_warning("WARNING: No enough memory, skip object dumping\n");
+                return;
+        }
+
+        p = strrchr(obj_path, '.');
+        if (!p || (strcmp(p, ".c") != 0)) {
+                pr_warning("WARNING: invalid llvm source path: '%s', skip object dumping\n",
+                           obj_path);
+                goto out;
+        }
+
+        p[1] = 'o';
+        fp = fopen(obj_path, "wb");
+        if (!fp) {
+                pr_warning("WARNING: failed to open '%s': %s, skip object dumping\n",
+                           obj_path, strerror(errno));
+                goto out;
+        }
+
+        pr_info("LLVM: dumping %s\n", obj_path);
+        if (fwrite(obj_buf, size, 1, fp) != 1)
+                pr_warning("WARNING: failed to write to file '%s': %s, skip object dumping\n",
+                           obj_path, strerror(errno));
+        fclose(fp);
+out:
+        free(obj_path);
+}
+
 int llvm__compile_bpf(const char *path, void **p_obj_buf,
                       size_t *p_obj_buf_sz)
 {
@@ -343,7 +384,7 @@ int llvm__compile_bpf(const char *path, void **p_obj_buf,
         if (path[0] != '-' && realpath(path, abspath) == NULL) {
                 err = errno;
                 pr_err("ERROR: problems with path %s: %s\n",
-                       path, strerror_r(err, serr, sizeof(serr)));
+                       path, str_error_r(err, serr, sizeof(serr)));
                 return -err;
         }
 
@@ -371,7 +412,7 @@ int llvm__compile_bpf(const char *path, void **p_obj_buf,
         if (nr_cpus_avail <= 0) {
                 pr_err(
 "WARNING:\tunable to get available CPUs in this system: %s\n"
-"        \tUse 128 instead.\n", strerror_r(errno, serr, sizeof(serr)));
+"        \tUse 128 instead.\n", str_error_r(errno, serr, sizeof(serr)));
                 nr_cpus_avail = 128;
         }
         snprintf(nr_cpus_avail_str, sizeof(nr_cpus_avail_str), "%d",
@@ -411,6 +452,10 @@ int llvm__compile_bpf(const char *path, void **p_obj_buf,
 
         free(kbuild_dir);
         free(kbuild_include_opts);
+
+        if (llvm_param.dump_obj)
+                dump_obj(path, obj_buf, obj_buf_sz);
+
         if (!p_obj_buf)
                 free(obj_buf);
         else
diff --git a/tools/perf/util/llvm-utils.h b/tools/perf/util/llvm-utils.h
index 23b9a743fe72..9f501cef06a1 100644
--- a/tools/perf/util/llvm-utils.h
+++ b/tools/perf/util/llvm-utils.h
@@ -30,6 +30,11 @@ struct llvm_param {
          */
         const char *kbuild_opts;
         /*
+         * Default is false. If set to true, write compiling result
+         * to object file.
+         */
+        bool dump_obj;
+        /*
          * Default is false. If one of the above fields is set by user
          * explicitly then user_set_llvm is set to true. This is used
          * for perf test. If user doesn't set anything in .perfconfig
diff --git a/tools/perf/util/lzma.c b/tools/perf/util/lzma.c
index 95a1acb61245..9ddea5cecd94 100644
--- a/tools/perf/util/lzma.c
+++ b/tools/perf/util/lzma.c
@@ -29,6 +29,7 @@ int lzma_decompress_to_file(const char *input, int output_fd)
         lzma_action action = LZMA_RUN;
         lzma_stream strm   = LZMA_STREAM_INIT;
         lzma_ret ret;
+        int err = -1;
 
         u8 buf_in[BUFSIZE];
         u8 buf_out[BUFSIZE];
@@ -45,7 +46,7 @@ int lzma_decompress_to_file(const char *input, int output_fd)
         if (ret != LZMA_OK) {
                 pr_err("lzma: lzma_stream_decoder failed %s (%d)\n",
                         lzma_strerror(ret), ret);
-                return -1;
+                goto err_fclose;
         }
 
         strm.next_in   = NULL;
@@ -60,7 +61,7 @@ int lzma_decompress_to_file(const char *input, int output_fd)
 
                         if (ferror(infile)) {
                                 pr_err("lzma: read error: %s\n", strerror(errno));
-                                return -1;
+                                goto err_fclose;
                         }
 
                         if (feof(infile))
@@ -74,7 +75,7 @@ int lzma_decompress_to_file(const char *input, int output_fd)
 
                         if (writen(output_fd, buf_out, write_size) != write_size) {
                                 pr_err("lzma: write error: %s\n", strerror(errno));
-                                return -1;
+                                goto err_fclose;
                         }
 
                         strm.next_out  = buf_out;
@@ -83,13 +84,15 @@ int lzma_decompress_to_file(const char *input, int output_fd)
 
                 if (ret != LZMA_OK) {
                         if (ret == LZMA_STREAM_END)
-                                return 0;
+                                break;
 
                         pr_err("lzma: failed %s\n", lzma_strerror(ret));
-                        return -1;
+                        goto err_fclose;
                 }
         }
 
+        err = 0;
+err_fclose:
         fclose(infile);
-        return 0;
+        return err;
 }
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index b1772180c820..df85b9efd80f 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -41,7 +41,6 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 
         machine->pid = pid;
 
-        machine->symbol_filter = NULL;
         machine->id_hdr_size = 0;
         machine->kptr_restrict_warned = false;
         machine->comm_exec = false;
@@ -138,15 +137,16 @@ void machine__exit(struct machine *machine)
 
 void machine__delete(struct machine *machine)
 {
-        machine__exit(machine);
-        free(machine);
+        if (machine) {
+                machine__exit(machine);
+                free(machine);
+        }
 }
 
 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)
@@ -170,8 +170,6 @@ 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);
@@ -187,21 +185,6 @@ 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;
-        }
-}
-
 void machines__set_comm_exec(struct machines *machines, bool comm_exec)
 {
         struct rb_node *nd;
@@ -914,10 +897,10 @@ int machines__create_kernel_maps(struct machines *machines, pid_t pid)
 }
 
 int __machine__load_kallsyms(struct machine *machine, const char *filename,
-                             enum map_type type, bool no_kcore, symbol_filter_t filter)
+                             enum map_type type, bool no_kcore)
 {
         struct map *map = machine__kernel_map(machine);
-        int ret = __dso__load_kallsyms(map->dso, filename, map, no_kcore, filter);
+        int ret = __dso__load_kallsyms(map->dso, filename, map, no_kcore);
 
         if (ret > 0) {
                 dso__set_loaded(map->dso, type);
@@ -933,16 +916,15 @@ int __machine__load_kallsyms(struct machine *machine, const char *filename,
 }
 
 int machine__load_kallsyms(struct machine *machine, const char *filename,
-                           enum map_type type, symbol_filter_t filter)
+                           enum map_type type)
 {
-        return __machine__load_kallsyms(machine, filename, type, false, filter);
+        return __machine__load_kallsyms(machine, filename, type, false);
 }
 
-int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
-                               symbol_filter_t filter)
+int machine__load_vmlinux_path(struct machine *machine, enum map_type type)
 {
         struct map *map = machine__kernel_map(machine);
-        int ret = dso__load_vmlinux_path(map->dso, map, filter);
+        int ret = dso__load_vmlinux_path(map->dso, map);
 
         if (ret > 0)
                 dso__set_loaded(map->dso, type);
@@ -1091,12 +1073,20 @@ static int machine__set_modules_path(struct machine *machine)
 
         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path, 0);
 }
+int __weak arch__fix_module_text_start(u64 *start __maybe_unused,
+                                const char *name __maybe_unused)
+{
+        return 0;
+}
 
 static int machine__create_module(void *arg, const char *name, u64 start)
 {
         struct machine *machine = arg;
         struct map *map;
 
+        if (arch__fix_module_text_start(&start, name) < 0)
+                return -1;
+
         map = machine__findnew_module_map(machine, start, name);
         if (map == NULL)
                 return -1;
@@ -1303,7 +1293,7 @@ static int machine__process_kernel_mmap_event(struct machine *machine,
                         /*
                          * preload dso of guest kernel and modules
                          */
-                        dso__load(kernel, machine__kernel_map(machine), NULL);
+                        dso__load(kernel, machine__kernel_map(machine));
                 }
         }
         return 0;
@@ -1353,11 +1343,16 @@ int machine__process_mmap2_event(struct machine *machine,
         if (map == NULL)
                 goto out_problem_map;
 
-        thread__insert_map(thread, map);
+        ret = thread__insert_map(thread, map);
+        if (ret)
+                goto out_problem_insert;
+
         thread__put(thread);
         map__put(map);
         return 0;
 
+out_problem_insert:
+        map__put(map);
 out_problem_map:
         thread__put(thread);
 out_problem:
@@ -1403,11 +1398,16 @@ int machine__process_mmap_event(struct machine *machine, union perf_event *event
         if (map == NULL)
                 goto out_problem_map;
 
-        thread__insert_map(thread, map);
+        ret = thread__insert_map(thread, map);
+        if (ret)
+                goto out_problem_insert;
+
         thread__put(thread);
         map__put(map);
         return 0;
 
+out_problem_insert:
+        map__put(map);
 out_problem_map:
         thread__put(thread);
 out_problem:
@@ -1745,9 +1745,8 @@ static int resolve_lbr_callchain_sample(struct thread *thread,
                                         int max_stack)
 {
         struct ip_callchain *chain = sample->callchain;
-        int chain_nr = min(max_stack, (int)chain->nr);
+        int chain_nr = min(max_stack, (int)chain->nr), i;
         u8 cpumode = PERF_RECORD_MISC_USER;
-        int i, j, err;
         u64 ip;
 
         for (i = 0; i < chain_nr; i++) {
@@ -1758,7 +1757,7 @@ static int resolve_lbr_callchain_sample(struct thread *thread,
         /* LBR only affects the user callchain */
         if (i != chain_nr) {
                 struct branch_stack *lbr_stack = sample->branch_stack;
-                int lbr_nr = lbr_stack->nr;
+                int lbr_nr = lbr_stack->nr, j;
                 /*
                  * LBR callstack can only get user call chain.
                  * The mix_chain_nr is kernel call chain
@@ -1772,6 +1771,7 @@ static int resolve_lbr_callchain_sample(struct thread *thread,
                 int mix_chain_nr = i + 1 + lbr_nr + 1;
 
                 for (j = 0; j < mix_chain_nr; j++) {
+                        int err;
                         if (callchain_param.order == ORDER_CALLEE) {
                                 if (j < i + 1)
                                         ip = chain->ips[j];
@@ -2095,7 +2095,7 @@ int machine__get_kernel_start(struct machine *machine)
          */
         machine->kernel_start = 1ULL << 63;
         if (map) {
-                err = map__load(map, machine->symbol_filter);
+                err = map__load(map);
                 if (map->start)
                         machine->kernel_start = map->start;
         }
@@ -2111,7 +2111,7 @@ char *machine__resolve_kernel_addr(void *vmachine, unsigned long long *addrp, ch
 {
         struct machine *machine = vmachine;
         struct map *map;
-        struct symbol *sym = map_groups__find_symbol(&machine->kmaps, MAP__FUNCTION, *addrp, &map,  NULL);
+        struct symbol *sym = map_groups__find_symbol(&machine->kmaps, MAP__FUNCTION, *addrp, &map);
 
         if (sym == NULL)
                 return NULL;
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 41ac9cfd416b..354de6e56109 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -41,7 +41,6 @@ struct machine {
         struct map_groups kmaps;
         struct map        *vmlinux_maps[MAP__NR_TYPES];
         u64               kernel_start;
-        symbol_filter_t   symbol_filter;
         pid_t             *current_tid;
         union { /* Tool specific area */
                 void      *priv;
@@ -110,7 +109,6 @@ 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);
@@ -128,8 +126,6 @@ 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);
 void machines__set_comm_exec(struct machines *machines, bool comm_exec);
 
 struct machine *machine__new_host(void);
@@ -178,51 +174,44 @@ size_t machine__fprintf(struct machine *machine, FILE *fp);
 static inline
 struct symbol *machine__find_kernel_symbol(struct machine *machine,
                                            enum map_type type, u64 addr,
-                                           struct map **mapp,
-                                           symbol_filter_t filter)
+                                           struct map **mapp)
 {
-        return map_groups__find_symbol(&machine->kmaps, type, addr,
-                                       mapp, filter);
+        return map_groups__find_symbol(&machine->kmaps, type, addr, mapp);
 }
 
 static inline
 struct symbol *machine__find_kernel_symbol_by_name(struct machine *machine,
                                                    enum map_type type, const char *name,
-                                                   struct map **mapp,
-                                                   symbol_filter_t filter)
+                                                   struct map **mapp)
 {
-        return map_groups__find_symbol_by_name(&machine->kmaps, type, name,
-                                               mapp, filter);
+        return map_groups__find_symbol_by_name(&machine->kmaps, type, name, mapp);
 }
 
 static inline
 struct symbol *machine__find_kernel_function(struct machine *machine, u64 addr,
-                                             struct map **mapp,
-                                             symbol_filter_t filter)
+                                             struct map **mapp)
 {
         return machine__find_kernel_symbol(machine, MAP__FUNCTION, addr,
-                                           mapp, filter);
+                                           mapp);
 }
 
 static inline
 struct symbol *machine__find_kernel_function_by_name(struct machine *machine,
                                                      const char *name,
-                                                     struct map **mapp,
-                                                     symbol_filter_t filter)
+                                                     struct map **mapp)
 {
-        return map_groups__find_function_by_name(&machine->kmaps, name, mapp,
-                                                 filter);
+        return map_groups__find_function_by_name(&machine->kmaps, name, mapp);
 }
 
 struct map *machine__findnew_module_map(struct machine *machine, u64 start,
                                         const char *filename);
+int arch__fix_module_text_start(u64 *start, const char *name);
 
 int __machine__load_kallsyms(struct machine *machine, const char *filename,
-                             enum map_type type, bool no_kcore, symbol_filter_t filter);
+                             enum map_type type, bool no_kcore);
 int machine__load_kallsyms(struct machine *machine, const char *filename,
-                           enum map_type type, symbol_filter_t filter);
-int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
-                               symbol_filter_t filter);
+                           enum map_type type);
+int machine__load_vmlinux_path(struct machine *machine, enum map_type type);
 
 size_t machine__fprintf_dsos_buildid(struct machine *machine, FILE *fp,
                                      bool (skip)(struct dso *dso, int parm), int parm);
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index b19bcd3b7128..c662fef95d14 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdio.h>
 #include <unistd.h>
+#include <uapi/linux/mman.h> /* To get things like MAP_HUGETLB even on older libc headers */
 #include "map.h"
 #include "thread.h"
 #include "strlist.h"
@@ -15,6 +16,7 @@
 #include "debug.h"
 #include "machine.h"
 #include <linux/string.h>
+#include "unwind.h"
 
 static void __maps__insert(struct maps *maps, struct map *map);
 
@@ -23,9 +25,10 @@ const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__VARIABLE] = "Variables",
 };
 
-static inline int is_anon_memory(const char *filename)
+static inline int is_anon_memory(const char *filename, u32 flags)
 {
-        return !strcmp(filename, "//anon") ||
+        return flags & MAP_HUGETLB ||
+               !strcmp(filename, "//anon") ||
                !strncmp(filename, "/dev/zero", sizeof("/dev/zero") - 1) ||
                !strncmp(filename, "/anon_hugepage", sizeof("/anon_hugepage") - 1);
 }
@@ -154,7 +157,7 @@ struct map *map__new(struct machine *machine, u64 start, u64 len,
                 int anon, no_dso, vdso, android;
 
                 android = is_android_lib(filename);
-                anon = is_anon_memory(filename);
+                anon = is_anon_memory(filename, flags);
                 vdso = is_vdso_map(filename);
                 no_dso = is_no_dso_memory(filename);
 
@@ -278,7 +281,7 @@ void map__fixup_end(struct map *map)
 
 #define DSO__DELETED "(deleted)"
 
-int map__load(struct map *map, symbol_filter_t filter)
+int map__load(struct map *map)
 {
         const char *name = map->dso->long_name;
         int nr;
@@ -286,7 +289,7 @@ int map__load(struct map *map, symbol_filter_t filter)
         if (dso__loaded(map->dso, map->type))
                 return 0;
 
-        nr = dso__load(map->dso, map, filter);
+        nr = dso__load(map->dso, map);
         if (nr < 0) {
                 if (map->dso->has_build_id) {
                         char sbuild_id[SBUILD_ID_SIZE];
@@ -327,19 +330,17 @@ int __weak arch__compare_symbol_names(const char *namea, const char *nameb)
         return strcmp(namea, nameb);
 }
 
-struct symbol *map__find_symbol(struct map *map, u64 addr,
-                                symbol_filter_t filter)
+struct symbol *map__find_symbol(struct map *map, u64 addr)
 {
-        if (map__load(map, filter) < 0)
+        if (map__load(map) < 0)
                 return NULL;
 
         return dso__find_symbol(map->dso, map->type, addr);
 }
 
-struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
-                                        symbol_filter_t filter)
+struct symbol *map__find_symbol_by_name(struct map *map, const char *name)
 {
-        if (map__load(map, filter) < 0)
+        if (map__load(map) < 0)
                 return NULL;
 
         if (!dso__sorted_by_name(map->dso, map->type))
@@ -552,23 +553,22 @@ void map_groups__put(struct map_groups *mg)
 
 struct symbol *map_groups__find_symbol(struct map_groups *mg,
                                        enum map_type type, u64 addr,
-                                       struct map **mapp,
-                                       symbol_filter_t filter)
+                                       struct map **mapp)
 {
         struct map *map = map_groups__find(mg, type, addr);
 
         /* Ensure map is loaded before using map->map_ip */
-        if (map != NULL && map__load(map, filter) >= 0) {
+        if (map != NULL && map__load(map) >= 0) {
                 if (mapp != NULL)
                         *mapp = map;
-                return map__find_symbol(map, map->map_ip(map, addr), filter);
+                return map__find_symbol(map, map->map_ip(map, addr));
         }
 
         return NULL;
 }
 
 struct symbol *maps__find_symbol_by_name(struct maps *maps, const char *name,
-                                         struct map **mapp, symbol_filter_t filter)
+                                         struct map **mapp)
 {
         struct symbol *sym;
         struct rb_node *nd;
@@ -578,7 +578,7 @@ struct symbol *maps__find_symbol_by_name(struct maps *maps, const char *name,
         for (nd = rb_first(&maps->entries); nd; nd = rb_next(nd)) {
                 struct map *pos = rb_entry(nd, struct map, rb_node);
 
-                sym = map__find_symbol_by_name(pos, name, filter);
+                sym = map__find_symbol_by_name(pos, name);
 
                 if (sym == NULL)
                         continue;
@@ -596,15 +596,14 @@ out:
 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
                                                enum map_type type,
                                                const char *name,
-                                               struct map **mapp,
-                                               symbol_filter_t filter)
+                                               struct map **mapp)
 {
-        struct symbol *sym = maps__find_symbol_by_name(&mg->maps[type], name, mapp, filter);
+        struct symbol *sym = maps__find_symbol_by_name(&mg->maps[type], name, mapp);
 
         return sym;
 }
 
-int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter)
+int map_groups__find_ams(struct addr_map_symbol *ams)
 {
         if (ams->addr < ams->map->start || ams->addr >= ams->map->end) {
                 if (ams->map->groups == NULL)
@@ -616,7 +615,7 @@ int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter)
         }
 
         ams->al_addr = ams->map->map_ip(ams->map, ams->addr);
-        ams->sym = map__find_symbol(ams->map, ams->al_addr, filter);
+        ams->sym = map__find_symbol(ams->map, ams->al_addr);
 
         return ams->sym ? 0 : -1;
 }
@@ -744,9 +743,10 @@ int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
 /*
  * XXX This should not really _copy_ te maps, but refcount them.
  */
-int map_groups__clone(struct map_groups *mg,
+int map_groups__clone(struct thread *thread,
                       struct map_groups *parent, enum map_type type)
 {
+        struct map_groups *mg = thread->mg;
         int err = -ENOMEM;
         struct map *map;
         struct maps *maps = &parent->maps[type];
@@ -757,6 +757,11 @@ int map_groups__clone(struct map_groups *mg,
                 struct map *new = map__clone(map);
                 if (new == NULL)
                         goto out_unlock;
+
+                err = unwind__prepare_access(thread, new, NULL);
+                if (err)
+                        goto out_unlock;
+
                 map_groups__insert(mg, new);
                 map__put(new);
         }
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 7309d64ce39e..abdacf800c98 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -127,17 +127,14 @@ struct thread;
  * @map: the 'struct map *' in which symbols itereated
  * @sym_name: the symbol name
  * @pos: the 'struct symbol *' to use as a loop cursor
- * @filter: to use when loading the DSO
  */
-#define __map__for_each_symbol_by_name(map, sym_name, pos, filter)      \
-        for (pos = map__find_symbol_by_name(map, sym_name, filter);     \
+#define __map__for_each_symbol_by_name(map, sym_name, pos)      \
+        for (pos = map__find_symbol_by_name(map, sym_name);     \
              pos && arch__compare_symbol_names(pos->name, sym_name) == 0;       \
              pos = symbol__next_by_name(pos))
 
 #define map__for_each_symbol_by_name(map, sym_name, pos)                \
-        __map__for_each_symbol_by_name(map, sym_name, (pos), NULL)
-
-typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
+        __map__for_each_symbol_by_name(map, sym_name, (pos))
 
 int arch__compare_symbol_names(const char *namea, const char *nameb);
 void map__init(struct map *map, enum map_type type,
@@ -173,11 +170,9 @@ size_t map__fprintf_dsoname(struct map *map, FILE *fp);
 int map__fprintf_srcline(struct map *map, u64 addr, const char *prefix,
                          FILE *fp);
 
-int map__load(struct map *map, symbol_filter_t filter);
-struct symbol *map__find_symbol(struct map *map,
-                                u64 addr, symbol_filter_t filter);
-struct symbol *map__find_symbol_by_name(struct map *map, const char *name,
-                                        symbol_filter_t filter);
+int map__load(struct map *map);
+struct symbol *map__find_symbol(struct map *map, u64 addr);
+struct symbol *map__find_symbol_by_name(struct map *map, const char *name);
 void map__fixup_start(struct map *map);
 void map__fixup_end(struct map *map);
 
@@ -191,10 +186,10 @@ struct map *maps__find(struct maps *maps, u64 addr);
 struct map *maps__first(struct maps *maps);
 struct map *map__next(struct map *map);
 struct symbol *maps__find_symbol_by_name(struct maps *maps, const char *name,
-                                         struct map **mapp, symbol_filter_t filter);
+                                         struct map **mapp);
 void map_groups__init(struct map_groups *mg, struct machine *machine);
 void map_groups__exit(struct map_groups *mg);
-int map_groups__clone(struct map_groups *mg,
+int map_groups__clone(struct thread *thread,
                       struct map_groups *parent, enum map_type type);
 size_t map_groups__fprintf(struct map_groups *mg, FILE *fp);
 
@@ -231,25 +226,22 @@ static inline struct map *map_groups__next(struct map *map)
 
 struct symbol *map_groups__find_symbol(struct map_groups *mg,
                                        enum map_type type, u64 addr,
-                                       struct map **mapp,
-                                       symbol_filter_t filter);
+                                       struct map **mapp);
 
 struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
                                                enum map_type type,
                                                const char *name,
-                                               struct map **mapp,
-                                               symbol_filter_t filter);
+                                               struct map **mapp);
 
 struct addr_map_symbol;
 
-int map_groups__find_ams(struct addr_map_symbol *ams, symbol_filter_t filter);
+int map_groups__find_ams(struct addr_map_symbol *ams);
 
 static inline
 struct symbol *map_groups__find_function_by_name(struct map_groups *mg,
-                                                 const char *name, struct map **mapp,
-                                                 symbol_filter_t filter)
+                                                 const char *name, struct map **mapp)
 {
-        return map_groups__find_symbol_by_name(mg, MAP__FUNCTION, name, mapp, filter);
+        return map_groups__find_symbol_by_name(mg, MAP__FUNCTION, name, mapp);
 }
 
 int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
diff --git a/tools/perf/util/mem-events.c b/tools/perf/util/mem-events.c
index 75465f89a413..bbc368e7d1e4 100644
--- a/tools/perf/util/mem-events.c
+++ b/tools/perf/util/mem-events.c
@@ -10,18 +10,33 @@
 #include "debug.h"
 #include "symbol.h"
 
+unsigned int perf_mem_events__loads_ldlat = 30;
+
 #define E(t, n, s) { .tag = t, .name = n, .sysfs_name = s }
 
 struct perf_mem_event perf_mem_events[PERF_MEM_EVENTS__MAX] = {
-        E("ldlat-loads",        "cpu/mem-loads,ldlat=30/P",     "mem-loads"),
+        E("ldlat-loads",        "cpu/mem-loads,ldlat=%u/P",     "mem-loads"),
         E("ldlat-stores",       "cpu/mem-stores/P",             "mem-stores"),
 };
 #undef E
 
 #undef E
 
+static char mem_loads_name[100];
+static bool mem_loads_name__init;
+
 char *perf_mem_events__name(int i)
 {
+        if (i == PERF_MEM_EVENTS__LOAD) {
+                if (!mem_loads_name__init) {
+                        mem_loads_name__init = true;
+                        scnprintf(mem_loads_name, sizeof(mem_loads_name),
+                                  perf_mem_events[i].name,
+                                  perf_mem_events__loads_ldlat);
+                }
+                return mem_loads_name;
+        }
+
         return (char *)perf_mem_events[i].name;
 }
 
diff --git a/tools/perf/util/mem-events.h b/tools/perf/util/mem-events.h
index 5d6d93066a6e..7f69bf9d789d 100644
--- a/tools/perf/util/mem-events.h
+++ b/tools/perf/util/mem-events.h
@@ -18,6 +18,7 @@ enum {
 };
 
 extern struct perf_mem_event perf_mem_events[PERF_MEM_EVENTS__MAX];
+extern unsigned int perf_mem_events__loads_ldlat;
 
 int perf_mem_events__parse(const char *str);
 int perf_mem_events__init(void);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index c6fd0479f4cd..4e778eae1510 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -20,6 +20,7 @@
 #include "pmu.h"
 #include "thread_map.h"
 #include "cpumap.h"
+#include "probe-file.h"
 #include "asm/bug.h"
 
 #define MAX_NAME_LEN 100
@@ -436,7 +437,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
 }
 
 static void tracepoint_error(struct parse_events_error *e, int err,
-                             char *sys, char *name)
+                             const char *sys, const char *name)
 {
         char help[BUFSIZ];
 
@@ -466,7 +467,7 @@ static void tracepoint_error(struct parse_events_error *e, int err,
 }
 
 static int add_tracepoint(struct list_head *list, int *idx,
-                          char *sys_name, char *evt_name,
+                          const char *sys_name, const char *evt_name,
                           struct parse_events_error *err,
                           struct list_head *head_config)
 {
@@ -491,7 +492,7 @@ static int add_tracepoint(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_multi_event(struct list_head *list, int *idx,
-                                      char *sys_name, char *evt_name,
+                                      const char *sys_name, const char *evt_name,
                                       struct parse_events_error *err,
                                       struct list_head *head_config)
 {
@@ -533,7 +534,7 @@ static int add_tracepoint_multi_event(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_event(struct list_head *list, int *idx,
-                                char *sys_name, char *evt_name,
+                                const char *sys_name, const char *evt_name,
                                 struct parse_events_error *err,
                                 struct list_head *head_config)
 {
@@ -545,7 +546,7 @@ static int add_tracepoint_event(struct list_head *list, int *idx,
 }
 
 static int add_tracepoint_multi_sys(struct list_head *list, int *idx,
-                                    char *sys_name, char *evt_name,
+                                    const char *sys_name, const char *evt_name,
                                     struct parse_events_error *err,
                                     struct list_head *head_config)
 {
@@ -584,7 +585,7 @@ struct __add_bpf_event_param {
         struct list_head *head_config;
 };
 
-static int add_bpf_event(struct probe_trace_event *tev, int fd,
+static int add_bpf_event(const char *group, const char *event, int fd,
                          void *_param)
 {
         LIST_HEAD(new_evsels);
@@ -595,27 +596,27 @@ static int add_bpf_event(struct probe_trace_event *tev, int fd,
         int err;
 
         pr_debug("add bpf event %s:%s and attach bpf program %d\n",
-                 tev->group, tev->event, fd);
+                 group, event, fd);
 
-        err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, tev->group,
-                                          tev->event, evlist->error,
+        err = parse_events_add_tracepoint(&new_evsels, &evlist->idx, group,
+                                          event, evlist->error,
                                           param->head_config);
         if (err) {
                 struct perf_evsel *evsel, *tmp;
 
                 pr_debug("Failed to add BPF event %s:%s\n",
-                         tev->group, tev->event);
+                         group, event);
                 list_for_each_entry_safe(evsel, tmp, &new_evsels, node) {
                         list_del(&evsel->node);
                         perf_evsel__delete(evsel);
                 }
                 return err;
         }
-        pr_debug("adding %s:%s\n", tev->group, tev->event);
+        pr_debug("adding %s:%s\n", group, event);
 
         list_for_each_entry(pos, &new_evsels, node) {
                 pr_debug("adding %s:%s to %p\n",
-                         tev->group, tev->event, pos);
+                         group, event, pos);
                 pos->bpf_fd = fd;
         }
         list_splice(&new_evsels, list);
@@ -661,7 +662,7 @@ int parse_events_load_bpf_obj(struct parse_events_evlist *data,
                 goto errout;
         }
 
-        err = bpf__foreach_tev(obj, add_bpf_event, &param);
+        err = bpf__foreach_event(obj, add_bpf_event, &param);
         if (err) {
                 snprintf(errbuf, sizeof(errbuf),
                          "Attach events in BPF object failed");
@@ -900,6 +901,10 @@ static const char *config_term_names[__PARSE_EVENTS__TERM_TYPE_NR] = {
         [PARSE_EVENTS__TERM_TYPE_STACKSIZE]             = "stack-size",
         [PARSE_EVENTS__TERM_TYPE_NOINHERIT]             = "no-inherit",
         [PARSE_EVENTS__TERM_TYPE_INHERIT]               = "inherit",
+        [PARSE_EVENTS__TERM_TYPE_MAX_STACK]             = "max-stack",
+        [PARSE_EVENTS__TERM_TYPE_OVERWRITE]             = "overwrite",
+        [PARSE_EVENTS__TERM_TYPE_NOOVERWRITE]           = "no-overwrite",
+        [PARSE_EVENTS__TERM_TYPE_DRV_CFG]               = "driver-config",
 };
 
 static bool config_term_shrinked;
@@ -919,6 +924,7 @@ config_term_avail(int term_type, struct parse_events_error *err)
         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
         case PARSE_EVENTS__TERM_TYPE_NAME:
+        case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
                 return true;
         default:
                 if (!err)
@@ -992,9 +998,18 @@ do {									   \
         case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
                 CHECK_TYPE_VAL(NUM);
                 break;
+        case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
+                CHECK_TYPE_VAL(NUM);
+                break;
+        case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
+                CHECK_TYPE_VAL(NUM);
+                break;
         case PARSE_EVENTS__TERM_TYPE_NAME:
                 CHECK_TYPE_VAL(STR);
                 break;
+        case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
+                CHECK_TYPE_VAL(NUM);
+                break;
         default:
                 err->str = strdup("unknown term");
                 err->idx = term->err_term;
@@ -1021,7 +1036,8 @@ static int config_term_pmu(struct perf_event_attr *attr,
                            struct parse_events_term *term,
                            struct parse_events_error *err)
 {
-        if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER)
+        if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER ||
+            term->type_term == PARSE_EVENTS__TERM_TYPE_DRV_CFG)
                 /*
                  * Always succeed for sysfs terms, as we dont know
                  * at this point what type they need to have.
@@ -1040,6 +1056,9 @@ static int config_term_tracepoint(struct perf_event_attr *attr,
         case PARSE_EVENTS__TERM_TYPE_STACKSIZE:
         case PARSE_EVENTS__TERM_TYPE_INHERIT:
         case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
+        case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
+        case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
+        case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
                 return config_term_common(attr, term, err);
         default:
                 if (err) {
@@ -1109,6 +1128,18 @@ do {								\
                 case PARSE_EVENTS__TERM_TYPE_NOINHERIT:
                         ADD_CONFIG_TERM(INHERIT, inherit, term->val.num ? 0 : 1);
                         break;
+                case PARSE_EVENTS__TERM_TYPE_MAX_STACK:
+                        ADD_CONFIG_TERM(MAX_STACK, max_stack, term->val.num);
+                        break;
+                case PARSE_EVENTS__TERM_TYPE_OVERWRITE:
+                        ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 1 : 0);
+                        break;
+                case PARSE_EVENTS__TERM_TYPE_NOOVERWRITE:
+                        ADD_CONFIG_TERM(OVERWRITE, overwrite, term->val.num ? 0 : 1);
+                        break;
+                case PARSE_EVENTS__TERM_TYPE_DRV_CFG:
+                        ADD_CONFIG_TERM(DRV_CFG, drv_cfg, term->val.str);
+                        break;
                 default:
                         break;
                 }
@@ -1118,7 +1149,7 @@ do {								\
 }
 
 int parse_events_add_tracepoint(struct list_head *list, int *idx,
-                                char *sys, char *event,
+                                const char *sys, const char *event,
                                 struct parse_events_error *err,
                                 struct list_head *head_config)
 {
@@ -1388,7 +1419,7 @@ int parse_events__modifier_event(struct list_head *list, char *str, bool add)
         if (!add && get_event_modifier(&mod, str, NULL))
                 return -EINVAL;
 
-        __evlist__for_each(list, evsel) {
+        __evlist__for_each_entry(list, evsel) {
                 if (add && get_event_modifier(&mod, str, evsel))
                         return -EINVAL;
 
@@ -1414,7 +1445,7 @@ int parse_events_name(struct list_head *list, char *name)
 {
         struct perf_evsel *evsel;
 
-        __evlist__for_each(list, evsel) {
+        __evlist__for_each_entry(list, evsel) {
                 if (!evsel->name)
                         evsel->name = strdup(name);
         }
@@ -1428,7 +1459,7 @@ comp_pmu(const void *p1, const void *p2)
         struct perf_pmu_event_symbol *pmu1 = (struct perf_pmu_event_symbol *) p1;
         struct perf_pmu_event_symbol *pmu2 = (struct perf_pmu_event_symbol *) p2;
 
-        return strcmp(pmu1->symbol, pmu2->symbol);
+        return strcasecmp(pmu1->symbol, pmu2->symbol);
 }
 
 static void perf_pmu__parse_cleanup(void)
@@ -1730,20 +1761,49 @@ foreach_evsel_in_last_glob(struct perf_evlist *evlist,
 static int set_filter(struct perf_evsel *evsel, const void *arg)
 {
         const char *str = arg;
+        bool found = false;
+        int nr_addr_filters = 0;
+        struct perf_pmu *pmu = NULL;
 
-        if (evsel == NULL || evsel->attr.type != PERF_TYPE_TRACEPOINT) {
-                fprintf(stderr,
-                        "--filter option should follow a -e tracepoint option\n");
-                return -1;
+        if (evsel == NULL)
+                goto err;
+
+        if (evsel->attr.type == PERF_TYPE_TRACEPOINT) {
+                if (perf_evsel__append_tp_filter(evsel, str) < 0) {
+                        fprintf(stderr,
+                                "not enough memory to hold filter string\n");
+                        return -1;
+                }
+
+                return 0;
         }
 
-        if (perf_evsel__append_filter(evsel, "&&", str) < 0) {
+        while ((pmu = perf_pmu__scan(pmu)) != NULL)
+                if (pmu->type == evsel->attr.type) {
+                        found = true;
+                        break;
+                }
+
+        if (found)
+                perf_pmu__scan_file(pmu, "nr_addr_filters",
+                                    "%d", &nr_addr_filters);
+
+        if (!nr_addr_filters)
+                goto err;
+
+        if (perf_evsel__append_addr_filter(evsel, str) < 0) {
                 fprintf(stderr,
                         "not enough memory to hold filter string\n");
                 return -1;
         }
 
         return 0;
+
+err:
+        fprintf(stderr,
+                "--filter option should follow a -e tracepoint or HW tracer option\n");
+
+        return -1;
 }
 
 int parse_filter(const struct option *opt, const char *str,
@@ -1768,7 +1828,7 @@ static int add_exclude_perf_filter(struct perf_evsel *evsel,
 
         snprintf(new_filter, sizeof(new_filter), "common_pid != %d", getpid());
 
-        if (perf_evsel__append_filter(evsel, "&&", new_filter) < 0) {
+        if (perf_evsel__append_tp_filter(evsel, new_filter) < 0) {
                 fprintf(stderr,
                         "not enough memory to hold filter string\n");
                 return -1;
@@ -1976,6 +2036,85 @@ static bool is_event_supported(u8 type, unsigned config)
         return ret;
 }
 
+void print_sdt_events(const char *subsys_glob, const char *event_glob,
+                      bool name_only)
+{
+        struct probe_cache *pcache;
+        struct probe_cache_entry *ent;
+        struct strlist *bidlist, *sdtlist;
+        struct strlist_config cfg = {.dont_dupstr = true};
+        struct str_node *nd, *nd2;
+        char *buf, *path, *ptr = NULL;
+        bool show_detail = false;
+        int ret;
+
+        sdtlist = strlist__new(NULL, &cfg);
+        if (!sdtlist) {
+                pr_debug("Failed to allocate new strlist for SDT\n");
+                return;
+        }
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist) {
+                pr_debug("Failed to get buildids: %d\n", errno);
+                return;
+        }
+        strlist__for_each_entry(nd, bidlist) {
+                pcache = probe_cache__new(nd->s);
+                if (!pcache)
+                        continue;
+                list_for_each_entry(ent, &pcache->entries, node) {
+                        if (!ent->sdt)
+                                continue;
+                        if (subsys_glob &&
+                            !strglobmatch(ent->pev.group, subsys_glob))
+                                continue;
+                        if (event_glob &&
+                            !strglobmatch(ent->pev.event, event_glob))
+                                continue;
+                        ret = asprintf(&buf, "%s:%s@%s", ent->pev.group,
+                                        ent->pev.event, nd->s);
+                        if (ret > 0)
+                                strlist__add(sdtlist, buf);
+                }
+                probe_cache__delete(pcache);
+        }
+        strlist__delete(bidlist);
+
+        strlist__for_each_entry(nd, sdtlist) {
+                buf = strchr(nd->s, '@');
+                if (buf)
+                        *(buf++) = '\0';
+                if (name_only) {
+                        printf("%s ", nd->s);
+                        continue;
+                }
+                nd2 = strlist__next(nd);
+                if (nd2) {
+                        ptr = strchr(nd2->s, '@');
+                        if (ptr)
+                                *ptr = '\0';
+                        if (strcmp(nd->s, nd2->s) == 0)
+                                show_detail = true;
+                }
+                if (show_detail) {
+                        path = build_id_cache__origname(buf);
+                        ret = asprintf(&buf, "%s@%s(%.12s)", nd->s, path, buf);
+                        if (ret > 0) {
+                                printf("  %-50s [%s]\n", buf, "SDT event");
+                                free(buf);
+                        }
+                } else
+                        printf("  %-50s [%s]\n", nd->s, "SDT event");
+                if (nd2) {
+                        if (strcmp(nd->s, nd2->s) != 0)
+                                show_detail = false;
+                        if (ptr)
+                                *ptr = '@';
+                }
+        }
+        strlist__delete(sdtlist);
+}
+
 int print_hwcache_events(const char *event_glob, bool name_only)
 {
         unsigned int type, op, i, evt_i = 0, evt_num = 0;
@@ -2125,7 +2264,8 @@ out_enomem:
 /*
  * Print the help text for the event symbols:
  */
-void print_events(const char *event_glob, bool name_only)
+void print_events(const char *event_glob, bool name_only, bool quiet_flag,
+                        bool long_desc)
 {
         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
                             event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
@@ -2135,7 +2275,7 @@ void print_events(const char *event_glob, bool name_only)
 
         print_hwcache_events(event_glob, name_only);
 
-        print_pmu_events(event_glob, name_only);
+        print_pmu_events(event_glob, name_only, quiet_flag, long_desc);
 
         if (event_glob != NULL)
                 return;
@@ -2158,6 +2298,8 @@ void print_events(const char *event_glob, bool name_only)
         }
 
         print_tracepoint_events(NULL, NULL, name_only);
+
+        print_sdt_events(NULL, NULL, name_only);
 }
 
 int parse_events__is_hardcoded_term(struct parse_events_term *term)
@@ -2322,9 +2464,9 @@ static void config_terms_list(char *buf, size_t buf_sz)
 char *parse_events_formats_error_string(char *additional_terms)
 {
         char *str;
-        /* "branch_type" is the longest name */
+        /* "no-overwrite" is the longest name */
         char static_terms[__PARSE_EVENTS__TERM_TYPE_NR *
-                          (sizeof("branch_type") - 1)];
+                          (sizeof("no-overwrite") - 1)];
 
         config_terms_list(static_terms, sizeof(static_terms));
         /* valid terms */
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index d740c3ca9a1d..da246a3ddb69 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -68,6 +68,10 @@ enum {
         PARSE_EVENTS__TERM_TYPE_STACKSIZE,
         PARSE_EVENTS__TERM_TYPE_NOINHERIT,
         PARSE_EVENTS__TERM_TYPE_INHERIT,
+        PARSE_EVENTS__TERM_TYPE_MAX_STACK,
+        PARSE_EVENTS__TERM_TYPE_NOOVERWRITE,
+        PARSE_EVENTS__TERM_TYPE_OVERWRITE,
+        PARSE_EVENTS__TERM_TYPE_DRV_CFG,
         __PARSE_EVENTS__TERM_TYPE_NR,
 };
 
@@ -133,7 +137,7 @@ 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,
-                                char *sys, char *event,
+                                const char *sys, const char *event,
                                 struct parse_events_error *error,
                                 struct list_head *head_config);
 int parse_events_load_bpf(struct parse_events_evlist *data,
@@ -168,7 +172,8 @@ void parse_events_update_lists(struct list_head *list_event,
 void parse_events_evlist_error(struct parse_events_evlist *data,
                                int idx, const char *str);
 
-void print_events(const char *event_glob, bool name_only);
+void print_events(const char *event_glob, bool name_only, bool quiet,
+                  bool long_desc);
 
 struct event_symbol {
         const char      *symbol;
@@ -182,6 +187,8 @@ void print_symbol_events(const char *event_glob, unsigned type,
 void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
                              bool name_only);
 int print_hwcache_events(const char *event_glob, bool name_only);
+void print_sdt_events(const char *subsys_glob, const char *event_glob,
+                      bool name_only);
 int is_valid_tracepoint(const char *event_string);
 
 int valid_event_mount(const char *eventfs);
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 1477fbc78993..9f43fda2570f 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -53,6 +53,26 @@ static int str(yyscan_t scanner, int token)
         return token;
 }
 
+/*
+ * This function is called when the parser gets two kind of input:
+ *
+ *      @cfg1 or @cfg2=config
+ *
+ * The leading '@' is stripped off before 'cfg1' and 'cfg2=config' are given to
+ * bison.  In the latter case it is necessary to keep the string intact so that
+ * the PMU kernel driver can determine what configurable is associated to
+ * 'config'.
+ */
+static int drv_str(yyscan_t scanner, int token)
+{
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+        char *text = parse_events_get_text(scanner);
+
+        /* Strip off the '@' */
+        yylval->str = strdup(text + 1);
+        return token;
+}
+
 #define REWIND(__alloc)                         \
 do {                                                            \
         YYSTYPE *__yylval = parse_events_get_lval(yyscanner);   \
@@ -124,6 +144,7 @@ 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\-_*?.:]*
+drv_cfg_term    [a-zA-Z0-9_\.]+(=[a-zA-Z0-9_*?\.:]+)?
 /* If you add a modifier you need to update check_modifier() */
 modifier_event  [ukhpPGHSDI]+
 modifier_bp     [rwx]{1,3}
@@ -199,13 +220,17 @@ branch_type		{ return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE
 time                    { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_TIME); }
 call-graph              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CALLGRAPH); }
 stack-size              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_STACKSIZE); }
+max-stack               { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_MAX_STACK); }
 inherit                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_INHERIT); }
 no-inherit              { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOINHERIT); }
+overwrite               { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_OVERWRITE); }
+no-overwrite            { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NOOVERWRITE); }
 ,                       { return ','; }
 "/"                     { BEGIN(INITIAL); return '/'; }
 {name_minus}            { return str(yyscanner, PE_NAME); }
 \[all\]                 { return PE_ARRAY_ALL; }
 "["                     { BEGIN(array); return '['; }
+@{drv_cfg_term}         { return drv_str(yyscanner, PE_DRV_CFG_TERM); }
 }
 
 <mem>{
@@ -259,6 +284,7 @@ cycles-ct					{ return str(yyscanner, PE_KERNEL_PMU_EVENT); }
 cycles-t                                        { return str(yyscanner, PE_KERNEL_PMU_EVENT); }
 mem-loads                                       { return str(yyscanner, PE_KERNEL_PMU_EVENT); }
 mem-stores                                      { return str(yyscanner, PE_KERNEL_PMU_EVENT); }
+topdown-[a-z-]+                                 { return str(yyscanner, PE_KERNEL_PMU_EVENT); }
 
 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 5be4a5f216d6..879115f93edc 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -49,6 +49,7 @@ static void inc_group_count(struct list_head *list,
 %token PE_ERROR
 %token PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
 %token PE_ARRAY_ALL PE_ARRAY_RANGE
+%token PE_DRV_CFG_TERM
 %type <num> PE_VALUE
 %type <num> PE_VALUE_SYM_HW
 %type <num> PE_VALUE_SYM_SW
@@ -63,6 +64,7 @@ static void inc_group_count(struct list_head *list,
 %type <str> PE_MODIFIER_BP
 %type <str> PE_EVENT_NAME
 %type <str> PE_PMU_EVENT_PRE PE_PMU_EVENT_SUF PE_KERNEL_PMU_EVENT
+%type <str> PE_DRV_CFG_TERM
 %type <num> value_sym
 %type <head> event_config
 %type <head> opt_event_config
@@ -599,6 +601,15 @@ PE_NAME array '=' PE_VALUE
         term->array = $2;
         $$ = term;
 }
+|
+PE_DRV_CFG_TERM
+{
+        struct parse_events_term *term;
+
+        ABORT_ON(parse_events_term__str(&term, PARSE_EVENTS__TERM_TYPE_DRV_CFG,
+                                        $1, $1, &@1, NULL));
+        $$ = term;
+}
 
 array:
 '[' array_terms ']'
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index 3bf6bf82ff2d..7c7630be5a89 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -11,17 +11,13 @@
  * which is what it's designed for.
  */
 #include "cache.h"
+#include "util.h"
+#include <limits.h>
 
 static char bad_path[] = "/bad-path/";
 /*
- * Two hacks:
+ * One hack:
  */
-
-static const char *get_perf_dir(void)
-{
-        return ".";
-}
-
 static char *get_pathname(void)
 {
         static char pathname_array[4][PATH_MAX];
@@ -54,60 +50,3 @@ char *mkpath(const char *fmt, ...)
                 return bad_path;
         return cleanup_path(pathname);
 }
-
-char *perf_path(const char *fmt, ...)
-{
-        const char *perf_dir = get_perf_dir();
-        char *pathname = get_pathname();
-        va_list args;
-        unsigned len;
-
-        len = strlen(perf_dir);
-        if (len > PATH_MAX-100)
-                return bad_path;
-        memcpy(pathname, perf_dir, len);
-        if (len && perf_dir[len-1] != '/')
-                pathname[len++] = '/';
-        va_start(args, fmt);
-        len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
-        va_end(args);
-        if (len >= PATH_MAX)
-                return bad_path;
-        return cleanup_path(pathname);
-}
-
-/* strip arbitrary amount of directory separators at end of path */
-static inline int chomp_trailing_dir_sep(const char *path, int len)
-{
-        while (len && is_dir_sep(path[len - 1]))
-                len--;
-        return len;
-}
-
-/*
- * If path ends with suffix (complete path components), returns the
- * part before suffix (sans trailing directory separators).
- * Otherwise returns NULL.
- */
-char *strip_path_suffix(const char *path, const char *suffix)
-{
-        int path_len = strlen(path), suffix_len = strlen(suffix);
-
-        while (suffix_len) {
-                if (!path_len)
-                        return NULL;
-
-                if (is_dir_sep(path[path_len - 1])) {
-                        if (!is_dir_sep(suffix[suffix_len - 1]))
-                                return NULL;
-                        path_len = chomp_trailing_dir_sep(path, path_len);
-                        suffix_len = chomp_trailing_dir_sep(suffix, suffix_len);
-                }
-                else if (path[--path_len] != suffix[--suffix_len])
-                        return NULL;
-        }
-
-        if (path_len && !is_dir_sep(path[path_len - 1]))
-                return NULL;
-        return strndup(path, chomp_trailing_dir_sep(path, path_len));
-}
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index ddb0261b2577..b1474dcadfa2 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -12,6 +12,9 @@
 #include "pmu.h"
 #include "parse-events.h"
 #include "cpumap.h"
+#include "header.h"
+#include "pmu-events/pmu-events.h"
+#include "cache.h"
 
 struct perf_pmu_format {
         char *name;
@@ -220,7 +223,8 @@ static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
 }
 
 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
-                                 char *desc __maybe_unused, char *val)
+                                 char *desc, char *val, char *long_desc,
+                                 char *topic)
 {
         struct perf_pmu_alias *alias;
         int ret;
@@ -253,6 +257,11 @@ static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                 perf_pmu__parse_snapshot(alias, dir, name);
         }
 
+        alias->desc = desc ? strdup(desc) : NULL;
+        alias->long_desc = long_desc ? strdup(long_desc) :
+                                desc ? strdup(desc) : NULL;
+        alias->topic = topic ? strdup(topic) : NULL;
+
         list_add_tail(&alias->list, list);
 
         return 0;
@@ -269,7 +278,7 @@ static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FI
 
         buf[ret] = 0;
 
-        return __perf_pmu__new_alias(list, dir, name, NULL, buf);
+        return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL);
 }
 
 static inline bool pmu_alias_info_file(char *name)
@@ -445,14 +454,23 @@ static struct cpu_map *pmu_cpumask(const char *name)
         FILE *file;
         struct cpu_map *cpus;
         const char *sysfs = sysfs__mountpoint();
+        const char *templates[] = {
+                 "%s/bus/event_source/devices/%s/cpumask",
+                 "%s/bus/event_source/devices/%s/cpus",
+                 NULL
+        };
+        const char **template;
 
         if (!sysfs)
                 return NULL;
 
-        snprintf(path, PATH_MAX,
-                 "%s/bus/event_source/devices/%s/cpumask", sysfs, name);
+        for (template = templates; *template; template++) {
+                snprintf(path, PATH_MAX, *template, sysfs, name);
+                if (stat(path, &st) == 0)
+                        break;
+        }
 
-        if (stat(path, &st) < 0)
+        if (!*template)
                 return NULL;
 
         file = fopen(path, "r");
@@ -464,6 +482,68 @@ static struct cpu_map *pmu_cpumask(const char *name)
         return cpus;
 }
 
+/*
+ * Return the CPU id as a raw string.
+ *
+ * Each architecture should provide a more precise id string that
+ * can be use to match the architecture's "mapfile".
+ */
+char * __weak get_cpuid_str(void)
+{
+        return NULL;
+}
+
+/*
+ * From the pmu_events_map, find the table of PMU events that corresponds
+ * to the current running CPU. Then, add all PMU events from that table
+ * as aliases.
+ */
+static void pmu_add_cpu_aliases(struct list_head *head)
+{
+        int i;
+        struct pmu_events_map *map;
+        struct pmu_event *pe;
+        char *cpuid;
+
+        cpuid = getenv("PERF_CPUID");
+        if (cpuid)
+                cpuid = strdup(cpuid);
+        if (!cpuid)
+                cpuid = get_cpuid_str();
+        if (!cpuid)
+                return;
+
+        pr_debug("Using CPUID %s\n", cpuid);
+
+        i = 0;
+        while (1) {
+                map = &pmu_events_map[i++];
+                if (!map->table)
+                        goto out;
+
+                if (!strcmp(map->cpuid, cpuid))
+                        break;
+        }
+
+        /*
+         * Found a matching PMU events table. Create aliases
+         */
+        i = 0;
+        while (1) {
+                pe = &map->table[i++];
+                if (!pe->name)
+                        break;
+
+                /* need type casts to override 'const' */
+                __perf_pmu__new_alias(head, NULL, (char *)pe->name,
+                                (char *)pe->desc, (char *)pe->event,
+                                (char *)pe->long_desc, (char *)pe->topic);
+        }
+
+out:
+        free(cpuid);
+}
+
 struct perf_event_attr * __weak
 perf_pmu__get_default_config(struct perf_pmu *pmu __maybe_unused)
 {
@@ -488,6 +568,9 @@ static struct perf_pmu *pmu_lookup(const char *name)
         if (pmu_aliases(name, &aliases))
                 return NULL;
 
+        if (!strcmp(name, "cpu"))
+                pmu_add_cpu_aliases(&aliases);
+
         if (pmu_type(name, &type))
                 return NULL;
 
@@ -974,21 +1057,63 @@ static char *format_alias_or(char *buf, int len, struct perf_pmu *pmu,
         return buf;
 }
 
-static int cmp_string(const void *a, const void *b)
+struct sevent {
+        char *name;
+        char *desc;
+        char *topic;
+};
+
+static int cmp_sevent(const void *a, const void *b)
 {
-        const char * const *as = a;
-        const char * const *bs = b;
-        return strcmp(*as, *bs);
+        const struct sevent *as = a;
+        const struct sevent *bs = b;
+
+        /* Put extra events last */
+        if (!!as->desc != !!bs->desc)
+                return !!as->desc - !!bs->desc;
+        if (as->topic && bs->topic) {
+                int n = strcmp(as->topic, bs->topic);
+
+                if (n)
+                        return n;
+        }
+        return strcmp(as->name, bs->name);
 }
 
-void print_pmu_events(const char *event_glob, bool name_only)
+static void wordwrap(char *s, int start, int max, int corr)
+{
+        int column = start;
+        int n;
+
+        while (*s) {
+                int wlen = strcspn(s, " \t");
+
+                if (column + wlen >= max && column > start) {
+                        printf("\n%*s", start, "");
+                        column = start + corr;
+                }
+                n = printf("%s%.*s", column > start ? " " : "", wlen, s);
+                if (n <= 0)
+                        break;
+                s += wlen;
+                column += n;
+                while (isspace(*s))
+                        s++;
+        }
+}
+
+void print_pmu_events(const char *event_glob, bool name_only, bool quiet_flag,
+                        bool long_desc)
 {
         struct perf_pmu *pmu;
         struct perf_pmu_alias *alias;
         char buf[1024];
         int printed = 0;
         int len, j;
-        char **aliases;
+        struct sevent *aliases;
+        int numdesc = 0;
+        int columns = pager_get_columns();
+        char *topic = NULL;
 
         pmu = NULL;
         len = 0;
@@ -998,14 +1123,15 @@ void print_pmu_events(const char *event_glob, bool name_only)
                 if (pmu->selectable)
                         len++;
         }
-        aliases = zalloc(sizeof(char *) * len);
+        aliases = zalloc(sizeof(struct sevent) * len);
         if (!aliases)
                 goto out_enomem;
         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);
+                        char *name = alias->desc ? alias->name :
+                                format_alias(buf, sizeof(buf), pmu, alias);
                         bool is_cpu = !strcmp(pmu->name, "cpu");
 
                         if (event_glob != NULL &&
@@ -1014,12 +1140,21 @@ void print_pmu_events(const char *event_glob, bool name_only)
                                                        event_glob))))
                                 continue;
 
-                        if (is_cpu && !name_only)
+                        if (is_cpu && !name_only && !alias->desc)
                                 name = format_alias_or(buf, sizeof(buf), pmu, alias);
 
-                        aliases[j] = strdup(name);
-                        if (aliases[j] == NULL)
+                        aliases[j].name = name;
+                        if (is_cpu && !name_only && !alias->desc)
+                                aliases[j].name = format_alias_or(buf,
+                                                                  sizeof(buf),
+                                                                  pmu, alias);
+                        aliases[j].name = strdup(aliases[j].name);
+                        if (!aliases[j].name)
                                 goto out_enomem;
+
+                        aliases[j].desc = long_desc ? alias->long_desc :
+                                                alias->desc;
+                        aliases[j].topic = alias->topic;
                         j++;
                 }
                 if (pmu->selectable &&
@@ -1027,25 +1162,39 @@ void print_pmu_events(const char *event_glob, bool name_only)
                         char *s;
                         if (asprintf(&s, "%s//", pmu->name) < 0)
                                 goto out_enomem;
-                        aliases[j] = s;
+                        aliases[j].name = s;
                         j++;
                 }
         }
         len = j;
-        qsort(aliases, len, sizeof(char *), cmp_string);
+        qsort(aliases, len, sizeof(struct sevent), cmp_sevent);
         for (j = 0; j < len; j++) {
                 if (name_only) {
-                        printf("%s ", aliases[j]);
+                        printf("%s ", aliases[j].name);
                         continue;
                 }
-                printf("  %-50s [Kernel PMU event]\n", aliases[j]);
+                if (aliases[j].desc && !quiet_flag) {
+                        if (numdesc++ == 0)
+                                printf("\n");
+                        if (aliases[j].topic && (!topic ||
+                                        strcmp(topic, aliases[j].topic))) {
+                                printf("%s%s:\n", topic ? "\n" : "",
+                                                aliases[j].topic);
+                                topic = aliases[j].topic;
+                        }
+                        printf("  %-50s\n", aliases[j].name);
+                        printf("%*s", 8, "[");
+                        wordwrap(aliases[j].desc, 8, columns, 0);
+                        printf("]\n");
+                } else
+                        printf("  %-50s [Kernel PMU event]\n", aliases[j].name);
                 printed++;
         }
         if (printed && pager_in_use())
                 printf("\n");
 out_free:
         for (j = 0; j < len; j++)
-                zfree(&aliases[j]);
+                zfree(&aliases[j].name);
         zfree(&aliases);
         return;
 
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 5d7e84466bee..25712034c815 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -4,6 +4,7 @@
 #include <linux/bitmap.h>
 #include <linux/perf_event.h>
 #include <stdbool.h>
+#include "evsel.h"
 #include "parse-events.h"
 
 enum {
@@ -25,6 +26,7 @@ struct perf_pmu {
         struct list_head format;  /* HEAD struct perf_pmu_format -> list */
         struct list_head aliases; /* HEAD struct perf_pmu_alias -> list */
         struct list_head list;    /* ELEM */
+        int (*set_drv_config)   (struct perf_evsel_config_term *term);
 };
 
 struct perf_pmu_info {
@@ -38,6 +40,9 @@ struct perf_pmu_info {
 
 struct perf_pmu_alias {
         char *name;
+        char *desc;
+        char *long_desc;
+        char *topic;
         struct list_head terms; /* HEAD struct parse_events_term -> list */
         struct list_head list;  /* ELEM */
         char unit[UNIT_MAX_LEN+1];
@@ -69,7 +74,8 @@ 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);
+void print_pmu_events(const char *event_glob, bool name_only, bool quiet,
+                      bool long_desc);
 bool pmu_have_event(const char *pname, const char *name);
 
 int perf_pmu__scan_file(struct perf_pmu *pmu, const char *name, const char *fmt,
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 74401a20106d..d281ae2b54e8 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -67,7 +67,6 @@ int e_snprintf(char *str, size_t size, const char *format, ...)
         return ret;
 }
 
-static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
 static struct machine *host_machine;
 
 /* Initialize symbol maps and path of vmlinux/modules */
@@ -103,23 +102,20 @@ out:
 
 void exit_probe_symbol_maps(void)
 {
-        if (host_machine) {
-                machine__delete(host_machine);
-                host_machine = NULL;
-        }
+        machine__delete(host_machine);
+        host_machine = NULL;
         symbol__exit();
 }
 
 static struct symbol *__find_kernel_function_by_name(const char *name,
                                                      struct map **mapp)
 {
-        return machine__find_kernel_function_by_name(host_machine, name, mapp,
-                                                     NULL);
+        return machine__find_kernel_function_by_name(host_machine, name, mapp);
 }
 
 static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
 {
-        return machine__find_kernel_function(host_machine, addr, mapp, NULL);
+        return machine__find_kernel_function(host_machine, addr, mapp);
 }
 
 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
@@ -128,7 +124,7 @@ static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
         struct kmap *kmap;
         struct map *map = machine__kernel_map(host_machine);
 
-        if (map__load(map, NULL) < 0)
+        if (map__load(map) < 0)
                 return NULL;
 
         kmap = map__kmap(map);
@@ -173,15 +169,17 @@ static struct map *kernel_get_module_map(const char *module)
                 module = "kernel";
 
         for (pos = maps__first(maps); pos; pos = map__next(pos)) {
+                /* short_name is "[module]" */
                 if (strncmp(pos->dso->short_name + 1, module,
-                            pos->dso->short_name_len - 2) == 0) {
+                            pos->dso->short_name_len - 2) == 0 &&
+                    module[pos->dso->short_name_len - 2] == '\0') {
                         return pos;
                 }
         }
         return NULL;
 }
 
-static struct map *get_target_map(const char *target, bool user)
+struct map *get_target_map(const char *target, bool user)
 {
         /* Init maps of given executable or kernel */
         if (user)
@@ -215,9 +213,13 @@ static int convert_exec_to_group(const char *exec, char **result)
                 goto out;
         }
 
-        ptr2 = strpbrk(ptr1, "-._");
-        if (ptr2)
-                *ptr2 = '\0';
+        for (ptr2 = ptr1; *ptr2 != '\0'; ptr2++) {
+                if (!isalnum(*ptr2) && *ptr2 != '_') {
+                        *ptr2 = '\0';
+                        break;
+                }
+        }
+
         ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
         if (ret < 0)
                 goto out;
@@ -352,9 +354,9 @@ static int kernel_get_module_dso(const char *module, struct dso **pdso)
         vmlinux_name = symbol_conf.vmlinux_name;
         dso->load_errno = 0;
         if (vmlinux_name)
-                ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL);
+                ret = dso__load_vmlinux(dso, map, vmlinux_name, false);
         else
-                ret = dso__load_vmlinux_path(dso, map, NULL);
+                ret = dso__load_vmlinux_path(dso, map);
 found:
         *pdso = dso;
         return ret;
@@ -388,7 +390,7 @@ static int find_alternative_probe_point(struct debuginfo *dinfo,
                 if (uprobes)
                         address = sym->start;
                 else
-                        address = map->unmap_ip(map, sym->start);
+                        address = map->unmap_ip(map, sym->start) - map->reloc;
                 break;
         }
         if (!address) {
@@ -471,7 +473,7 @@ static struct debuginfo *open_debuginfo(const char *module, bool silent)
                 err = kernel_get_module_dso(module, &dso);
                 if (err < 0) {
                         if (!dso || dso->load_errno == 0) {
-                                if (!strerror_r(-err, reason, STRERR_BUFSIZE))
+                                if (!str_error_r(-err, reason, STRERR_BUFSIZE))
                                         strcpy(reason, "(unknown)");
                         } else
                                 dso__strerror_load(dso, reason, STRERR_BUFSIZE);
@@ -667,21 +669,17 @@ static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
         return ret;
 }
 
-/* Post processing the probe events */
-static int post_process_probe_trace_events(struct probe_trace_event *tevs,
-                                           int ntevs, const char *module,
-                                           bool uprobe)
+static int
+post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
+                                       int ntevs)
 {
         struct ref_reloc_sym *reloc_sym;
         char *tmp;
         int i, skipped = 0;
 
-        if (uprobe)
-                return add_exec_to_probe_trace_events(tevs, ntevs, module);
-
-        /* Note that currently ref_reloc_sym based probe is not for drivers */
-        if (module)
-                return add_module_to_probe_trace_events(tevs, ntevs, module);
+        /* Skip post process if the target is an offline kernel */
+        if (symbol_conf.ignore_vmlinux_buildid)
+                return 0;
 
         reloc_sym = kernel_get_ref_reloc_sym();
         if (!reloc_sym) {
@@ -714,6 +712,34 @@ static int post_process_probe_trace_events(struct probe_trace_event *tevs,
         return skipped;
 }
 
+void __weak
+arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
+                                      int ntevs __maybe_unused)
+{
+}
+
+/* Post processing the probe events */
+static int post_process_probe_trace_events(struct perf_probe_event *pev,
+                                           struct probe_trace_event *tevs,
+                                           int ntevs, const char *module,
+                                           bool uprobe)
+{
+        int ret;
+
+        if (uprobe)
+                ret = add_exec_to_probe_trace_events(tevs, ntevs, module);
+        else if (module)
+                /* Currently ref_reloc_sym based probe is not for drivers */
+                ret = add_module_to_probe_trace_events(tevs, ntevs, module);
+        else
+                ret = post_process_kernel_probe_trace_events(tevs, ntevs);
+
+        if (ret >= 0)
+                arch__post_process_probe_trace_events(pev, ntevs);
+
+        return ret;
+}
+
 /* Try to find perf_probe_event with debuginfo */
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                           struct probe_trace_event **tevs)
@@ -752,7 +778,7 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 
         if (ntevs > 0) {        /* Succeeded to find trace events */
                 pr_debug("Found %d probe_trace_events.\n", ntevs);
-                ret = post_process_probe_trace_events(*tevs, ntevs,
+                ret = post_process_probe_trace_events(pev, *tevs, ntevs,
                                                 pev->target, pev->uprobes);
                 if (ret < 0 || ret == ntevs) {
                         clear_probe_trace_events(*tevs, ntevs);
@@ -809,7 +835,7 @@ static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 error:
         if (ferror(fp)) {
                 pr_warning("File read error: %s\n",
-                           strerror_r(errno, sbuf, sizeof(sbuf)));
+                           str_error_r(errno, sbuf, sizeof(sbuf)));
                 return -1;
         }
         return 0;
@@ -889,7 +915,7 @@ static int __show_line_range(struct line_range *lr, const char *module,
         fp = fopen(lr->path, "r");
         if (fp == NULL) {
                 pr_warning("Failed to open %s: %s\n", lr->path,
-                           strerror_r(errno, sbuf, sizeof(sbuf)));
+                           str_error_r(errno, sbuf, sizeof(sbuf)));
                 return -errno;
         }
         /* Skip to starting line number */
@@ -899,7 +925,7 @@ static int __show_line_range(struct line_range *lr, const char *module,
                         goto end;
         }
 
-        intlist__for_each(ln, lr->line_list) {
+        intlist__for_each_entry(ln, lr->line_list) {
                 for (; ln->i > l; l++) {
                         ret = show_one_line(fp, l - lr->offset);
                         if (ret < 0)
@@ -983,7 +1009,7 @@ static int show_available_vars_at(struct debuginfo *dinfo,
                 zfree(&vl->point.symbol);
                 nvars = 0;
                 if (vl->vars) {
-                        strlist__for_each(node, vl->vars) {
+                        strlist__for_each_entry(node, vl->vars) {
                                 var = strchr(node->s, '\t') + 1;
                                 if (strfilter__compare(_filter, var)) {
                                         fprintf(stdout, "\t\t%s\n", node->s);
@@ -1200,6 +1226,34 @@ err:
         return err;
 }
 
+static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
+{
+        char *ptr;
+
+        ptr = strchr(*arg, ':');
+        if (ptr) {
+                *ptr = '\0';
+                if (!pev->sdt && !is_c_func_name(*arg))
+                        goto ng_name;
+                pev->group = strdup(*arg);
+                if (!pev->group)
+                        return -ENOMEM;
+                *arg = ptr + 1;
+        } else
+                pev->group = NULL;
+        if (!pev->sdt && !is_c_func_name(*arg)) {
+ng_name:
+                semantic_error("%s is bad for event name -it must "
+                               "follow C symbol-naming rule.\n", *arg);
+                return -EINVAL;
+        }
+        pev->event = strdup(*arg);
+        if (pev->event == NULL)
+                return -ENOMEM;
+
+        return 0;
+}
+
 /* Parse probepoint definition. */
 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
@@ -1207,33 +1261,64 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
         char *ptr, *tmp;
         char c, nc = 0;
         bool file_spec = false;
+        int ret;
+
         /*
          * <Syntax>
-         * perf probe [EVENT=]SRC[:LN|;PTN]
-         * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
-         *
-         * TODO:Group name support
+         * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
+         * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
+         * perf probe %[GRP:]SDT_EVENT
          */
         if (!arg)
                 return -EINVAL;
 
+        /*
+         * If the probe point starts with '%',
+         * or starts with "sdt_" and has a ':' but no '=',
+         * then it should be a SDT/cached probe point.
+         */
+        if (arg[0] == '%' ||
+            (!strncmp(arg, "sdt_", 4) &&
+             !!strchr(arg, ':') && !strchr(arg, '='))) {
+                pev->sdt = true;
+                if (arg[0] == '%')
+                        arg++;
+        }
+
         ptr = strpbrk(arg, ";=@+%");
+        if (pev->sdt) {
+                if (ptr) {
+                        if (*ptr != '@') {
+                                semantic_error("%s must be an SDT name.\n",
+                                               arg);
+                                return -EINVAL;
+                        }
+                        /* This must be a target file name or build id */
+                        tmp = build_id_cache__complement(ptr + 1);
+                        if (tmp) {
+                                pev->target = build_id_cache__origname(tmp);
+                                free(tmp);
+                        } else
+                                pev->target = strdup(ptr + 1);
+                        if (!pev->target)
+                                return -ENOMEM;
+                        *ptr = '\0';
+                }
+                ret = parse_perf_probe_event_name(&arg, pev);
+                if (ret == 0) {
+                        if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
+                                ret = -errno;
+                }
+                return ret;
+        }
+
         if (ptr && *ptr == '=') {       /* Event name */
                 *ptr = '\0';
                 tmp = ptr + 1;
-                if (strchr(arg, ':')) {
-                        semantic_error("Group name is not supported yet.\n");
-                        return -ENOTSUP;
-                }
-                if (!is_c_func_name(arg)) {
-                        semantic_error("%s is bad for event name -it must "
-                                       "follow C symbol-naming rule.\n", arg);
-                        return -EINVAL;
-                }
-                pev->event = strdup(arg);
-                if (pev->event == NULL)
-                        return -ENOMEM;
-                pev->group = NULL;
+                ret = parse_perf_probe_event_name(&arg, pev);
+                if (ret < 0)
+                        return ret;
+
                 arg = tmp;
         }
 
@@ -1536,17 +1621,27 @@ out:
         return ret;
 }
 
+/* Returns true if *any* ARG is either C variable, $params or $vars. */
+bool perf_probe_with_var(struct perf_probe_event *pev)
+{
+        int i = 0;
+
+        for (i = 0; i < pev->nargs; i++)
+                if (is_c_varname(pev->args[i].var)              ||
+                    !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
+                    !strcmp(pev->args[i].var, PROBE_ARG_VARS))
+                        return true;
+        return false;
+}
+
 /* Return true if this perf_probe_event requires debuginfo */
 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
 {
-        int i;
-
         if (pev->point.file || pev->point.line || pev->point.lazy_line)
                 return true;
 
-        for (i = 0; i < pev->nargs; i++)
-                if (is_c_varname(pev->args[i].var))
-                        return true;
+        if (perf_probe_with_var(pev))
+                return true;
 
         return false;
 }
@@ -1603,6 +1698,11 @@ int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
         p = strchr(argv[1], ':');
         if (p) {
                 tp->module = strndup(argv[1], p - argv[1]);
+                if (!tp->module) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
+                tev->uprobes = (tp->module[0] == '/');
                 p++;
         } else
                 p = argv[1];
@@ -1712,7 +1812,7 @@ out:
 }
 
 /* Compose only probe point (not argument) */
-static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
+char *synthesize_perf_probe_point(struct perf_probe_point *pp)
 {
         struct strbuf buf;
         char *tmp, *ret = NULL;
@@ -1751,30 +1851,36 @@ out:
         return ret;
 }
 
-#if 0
 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 {
-        char *buf;
-        int i, len, ret;
+        struct strbuf buf;
+        char *tmp, *ret = NULL;
+        int i;
 
-        buf = synthesize_perf_probe_point(&pev->point);
-        if (!buf)
+        if (strbuf_init(&buf, 64))
                 return NULL;
+        if (pev->event)
+                if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
+                                pev->event) < 0)
+                        goto out;
+
+        tmp = synthesize_perf_probe_point(&pev->point);
+        if (!tmp || strbuf_addstr(&buf, tmp) < 0)
+                goto out;
+        free(tmp);
 
-        len = strlen(buf);
         for (i = 0; i < pev->nargs; i++) {
-                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
-                                 pev->args[i].name);
-                if (ret <= 0) {
-                        free(buf);
-                        return NULL;
-                }
-                len += ret;
+                tmp = synthesize_perf_probe_arg(pev->args + i);
+                if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
+                        goto out;
+                free(tmp);
         }
 
-        return buf;
+        ret = strbuf_detach(&buf, NULL);
+out:
+        strbuf_release(&buf);
+        return ret;
 }
-#endif
 
 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
                                             struct strbuf *buf, int depth)
@@ -1896,7 +2002,7 @@ static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
                 map = dso__new_map(tp->module);
                 if (!map)
                         goto out;
-                sym = map__find_symbol(map, addr, NULL);
+                sym = map__find_symbol(map, addr);
         } else {
                 if (tp->symbol && !addr) {
                         if (kernel_get_symbol_address_by_name(tp->symbol,
@@ -2026,6 +2132,79 @@ void clear_perf_probe_event(struct perf_probe_event *pev)
         memset(pev, 0, sizeof(*pev));
 }
 
+#define strdup_or_goto(str, label)      \
+({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
+
+static int perf_probe_point__copy(struct perf_probe_point *dst,
+                                  struct perf_probe_point *src)
+{
+        dst->file = strdup_or_goto(src->file, out_err);
+        dst->function = strdup_or_goto(src->function, out_err);
+        dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
+        dst->line = src->line;
+        dst->retprobe = src->retprobe;
+        dst->offset = src->offset;
+        return 0;
+
+out_err:
+        clear_perf_probe_point(dst);
+        return -ENOMEM;
+}
+
+static int perf_probe_arg__copy(struct perf_probe_arg *dst,
+                                struct perf_probe_arg *src)
+{
+        struct perf_probe_arg_field *field, **ppfield;
+
+        dst->name = strdup_or_goto(src->name, out_err);
+        dst->var = strdup_or_goto(src->var, out_err);
+        dst->type = strdup_or_goto(src->type, out_err);
+
+        field = src->field;
+        ppfield = &(dst->field);
+        while (field) {
+                *ppfield = zalloc(sizeof(*field));
+                if (!*ppfield)
+                        goto out_err;
+                (*ppfield)->name = strdup_or_goto(field->name, out_err);
+                (*ppfield)->index = field->index;
+                (*ppfield)->ref = field->ref;
+                field = field->next;
+                ppfield = &((*ppfield)->next);
+        }
+        return 0;
+out_err:
+        return -ENOMEM;
+}
+
+int perf_probe_event__copy(struct perf_probe_event *dst,
+                           struct perf_probe_event *src)
+{
+        int i;
+
+        dst->event = strdup_or_goto(src->event, out_err);
+        dst->group = strdup_or_goto(src->group, out_err);
+        dst->target = strdup_or_goto(src->target, out_err);
+        dst->uprobes = src->uprobes;
+
+        if (perf_probe_point__copy(&dst->point, &src->point) < 0)
+                goto out_err;
+
+        dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
+        if (!dst->args)
+                goto out_err;
+        dst->nargs = src->nargs;
+
+        for (i = 0; i < src->nargs; i++)
+                if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
+                        goto out_err;
+        return 0;
+
+out_err:
+        clear_perf_probe_event(dst);
+        return -ENOMEM;
+}
+
 void clear_probe_trace_event(struct probe_trace_event *tev)
 {
         struct probe_trace_arg_ref *ref, *next;
@@ -2253,7 +2432,7 @@ static int __show_perf_probe_events(int fd, bool is_kprobe,
         if (!rawlist)
                 return -ENOMEM;
 
-        strlist__for_each(ent, rawlist) {
+        strlist__for_each_entry(ent, rawlist) {
                 ret = parse_probe_trace_command(ent->s, &tev);
                 if (ret >= 0) {
                         if (!filter_probe_trace_event(&tev, filter))
@@ -2286,6 +2465,9 @@ int show_perf_probe_events(struct strfilter *filter)
 
         setup_pager();
 
+        if (probe_conf.cache)
+                return probe_cache__show_all_caches(filter);
+
         ret = init_probe_symbol_maps(false);
         if (ret < 0)
                 return ret;
@@ -2394,17 +2576,24 @@ static int probe_trace_event__set_name(struct probe_trace_event *tev,
         char buf[64];
         int ret;
 
-        if (pev->event)
+        /* If probe_event or trace_event already have the name, reuse it */
+        if (pev->event && !pev->sdt)
                 event = pev->event;
-        else
+        else if (tev->event)
+                event = tev->event;
+        else {
+                /* Or generate new one from probe point */
                 if (pev->point.function &&
                         (strncmp(pev->point.function, "0x", 2) != 0) &&
                         !strisglob(pev->point.function))
                         event = pev->point.function;
                 else
                         event = tev->point.realname;
-        if (pev->group)
+        }
+        if (pev->group && !pev->sdt)
                 group = pev->group;
+        else if (tev->group)
+                group = tev->group;
         else
                 group = PERFPROBE_GROUP;
 
@@ -2426,40 +2615,60 @@ static int probe_trace_event__set_name(struct probe_trace_event *tev,
         return 0;
 }
 
-static int __add_probe_trace_events(struct perf_probe_event *pev,
-                                     struct probe_trace_event *tevs,
-                                     int ntevs, bool allow_suffix)
+static int __open_probe_file_and_namelist(bool uprobe,
+                                          struct strlist **namelist)
 {
-        int i, fd, ret;
-        struct probe_trace_event *tev = NULL;
-        struct strlist *namelist;
+        int fd;
 
-        fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0));
+        fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
         if (fd < 0)
                 return fd;
 
         /* Get current event names */
-        namelist = probe_file__get_namelist(fd);
-        if (!namelist) {
+        *namelist = probe_file__get_namelist(fd);
+        if (!(*namelist)) {
                 pr_debug("Failed to get current event list.\n");
-                ret = -ENOMEM;
-                goto close_out;
+                close(fd);
+                return -ENOMEM;
         }
+        return fd;
+}
+
+static int __add_probe_trace_events(struct perf_probe_event *pev,
+                                     struct probe_trace_event *tevs,
+                                     int ntevs, bool allow_suffix)
+{
+        int i, fd[2] = {-1, -1}, up, ret;
+        struct probe_trace_event *tev = NULL;
+        struct probe_cache *cache = NULL;
+        struct strlist *namelist[2] = {NULL, NULL};
+
+        up = pev->uprobes ? 1 : 0;
+        fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
+        if (fd[up] < 0)
+                return fd[up];
 
         ret = 0;
         for (i = 0; i < ntevs; i++) {
                 tev = &tevs[i];
+                up = tev->uprobes ? 1 : 0;
+                if (fd[up] == -1) {     /* Open the kprobe/uprobe_events */
+                        fd[up] = __open_probe_file_and_namelist(up,
+                                                                &namelist[up]);
+                        if (fd[up] < 0)
+                                goto close_out;
+                }
                 /* Skip if the symbol is out of .text or blacklisted */
-                if (!tev->point.symbol)
+                if (!tev->point.symbol && !pev->uprobes)
                         continue;
 
                 /* Set new name for tev (and update namelist) */
-                ret = probe_trace_event__set_name(tev, pev, namelist,
+                ret = probe_trace_event__set_name(tev, pev, namelist[up],
                                                   allow_suffix);
                 if (ret < 0)
                         break;
 
-                ret = probe_file__add_event(fd, tev);
+                ret = probe_file__add_event(fd[up], tev);
                 if (ret < 0)
                         break;
 
@@ -2473,10 +2682,21 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         }
         if (ret == -EINVAL && pev->uprobes)
                 warn_uprobe_event_compat(tev);
+        if (ret == 0 && probe_conf.cache) {
+                cache = probe_cache__new(pev->target);
+                if (!cache ||
+                    probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
+                    probe_cache__commit(cache) < 0)
+                        pr_warning("Failed to add event to probe cache\n");
+                probe_cache__delete(cache);
+        }
 
-        strlist__delete(namelist);
 close_out:
-        close(fd);
+        for (up = 0; up < 2; up++) {
+                strlist__delete(namelist[up]);
+                if (fd[up] >= 0)
+                        close(fd[up]);
+        }
         return ret;
 }
 
@@ -2487,7 +2707,7 @@ static int find_probe_functions(struct map *map, char *name,
         struct symbol *sym;
         struct rb_node *tmp;
 
-        if (map__load(map, NULL) < 0)
+        if (map__load(map) < 0)
                 return 0;
 
         map__for_each_symbol(map, sym, tmp) {
@@ -2501,9 +2721,6 @@ static int find_probe_functions(struct map *map, char *name,
         return found;
 }
 
-#define strdup_or_goto(str, label)      \
-        ({ char *__p = strdup(str); if (!__p) goto label; __p; })
-
 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
                                 struct probe_trace_event *tev __maybe_unused,
                                 struct map *map __maybe_unused,
@@ -2756,14 +2973,205 @@ errout:
         return err;
 }
 
-bool __weak arch__prefers_symtab(void) { return false; }
+/* Concatinate two arrays */
+static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
+{
+        void *ret;
+
+        ret = malloc(sz_a + sz_b);
+        if (ret) {
+                memcpy(ret, a, sz_a);
+                memcpy(ret + sz_a, b, sz_b);
+        }
+        return ret;
+}
+
+static int
+concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
+                          struct probe_trace_event **tevs2, int ntevs2)
+{
+        struct probe_trace_event *new_tevs;
+        int ret = 0;
+
+        if (ntevs == 0) {
+                *tevs = *tevs2;
+                *ntevs = ntevs2;
+                *tevs2 = NULL;
+                return 0;
+        }
+
+        if (*ntevs + ntevs2 > probe_conf.max_probes)
+                ret = -E2BIG;
+        else {
+                /* Concatinate the array of probe_trace_event */
+                new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
+                                  *tevs2, ntevs2 * sizeof(**tevs2));
+                if (!new_tevs)
+                        ret = -ENOMEM;
+                else {
+                        free(*tevs);
+                        *tevs = new_tevs;
+                        *ntevs += ntevs2;
+                }
+        }
+        if (ret < 0)
+                clear_probe_trace_events(*tevs2, ntevs2);
+        zfree(tevs2);
+
+        return ret;
+}
+
+/*
+ * Try to find probe_trace_event from given probe caches. Return the number
+ * of cached events found, if an error occurs return the error.
+ */
+static int find_cached_events(struct perf_probe_event *pev,
+                              struct probe_trace_event **tevs,
+                              const char *target)
+{
+        struct probe_cache *cache;
+        struct probe_cache_entry *entry;
+        struct probe_trace_event *tmp_tevs = NULL;
+        int ntevs = 0;
+        int ret = 0;
+
+        cache = probe_cache__new(target);
+        /* Return 0 ("not found") if the target has no probe cache. */
+        if (!cache)
+                return 0;
+
+        for_each_probe_cache_entry(entry, cache) {
+                /* Skip the cache entry which has no name */
+                if (!entry->pev.event || !entry->pev.group)
+                        continue;
+                if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
+                    strglobmatch(entry->pev.event, pev->event)) {
+                        ret = probe_cache_entry__get_event(entry, &tmp_tevs);
+                        if (ret > 0)
+                                ret = concat_probe_trace_events(tevs, &ntevs,
+                                                                &tmp_tevs, ret);
+                        if (ret < 0)
+                                break;
+                }
+        }
+        probe_cache__delete(cache);
+        if (ret < 0) {
+                clear_probe_trace_events(*tevs, ntevs);
+                zfree(tevs);
+        } else {
+                ret = ntevs;
+                if (ntevs > 0 && target && target[0] == '/')
+                        pev->uprobes = true;
+        }
+
+        return ret;
+}
+
+/* Try to find probe_trace_event from all probe caches */
+static int find_cached_events_all(struct perf_probe_event *pev,
+                                   struct probe_trace_event **tevs)
+{
+        struct probe_trace_event *tmp_tevs = NULL;
+        struct strlist *bidlist;
+        struct str_node *nd;
+        char *pathname;
+        int ntevs = 0;
+        int ret;
+
+        /* Get the buildid list of all valid caches */
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist) {
+                ret = -errno;
+                pr_debug("Failed to get buildids: %d\n", ret);
+                return ret;
+        }
+
+        ret = 0;
+        strlist__for_each_entry(nd, bidlist) {
+                pathname = build_id_cache__origname(nd->s);
+                ret = find_cached_events(pev, &tmp_tevs, pathname);
+                /* In the case of cnt == 0, we just skip it */
+                if (ret > 0)
+                        ret = concat_probe_trace_events(tevs, &ntevs,
+                                                        &tmp_tevs, ret);
+                free(pathname);
+                if (ret < 0)
+                        break;
+        }
+        strlist__delete(bidlist);
+
+        if (ret < 0) {
+                clear_probe_trace_events(*tevs, ntevs);
+                zfree(tevs);
+        } else
+                ret = ntevs;
+
+        return ret;
+}
+
+static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
+                                              struct probe_trace_event **tevs)
+{
+        struct probe_cache *cache;
+        struct probe_cache_entry *entry;
+        struct probe_trace_event *tev;
+        struct str_node *node;
+        int ret, i;
+
+        if (pev->sdt) {
+                /* For SDT/cached events, we use special search functions */
+                if (!pev->target)
+                        return find_cached_events_all(pev, tevs);
+                else
+                        return find_cached_events(pev, tevs, pev->target);
+        }
+        cache = probe_cache__new(pev->target);
+        if (!cache)
+                return 0;
+
+        entry = probe_cache__find(cache, pev);
+        if (!entry) {
+                /* SDT must be in the cache */
+                ret = pev->sdt ? -ENOENT : 0;
+                goto out;
+        }
+
+        ret = strlist__nr_entries(entry->tevlist);
+        if (ret > probe_conf.max_probes) {
+                pr_debug("Too many entries matched in the cache of %s\n",
+                         pev->target ? : "kernel");
+                ret = -E2BIG;
+                goto out;
+        }
+
+        *tevs = zalloc(ret * sizeof(*tev));
+        if (!*tevs) {
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        i = 0;
+        strlist__for_each_entry(node, entry->tevlist) {
+                tev = &(*tevs)[i++];
+                ret = parse_probe_trace_command(node->s, tev);
+                if (ret < 0)
+                        goto out;
+                /* Set the uprobes attribute as same as original */
+                tev->uprobes = pev->uprobes;
+        }
+        ret = i;
+
+out:
+        probe_cache__delete(cache);
+        return ret;
+}
 
 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                                          struct probe_trace_event **tevs)
 {
         int ret;
 
-        if (!pev->group) {
+        if (!pev->group && !pev->sdt) {
                 /* Set group name if not given */
                 if (!pev->uprobes) {
                         pev->group = strdup(PERFPROBE_GROUP);
@@ -2780,11 +3188,10 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
         if (ret > 0)
                 return ret;
 
-        if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
-                ret = find_probe_trace_events_from_map(pev, tevs);
-                if (ret > 0)
-                        return ret; /* Found in symbol table */
-        }
+        /* At first, we need to lookup cache entry */
+        ret = find_probe_trace_events_from_cache(pev, tevs);
+        if (ret > 0 || pev->sdt)        /* SDT can be found only in the cache */
+                return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
 
         /* Convert perf_probe_event with debuginfo */
         ret = try_to_find_probe_trace_events(pev, tevs);
@@ -2815,6 +3222,52 @@ int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
         return 0;
 }
 
+static int show_probe_trace_event(struct probe_trace_event *tev)
+{
+        char *buf = synthesize_probe_trace_command(tev);
+
+        if (!buf) {
+                pr_debug("Failed to synthesize probe trace event.\n");
+                return -EINVAL;
+        }
+
+        /* Showing definition always go stdout */
+        printf("%s\n", buf);
+        free(buf);
+
+        return 0;
+}
+
+int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
+{
+        struct strlist *namelist = strlist__new(NULL, NULL);
+        struct probe_trace_event *tev;
+        struct perf_probe_event *pev;
+        int i, j, ret = 0;
+
+        if (!namelist)
+                return -ENOMEM;
+
+        for (j = 0; j < npevs && !ret; j++) {
+                pev = &pevs[j];
+                for (i = 0; i < pev->ntevs && !ret; i++) {
+                        tev = &pev->tevs[i];
+                        /* Skip if the symbol is out of .text or blacklisted */
+                        if (!tev->point.symbol && !pev->uprobes)
+                                continue;
+
+                        /* Set new name for tev (and update namelist) */
+                        ret = probe_trace_event__set_name(tev, pev,
+                                                          namelist, true);
+                        if (!ret)
+                                ret = show_probe_trace_event(tev);
+                }
+        }
+        strlist__delete(namelist);
+
+        return ret;
+}
+
 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
 {
         int i, ret = 0;
@@ -2897,24 +3350,10 @@ out:
         return ret;
 }
 
-/* TODO: don't use a global variable for filter ... */
-static struct strfilter *available_func_filter;
-
-/*
- * If a symbol corresponds to a function with global binding and
- * matches filter return 0. For all others return 1.
- */
-static int filter_available_functions(struct map *map __maybe_unused,
-                                      struct symbol *sym)
-{
-        if (strfilter__compare(available_func_filter, sym->name))
-                return 0;
-        return 1;
-}
-
 int show_available_funcs(const char *target, struct strfilter *_filter,
                                         bool user)
 {
+        struct rb_node *nd;
         struct map *map;
         int ret;
 
@@ -2932,10 +3371,16 @@ int show_available_funcs(const char *target, struct strfilter *_filter,
                 return -EINVAL;
         }
 
-        /* Load symbols with given filter */
-        available_func_filter = _filter;
-        if (map__load(map, filter_available_functions)) {
-                pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
+        ret = map__load(map);
+        if (ret) {
+                if (ret == -2) {
+                        char *str = strfilter__string(_filter);
+                        pr_err("Failed to find symbols matched to \"%s\"\n",
+                               str);
+                        free(str);
+                } else
+                        pr_err("Failed to load symbols in %s\n",
+                               (target) ? : "kernel");
                 goto end;
         }
         if (!dso__sorted_by_name(map->dso, map->type))
@@ -2943,7 +3388,14 @@ int show_available_funcs(const char *target, struct strfilter *_filter,
 
         /* Show all (filtered) symbols */
         setup_pager();
-        dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
+
+        for (nd = rb_first(&map->dso->symbol_names[map->type]); nd; nd = rb_next(nd)) {
+                struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
+
+                if (strfilter__compare(_filter, pos->sym.name))
+                        printf("%s\n", pos->sym.name);
+        }
+
 end:
         if (user) {
                 map__put(map);
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 5a27eb4fad05..8091d15113f7 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -12,6 +12,7 @@ struct probe_conf {
         bool    show_location_range;
         bool    force_add;
         bool    no_inlines;
+        bool    cache;
         int     max_probes;
 };
 extern struct probe_conf probe_conf;
@@ -84,6 +85,7 @@ struct perf_probe_event {
         char                    *group; /* Group name */
         struct perf_probe_point point;  /* Probe point */
         int                     nargs;  /* Number of arguments */
+        bool                    sdt;    /* SDT/cached event flag */
         bool                    uprobes;        /* Uprobe event flag */
         char                    *target;        /* Target binary */
         struct perf_probe_arg   *args;  /* Arguments */
@@ -121,6 +123,12 @@ int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev);
 char *synthesize_perf_probe_command(struct perf_probe_event *pev);
 char *synthesize_probe_trace_command(struct probe_trace_event *tev);
 char *synthesize_perf_probe_arg(struct perf_probe_arg *pa);
+char *synthesize_perf_probe_point(struct perf_probe_point *pp);
+
+int perf_probe_event__copy(struct perf_probe_event *dst,
+                           struct perf_probe_event *src);
+
+bool perf_probe_with_var(struct perf_probe_event *pev);
 
 /* Check the perf_probe_event needs debuginfo */
 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev);
@@ -141,6 +149,7 @@ int line_range__init(struct line_range *lr);
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs);
+int show_probe_trace_events(struct perf_probe_event *pevs, int npevs);
 void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs);
 int del_perf_probe_events(struct strfilter *filter);
 
@@ -152,7 +161,6 @@ int show_line_range(struct line_range *lr, const char *module, bool user);
 int show_available_vars(struct perf_probe_event *pevs, int npevs,
                         struct strfilter *filter);
 int show_available_funcs(const char *module, struct strfilter *filter, bool user);
-bool arch__prefers_symtab(void);
 void arch__fix_tev_from_maps(struct perf_probe_event *pev,
                              struct probe_trace_event *tev, struct map *map,
                              struct symbol *sym);
@@ -167,4 +175,9 @@ int e_snprintf(char *str, size_t size, const char *format, ...)
 int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
                             struct perf_probe_arg *pvar);
 
+struct map *get_target_map(const char *target, bool user);
+
+void arch__post_process_probe_trace_events(struct perf_probe_event *pev,
+                                           int ntevs);
+
 #endif /*_PROBE_EVENT_H */
diff --git a/tools/perf/util/probe-file.c b/tools/perf/util/probe-file.c
index 3fe6214970e6..436b64731f65 100644
--- a/tools/perf/util/probe-file.c
+++ b/tools/perf/util/probe-file.c
@@ -14,6 +14,7 @@
  * GNU General Public License for more details.
  *
  */
+#include <sys/uio.h>
 #include "util.h"
 #include "event.h"
 #include "strlist.h"
@@ -49,7 +50,7 @@ static void print_open_warning(int err, bool uprobe)
         else
                 pr_warning("Failed to open %cprobe_events: %s\n",
                            uprobe ? 'u' : 'k',
-                           strerror_r(-err, sbuf, sizeof(sbuf)));
+                           str_error_r(-err, sbuf, sizeof(sbuf)));
 }
 
 static void print_both_open_warning(int kerr, int uerr)
@@ -63,20 +64,19 @@ static void print_both_open_warning(int kerr, int uerr)
         else {
                 char sbuf[STRERR_BUFSIZE];
                 pr_warning("Failed to open kprobe events: %s.\n",
-                           strerror_r(-kerr, sbuf, sizeof(sbuf)));
+                           str_error_r(-kerr, sbuf, sizeof(sbuf)));
                 pr_warning("Failed to open uprobe events: %s.\n",
-                           strerror_r(-uerr, sbuf, sizeof(sbuf)));
+                           str_error_r(-uerr, sbuf, sizeof(sbuf)));
         }
 }
 
 static int open_probe_events(const char *trace_file, bool readwrite)
 {
         char buf[PATH_MAX];
-        const char *tracing_dir = "";
         int ret;
 
-        ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
-                         tracing_path, tracing_dir, trace_file);
+        ret = e_snprintf(buf, PATH_MAX, "%s/%s",
+                         tracing_path, trace_file);
         if (ret >= 0) {
                 pr_debug("Opening %s write=%d\n", buf, readwrite);
                 if (readwrite && !probe_event_dry_run)
@@ -132,7 +132,7 @@ int probe_file__open_both(int *kfd, int *ufd, int flag)
 /* Get raw string list of current kprobe_events  or uprobe_events */
 struct strlist *probe_file__get_rawlist(int fd)
 {
-        int ret, idx;
+        int ret, idx, fddup;
         FILE *fp;
         char buf[MAX_CMDLEN];
         char *p;
@@ -142,8 +142,17 @@ struct strlist *probe_file__get_rawlist(int fd)
                 return NULL;
 
         sl = strlist__new(NULL, NULL);
+        if (sl == NULL)
+                return NULL;
+
+        fddup = dup(fd);
+        if (fddup < 0)
+                goto out_free_sl;
+
+        fp = fdopen(fddup, "r");
+        if (!fp)
+                goto out_close_fddup;
 
-        fp = fdopen(dup(fd), "r");
         while (!feof(fp)) {
                 p = fgets(buf, MAX_CMDLEN, fp);
                 if (!p)
@@ -155,13 +164,21 @@ struct strlist *probe_file__get_rawlist(int fd)
                 ret = strlist__add(sl, buf);
                 if (ret < 0) {
                         pr_debug("strlist__add failed (%d)\n", ret);
-                        strlist__delete(sl);
-                        return NULL;
+                        goto out_close_fp;
                 }
         }
         fclose(fp);
 
         return sl;
+
+out_close_fp:
+        fclose(fp);
+        goto out_free_sl;
+out_close_fddup:
+        close(fddup);
+out_free_sl:
+        strlist__delete(sl);
+        return NULL;
 }
 
 static struct strlist *__probe_file__get_namelist(int fd, bool include_group)
@@ -177,7 +194,7 @@ static struct strlist *__probe_file__get_namelist(int fd, bool include_group)
         if (!rawlist)
                 return NULL;
         sl = strlist__new(NULL, NULL);
-        strlist__for_each(ent, rawlist) {
+        strlist__for_each_entry(ent, rawlist) {
                 ret = parse_probe_trace_command(ent->s, &tev);
                 if (ret < 0)
                         break;
@@ -223,7 +240,7 @@ int probe_file__add_event(int fd, struct probe_trace_event *tev)
                 if (write(fd, buf, strlen(buf)) < (int)strlen(buf)) {
                         ret = -errno;
                         pr_warning("Failed to write event: %s\n",
-                                   strerror_r(errno, sbuf, sizeof(sbuf)));
+                                   str_error_r(errno, sbuf, sizeof(sbuf)));
                 }
         }
         free(buf);
@@ -261,7 +278,7 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
         return 0;
 error:
         pr_warning("Failed to delete event: %s\n",
-                   strerror_r(-ret, buf, sizeof(buf)));
+                   str_error_r(-ret, buf, sizeof(buf)));
         return ret;
 }
 
@@ -280,7 +297,7 @@ int probe_file__get_events(int fd, struct strfilter *filter,
         if (!namelist)
                 return -ENOENT;
 
-        strlist__for_each(ent, namelist) {
+        strlist__for_each_entry(ent, namelist) {
                 p = strchr(ent->s, ':');
                 if ((p && strfilter__compare(filter, p + 1)) ||
                     strfilter__compare(filter, ent->s)) {
@@ -298,7 +315,7 @@ int probe_file__del_strlist(int fd, struct strlist *namelist)
         int ret = 0;
         struct str_node *ent;
 
-        strlist__for_each(ent, namelist) {
+        strlist__for_each_entry(ent, namelist) {
                 ret = __del_trace_probe_event(fd, ent);
                 if (ret < 0)
                         break;
@@ -324,3 +341,595 @@ int probe_file__del_events(int fd, struct strfilter *filter)
 
         return ret;
 }
+
+/* Caller must ensure to remove this entry from list */
+static void probe_cache_entry__delete(struct probe_cache_entry *entry)
+{
+        if (entry) {
+                BUG_ON(!list_empty(&entry->node));
+
+                strlist__delete(entry->tevlist);
+                clear_perf_probe_event(&entry->pev);
+                zfree(&entry->spev);
+                free(entry);
+        }
+}
+
+static struct probe_cache_entry *
+probe_cache_entry__new(struct perf_probe_event *pev)
+{
+        struct probe_cache_entry *entry = zalloc(sizeof(*entry));
+
+        if (entry) {
+                INIT_LIST_HEAD(&entry->node);
+                entry->tevlist = strlist__new(NULL, NULL);
+                if (!entry->tevlist)
+                        zfree(&entry);
+                else if (pev) {
+                        entry->spev = synthesize_perf_probe_command(pev);
+                        if (!entry->spev ||
+                            perf_probe_event__copy(&entry->pev, pev) < 0) {
+                                probe_cache_entry__delete(entry);
+                                return NULL;
+                        }
+                }
+        }
+
+        return entry;
+}
+
+int probe_cache_entry__get_event(struct probe_cache_entry *entry,
+                                 struct probe_trace_event **tevs)
+{
+        struct probe_trace_event *tev;
+        struct str_node *node;
+        int ret, i;
+
+        ret = strlist__nr_entries(entry->tevlist);
+        if (ret > probe_conf.max_probes)
+                return -E2BIG;
+
+        *tevs = zalloc(ret * sizeof(*tev));
+        if (!*tevs)
+                return -ENOMEM;
+
+        i = 0;
+        strlist__for_each_entry(node, entry->tevlist) {
+                tev = &(*tevs)[i++];
+                ret = parse_probe_trace_command(node->s, tev);
+                if (ret < 0)
+                        break;
+        }
+        return i;
+}
+
+/* For the kernel probe caches, pass target = NULL or DSO__NAME_KALLSYMS */
+static int probe_cache__open(struct probe_cache *pcache, const char *target)
+{
+        char cpath[PATH_MAX];
+        char sbuildid[SBUILD_ID_SIZE];
+        char *dir_name = NULL;
+        bool is_kallsyms = false;
+        int ret, fd;
+
+        if (target && build_id_cache__cached(target)) {
+                /* This is a cached buildid */
+                strncpy(sbuildid, target, SBUILD_ID_SIZE);
+                dir_name = build_id_cache__linkname(sbuildid, NULL, 0);
+                goto found;
+        }
+
+        if (!target || !strcmp(target, DSO__NAME_KALLSYMS)) {
+                target = DSO__NAME_KALLSYMS;
+                is_kallsyms = true;
+                ret = sysfs__sprintf_build_id("/", sbuildid);
+        } else
+                ret = filename__sprintf_build_id(target, sbuildid);
+
+        if (ret < 0) {
+                pr_debug("Failed to get build-id from %s.\n", target);
+                return ret;
+        }
+
+        /* If we have no buildid cache, make it */
+        if (!build_id_cache__cached(sbuildid)) {
+                ret = build_id_cache__add_s(sbuildid, target,
+                                            is_kallsyms, NULL);
+                if (ret < 0) {
+                        pr_debug("Failed to add build-id cache: %s\n", target);
+                        return ret;
+                }
+        }
+
+        dir_name = build_id_cache__cachedir(sbuildid, target, is_kallsyms,
+                                            false);
+found:
+        if (!dir_name) {
+                pr_debug("Failed to get cache from %s\n", target);
+                return -ENOMEM;
+        }
+
+        snprintf(cpath, PATH_MAX, "%s/probes", dir_name);
+        fd = open(cpath, O_CREAT | O_RDWR, 0644);
+        if (fd < 0)
+                pr_debug("Failed to open cache(%d): %s\n", fd, cpath);
+        free(dir_name);
+        pcache->fd = fd;
+
+        return fd;
+}
+
+static int probe_cache__load(struct probe_cache *pcache)
+{
+        struct probe_cache_entry *entry = NULL;
+        char buf[MAX_CMDLEN], *p;
+        int ret = 0, fddup;
+        FILE *fp;
+
+        fddup = dup(pcache->fd);
+        if (fddup < 0)
+                return -errno;
+        fp = fdopen(fddup, "r");
+        if (!fp) {
+                close(fddup);
+                return -EINVAL;
+        }
+
+        while (!feof(fp)) {
+                if (!fgets(buf, MAX_CMDLEN, fp))
+                        break;
+                p = strchr(buf, '\n');
+                if (p)
+                        *p = '\0';
+                /* #perf_probe_event or %sdt_event */
+                if (buf[0] == '#' || buf[0] == '%') {
+                        entry = probe_cache_entry__new(NULL);
+                        if (!entry) {
+                                ret = -ENOMEM;
+                                goto out;
+                        }
+                        if (buf[0] == '%')
+                                entry->sdt = true;
+                        entry->spev = strdup(buf + 1);
+                        if (entry->spev)
+                                ret = parse_perf_probe_command(buf + 1,
+                                                                &entry->pev);
+                        else
+                                ret = -ENOMEM;
+                        if (ret < 0) {
+                                probe_cache_entry__delete(entry);
+                                goto out;
+                        }
+                        list_add_tail(&entry->node, &pcache->entries);
+                } else {        /* trace_probe_event */
+                        if (!entry) {
+                                ret = -EINVAL;
+                                goto out;
+                        }
+                        strlist__add(entry->tevlist, buf);
+                }
+        }
+out:
+        fclose(fp);
+        return ret;
+}
+
+static struct probe_cache *probe_cache__alloc(void)
+{
+        struct probe_cache *pcache = zalloc(sizeof(*pcache));
+
+        if (pcache) {
+                INIT_LIST_HEAD(&pcache->entries);
+                pcache->fd = -EINVAL;
+        }
+        return pcache;
+}
+
+void probe_cache__purge(struct probe_cache *pcache)
+{
+        struct probe_cache_entry *entry, *n;
+
+        list_for_each_entry_safe(entry, n, &pcache->entries, node) {
+                list_del_init(&entry->node);
+                probe_cache_entry__delete(entry);
+        }
+}
+
+void probe_cache__delete(struct probe_cache *pcache)
+{
+        if (!pcache)
+                return;
+
+        probe_cache__purge(pcache);
+        if (pcache->fd > 0)
+                close(pcache->fd);
+        free(pcache);
+}
+
+struct probe_cache *probe_cache__new(const char *target)
+{
+        struct probe_cache *pcache = probe_cache__alloc();
+        int ret;
+
+        if (!pcache)
+                return NULL;
+
+        ret = probe_cache__open(pcache, target);
+        if (ret < 0) {
+                pr_debug("Cache open error: %d\n", ret);
+                goto out_err;
+        }
+
+        ret = probe_cache__load(pcache);
+        if (ret < 0) {
+                pr_debug("Cache read error: %d\n", ret);
+                goto out_err;
+        }
+
+        return pcache;
+
+out_err:
+        probe_cache__delete(pcache);
+        return NULL;
+}
+
+static bool streql(const char *a, const char *b)
+{
+        if (a == b)
+                return true;
+
+        if (!a || !b)
+                return false;
+
+        return !strcmp(a, b);
+}
+
+struct probe_cache_entry *
+probe_cache__find(struct probe_cache *pcache, struct perf_probe_event *pev)
+{
+        struct probe_cache_entry *entry = NULL;
+        char *cmd = synthesize_perf_probe_command(pev);
+
+        if (!cmd)
+                return NULL;
+
+        for_each_probe_cache_entry(entry, pcache) {
+                if (pev->sdt) {
+                        if (entry->pev.event &&
+                            streql(entry->pev.event, pev->event) &&
+                            (!pev->group ||
+                             streql(entry->pev.group, pev->group)))
+                                goto found;
+
+                        continue;
+                }
+                /* Hit if same event name or same command-string */
+                if ((pev->event &&
+                     (streql(entry->pev.group, pev->group) &&
+                      streql(entry->pev.event, pev->event))) ||
+                    (!strcmp(entry->spev, cmd)))
+                        goto found;
+        }
+        entry = NULL;
+
+found:
+        free(cmd);
+        return entry;
+}
+
+struct probe_cache_entry *
+probe_cache__find_by_name(struct probe_cache *pcache,
+                          const char *group, const char *event)
+{
+        struct probe_cache_entry *entry = NULL;
+
+        for_each_probe_cache_entry(entry, pcache) {
+                /* Hit if same event name or same command-string */
+                if (streql(entry->pev.group, group) &&
+                    streql(entry->pev.event, event))
+                        goto found;
+        }
+        entry = NULL;
+
+found:
+        return entry;
+}
+
+int probe_cache__add_entry(struct probe_cache *pcache,
+                           struct perf_probe_event *pev,
+                           struct probe_trace_event *tevs, int ntevs)
+{
+        struct probe_cache_entry *entry = NULL;
+        char *command;
+        int i, ret = 0;
+
+        if (!pcache || !pev || !tevs || ntevs <= 0) {
+                ret = -EINVAL;
+                goto out_err;
+        }
+
+        /* Remove old cache entry */
+        entry = probe_cache__find(pcache, pev);
+        if (entry) {
+                list_del_init(&entry->node);
+                probe_cache_entry__delete(entry);
+        }
+
+        ret = -ENOMEM;
+        entry = probe_cache_entry__new(pev);
+        if (!entry)
+                goto out_err;
+
+        for (i = 0; i < ntevs; i++) {
+                if (!tevs[i].point.symbol)
+                        continue;
+
+                command = synthesize_probe_trace_command(&tevs[i]);
+                if (!command)
+                        goto out_err;
+                strlist__add(entry->tevlist, command);
+                free(command);
+        }
+        list_add_tail(&entry->node, &pcache->entries);
+        pr_debug("Added probe cache: %d\n", ntevs);
+        return 0;
+
+out_err:
+        pr_debug("Failed to add probe caches\n");
+        probe_cache_entry__delete(entry);
+        return ret;
+}
+
+#ifdef HAVE_GELF_GETNOTE_SUPPORT
+static unsigned long long sdt_note__get_addr(struct sdt_note *note)
+{
+        return note->bit32 ? (unsigned long long)note->addr.a32[0]
+                 : (unsigned long long)note->addr.a64[0];
+}
+
+int probe_cache__scan_sdt(struct probe_cache *pcache, const char *pathname)
+{
+        struct probe_cache_entry *entry = NULL;
+        struct list_head sdtlist;
+        struct sdt_note *note;
+        char *buf;
+        char sdtgrp[64];
+        int ret;
+
+        INIT_LIST_HEAD(&sdtlist);
+        ret = get_sdt_note_list(&sdtlist, pathname);
+        if (ret < 0) {
+                pr_debug4("Failed to get sdt note: %d\n", ret);
+                return ret;
+        }
+        list_for_each_entry(note, &sdtlist, note_list) {
+                ret = snprintf(sdtgrp, 64, "sdt_%s", note->provider);
+                if (ret < 0)
+                        break;
+                /* Try to find same-name entry */
+                entry = probe_cache__find_by_name(pcache, sdtgrp, note->name);
+                if (!entry) {
+                        entry = probe_cache_entry__new(NULL);
+                        if (!entry) {
+                                ret = -ENOMEM;
+                                break;
+                        }
+                        entry->sdt = true;
+                        ret = asprintf(&entry->spev, "%s:%s=%s", sdtgrp,
+                                        note->name, note->name);
+                        if (ret < 0)
+                                break;
+                        entry->pev.event = strdup(note->name);
+                        entry->pev.group = strdup(sdtgrp);
+                        list_add_tail(&entry->node, &pcache->entries);
+                }
+                ret = asprintf(&buf, "p:%s/%s %s:0x%llx",
+                                sdtgrp, note->name, pathname,
+                                sdt_note__get_addr(note));
+                if (ret < 0)
+                        break;
+                strlist__add(entry->tevlist, buf);
+                free(buf);
+                entry = NULL;
+        }
+        if (entry) {
+                list_del_init(&entry->node);
+                probe_cache_entry__delete(entry);
+        }
+        cleanup_sdt_note_list(&sdtlist);
+        return ret;
+}
+#endif
+
+static int probe_cache_entry__write(struct probe_cache_entry *entry, int fd)
+{
+        struct str_node *snode;
+        struct stat st;
+        struct iovec iov[3];
+        const char *prefix = entry->sdt ? "%" : "#";
+        int ret;
+        /* Save stat for rollback */
+        ret = fstat(fd, &st);
+        if (ret < 0)
+                return ret;
+
+        pr_debug("Writing cache: %s%s\n", prefix, entry->spev);
+        iov[0].iov_base = (void *)prefix; iov[0].iov_len = 1;
+        iov[1].iov_base = entry->spev; iov[1].iov_len = strlen(entry->spev);
+        iov[2].iov_base = (void *)"\n"; iov[2].iov_len = 1;
+        ret = writev(fd, iov, 3);
+        if (ret < (int)iov[1].iov_len + 2)
+                goto rollback;
+
+        strlist__for_each_entry(snode, entry->tevlist) {
+                iov[0].iov_base = (void *)snode->s;
+                iov[0].iov_len = strlen(snode->s);
+                iov[1].iov_base = (void *)"\n"; iov[1].iov_len = 1;
+                ret = writev(fd, iov, 2);
+                if (ret < (int)iov[0].iov_len + 1)
+                        goto rollback;
+        }
+        return 0;
+
+rollback:
+        /* Rollback to avoid cache file corruption */
+        if (ret > 0)
+                ret = -1;
+        if (ftruncate(fd, st.st_size) < 0)
+                ret = -2;
+
+        return ret;
+}
+
+int probe_cache__commit(struct probe_cache *pcache)
+{
+        struct probe_cache_entry *entry;
+        int ret = 0;
+
+        /* TBD: if we do not update existing entries, skip it */
+        ret = lseek(pcache->fd, 0, SEEK_SET);
+        if (ret < 0)
+                goto out;
+
+        ret = ftruncate(pcache->fd, 0);
+        if (ret < 0)
+                goto out;
+
+        for_each_probe_cache_entry(entry, pcache) {
+                ret = probe_cache_entry__write(entry, pcache->fd);
+                pr_debug("Cache committed: %d\n", ret);
+                if (ret < 0)
+                        break;
+        }
+out:
+        return ret;
+}
+
+static bool probe_cache_entry__compare(struct probe_cache_entry *entry,
+                                       struct strfilter *filter)
+{
+        char buf[128], *ptr = entry->spev;
+
+        if (entry->pev.event) {
+                snprintf(buf, 128, "%s:%s", entry->pev.group, entry->pev.event);
+                ptr = buf;
+        }
+        return strfilter__compare(filter, ptr);
+}
+
+int probe_cache__filter_purge(struct probe_cache *pcache,
+                              struct strfilter *filter)
+{
+        struct probe_cache_entry *entry, *tmp;
+
+        list_for_each_entry_safe(entry, tmp, &pcache->entries, node) {
+                if (probe_cache_entry__compare(entry, filter)) {
+                        pr_info("Removed cached event: %s\n", entry->spev);
+                        list_del_init(&entry->node);
+                        probe_cache_entry__delete(entry);
+                }
+        }
+        return 0;
+}
+
+static int probe_cache__show_entries(struct probe_cache *pcache,
+                                     struct strfilter *filter)
+{
+        struct probe_cache_entry *entry;
+
+        for_each_probe_cache_entry(entry, pcache) {
+                if (probe_cache_entry__compare(entry, filter))
+                        printf("%s\n", entry->spev);
+        }
+        return 0;
+}
+
+/* Show all cached probes */
+int probe_cache__show_all_caches(struct strfilter *filter)
+{
+        struct probe_cache *pcache;
+        struct strlist *bidlist;
+        struct str_node *nd;
+        char *buf = strfilter__string(filter);
+
+        pr_debug("list cache with filter: %s\n", buf);
+        free(buf);
+
+        bidlist = build_id_cache__list_all(true);
+        if (!bidlist) {
+                pr_debug("Failed to get buildids: %d\n", errno);
+                return -EINVAL;
+        }
+        strlist__for_each_entry(nd, bidlist) {
+                pcache = probe_cache__new(nd->s);
+                if (!pcache)
+                        continue;
+                if (!list_empty(&pcache->entries)) {
+                        buf = build_id_cache__origname(nd->s);
+                        printf("%s (%s):\n", buf, nd->s);
+                        free(buf);
+                        probe_cache__show_entries(pcache, filter);
+                }
+                probe_cache__delete(pcache);
+        }
+        strlist__delete(bidlist);
+
+        return 0;
+}
+
+static struct {
+        const char *pattern;
+        bool    avail;
+        bool    checked;
+} probe_type_table[] = {
+#define DEFINE_TYPE(idx, pat, def_avail)        \
+        [idx] = {.pattern = pat, .avail = (def_avail)}
+        DEFINE_TYPE(PROBE_TYPE_U, "* u8/16/32/64,*", true),
+        DEFINE_TYPE(PROBE_TYPE_S, "* s8/16/32/64,*", true),
+        DEFINE_TYPE(PROBE_TYPE_X, "* x8/16/32/64,*", false),
+        DEFINE_TYPE(PROBE_TYPE_STRING, "* string,*", true),
+        DEFINE_TYPE(PROBE_TYPE_BITFIELD,
+                    "* b<bit-width>@<bit-offset>/<container-size>", true),
+};
+
+bool probe_type_is_available(enum probe_type type)
+{
+        FILE *fp;
+        char *buf = NULL;
+        size_t len = 0;
+        bool target_line = false;
+        bool ret = probe_type_table[type].avail;
+
+        if (type >= PROBE_TYPE_END)
+                return false;
+        /* We don't have to check the type which supported by default */
+        if (ret || probe_type_table[type].checked)
+                return ret;
+
+        if (asprintf(&buf, "%s/README", tracing_path) < 0)
+                return ret;
+
+        fp = fopen(buf, "r");
+        if (!fp)
+                goto end;
+
+        zfree(&buf);
+        while (getline(&buf, &len, fp) > 0 && !ret) {
+                if (!target_line) {
+                        target_line = !!strstr(buf, " type: ");
+                        if (!target_line)
+                                continue;
+                } else if (strstr(buf, "\t          ") != buf)
+                        break;
+                ret = strglobmatch(buf, probe_type_table[type].pattern);
+        }
+        /* Cache the result */
+        probe_type_table[type].checked = true;
+        probe_type_table[type].avail = ret;
+
+        fclose(fp);
+end:
+        free(buf);
+
+        return ret;
+}
diff --git a/tools/perf/util/probe-file.h b/tools/perf/util/probe-file.h
index 18ac9cf51c34..eba44c3e9dca 100644
--- a/tools/perf/util/probe-file.h
+++ b/tools/perf/util/probe-file.h
@@ -5,9 +5,36 @@
 #include "strfilter.h"
 #include "probe-event.h"
 
+/* Cache of probe definitions */
+struct probe_cache_entry {
+        struct list_head        node;
+        bool                    sdt;
+        struct perf_probe_event pev;
+        char                    *spev;
+        struct strlist          *tevlist;
+};
+
+struct probe_cache {
+        int     fd;
+        struct list_head entries;
+};
+
+enum probe_type {
+        PROBE_TYPE_U = 0,
+        PROBE_TYPE_S,
+        PROBE_TYPE_X,
+        PROBE_TYPE_STRING,
+        PROBE_TYPE_BITFIELD,
+        PROBE_TYPE_END,
+};
+
 #define PF_FL_UPROBE    1
 #define PF_FL_RW        2
+#define for_each_probe_cache_entry(entry, pcache) \
+        list_for_each_entry(entry, &pcache->entries, node)
 
+/* probe-file.c depends on libelf */
+#ifdef HAVE_LIBELF_SUPPORT
 int probe_file__open(int flag);
 int probe_file__open_both(int *kfd, int *ufd, int flag);
 struct strlist *probe_file__get_namelist(int fd);
@@ -18,5 +45,30 @@ int probe_file__get_events(int fd, struct strfilter *filter,
                                   struct strlist *plist);
 int probe_file__del_strlist(int fd, struct strlist *namelist);
 
+int probe_cache_entry__get_event(struct probe_cache_entry *entry,
+                                 struct probe_trace_event **tevs);
 
+struct probe_cache *probe_cache__new(const char *target);
+int probe_cache__add_entry(struct probe_cache *pcache,
+                           struct perf_probe_event *pev,
+                           struct probe_trace_event *tevs, int ntevs);
+int probe_cache__scan_sdt(struct probe_cache *pcache, const char *pathname);
+int probe_cache__commit(struct probe_cache *pcache);
+void probe_cache__purge(struct probe_cache *pcache);
+void probe_cache__delete(struct probe_cache *pcache);
+int probe_cache__filter_purge(struct probe_cache *pcache,
+                              struct strfilter *filter);
+struct probe_cache_entry *probe_cache__find(struct probe_cache *pcache,
+                                            struct perf_probe_event *pev);
+struct probe_cache_entry *probe_cache__find_by_name(struct probe_cache *pcache,
+                                        const char *group, const char *event);
+int probe_cache__show_all_caches(struct strfilter *filter);
+bool probe_type_is_available(enum probe_type type);
+#else   /* ! HAVE_LIBELF_SUPPORT */
+static inline struct probe_cache *probe_cache__new(const char *tgt __maybe_unused)
+{
+        return NULL;
+}
+#define probe_cache__delete(pcache) do {} while (0)
+#endif
 #endif
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 1259839dbf6d..df4debe564da 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -39,6 +39,7 @@
 #include "util.h"
 #include "symbol.h"
 #include "probe-finder.h"
+#include "probe-file.h"
 
 /* Kprobe tracer basic type is up to u64 */
 #define MAX_BASIC_TYPE_BITS     64
@@ -170,6 +171,7 @@ static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
  */
 static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
                                      Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
+                                     unsigned int machine,
                                      struct probe_trace_arg *tvar)
 {
         Dwarf_Attribute attr;
@@ -265,7 +267,7 @@ static_var:
         if (!tvar)
                 return ret2;
 
-        regs = get_arch_regstr(regn);
+        regs = get_dwarf_regstr(regn, machine);
         if (!regs) {
                 /* This should be a bug in DWARF or this tool */
                 pr_warning("Mapping for the register number %u "
@@ -297,10 +299,13 @@ static int convert_variable_type(Dwarf_Die *vr_die,
         char sbuf[STRERR_BUFSIZE];
         int bsize, boffs, total;
         int ret;
+        char prefix;
 
         /* TODO: check all types */
-        if (cast && strcmp(cast, "string") != 0) {
+        if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "x") != 0 &&
+            strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) {
                 /* Non string type is OK */
+                /* and respect signedness/hexadecimal cast */
                 tvar->type = strdup(cast);
                 return (tvar->type == NULL) ? -ENOMEM : 0;
         }
@@ -361,6 +366,17 @@ static int convert_variable_type(Dwarf_Die *vr_die,
                 return (tvar->type == NULL) ? -ENOMEM : 0;
         }
 
+        if (cast && (strcmp(cast, "u") == 0))
+                prefix = 'u';
+        else if (cast && (strcmp(cast, "s") == 0))
+                prefix = 's';
+        else if (cast && (strcmp(cast, "x") == 0) &&
+                 probe_type_is_available(PROBE_TYPE_X))
+                prefix = 'x';
+        else
+                prefix = die_is_signed_type(&type) ? 's' :
+                         probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u';
+
         ret = dwarf_bytesize(&type);
         if (ret <= 0)
                 /* No size ... try to use default type */
@@ -373,15 +389,14 @@ static int convert_variable_type(Dwarf_Die *vr_die,
                         dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
                 ret = MAX_BASIC_TYPE_BITS;
         }
-        ret = snprintf(buf, 16, "%c%d",
-                       die_is_signed_type(&type) ? 's' : 'u', ret);
+        ret = snprintf(buf, 16, "%c%d", prefix, ret);
 
 formatted:
         if (ret < 0 || ret >= 16) {
                 if (ret >= 16)
                         ret = -E2BIG;
                 pr_warning("Failed to convert variable type: %s\n",
-                           strerror_r(-ret, sbuf, sizeof(sbuf)));
+                           str_error_r(-ret, sbuf, sizeof(sbuf)));
                 return ret;
         }
         tvar->type = strdup(buf);
@@ -529,7 +544,7 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
                  dwarf_diename(vr_die));
 
         ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
-                                        &pf->sp_die, pf->tvar);
+                                        &pf->sp_die, pf->machine, pf->tvar);
         if (ret == -ENOENT || ret == -EINVAL) {
                 pr_err("Failed to find the location of the '%s' variable at this address.\n"
                        " Perhaps it has been optimized out.\n"
@@ -809,7 +824,7 @@ static int find_lazy_match_lines(struct intlist *list,
         fp = fopen(fname, "r");
         if (!fp) {
                 pr_warning("Failed to open %s: %s\n", fname,
-                           strerror_r(errno, sbuf, sizeof(sbuf)));
+                           str_error_r(errno, sbuf, sizeof(sbuf)));
                 return -errno;
         }
 
@@ -892,6 +907,38 @@ static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
         return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
 }
 
+static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        struct perf_probe_point *pp = &pf->pev->point;
+
+        /* Not uprobe? */
+        if (!pf->pev->uprobes)
+                return;
+
+        /* Compiled with optimization? */
+        if (die_is_optimized_target(&pf->cu_die))
+                return;
+
+        /* Don't know entrypc? */
+        if (!pf->addr)
+                return;
+
+        /* Only FUNC and FUNC@SRC are eligible. */
+        if (!pp->function || pp->line || pp->retprobe || pp->lazy_line ||
+            pp->offset || pp->abs_address)
+                return;
+
+        /* Not interested in func parameter? */
+        if (!perf_probe_with_var(pf->pev))
+                return;
+
+        pr_info("Target program is compiled without optimization. Skipping prologue.\n"
+                "Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n",
+                pf->addr);
+
+        die_skip_prologue(sp_die, &pf->cu_die, &pf->addr);
+}
+
 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 {
         struct probe_finder *pf = data;
@@ -908,6 +955,11 @@ static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
                                    dwarf_diename(in_die));
                         return -ENOENT;
                 }
+                if (addr == 0) {
+                        pr_debug("%s has no valid entry address. skipped.\n",
+                                 dwarf_diename(in_die));
+                        return -ENOENT;
+                }
                 pf->addr = addr;
                 pf->addr += pp->offset;
                 pr_debug("found inline addr: 0x%jx\n",
@@ -941,7 +993,8 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
         if (pp->file && strtailcmp(pp->file, dwarf_decl_file(sp_die)))
                 return DWARF_CB_OK;
 
-        pr_debug("Matched function: %s\n", dwarf_diename(sp_die));
+        pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die),
+                 (unsigned long)dwarf_dieoffset(sp_die));
         pf->fname = dwarf_decl_file(sp_die);
         if (pp->line) { /* Function relative line */
                 dwarf_decl_line(sp_die, &pf->lno);
@@ -950,10 +1003,16 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
         } else if (die_is_func_instance(sp_die)) {
                 /* Instances always have the entry address */
                 dwarf_entrypc(sp_die, &pf->addr);
+                /* But in some case the entry address is 0 */
+                if (pf->addr == 0) {
+                        pr_debug("%s has no entry PC. Skipped\n",
+                                 dwarf_diename(sp_die));
+                        param->retval = 0;
                 /* Real function */
-                if (pp->lazy_line)
+                } else if (pp->lazy_line)
                         param->retval = find_probe_point_lazy(sp_die, pf);
                 else {
+                        skip_prologue(sp_die, pf);
                         pf->addr += pp->offset;
                         /* TODO: Check the address in this function */
                         param->retval = call_probe_finder(sp_die, pf);
@@ -963,7 +1022,7 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
                 param->retval = die_walk_instances(sp_die,
                                         probe_point_inline_cb, (void *)pf);
                 /* This could be a non-existed inline definition */
-                if (param->retval == -ENOENT && strisglob(pp->function))
+                if (param->retval == -ENOENT)
                         param->retval = 0;
         }
 
@@ -1092,11 +1151,8 @@ static int debuginfo__find_probes(struct debuginfo *dbg,
                                   struct probe_finder *pf)
 {
         int ret = 0;
-
-#if _ELFUTILS_PREREQ(0, 142)
         Elf *elf;
         GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
 
         if (pf->cfi_eh || pf->cfi_dbg)
                 return debuginfo__find_probe_location(dbg, pf);
@@ -1109,11 +1165,18 @@ static int debuginfo__find_probes(struct debuginfo *dbg,
         if (gelf_getehdr(elf, &ehdr) == NULL)
                 return -EINVAL;
 
-        if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
-            shdr.sh_type == SHT_PROGBITS)
-                pf->cfi_eh = dwarf_getcfi_elf(elf);
+        pf->machine = ehdr.e_machine;
+
+#if _ELFUTILS_PREREQ(0, 142)
+        do {
+                GElf_Shdr shdr;
+
+                if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
+                    shdr.sh_type == SHT_PROGBITS)
+                        pf->cfi_eh = dwarf_getcfi_elf(elf);
 
-        pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
+                pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
+        } while (0);
 #endif
 
         ret = debuginfo__find_probe_location(dbg, pf);
@@ -1141,7 +1204,7 @@ static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
             (tag == DW_TAG_variable && vf->vars)) {
                 if (convert_variable_location(die_mem, vf->pf->addr,
                                               vf->pf->fb_ops, &pf->sp_die,
-                                              NULL) == 0) {
+                                              pf->machine, NULL) == 0) {
                         vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
                         if (vf->args[vf->nargs].var == NULL) {
                                 vf->ret = -ENOMEM;
@@ -1304,7 +1367,7 @@ static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
             tag == DW_TAG_variable) {
                 ret = convert_variable_location(die_mem, af->pf.addr,
                                                 af->pf.fb_ops, &af->pf.sp_die,
-                                                NULL);
+                                                af->pf.machine, NULL);
                 if (ret == 0 || ret == -ERANGE) {
                         int ret2;
                         bool externs = !af->child;
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index 51137fccb9c8..f1d8558f498e 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -80,6 +80,7 @@ struct probe_finder {
         Dwarf_CFI               *cfi_dbg;
 #endif
         Dwarf_Op                *fb_ops;        /* Frame base attribute */
+        unsigned int            machine;        /* Target machine arch */
         struct perf_probe_arg   *pvar;          /* Current target variable */
         struct probe_trace_arg  *tvar;          /* Current result variable */
 };
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 36c6862119e3..b7d4f4aeee61 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -13,6 +13,7 @@ util/cpumap.c
 ../lib/bitmap.c
 ../lib/find_bit.c
 ../lib/hweight.c
+../lib/vsprintf.c
 util/thread_map.c
 util/util.c
 util/xyarray.c
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 98f127abfa42..a5fbc012e3df 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -2,6 +2,7 @@
 #include <structmember.h>
 #include <inttypes.h>
 #include <poll.h>
+#include <linux/err.h>
 #include "evlist.h"
 #include "evsel.h"
 #include "event.h"
@@ -47,6 +48,7 @@ PyMODINIT_FUNC initperf(void);
 
 struct pyrf_event {
         PyObject_HEAD
+        struct perf_evsel *evsel;
         struct perf_sample sample;
         union perf_event   event;
 };
@@ -288,6 +290,85 @@ static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent)
         return ret;
 }
 
+static bool is_tracepoint(struct pyrf_event *pevent)
+{
+        return pevent->evsel->attr.type == PERF_TYPE_TRACEPOINT;
+}
+
+static PyObject*
+tracepoint_field(struct pyrf_event *pe, struct format_field *field)
+{
+        struct pevent *pevent = field->event->pevent;
+        void *data = pe->sample.raw_data;
+        PyObject *ret = NULL;
+        unsigned long long val;
+        unsigned int offset, len;
+
+        if (field->flags & FIELD_IS_ARRAY) {
+                offset = field->offset;
+                len    = field->size;
+                if (field->flags & FIELD_IS_DYNAMIC) {
+                        val     = pevent_read_number(pevent, data + offset, len);
+                        offset  = val;
+                        len     = offset >> 16;
+                        offset &= 0xffff;
+                }
+                if (field->flags & FIELD_IS_STRING &&
+                    is_printable_array(data + offset, len)) {
+                        ret = PyString_FromString((char *)data + offset);
+                } else {
+                        ret = PyByteArray_FromStringAndSize((const char *) data + offset, len);
+                        field->flags &= ~FIELD_IS_STRING;
+                }
+        } else {
+                val = pevent_read_number(pevent, data + field->offset,
+                                         field->size);
+                if (field->flags & FIELD_IS_POINTER)
+                        ret = PyLong_FromUnsignedLong((unsigned long) val);
+                else if (field->flags & FIELD_IS_SIGNED)
+                        ret = PyLong_FromLong((long) val);
+                else
+                        ret = PyLong_FromUnsignedLong((unsigned long) val);
+        }
+
+        return ret;
+}
+
+static PyObject*
+get_tracepoint_field(struct pyrf_event *pevent, PyObject *attr_name)
+{
+        const char *str = PyString_AsString(PyObject_Str(attr_name));
+        struct perf_evsel *evsel = pevent->evsel;
+        struct format_field *field;
+
+        if (!evsel->tp_format) {
+                struct event_format *tp_format;
+
+                tp_format = trace_event__tp_format_id(evsel->attr.config);
+                if (!tp_format)
+                        return NULL;
+
+                evsel->tp_format = tp_format;
+        }
+
+        field = pevent_find_any_field(evsel->tp_format, str);
+        if (!field)
+                return NULL;
+
+        return tracepoint_field(pevent, field);
+}
+
+static PyObject*
+pyrf_sample_event__getattro(struct pyrf_event *pevent, PyObject *attr_name)
+{
+        PyObject *obj = NULL;
+
+        if (is_tracepoint(pevent))
+                obj = get_tracepoint_field(pevent, attr_name);
+
+        return obj ?: PyObject_GenericGetAttr((PyObject *) pevent, attr_name);
+}
+
 static PyTypeObject pyrf_sample_event__type = {
         PyVarObject_HEAD_INIT(NULL, 0)
         .tp_name        = "perf.sample_event",
@@ -296,6 +377,7 @@ static PyTypeObject pyrf_sample_event__type = {
         .tp_doc         = pyrf_sample_event__doc,
         .tp_members     = pyrf_sample_event__members,
         .tp_repr        = (reprfunc)pyrf_sample_event__repr,
+        .tp_getattro    = (getattrofunc) pyrf_sample_event__getattro,
 };
 
 static char pyrf_context_switch_event__doc[] = PyDoc_STR("perf context_switch event object.");
@@ -653,6 +735,7 @@ static int pyrf_evsel__init(struct pyrf_evsel *pevsel,
         attr.precise_ip     = precise_ip;
         attr.mmap_data      = mmap_data;
         attr.sample_id_all  = sample_id_all;
+        attr.size           = sizeof(attr);
 
         perf_evsel__init(&pevsel->evsel, &attr, idx);
         return 0;
@@ -863,13 +946,22 @@ static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
         if (event != NULL) {
                 PyObject *pyevent = pyrf_event__new(event);
                 struct pyrf_event *pevent = (struct pyrf_event *)pyevent;
-
-                perf_evlist__mmap_consume(evlist, cpu);
+                struct perf_evsel *evsel;
 
                 if (pyevent == NULL)
                         return PyErr_NoMemory();
 
-                err = perf_evlist__parse_sample(evlist, event, &pevent->sample);
+                evsel = perf_evlist__event2evsel(evlist, event);
+                if (!evsel)
+                        return Py_None;
+
+                pevent->evsel = evsel;
+
+                err = perf_evsel__parse_sample(evsel, event, &pevent->sample);
+
+                /* Consume the even only after we parsed it out. */
+                perf_evlist__mmap_consume(evlist, cpu);
+
                 if (err)
                         return PyErr_Format(PyExc_OSError,
                                             "perf: can't parse sample, err=%d", err);
@@ -957,7 +1049,7 @@ static PyObject *pyrf_evlist__item(PyObject *obj, Py_ssize_t i)
         if (i >= pevlist->evlist.nr_entries)
                 return NULL;
 
-        evlist__for_each(&pevlist->evlist, pos) {
+        evlist__for_each_entry(&pevlist->evlist, pos) {
                 if (i-- == 0)
                         break;
         }
@@ -1073,7 +1165,32 @@ static struct {
         { .name = NULL, },
 };
 
+static PyObject *pyrf__tracepoint(struct pyrf_evsel *pevsel,
+                                  PyObject *args, PyObject *kwargs)
+{
+        struct event_format *tp_format;
+        static char *kwlist[] = { "sys", "name", NULL };
+        char *sys  = NULL;
+        char *name = NULL;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ss", kwlist,
+                                         &sys, &name))
+                return NULL;
+
+        tp_format = trace_event__tp_format(sys, name);
+        if (IS_ERR(tp_format))
+                return PyInt_FromLong(-1);
+
+        return PyInt_FromLong(tp_format->id);
+}
+
 static PyMethodDef perf__methods[] = {
+        {
+                .ml_name  = "tracepoint",
+                .ml_meth  = (PyCFunction) pyrf__tracepoint,
+                .ml_flags = METH_VARARGS | METH_KEYWORDS,
+                .ml_doc   = PyDoc_STR("Get tracepoint config.")
+        },
         { .ml_name = NULL, }
 };
 
@@ -1100,6 +1217,33 @@ PyMODINIT_FUNC initperf(void)
         Py_INCREF(&pyrf_evsel__type);
         PyModule_AddObject(module, "evsel", (PyObject*)&pyrf_evsel__type);
 
+        Py_INCREF(&pyrf_mmap_event__type);
+        PyModule_AddObject(module, "mmap_event", (PyObject *)&pyrf_mmap_event__type);
+
+        Py_INCREF(&pyrf_lost_event__type);
+        PyModule_AddObject(module, "lost_event", (PyObject *)&pyrf_lost_event__type);
+
+        Py_INCREF(&pyrf_comm_event__type);
+        PyModule_AddObject(module, "comm_event", (PyObject *)&pyrf_comm_event__type);
+
+        Py_INCREF(&pyrf_task_event__type);
+        PyModule_AddObject(module, "task_event", (PyObject *)&pyrf_task_event__type);
+
+        Py_INCREF(&pyrf_throttle_event__type);
+        PyModule_AddObject(module, "throttle_event", (PyObject *)&pyrf_throttle_event__type);
+
+        Py_INCREF(&pyrf_task_event__type);
+        PyModule_AddObject(module, "task_event", (PyObject *)&pyrf_task_event__type);
+
+        Py_INCREF(&pyrf_read_event__type);
+        PyModule_AddObject(module, "read_event", (PyObject *)&pyrf_read_event__type);
+
+        Py_INCREF(&pyrf_sample_event__type);
+        PyModule_AddObject(module, "sample_event", (PyObject *)&pyrf_sample_event__type);
+
+        Py_INCREF(&pyrf_context_switch_event__type);
+        PyModule_AddObject(module, "switch_event", (PyObject *)&pyrf_context_switch_event__type);
+
         Py_INCREF(&pyrf_thread_map__type);
         PyModule_AddObject(module, "thread_map", (PyObject*)&pyrf_thread_map__type);
 
diff --git a/tools/perf/util/quote.c b/tools/perf/util/quote.c
index c6d4ee2de752..639d1da2f978 100644
--- a/tools/perf/util/quote.c
+++ b/tools/perf/util/quote.c
@@ -1,5 +1,7 @@
-#include "cache.h"
+#include <stdlib.h>
+#include "strbuf.h"
 #include "quote.h"
+#include "util.h"
 
 /* Help to copy the thing properly quoted for the shell safety.
  * any single quote is replaced with '\'', any exclamation point
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
index e1ec19146fb0..055ca45bed99 100644
--- a/tools/perf/util/quote.h
+++ b/tools/perf/util/quote.h
@@ -2,7 +2,6 @@
 #define __PERF_QUOTE_H
 
 #include <stddef.h>
-#include <stdio.h>
 
 /* Help to copy the thing properly quoted for the shell safety.
  * any single quote is replaced with '\'', any exclamation point
@@ -24,6 +23,8 @@
  * sq_quote() in a real application.
  */
 
+struct strbuf;
+
 int sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen);
 
 #endif /* __PERF_QUOTE_H */
diff --git a/tools/perf/util/rb_resort.h b/tools/perf/util/rb_resort.h
index abc76e3d3098..808cc45611fe 100644
--- a/tools/perf/util/rb_resort.h
+++ b/tools/perf/util/rb_resort.h
@@ -35,7 +35,7 @@ DEFINE_RB_RESORT_RB(threads, strcmp(a->thread->shortname,
 
         struct rb_node *nd;
 
-        resort_rb__for_each(nd, threads) {
+        resort_rb__for_each_entry(nd, threads) {
                 struct thread *t = threads_entry;
                 printf("%s: %d\n", t->shortname, t->tid);
         }
@@ -123,7 +123,7 @@ static void __name##_sorted__init_entry(struct rb_node *nd,			\
 struct __name##_sorted_entry *__name##_entry;                                   \
 struct __name##_sorted *__name = __name##_sorted__new
 
-#define resort_rb__for_each(__nd, __name)                                       \
+#define resort_rb__for_each_entry(__nd, __name)                                 \
         for (__nd = rb_first(&__name->entries);                                 \
              __name##_entry = rb_entry(__nd, struct __name##_sorted_entry,      \
                                        rb_node), __nd;                          \
diff --git a/tools/perf/util/record.c b/tools/perf/util/record.c
index 481792c7484b..98bf584853ea 100644
--- a/tools/perf/util/record.c
+++ b/tools/perf/util/record.c
@@ -148,7 +148,7 @@ void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts,
 
         use_comm_exec = perf_can_comm_exec();
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 perf_evsel__config(evsel, opts, callchain);
                 if (evsel->tracking && use_comm_exec)
                         evsel->attr.comm_exec = 1;
@@ -161,18 +161,18 @@ void perf_evlist__config(struct perf_evlist *evlist, struct record_opts *opts,
                  * match the id.
                  */
                 use_sample_identifier = perf_can_sample_identifier();
-                evlist__for_each(evlist, evsel)
+                evlist__for_each_entry(evlist, evsel)
                         perf_evsel__set_sample_id(evsel, use_sample_identifier);
         } else if (evlist->nr_entries > 1) {
                 struct perf_evsel *first = perf_evlist__first(evlist);
 
-                evlist__for_each(evlist, evsel) {
+                evlist__for_each_entry(evlist, evsel) {
                         if (evsel->attr.sample_type == first->attr.sample_type)
                                 continue;
                         use_sample_identifier = perf_can_sample_identifier();
                         break;
                 }
-                evlist__for_each(evlist, evsel)
+                evlist__for_each_entry(evlist, evsel)
                         perf_evsel__set_sample_id(evsel, use_sample_identifier);
         }
 
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 5d1eb1ccd96c..e55a132f69b7 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -25,6 +25,7 @@
 #include <ctype.h>
 #include <errno.h>
 #include <linux/bitmap.h>
+#include <linux/time64.h>
 
 #include "../util.h"
 #include <EXTERN.h>
@@ -359,8 +360,8 @@ static void perl_process_tracepoint(struct perf_sample *sample,
         if (!test_and_set_bit(event->id, events_defined))
                 define_event_symbols(event, handler, event->print_fmt.args);
 
-        s = nsecs / NSECS_PER_SEC;
-        ns = nsecs - s * NSECS_PER_SEC;
+        s = nsecs / NSEC_PER_SEC;
+        ns = nsecs - s * NSEC_PER_SEC;
 
         scripting_context->event_data = data;
         scripting_context->pevent = evsel->tp_format->pevent;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index ff134700bf30..089438da1f7f 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -27,6 +27,7 @@
 #include <stdbool.h>
 #include <errno.h>
 #include <linux/bitmap.h>
+#include <linux/time64.h>
 
 #include "../../perf.h"
 #include "../debug.h"
@@ -273,7 +274,7 @@ static PyObject *get_field_numeric_entry(struct event_format *event,
                 struct format_field *field, void *data)
 {
         bool is_array = field->flags & FIELD_IS_ARRAY;
-        PyObject *obj, *list = NULL;
+        PyObject *obj = NULL, *list = NULL;
         unsigned long long val;
         unsigned int item_size, n_items, i;
 
@@ -386,13 +387,12 @@ exit:
         return pylist;
 }
 
-
 static void python_process_tracepoint(struct perf_sample *sample,
                                       struct perf_evsel *evsel,
                                       struct addr_location *al)
 {
         struct event_format *event = evsel->tp_format;
-        PyObject *handler, *context, *t, *obj, *callchain;
+        PyObject *handler, *context, *t, *obj = NULL, *callchain;
         PyObject *dict = NULL;
         static char handler_name[256];
         struct format_field *field;
@@ -427,8 +427,8 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 if (!dict)
                         Py_FatalError("couldn't create Python dict");
         }
-        s = nsecs / NSECS_PER_SEC;
-        ns = nsecs - s * NSECS_PER_SEC;
+        s = nsecs / NSEC_PER_SEC;
+        ns = nsecs - s * NSEC_PER_SEC;
 
         scripting_context->event_data = data;
         scripting_context->pevent = evsel->tp_format->pevent;
@@ -457,14 +457,26 @@ static void python_process_tracepoint(struct perf_sample *sample,
                 pydict_set_item_string_decref(dict, "common_callchain", callchain);
         }
         for (field = event->format.fields; field; field = field->next) {
-                if (field->flags & FIELD_IS_STRING) {
-                        int offset;
+                unsigned int offset, len;
+                unsigned long long val;
+
+                if (field->flags & FIELD_IS_ARRAY) {
+                        offset = field->offset;
+                        len    = field->size;
                         if (field->flags & FIELD_IS_DYNAMIC) {
-                                offset = *(int *)(data + field->offset);
+                                val     = pevent_read_number(scripting_context->pevent,
+                                                             data + offset, len);
+                                offset  = val;
+                                len     = offset >> 16;
                                 offset &= 0xffff;
-                        } else
-                                offset = field->offset;
-                        obj = PyString_FromString((char *)data + offset);
+                        }
+                        if (field->flags & FIELD_IS_STRING &&
+                            is_printable_array(data + offset, len)) {
+                                obj = PyString_FromString((char *) data + offset);
+                        } else {
+                                obj = PyByteArray_FromStringAndSize((const char *) data + offset, len);
+                                field->flags &= ~FIELD_IS_STRING;
+                        }
                 } else { /* FIELD_IS_NUMERIC */
                         obj = get_field_numeric_entry(event, field, data);
                 }
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 5214974e841a..5d61242a6e64 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -83,7 +83,7 @@ static bool perf_session__has_comm_exec(struct perf_session *session)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (evsel->attr.comm_exec)
                         return true;
         }
@@ -178,6 +178,8 @@ static void perf_session__delete_threads(struct perf_session *session)
 
 void perf_session__delete(struct perf_session *session)
 {
+        if (session == NULL)
+                return;
         auxtrace__free(session);
         auxtrace_index__free(&session->auxtrace_index);
         perf_session__destroy_kernel_maps(session);
@@ -593,6 +595,7 @@ do { 						\
         if (bswap_safe(f, 0))                   \
                 attr->f = bswap_##sz(attr->f);  \
 } while(0)
+#define bswap_field_16(f) bswap_field(f, 16)
 #define bswap_field_32(f) bswap_field(f, 32)
 #define bswap_field_64(f) bswap_field(f, 64)
 
@@ -608,6 +611,7 @@ do { 						\
         bswap_field_64(sample_regs_user);
         bswap_field_32(sample_stack_user);
         bswap_field_32(aux_watermark);
+        bswap_field_16(sample_max_stack);
 
         /*
          * After read_format are bitfields. Check read_format because
@@ -1495,10 +1499,27 @@ int perf_session__register_idle_thread(struct perf_session *session)
         return err;
 }
 
+static void
+perf_session__warn_order(const struct perf_session *session)
+{
+        const struct ordered_events *oe = &session->ordered_events;
+        struct perf_evsel *evsel;
+        bool should_warn = true;
+
+        evlist__for_each_entry(session->evlist, evsel) {
+                if (evsel->attr.write_backward)
+                        should_warn = false;
+        }
+
+        if (!should_warn)
+                return;
+        if (oe->nr_unordered_events != 0)
+                ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
+}
+
 static void perf_session__warn_about_errors(const struct perf_session *session)
 {
         const struct events_stats *stats = &session->evlist->stats;
-        const struct ordered_events *oe = &session->ordered_events;
 
         if (session->tool->lost == perf_event__process_lost &&
             stats->nr_events[PERF_RECORD_LOST] != 0) {
@@ -1555,8 +1576,7 @@ static void perf_session__warn_about_errors(const struct perf_session *session)
                             stats->nr_unprocessable_samples);
         }
 
-        if (oe->nr_unordered_events != 0)
-                ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
+        perf_session__warn_order(session);
 
         events_stats__auxtrace_error_warn(stats);
 
@@ -1868,7 +1888,7 @@ bool perf_session__has_traces(struct perf_session *session, const char *msg)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(session->evlist, evsel) {
+        evlist__for_each_entry(session->evlist, evsel) {
                 if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
                         return true;
         }
@@ -1950,7 +1970,7 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 {
         struct perf_evsel *pos;
 
-        evlist__for_each(session->evlist, pos) {
+        evlist__for_each_entry(session->evlist, pos) {
                 if (pos->attr.type == type)
                         return pos;
         }
@@ -2105,7 +2125,7 @@ int perf_event__synthesize_id_index(struct perf_tool *tool,
         max_nr = (UINT16_MAX - sizeof(struct id_index_event)) /
                  sizeof(struct id_index_entry);
 
-        evlist__for_each(evlist, evsel)
+        evlist__for_each_entry(evlist, evsel)
                 nr += evsel->ids;
 
         n = nr > max_nr ? max_nr : nr;
@@ -2118,7 +2138,7 @@ int perf_event__synthesize_id_index(struct perf_tool *tool,
         ev->id_index.header.size = sz;
         ev->id_index.nr = n;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 u32 j;
 
                 for (j = 0; j < evsel->ids; j++) {
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index c4e9bd70723c..452e15a10dd2 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -11,7 +11,7 @@
 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      *default_sort_order = "comm,dso,symbol";
 const char      default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
 const char      default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
 const char      default_top_sort_order[] = "dso,symbol";
@@ -79,8 +79,8 @@ static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
 {
         const char *comm = thread__comm_str(he->thread);
 
-        width = max(7U, width) - 6;
-        return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
+        width = max(7U, width) - 8;
+        return repsep_snprintf(bf, size, "%7d:%-*.*s", he->thread->tid,
                                width, width, comm ?: "");
 }
 
@@ -95,7 +95,7 @@ static int hist_entry__thread_filter(struct hist_entry *he, int type, const void
 }
 
 struct sort_entry sort_thread = {
-        .se_header      = "  Pid:Command",
+        .se_header      = "    Pid:Command",
         .se_cmp         = sort__thread_cmp,
         .se_snprintf    = hist_entry__thread_snprintf,
         .se_filter      = hist_entry__thread_filter,
@@ -588,7 +588,11 @@ static char *get_trace_output(struct hist_entry *he)
         } else {
                 pevent_event_info(&seq, evsel->tp_format, &rec);
         }
-        return seq.buffer;
+        /*
+         * Trim the buffer, it starts at 4KB and we're not going to
+         * add anything more to this buffer.
+         */
+        return realloc(seq.buffer, seq.len + 1);
 }
 
 static int64_t
@@ -863,7 +867,7 @@ struct sort_entry sort_cycles = {
 };
 
 /* --sort daddr_sym */
-static int64_t
+int64_t
 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         uint64_t l = 0, r = 0;
@@ -892,7 +896,7 @@ static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
                                          width);
 }
 
-static int64_t
+int64_t
 sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         uint64_t l = 0, r = 0;
@@ -1058,7 +1062,7 @@ static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
         return repsep_snprintf(bf, size, "%-*s", width, out);
 }
 
-static int64_t
+int64_t
 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         u64 l, r;
@@ -1218,7 +1222,7 @@ struct sort_entry sort_mem_daddr_dso = {
         .se_header      = "Data Object",
         .se_cmp         = sort__dso_daddr_cmp,
         .se_snprintf    = hist_entry__dso_daddr_snprintf,
-        .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
+        .se_width_idx   = HISTC_MEM_DADDR_DSO,
 };
 
 struct sort_entry sort_mem_locked = {
@@ -1488,7 +1492,8 @@ void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
 }
 
 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                              struct perf_evsel *evsel)
+                              struct hists *hists, int line __maybe_unused,
+                              int *span __maybe_unused)
 {
         struct hpp_sort_entry *hse;
         size_t len = fmt->user_len;
@@ -1496,14 +1501,14 @@ static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
 
         if (!len)
-                len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
+                len = hists__col_len(hists, hse->se->se_width_idx);
 
         return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
 }
 
 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
                              struct perf_hpp *hpp __maybe_unused,
-                             struct perf_evsel *evsel)
+                             struct hists *hists)
 {
         struct hpp_sort_entry *hse;
         size_t len = fmt->user_len;
@@ -1511,7 +1516,7 @@ static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
         hse = container_of(fmt, struct hpp_sort_entry, hpp);
 
         if (!len)
-                len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
+                len = hists__col_len(hists, hse->se->se_width_idx);
 
         return len;
 }
@@ -1793,7 +1798,9 @@ static void update_dynamic_len(struct hpp_dynamic_entry *hde,
 }
 
 static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
-                              struct perf_evsel *evsel __maybe_unused)
+                              struct hists *hists __maybe_unused,
+                              int line __maybe_unused,
+                              int *span __maybe_unused)
 {
         struct hpp_dynamic_entry *hde;
         size_t len = fmt->user_len;
@@ -1808,7 +1815,7 @@ static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
 
 static int __sort__hde_width(struct perf_hpp_fmt *fmt,
                              struct perf_hpp *hpp __maybe_unused,
-                             struct perf_evsel *evsel __maybe_unused)
+                             struct hists *hists __maybe_unused)
 {
         struct hpp_dynamic_entry *hde;
         size_t len = fmt->user_len;
@@ -2069,7 +2076,7 @@ static struct perf_evsel *find_evsel(struct perf_evlist *evlist, char *event_nam
         }
 
         full_name = !!strchr(event_name, ':');
-        evlist__for_each(evlist, pos) {
+        evlist__for_each_entry(evlist, pos) {
                 /* case 2 */
                 if (full_name && !strcmp(pos->name, event_name))
                         return pos;
@@ -2125,7 +2132,7 @@ static int add_all_dynamic_fields(struct perf_evlist *evlist, bool raw_trace,
         int ret;
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
                         continue;
 
@@ -2143,7 +2150,7 @@ static int add_all_matching_fields(struct perf_evlist *evlist,
         struct perf_evsel *evsel;
         struct format_field *field;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
                         continue;
 
@@ -2301,9 +2308,9 @@ int hpp_dimension__add_output(unsigned col)
         return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]);
 }
 
-static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
-                               struct perf_evlist *evlist,
-                               int level)
+int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
+                        struct perf_evlist *evlist,
+                        int level)
 {
         unsigned int i;
 
@@ -2381,6 +2388,9 @@ static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
                 if (sort__mode != SORT_MODE__MEMORY)
                         return -EINVAL;
 
+                if (sd->entry == &sort_mem_dcacheline && cacheline_size == 0)
+                        return -EINVAL;
+
                 if (sd->entry == &sort_mem_daddr_sym)
                         list->sym = 1;
 
@@ -2424,7 +2434,10 @@ static int setup_sort_list(struct perf_hpp_list *list, char *str,
                 if (*tok) {
                         ret = sort_dimension__add(list, tok, evlist, level);
                         if (ret == -EINVAL) {
-                                error("Invalid --sort key: `%s'", tok);
+                                if (!cacheline_size && !strncasecmp(tok, "dcacheline", strlen(tok)))
+                                        error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
+                                else
+                                        error("Invalid --sort key: `%s'", tok);
                                 break;
                         } else if (ret == -ESRCH) {
                                 error("Unknown --sort key: `%s'", tok);
@@ -2456,7 +2469,7 @@ static const char *get_default_sort_order(struct perf_evlist *evlist)
         if (evlist == NULL)
                 goto out_no_evlist;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
                         use_trace = false;
                         break;
@@ -2672,7 +2685,7 @@ void sort__setup_elide(FILE *output)
         }
 }
 
-static int output_field_add(struct perf_hpp_list *list, char *tok)
+int output_field_add(struct perf_hpp_list *list, char *tok)
 {
         unsigned int i;
 
@@ -2735,7 +2748,7 @@ static int setup_output_list(struct perf_hpp_list *list, char *str)
         return ret;
 }
 
-static void reset_dimensions(void)
+void reset_dimensions(void)
 {
         unsigned int i;
 
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index ebb59cacd092..099c97557d33 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -28,7 +28,7 @@ extern const char *sort_order;
 extern const char *field_order;
 extern const char default_parent_pattern[];
 extern const char *parent_pattern;
-extern const char default_sort_order[];
+extern const char *default_sort_order;
 extern regex_t ignore_callees_regex;
 extern int have_ignore_callees;
 extern enum sort_mode sort__mode;
@@ -40,6 +40,7 @@ extern struct sort_entry sort_dso_from;
 extern struct sort_entry sort_dso_to;
 extern struct sort_entry sort_sym_from;
 extern struct sort_entry sort_sym_to;
+extern struct sort_entry sort_srcline;
 extern enum sort_type sort__first_dimension;
 extern const char default_mem_sort_order[];
 
@@ -67,6 +68,11 @@ struct hist_entry_diff {
         };
 };
 
+struct hist_entry_ops {
+        void    *(*new)(size_t size);
+        void    (*free)(void *ptr);
+};
+
 /**
  * struct hist_entry - histogram entry
  *
@@ -125,6 +131,7 @@ struct hist_entry {
         void                    *trace_output;
         struct perf_hpp_list    *hpp_list;
         struct hist_entry       *parent_he;
+        struct hist_entry_ops   *ops;
         union {
                 /* this is for hierarchical entry structure */
                 struct {
@@ -262,4 +269,15 @@ int report_parse_ignore_callees_opt(const struct option *opt, const char *arg, i
 bool is_strict_order(const char *order);
 
 int hpp_dimension__add_output(unsigned col);
+void reset_dimensions(void);
+int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
+                        struct perf_evlist *evlist,
+                        int level);
+int output_field_add(struct perf_hpp_list *list, char *tok);
+int64_t
+sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right);
+int64_t
+sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right);
+int64_t
+sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right);
 #endif  /* __PERF_SORT_H */
diff --git a/tools/perf/util/stat-shadow.c b/tools/perf/util/stat-shadow.c
index aa9efe08762b..8a2bbd2a4d82 100644
--- a/tools/perf/util/stat-shadow.c
+++ b/tools/perf/util/stat-shadow.c
@@ -36,6 +36,11 @@ static struct stats runtime_dtlb_cache_stats[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_cycles_in_tx_stats[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_transaction_stats[NUM_CTX][MAX_NR_CPUS];
 static struct stats runtime_elision_stats[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_topdown_total_slots[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_topdown_slots_issued[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_topdown_slots_retired[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_topdown_fetch_bubbles[NUM_CTX][MAX_NR_CPUS];
+static struct stats runtime_topdown_recovery_bubbles[NUM_CTX][MAX_NR_CPUS];
 static bool have_frontend_stalled;
 
 struct stats walltime_nsecs_stats;
@@ -82,6 +87,11 @@ void perf_stat__reset_shadow_stats(void)
                 sizeof(runtime_transaction_stats));
         memset(runtime_elision_stats, 0, sizeof(runtime_elision_stats));
         memset(&walltime_nsecs_stats, 0, sizeof(walltime_nsecs_stats));
+        memset(runtime_topdown_total_slots, 0, sizeof(runtime_topdown_total_slots));
+        memset(runtime_topdown_slots_retired, 0, sizeof(runtime_topdown_slots_retired));
+        memset(runtime_topdown_slots_issued, 0, sizeof(runtime_topdown_slots_issued));
+        memset(runtime_topdown_fetch_bubbles, 0, sizeof(runtime_topdown_fetch_bubbles));
+        memset(runtime_topdown_recovery_bubbles, 0, sizeof(runtime_topdown_recovery_bubbles));
 }
 
 /*
@@ -105,6 +115,16 @@ void perf_stat__update_shadow_stats(struct perf_evsel *counter, u64 *count,
                 update_stats(&runtime_transaction_stats[ctx][cpu], count[0]);
         else if (perf_stat_evsel__is(counter, ELISION_START))
                 update_stats(&runtime_elision_stats[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, TOPDOWN_TOTAL_SLOTS))
+                update_stats(&runtime_topdown_total_slots[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, TOPDOWN_SLOTS_ISSUED))
+                update_stats(&runtime_topdown_slots_issued[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, TOPDOWN_SLOTS_RETIRED))
+                update_stats(&runtime_topdown_slots_retired[ctx][cpu], count[0]);
+        else if (perf_stat_evsel__is(counter, TOPDOWN_FETCH_BUBBLES))
+                update_stats(&runtime_topdown_fetch_bubbles[ctx][cpu],count[0]);
+        else if (perf_stat_evsel__is(counter, TOPDOWN_RECOVERY_BUBBLES))
+                update_stats(&runtime_topdown_recovery_bubbles[ctx][cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_FRONTEND))
                 update_stats(&runtime_stalled_cycles_front_stats[ctx][cpu], count[0]);
         else if (perf_evsel__match(counter, HARDWARE, HW_STALLED_CYCLES_BACKEND))
@@ -302,6 +322,107 @@ static void print_ll_cache_misses(int cpu,
         out->print_metric(out->ctx, color, "%7.2f%%", "of all LL-cache hits", ratio);
 }
 
+/*
+ * High level "TopDown" CPU core pipe line bottleneck break down.
+ *
+ * Basic concept following
+ * Yasin, A Top Down Method for Performance analysis and Counter architecture
+ * ISPASS14
+ *
+ * The CPU pipeline is divided into 4 areas that can be bottlenecks:
+ *
+ * Frontend -> Backend -> Retiring
+ * BadSpeculation in addition means out of order execution that is thrown away
+ * (for example branch mispredictions)
+ * Frontend is instruction decoding.
+ * Backend is execution, like computation and accessing data in memory
+ * Retiring is good execution that is not directly bottlenecked
+ *
+ * The formulas are computed in slots.
+ * A slot is an entry in the pipeline each for the pipeline width
+ * (for example a 4-wide pipeline has 4 slots for each cycle)
+ *
+ * Formulas:
+ * BadSpeculation = ((SlotsIssued - SlotsRetired) + RecoveryBubbles) /
+ *                      TotalSlots
+ * Retiring = SlotsRetired / TotalSlots
+ * FrontendBound = FetchBubbles / TotalSlots
+ * BackendBound = 1.0 - BadSpeculation - Retiring - FrontendBound
+ *
+ * The kernel provides the mapping to the low level CPU events and any scaling
+ * needed for the CPU pipeline width, for example:
+ *
+ * TotalSlots = Cycles * 4
+ *
+ * The scaling factor is communicated in the sysfs unit.
+ *
+ * In some cases the CPU may not be able to measure all the formulas due to
+ * missing events. In this case multiple formulas are combined, as possible.
+ *
+ * Full TopDown supports more levels to sub-divide each area: for example
+ * BackendBound into computing bound and memory bound. For now we only
+ * support Level 1 TopDown.
+ */
+
+static double sanitize_val(double x)
+{
+        if (x < 0 && x >= -0.02)
+                return 0.0;
+        return x;
+}
+
+static double td_total_slots(int ctx, int cpu)
+{
+        return avg_stats(&runtime_topdown_total_slots[ctx][cpu]);
+}
+
+static double td_bad_spec(int ctx, int cpu)
+{
+        double bad_spec = 0;
+        double total_slots;
+        double total;
+
+        total = avg_stats(&runtime_topdown_slots_issued[ctx][cpu]) -
+                avg_stats(&runtime_topdown_slots_retired[ctx][cpu]) +
+                avg_stats(&runtime_topdown_recovery_bubbles[ctx][cpu]);
+        total_slots = td_total_slots(ctx, cpu);
+        if (total_slots)
+                bad_spec = total / total_slots;
+        return sanitize_val(bad_spec);
+}
+
+static double td_retiring(int ctx, int cpu)
+{
+        double retiring = 0;
+        double total_slots = td_total_slots(ctx, cpu);
+        double ret_slots = avg_stats(&runtime_topdown_slots_retired[ctx][cpu]);
+
+        if (total_slots)
+                retiring = ret_slots / total_slots;
+        return retiring;
+}
+
+static double td_fe_bound(int ctx, int cpu)
+{
+        double fe_bound = 0;
+        double total_slots = td_total_slots(ctx, cpu);
+        double fetch_bub = avg_stats(&runtime_topdown_fetch_bubbles[ctx][cpu]);
+
+        if (total_slots)
+                fe_bound = fetch_bub / total_slots;
+        return fe_bound;
+}
+
+static double td_be_bound(int ctx, int cpu)
+{
+        double sum = (td_fe_bound(ctx, cpu) +
+                      td_bad_spec(ctx, cpu) +
+                      td_retiring(ctx, cpu));
+        if (sum == 0)
+                return 0;
+        return sanitize_val(1.0 - sum);
+}
+
 void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                    double avg, int cpu,
                                    struct perf_stat_output_ctx *out)
@@ -309,6 +430,7 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
         void *ctxp = out->ctx;
         print_metric_t print_metric = out->print_metric;
         double total, ratio = 0.0, total2;
+        const char *color = NULL;
         int ctx = evsel_context(evsel);
 
         if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
@@ -452,6 +574,46 @@ void perf_stat__print_shadow_stats(struct perf_evsel *evsel,
                                      avg / ratio);
                 else
                         print_metric(ctxp, NULL, NULL, "CPUs utilized", 0);
+        } else if (perf_stat_evsel__is(evsel, TOPDOWN_FETCH_BUBBLES)) {
+                double fe_bound = td_fe_bound(ctx, cpu);
+
+                if (fe_bound > 0.2)
+                        color = PERF_COLOR_RED;
+                print_metric(ctxp, color, "%8.1f%%", "frontend bound",
+                                fe_bound * 100.);
+        } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_RETIRED)) {
+                double retiring = td_retiring(ctx, cpu);
+
+                if (retiring > 0.7)
+                        color = PERF_COLOR_GREEN;
+                print_metric(ctxp, color, "%8.1f%%", "retiring",
+                                retiring * 100.);
+        } else if (perf_stat_evsel__is(evsel, TOPDOWN_RECOVERY_BUBBLES)) {
+                double bad_spec = td_bad_spec(ctx, cpu);
+
+                if (bad_spec > 0.1)
+                        color = PERF_COLOR_RED;
+                print_metric(ctxp, color, "%8.1f%%", "bad speculation",
+                                bad_spec * 100.);
+        } else if (perf_stat_evsel__is(evsel, TOPDOWN_SLOTS_ISSUED)) {
+                double be_bound = td_be_bound(ctx, cpu);
+                const char *name = "backend bound";
+                static int have_recovery_bubbles = -1;
+
+                /* In case the CPU does not support topdown-recovery-bubbles */
+                if (have_recovery_bubbles < 0)
+                        have_recovery_bubbles = pmu_have_event("cpu",
+                                        "topdown-recovery-bubbles");
+                if (!have_recovery_bubbles)
+                        name = "backend bound/bad spec";
+
+                if (be_bound > 0.2)
+                        color = PERF_COLOR_RED;
+                if (td_total_slots(ctx, cpu) > 0)
+                        print_metric(ctxp, color, "%8.1f%%", name,
+                                        be_bound * 100.);
+                else
+                        print_metric(ctxp, NULL, NULL, name, 0);
         } else if (runtime_nsecs_stats[cpu].n != 0) {
                 char unit = 'M';
                 char unit_buf[10];
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
index ffa1d0653861..39345c2ddfc2 100644
--- a/tools/perf/util/stat.c
+++ b/tools/perf/util/stat.c
@@ -79,6 +79,11 @@ static const char *id_str[PERF_STAT_EVSEL_ID__MAX] = {
         ID(TRANSACTION_START,   cpu/tx-start/),
         ID(ELISION_START,       cpu/el-start/),
         ID(CYCLES_IN_TX_CP,     cpu/cycles-ct/),
+        ID(TOPDOWN_TOTAL_SLOTS, topdown-total-slots),
+        ID(TOPDOWN_SLOTS_ISSUED, topdown-slots-issued),
+        ID(TOPDOWN_SLOTS_RETIRED, topdown-slots-retired),
+        ID(TOPDOWN_FETCH_BUBBLES, topdown-fetch-bubbles),
+        ID(TOPDOWN_RECOVERY_BUBBLES, topdown-recovery-bubbles),
 };
 #undef ID
 
@@ -157,7 +162,7 @@ int perf_evlist__alloc_stats(struct perf_evlist *evlist, bool alloc_raw)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 if (perf_evsel__alloc_stats(evsel, alloc_raw))
                         goto out_free;
         }
@@ -173,7 +178,7 @@ void perf_evlist__free_stats(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 perf_evsel__free_stat_priv(evsel);
                 perf_evsel__free_counts(evsel);
                 perf_evsel__free_prev_raw_counts(evsel);
@@ -184,7 +189,7 @@ void perf_evlist__reset_stats(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        evlist__for_each(evlist, evsel) {
+        evlist__for_each_entry(evlist, evsel) {
                 perf_evsel__reset_stat_priv(evsel);
                 perf_evsel__reset_counts(evsel);
         }
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
index 0150e786ccc7..c29bb94c48a4 100644
--- a/tools/perf/util/stat.h
+++ b/tools/perf/util/stat.h
@@ -17,6 +17,11 @@ enum perf_stat_evsel_id {
         PERF_STAT_EVSEL_ID__TRANSACTION_START,
         PERF_STAT_EVSEL_ID__ELISION_START,
         PERF_STAT_EVSEL_ID__CYCLES_IN_TX_CP,
+        PERF_STAT_EVSEL_ID__TOPDOWN_TOTAL_SLOTS,
+        PERF_STAT_EVSEL_ID__TOPDOWN_SLOTS_ISSUED,
+        PERF_STAT_EVSEL_ID__TOPDOWN_SLOTS_RETIRED,
+        PERF_STAT_EVSEL_ID__TOPDOWN_FETCH_BUBBLES,
+        PERF_STAT_EVSEL_ID__TOPDOWN_RECOVERY_BUBBLES,
         PERF_STAT_EVSEL_ID__MAX,
 };
 
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index f95f682aa2b2..817593908d47 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -1,5 +1,5 @@
 #include "debug.h"
-#include "cache.h"
+#include "util.h"
 #include <linux/kernel.h>
 
 int prefixcmp(const char *str, const char *prefix)
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index 54b409297d4a..318424ea561d 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -40,6 +40,9 @@
 
 #include <assert.h>
 #include <stdarg.h>
+#include <stddef.h>
+#include <string.h>
+#include <sys/types.h>
 
 extern char strbuf_slopbuf[];
 struct strbuf {
@@ -63,9 +66,8 @@ static inline ssize_t strbuf_avail(const struct strbuf *sb) {
 int strbuf_grow(struct strbuf *buf, size_t);
 
 static inline int strbuf_setlen(struct strbuf *sb, size_t len) {
-        int ret;
         if (!sb->alloc) {
-                ret = strbuf_grow(sb, 0);
+                int ret = strbuf_grow(sb, 0);
                 if (ret)
                         return ret;
         }
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
index ca990029e243..19207e50fce5 100644
--- a/tools/perf/util/strlist.h
+++ b/tools/perf/util/strlist.h
@@ -73,7 +73,7 @@ static inline struct str_node *strlist__next(struct str_node *sn)
  * @pos:        the &struct str_node to use as a loop cursor.
  * @slist:      the &struct strlist for loop.
  */
-#define strlist__for_each(pos, slist)   \
+#define strlist__for_each_entry(pos, slist)     \
         for (pos = strlist__first(slist); pos; pos = strlist__next(pos))
 
 /**
@@ -83,7 +83,7 @@ static inline struct str_node *strlist__next(struct str_node *sn)
  * @n:          another &struct str_node to use as temporary storage.
  * @slist:      the &struct strlist for loop.
  */
-#define strlist__for_each_safe(pos, n, slist)   \
+#define strlist__for_each_entry_safe(pos, n, slist)     \
         for (pos = strlist__first(slist), n = strlist__next(pos); pos;\
              pos = n, n = strlist__next(n))
 #endif /* __PERF_STRLIST_H */
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
index eec6c1149f44..1cbada2dc6be 100644
--- a/tools/perf/util/svghelper.c
+++ b/tools/perf/util/svghelper.c
@@ -18,6 +18,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <linux/bitmap.h>
+#include <linux/time64.h>
 
 #include "perf.h"
 #include "svghelper.h"
@@ -274,14 +275,14 @@ static char *time_to_string(u64 duration)
 
         text[0] = 0;
 
-        if (duration < 1000) /* less than 1 usec */
+        if (duration < NSEC_PER_USEC) /* less than 1 usec */
                 return text;
 
-        if (duration < 1000 * 1000) { /* less than 1 msec */
-                sprintf(text, "%.1f us", duration / 1000.0);
+        if (duration < NSEC_PER_MSEC) { /* less than 1 msec */
+                sprintf(text, "%.1f us", duration / (double)NSEC_PER_USEC);
                 return text;
         }
-        sprintf(text, "%.1f ms", duration / 1000.0 / 1000);
+        sprintf(text, "%.1f ms", duration / (double)NSEC_PER_MSEC);
 
         return text;
 }
@@ -297,7 +298,7 @@ void svg_waiting(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
 
         style = "waiting";
 
-        if (end-start > 10 * 1000000) /* 10 msec */
+        if (end-start > 10 * NSEC_PER_MSEC) /* 10 msec */
                 style = "WAITING";
 
         text = time_to_string(end-start);
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 87a297dd8901..99400b0e8f2a 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -7,6 +7,7 @@
 
 #include "symbol.h"
 #include "demangle-java.h"
+#include "demangle-rust.h"
 #include "machine.h"
 #include "vdso.h"
 #include <symbol/kallsyms.h>
@@ -16,6 +17,7 @@
 #define EM_AARCH64      183  /* ARM 64 bit */
 #endif
 
+typedef Elf64_Nhdr GElf_Nhdr;
 
 #ifdef HAVE_CPLUS_DEMANGLE_SUPPORT
 extern char *cplus_demangle(const char *, int);
@@ -54,6 +56,14 @@ static int elf_getphdrnum(Elf *elf, size_t *dst)
 }
 #endif
 
+#ifndef HAVE_ELF_GETSHDRSTRNDX_SUPPORT
+static int elf_getshdrstrndx(Elf *elf __maybe_unused, size_t *dst __maybe_unused)
+{
+        pr_err("%s: update your libelf to > 0.140, this one lacks elf_getshdrstrndx().\n", __func__);
+        return -1;
+}
+#endif
+
 #ifndef NT_GNU_BUILD_ID
 #define NT_GNU_BUILD_ID 3
 #endif
@@ -196,6 +206,37 @@ Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
         return NULL;
 }
 
+static bool want_demangle(bool is_kernel_sym)
+{
+        return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
+}
+
+static char *demangle_sym(struct dso *dso, int kmodule, const char *elf_name)
+{
+        int demangle_flags = verbose ? (DMGL_PARAMS | DMGL_ANSI) : DMGL_NO_OPTS;
+        char *demangled = NULL;
+
+        /*
+         * We need to figure out if the object was created from C++ sources
+         * DWARF DW_compile_unit has this, but we don't always have access
+         * to it...
+         */
+        if (!want_demangle(dso->kernel || kmodule))
+            return demangled;
+
+        demangled = bfd_demangle(NULL, elf_name, demangle_flags);
+        if (demangled == NULL)
+                demangled = java_demangle_sym(elf_name, JAVA_DEMANGLE_NORET);
+        else if (rust_is_mangled(demangled))
+                /*
+                    * Input to Rust demangling is the BFD-demangled
+                    * name which it Rust-demangles in place.
+                    */
+                rust_demangle_sym(demangled);
+
+        return demangled;
+}
+
 #define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
         for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
              idx < nr_entries; \
@@ -213,8 +254,7 @@ Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
  * And always look at the original dso, not at debuginfo packages, that
  * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
  */
-int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss, struct map *map,
-                                symbol_filter_t filter)
+int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss, struct map *map)
 {
         uint32_t nr_rel_entries, idx;
         GElf_Sym sym;
@@ -291,45 +331,53 @@ int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss, struct map *
 
                 elf_section__for_each_rela(reldata, pos, pos_mem, idx,
                                            nr_rel_entries) {
+                        const char *elf_name = NULL;
+                        char *demangled = NULL;
                         symidx = GELF_R_SYM(pos->r_info);
                         plt_offset += shdr_plt.sh_entsize;
                         gelf_getsym(syms, symidx, &sym);
+
+                        elf_name = elf_sym__name(&sym, symstrs);
+                        demangled = demangle_sym(dso, 0, elf_name);
+                        if (demangled != NULL)
+                                elf_name = demangled;
                         snprintf(sympltname, sizeof(sympltname),
-                                 "%s@plt", elf_sym__name(&sym, symstrs));
+                                 "%s@plt", elf_name);
+                        free(demangled);
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
                                         STB_GLOBAL, sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        if (filter && filter(map, f))
-                                symbol__delete(f);
-                        else {
-                                symbols__insert(&dso->symbols[map->type], f);
-                                ++nr;
-                        }
+                        symbols__insert(&dso->symbols[map->type], f);
+                        ++nr;
                 }
         } else if (shdr_rel_plt.sh_type == SHT_REL) {
                 GElf_Rel pos_mem, *pos;
                 elf_section__for_each_rel(reldata, pos, pos_mem, idx,
                                           nr_rel_entries) {
+                        const char *elf_name = NULL;
+                        char *demangled = NULL;
                         symidx = GELF_R_SYM(pos->r_info);
                         plt_offset += shdr_plt.sh_entsize;
                         gelf_getsym(syms, symidx, &sym);
+
+                        elf_name = elf_sym__name(&sym, symstrs);
+                        demangled = demangle_sym(dso, 0, elf_name);
+                        if (demangled != NULL)
+                                elf_name = demangled;
                         snprintf(sympltname, sizeof(sympltname),
-                                 "%s@plt", elf_sym__name(&sym, symstrs));
+                                 "%s@plt", elf_name);
+                        free(demangled);
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
                                         STB_GLOBAL, sympltname);
                         if (!f)
                                 goto out_elf_end;
 
-                        if (filter && filter(map, f))
-                                symbol__delete(f);
-                        else {
-                                symbols__insert(&dso->symbols[map->type], f);
-                                ++nr;
-                        }
+                        symbols__insert(&dso->symbols[map->type], f);
+                        ++nr;
                 }
         }
 
@@ -675,7 +723,7 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
         }
 
         /* Always reject images with a mismatched build-id: */
-        if (dso->has_build_id) {
+        if (dso->has_build_id && !symbol_conf.ignore_vmlinux_buildid) {
                 u8 build_id[BUILD_ID_SIZE];
 
                 if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0) {
@@ -765,17 +813,11 @@ static u64 ref_reloc(struct kmap *kmap)
         return 0;
 }
 
-static bool want_demangle(bool is_kernel_sym)
-{
-        return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
-}
-
 void __weak arch__sym_update(struct symbol *s __maybe_unused,
                 GElf_Sym *sym __maybe_unused) { }
 
-int dso__load_sym(struct dso *dso, struct map *map,
-                  struct symsrc *syms_ss, struct symsrc *runtime_ss,
-                  symbol_filter_t filter, int kmodule)
+int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
+                  struct symsrc *runtime_ss, int kmodule)
 {
         struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
         struct map_groups *kmaps = kmap ? map__kmaps(map) : NULL;
@@ -827,7 +869,8 @@ int dso__load_sym(struct dso *dso, struct map *map,
         sec = syms_ss->symtab;
         shdr = syms_ss->symshdr;
 
-        if (elf_section_by_name(elf, &ehdr, &tshdr, ".text", NULL))
+        if (elf_section_by_name(runtime_ss->elf, &runtime_ss->ehdr, &tshdr,
+                                ".text", NULL))
                 dso->text_offset = tshdr.sh_addr - tshdr.sh_offset;
 
         if (runtime_ss->opdsec)
@@ -1059,22 +1102,10 @@ int dso__load_sym(struct dso *dso, struct map *map,
                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
                 }
 new_symbol:
-                /*
-                 * We need to figure out if the object was created from C++ sources
-                 * DWARF DW_compile_unit has this, but we don't always have access
-                 * to it...
-                 */
-                if (want_demangle(dso->kernel || kmodule)) {
-                        int demangle_flags = DMGL_NO_OPTS;
-                        if (verbose)
-                                demangle_flags = DMGL_PARAMS | DMGL_ANSI;
-
-                        demangled = bfd_demangle(NULL, elf_name, demangle_flags);
-                        if (demangled == NULL)
-                                demangled = java_demangle_sym(elf_name, JAVA_DEMANGLE_NORET);
-                        if (demangled != NULL)
-                                elf_name = demangled;
-                }
+                demangled = demangle_sym(dso, kmodule, elf_name);
+                if (demangled != NULL)
+                        elf_name = demangled;
+
                 f = symbol__new(sym.st_value, sym.st_size,
                                 GELF_ST_BIND(sym.st_info), elf_name);
                 free(demangled);
@@ -1083,21 +1114,16 @@ new_symbol:
 
                 arch__sym_update(f, &sym);
 
-                if (filter && filter(curr_map, f))
-                        symbol__delete(f);
-                else {
-                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
-                        nr++;
-                }
+                __symbols__insert(&curr_dso->symbols[curr_map->type], f, dso->kernel);
+                nr++;
         }
 
         /*
          * For misannotated, zeroed, ASM function sizes.
          */
         if (nr > 0) {
-                if (!symbol_conf.allow_aliases)
-                        symbols__fixup_duplicate(&dso->symbols[map->type]);
                 symbols__fixup_end(&dso->symbols[map->type]);
+                symbols__fixup_duplicate(&dso->symbols[map->type]);
                 if (kmap) {
                         /*
                          * We need to fixup this here too because we create new
@@ -1781,6 +1807,260 @@ void kcore_extract__delete(struct kcore_extract *kce)
         unlink(kce->extract_filename);
 }
 
+#ifdef HAVE_GELF_GETNOTE_SUPPORT
+/**
+ * populate_sdt_note : Parse raw data and identify SDT note
+ * @elf: elf of the opened file
+ * @data: raw data of a section with description offset applied
+ * @len: note description size
+ * @type: type of the note
+ * @sdt_notes: List to add the SDT note
+ *
+ * Responsible for parsing the @data in section .note.stapsdt in @elf and
+ * if its an SDT note, it appends to @sdt_notes list.
+ */
+static int populate_sdt_note(Elf **elf, const char *data, size_t len,
+                             struct list_head *sdt_notes)
+{
+        const char *provider, *name;
+        struct sdt_note *tmp = NULL;
+        GElf_Ehdr ehdr;
+        GElf_Addr base_off = 0;
+        GElf_Shdr shdr;
+        int ret = -EINVAL;
+
+        union {
+                Elf64_Addr a64[NR_ADDR];
+                Elf32_Addr a32[NR_ADDR];
+        } buf;
+
+        Elf_Data dst = {
+                .d_buf = &buf, .d_type = ELF_T_ADDR, .d_version = EV_CURRENT,
+                .d_size = gelf_fsize((*elf), ELF_T_ADDR, NR_ADDR, EV_CURRENT),
+                .d_off = 0, .d_align = 0
+        };
+        Elf_Data src = {
+                .d_buf = (void *) data, .d_type = ELF_T_ADDR,
+                .d_version = EV_CURRENT, .d_size = dst.d_size, .d_off = 0,
+                .d_align = 0
+        };
+
+        tmp = (struct sdt_note *)calloc(1, sizeof(struct sdt_note));
+        if (!tmp) {
+                ret = -ENOMEM;
+                goto out_err;
+        }
+
+        INIT_LIST_HEAD(&tmp->note_list);
+
+        if (len < dst.d_size + 3)
+                goto out_free_note;
+
+        /* Translation from file representation to memory representation */
+        if (gelf_xlatetom(*elf, &dst, &src,
+                          elf_getident(*elf, NULL)[EI_DATA]) == NULL) {
+                pr_err("gelf_xlatetom : %s\n", elf_errmsg(-1));
+                goto out_free_note;
+        }
+
+        /* Populate the fields of sdt_note */
+        provider = data + dst.d_size;
+
+        name = (const char *)memchr(provider, '\0', data + len - provider);
+        if (name++ == NULL)
+                goto out_free_note;
+
+        tmp->provider = strdup(provider);
+        if (!tmp->provider) {
+                ret = -ENOMEM;
+                goto out_free_note;
+        }
+        tmp->name = strdup(name);
+        if (!tmp->name) {
+                ret = -ENOMEM;
+                goto out_free_prov;
+        }
+
+        if (gelf_getclass(*elf) == ELFCLASS32) {
+                memcpy(&tmp->addr, &buf, 3 * sizeof(Elf32_Addr));
+                tmp->bit32 = true;
+        } else {
+                memcpy(&tmp->addr, &buf, 3 * sizeof(Elf64_Addr));
+                tmp->bit32 = false;
+        }
+
+        if (!gelf_getehdr(*elf, &ehdr)) {
+                pr_debug("%s : cannot get elf header.\n", __func__);
+                ret = -EBADF;
+                goto out_free_name;
+        }
+
+        /* Adjust the prelink effect :
+         * Find out the .stapsdt.base section.
+         * This scn will help us to handle prelinking (if present).
+         * Compare the retrieved file offset of the base section with the
+         * base address in the description of the SDT note. If its different,
+         * then accordingly, adjust the note location.
+         */
+        if (elf_section_by_name(*elf, &ehdr, &shdr, SDT_BASE_SCN, NULL)) {
+                base_off = shdr.sh_offset;
+                if (base_off) {
+                        if (tmp->bit32)
+                                tmp->addr.a32[0] = tmp->addr.a32[0] + base_off -
+                                        tmp->addr.a32[1];
+                        else
+                                tmp->addr.a64[0] = tmp->addr.a64[0] + base_off -
+                                        tmp->addr.a64[1];
+                }
+        }
+
+        list_add_tail(&tmp->note_list, sdt_notes);
+        return 0;
+
+out_free_name:
+        free(tmp->name);
+out_free_prov:
+        free(tmp->provider);
+out_free_note:
+        free(tmp);
+out_err:
+        return ret;
+}
+
+/**
+ * construct_sdt_notes_list : constructs a list of SDT notes
+ * @elf : elf to look into
+ * @sdt_notes : empty list_head
+ *
+ * Scans the sections in 'elf' for the section
+ * .note.stapsdt. It, then calls populate_sdt_note to find
+ * out the SDT events and populates the 'sdt_notes'.
+ */
+static int construct_sdt_notes_list(Elf *elf, struct list_head *sdt_notes)
+{
+        GElf_Ehdr ehdr;
+        Elf_Scn *scn = NULL;
+        Elf_Data *data;
+        GElf_Shdr shdr;
+        size_t shstrndx, next;
+        GElf_Nhdr nhdr;
+        size_t name_off, desc_off, offset;
+        int ret = 0;
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                ret = -EBADF;
+                goto out_ret;
+        }
+        if (elf_getshdrstrndx(elf, &shstrndx) != 0) {
+                ret = -EBADF;
+                goto out_ret;
+        }
+
+        /* Look for the required section */
+        scn = elf_section_by_name(elf, &ehdr, &shdr, SDT_NOTE_SCN, NULL);
+        if (!scn) {
+                ret = -ENOENT;
+                goto out_ret;
+        }
+
+        if ((shdr.sh_type != SHT_NOTE) || (shdr.sh_flags & SHF_ALLOC)) {
+                ret = -ENOENT;
+                goto out_ret;
+        }
+
+        data = elf_getdata(scn, NULL);
+
+        /* Get the SDT notes */
+        for (offset = 0; (next = gelf_getnote(data, offset, &nhdr, &name_off,
+                                              &desc_off)) > 0; offset = next) {
+                if (nhdr.n_namesz == sizeof(SDT_NOTE_NAME) &&
+                    !memcmp(data->d_buf + name_off, SDT_NOTE_NAME,
+                            sizeof(SDT_NOTE_NAME))) {
+                        /* Check the type of the note */
+                        if (nhdr.n_type != SDT_NOTE_TYPE)
+                                goto out_ret;
+
+                        ret = populate_sdt_note(&elf, ((data->d_buf) + desc_off),
+                                                nhdr.n_descsz, sdt_notes);
+                        if (ret < 0)
+                                goto out_ret;
+                }
+        }
+        if (list_empty(sdt_notes))
+                ret = -ENOENT;
+
+out_ret:
+        return ret;
+}
+
+/**
+ * get_sdt_note_list : Wrapper to construct a list of sdt notes
+ * @head : empty list_head
+ * @target : file to find SDT notes from
+ *
+ * This opens the file, initializes
+ * the ELF and then calls construct_sdt_notes_list.
+ */
+int get_sdt_note_list(struct list_head *head, const char *target)
+{
+        Elf *elf;
+        int fd, ret;
+
+        fd = open(target, O_RDONLY);
+        if (fd < 0)
+                return -EBADF;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (!elf) {
+                ret = -EBADF;
+                goto out_close;
+        }
+        ret = construct_sdt_notes_list(elf, head);
+        elf_end(elf);
+out_close:
+        close(fd);
+        return ret;
+}
+
+/**
+ * cleanup_sdt_note_list : free the sdt notes' list
+ * @sdt_notes: sdt notes' list
+ *
+ * Free up the SDT notes in @sdt_notes.
+ * Returns the number of SDT notes free'd.
+ */
+int cleanup_sdt_note_list(struct list_head *sdt_notes)
+{
+        struct sdt_note *tmp, *pos;
+        int nr_free = 0;
+
+        list_for_each_entry_safe(pos, tmp, sdt_notes, note_list) {
+                list_del(&pos->note_list);
+                free(pos->name);
+                free(pos->provider);
+                free(pos);
+                nr_free++;
+        }
+        return nr_free;
+}
+
+/**
+ * sdt_notes__get_count: Counts the number of sdt events
+ * @start: list_head to sdt_notes list
+ *
+ * Returns the number of SDT notes in a list
+ */
+int sdt_notes__get_count(struct list_head *start)
+{
+        struct sdt_note *sdt_ptr;
+        int count = 0;
+
+        list_for_each_entry(sdt_ptr, start, note_list)
+                count++;
+        return count;
+}
+#endif
+
 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 48906333a858..11cdde980545 100644
--- a/tools/perf/util/symbol-minimal.c
+++ b/tools/perf/util/symbol-minimal.c
@@ -287,8 +287,7 @@ void symsrc__destroy(struct symsrc *ss)
 
 int dso__synthesize_plt_symbols(struct dso *dso __maybe_unused,
                                 struct symsrc *ss __maybe_unused,
-                                struct map *map __maybe_unused,
-                                symbol_filter_t filter __maybe_unused)
+                                struct map *map __maybe_unused)
 {
         return 0;
 }
@@ -334,7 +333,6 @@ enum dso_type dso__type_fd(int fd)
 int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
                   struct symsrc *ss,
                   struct symsrc *runtime_ss __maybe_unused,
-                  symbol_filter_t filter __maybe_unused,
                   int kmodule __maybe_unused)
 {
         unsigned char build_id[BUILD_ID_SIZE];
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 20f9cb32b703..aecff69a510d 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -9,6 +9,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <inttypes.h>
+#include "annotate.h"
 #include "build-id.h"
 #include "util.h"
 #include "debug.h"
@@ -23,10 +24,10 @@
 #include <symbol/kallsyms.h>
 #include <sys/utsname.h>
 
-static int dso__load_kernel_sym(struct dso *dso, struct map *map,
-                                symbol_filter_t filter);
-static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
-                        symbol_filter_t filter);
+static int dso__load_kernel_sym(struct dso *dso, struct map *map);
+static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map);
+static bool symbol__is_idle(const char *name);
+
 int vmlinux_path__nr_entries;
 char **vmlinux_path;
 
@@ -152,6 +153,9 @@ void symbols__fixup_duplicate(struct rb_root *symbols)
         struct rb_node *nd;
         struct symbol *curr, *next;
 
+        if (symbol_conf.allow_aliases)
+                return;
+
         nd = rb_first(symbols);
 
         while (nd) {
@@ -235,8 +239,13 @@ struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
         if (sym == NULL)
                 return NULL;
 
-        if (symbol_conf.priv_size)
+        if (symbol_conf.priv_size) {
+                if (symbol_conf.init_annotation) {
+                        struct annotation *notes = (void *)sym;
+                        pthread_mutex_init(&notes->lock, NULL);
+                }
                 sym = ((void *)sym) + symbol_conf.priv_size;
+        }
 
         sym->start   = start;
         sym->end     = len ? start + len : start;
@@ -268,13 +277,24 @@ void symbols__delete(struct rb_root *symbols)
         }
 }
 
-void symbols__insert(struct rb_root *symbols, struct symbol *sym)
+void __symbols__insert(struct rb_root *symbols, struct symbol *sym, bool kernel)
 {
         struct rb_node **p = &symbols->rb_node;
         struct rb_node *parent = NULL;
         const u64 ip = sym->start;
         struct symbol *s;
 
+        if (kernel) {
+                const char *name = sym->name;
+                /*
+                 * ppc64 uses function descriptors and appends a '.' to the
+                 * start of every instruction address. Remove it.
+                 */
+                if (name[0] == '.')
+                        name++;
+                sym->idle = symbol__is_idle(name);
+        }
+
         while (*p != NULL) {
                 parent = *p;
                 s = rb_entry(parent, struct symbol, rb_node);
@@ -287,6 +307,11 @@ void symbols__insert(struct rb_root *symbols, struct symbol *sym)
         rb_insert_color(&sym->rb_node, symbols);
 }
 
+void symbols__insert(struct rb_root *symbols, struct symbol *sym)
+{
+        __symbols__insert(symbols, sym, false);
+}
+
 static struct symbol *symbols__find(struct rb_root *symbols, u64 ip)
 {
         struct rb_node *n;
@@ -320,6 +345,16 @@ static struct symbol *symbols__first(struct rb_root *symbols)
         return NULL;
 }
 
+static struct symbol *symbols__last(struct rb_root *symbols)
+{
+        struct rb_node *n = rb_last(symbols);
+
+        if (n)
+                return rb_entry(n, struct symbol, rb_node);
+
+        return NULL;
+}
+
 static struct symbol *symbols__next(struct symbol *sym)
 {
         struct rb_node *n = rb_next(&sym->rb_node);
@@ -415,7 +450,7 @@ void dso__reset_find_symbol_cache(struct dso *dso)
 
 void dso__insert_symbol(struct dso *dso, enum map_type type, struct symbol *sym)
 {
-        symbols__insert(&dso->symbols[type], sym);
+        __symbols__insert(&dso->symbols[type], sym, dso->kernel);
 
         /* update the symbol cache if necessary */
         if (dso->last_find_result[type].addr >= sym->start &&
@@ -441,6 +476,11 @@ struct symbol *dso__first_symbol(struct dso *dso, enum map_type type)
         return symbols__first(&dso->symbols[type]);
 }
 
+struct symbol *dso__last_symbol(struct dso *dso, enum map_type type)
+{
+        return symbols__last(&dso->symbols[type]);
+}
+
 struct symbol *dso__next_symbol(struct symbol *sym)
 {
         return symbols__next(sym);
@@ -537,7 +577,7 @@ struct process_kallsyms_args {
  * These are symbols in the kernel image, so make sure that
  * sym is from a kernel DSO.
  */
-bool symbol__is_idle(struct symbol *sym)
+static bool symbol__is_idle(const char *name)
 {
         const char * const idle_symbols[] = {
                 "cpu_idle",
@@ -554,14 +594,10 @@ bool symbol__is_idle(struct symbol *sym)
                 "pseries_dedicated_idle_sleep",
                 NULL
         };
-
         int i;
 
-        if (!sym)
-                return false;
-
         for (i = 0; idle_symbols[i]; i++) {
-                if (!strcmp(idle_symbols[i], sym->name))
+                if (!strcmp(idle_symbols[i], name))
                         return true;
         }
 
@@ -590,7 +626,7 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
          * We will pass the symbols to the filter later, in
          * map__split_kallsyms, when we have split the maps per module
          */
-        symbols__insert(root, sym);
+        __symbols__insert(root, sym, !strchr(name, '['));
 
         return 0;
 }
@@ -607,8 +643,7 @@ 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)
+static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map)
 {
         struct map_groups *kmaps = map__kmaps(map);
         struct map *curr_map;
@@ -637,7 +672,7 @@ static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
 
                 curr_map = map_groups__find(kmaps, map->type, pos->start);
 
-                if (!curr_map || (filter && filter(curr_map, pos))) {
+                if (!curr_map) {
                         symbol__delete(pos);
                         continue;
                 }
@@ -660,8 +695,7 @@ static int dso__split_kallsyms_for_kcore(struct dso *dso, struct map *map,
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
-static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
-                               symbol_filter_t filter)
+static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta)
 {
         struct map_groups *kmaps = map__kmaps(map);
         struct machine *machine;
@@ -738,7 +772,7 @@ static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
 
                         if (count == 0) {
                                 curr_map = map;
-                                goto filter_symbol;
+                                goto add_symbol;
                         }
 
                         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
@@ -770,18 +804,18 @@ static int dso__split_kallsyms(struct dso *dso, struct map *map, u64 delta,
                         pos->start -= delta;
                         pos->end -= delta;
                 }
-filter_symbol:
-                if (filter && filter(curr_map, pos)) {
-discard_symbol:         rb_erase(&pos->rb_node, root);
-                        symbol__delete(pos);
-                } else {
-                        if (curr_map != map) {
-                                rb_erase(&pos->rb_node, root);
-                                symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
-                                ++moved;
-                        } else
-                                ++count;
-                }
+add_symbol:
+                if (curr_map != map) {
+                        rb_erase(&pos->rb_node, root);
+                        symbols__insert(&curr_map->dso->symbols[curr_map->type], pos);
+                        ++moved;
+                } else
+                        ++count;
+
+                continue;
+discard_symbol:
+                rb_erase(&pos->rb_node, root);
+                symbol__delete(pos);
         }
 
         if (curr_map != map &&
@@ -1221,7 +1255,7 @@ static int kallsyms__delta(struct map *map, const char *filename, u64 *delta)
 }
 
 int __dso__load_kallsyms(struct dso *dso, const char *filename,
-                         struct map *map, bool no_kcore, symbol_filter_t filter)
+                         struct map *map, bool no_kcore)
 {
         u64 delta = 0;
 
@@ -1234,8 +1268,8 @@ int __dso__load_kallsyms(struct dso *dso, const char *filename,
         if (kallsyms__delta(map, filename, &delta))
                 return -1;
 
-        symbols__fixup_duplicate(&dso->symbols[map->type]);
         symbols__fixup_end(&dso->symbols[map->type]);
+        symbols__fixup_duplicate(&dso->symbols[map->type]);
 
         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
                 dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
@@ -1243,19 +1277,18 @@ int __dso__load_kallsyms(struct dso *dso, const char *filename,
                 dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 
         if (!no_kcore && !dso__load_kcore(dso, map, filename))
-                return dso__split_kallsyms_for_kcore(dso, map, filter);
+                return dso__split_kallsyms_for_kcore(dso, map);
         else
-                return dso__split_kallsyms(dso, map, delta, filter);
+                return dso__split_kallsyms(dso, map, delta);
 }
 
 int dso__load_kallsyms(struct dso *dso, const char *filename,
-                       struct map *map, symbol_filter_t filter)
+                       struct map *map)
 {
-        return __dso__load_kallsyms(dso, filename, map, false, filter);
+        return __dso__load_kallsyms(dso, filename, map, false);
 }
 
-static int dso__load_perf_map(struct dso *dso, struct map *map,
-                              symbol_filter_t filter)
+static int dso__load_perf_map(struct dso *dso, struct map *map)
 {
         char *line = NULL;
         size_t n;
@@ -1297,12 +1330,8 @@ static int dso__load_perf_map(struct dso *dso, struct map *map,
                 if (sym == NULL)
                         goto out_delete_line;
 
-                if (filter && filter(map, sym))
-                        symbol__delete(sym);
-                else {
-                        symbols__insert(&dso->symbols[map->type], sym);
-                        nr_syms++;
-                }
+                symbols__insert(&dso->symbols[map->type], sym);
+                nr_syms++;
         }
 
         free(line);
@@ -1358,7 +1387,7 @@ static bool dso__is_compatible_symtab_type(struct dso *dso, bool kmod,
         }
 }
 
-int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
+int dso__load(struct dso *dso, struct map *map)
 {
         char *name;
         int ret = -1;
@@ -1381,9 +1410,9 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 
         if (dso->kernel) {
                 if (dso->kernel == DSO_TYPE_KERNEL)
-                        ret = dso__load_kernel_sym(dso, map, filter);
+                        ret = dso__load_kernel_sym(dso, map);
                 else if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
-                        ret = dso__load_guest_kernel_sym(dso, map, filter);
+                        ret = dso__load_guest_kernel_sym(dso, map);
 
                 goto out;
         }
@@ -1407,7 +1436,7 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
                         goto out;
                 }
 
-                ret = dso__load_perf_map(dso, map, filter);
+                ret = dso__load_perf_map(dso, map);
                 dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
                                              DSO_BINARY_TYPE__NOT_FOUND;
                 goto out;
@@ -1430,7 +1459,7 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
          * Read the build id if possible. This is required for
          * DSO_BINARY_TYPE__BUILDID_DEBUGINFO to work
          */
-        if (is_regular_file(name) &&
+        if (is_regular_file(dso->long_name) &&
             filename__read_build_id(dso->long_name, build_id, BUILD_ID_SIZE) > 0)
                 dso__set_build_id(dso, build_id);
 
@@ -1498,14 +1527,14 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
                         kmod = true;
 
         if (syms_ss)
-                ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, kmod);
+                ret = dso__load_sym(dso, map, syms_ss, runtime_ss, kmod);
         else
                 ret = -1;
 
         if (ret > 0) {
                 int nr_plt;
 
-                nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
+                nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map);
                 if (nr_plt > 0)
                         ret += nr_plt;
         }
@@ -1544,8 +1573,7 @@ out_unlock:
 }
 
 int dso__load_vmlinux(struct dso *dso, struct map *map,
-                      const char *vmlinux, bool vmlinux_allocated,
-                      symbol_filter_t filter)
+                      const char *vmlinux, bool vmlinux_allocated)
 {
         int err = -1;
         struct symsrc ss;
@@ -1565,7 +1593,7 @@ int dso__load_vmlinux(struct dso *dso, struct map *map,
         if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
                 return -1;
 
-        err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
+        err = dso__load_sym(dso, map, &ss, &ss, 0);
         symsrc__destroy(&ss);
 
         if (err > 0) {
@@ -1581,8 +1609,7 @@ int dso__load_vmlinux(struct dso *dso, struct map *map,
         return err;
 }
 
-int dso__load_vmlinux_path(struct dso *dso, struct map *map,
-                           symbol_filter_t filter)
+int dso__load_vmlinux_path(struct dso *dso, struct map *map)
 {
         int i, err = 0;
         char *filename = NULL;
@@ -1591,7 +1618,7 @@ int dso__load_vmlinux_path(struct dso *dso, struct map *map,
                  vmlinux_path__nr_entries + 1);
 
         for (i = 0; i < vmlinux_path__nr_entries; ++i) {
-                err = dso__load_vmlinux(dso, map, vmlinux_path[i], false, filter);
+                err = dso__load_vmlinux(dso, map, vmlinux_path[i], false);
                 if (err > 0)
                         goto out;
         }
@@ -1599,7 +1626,7 @@ int dso__load_vmlinux_path(struct dso *dso, struct map *map,
         if (!symbol_conf.ignore_vmlinux_buildid)
                 filename = dso__build_id_filename(dso, NULL, 0);
         if (filename != NULL) {
-                err = dso__load_vmlinux(dso, map, filename, true, filter);
+                err = dso__load_vmlinux(dso, map, filename, true);
                 if (err > 0)
                         goto out;
                 free(filename);
@@ -1626,7 +1653,7 @@ static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
         if (!dirs)
                 return -1;
 
-        strlist__for_each(nd, dirs) {
+        strlist__for_each_entry(nd, dirs) {
                 scnprintf(kallsyms_filename, sizeof(kallsyms_filename),
                           "%s/%s/kallsyms", dir, nd->s);
                 if (!validate_kcore_addresses(kallsyms_filename, map)) {
@@ -1641,6 +1668,20 @@ static int find_matching_kcore(struct map *map, char *dir, size_t dir_sz)
         return ret;
 }
 
+/*
+ * Use open(O_RDONLY) to check readability directly instead of access(R_OK)
+ * since access(R_OK) only checks with real UID/GID but open() use effective
+ * UID/GID and actual capabilities (e.g. /proc/kcore requires CAP_SYS_RAWIO).
+ */
+static bool filename__readable(const char *file)
+{
+        int fd = open(file, O_RDONLY);
+        if (fd < 0)
+                return false;
+        close(fd);
+        return true;
+}
+
 static char *dso__find_kallsyms(struct dso *dso, struct map *map)
 {
         u8 host_build_id[BUILD_ID_SIZE];
@@ -1660,62 +1701,46 @@ static char *dso__find_kallsyms(struct dso *dso, struct map *map)
                                  sizeof(host_build_id)) == 0)
                 is_host = dso__build_id_equal(dso, host_build_id);
 
-        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
-
-        scnprintf(path, sizeof(path), "%s/%s/%s", buildid_dir,
-                  DSO__NAME_KCORE, sbuild_id);
-
-        /* Use /proc/kallsyms if possible */
+        /* Try a fast path for /proc/kallsyms if possible */
         if (is_host) {
-                DIR *d;
-                int fd;
-
-                /* If no cached kcore go with /proc/kallsyms */
-                d = opendir(path);
-                if (!d)
-                        goto proc_kallsyms;
-                closedir(d);
-
                 /*
-                 * Do not check the build-id cache, until we know we cannot use
-                 * /proc/kcore.
+                 * Do not check the build-id cache, unless we know we cannot use
+                 * /proc/kcore or module maps don't match to /proc/kallsyms.
+                 * To check readability of /proc/kcore, do not use access(R_OK)
+                 * since /proc/kcore requires CAP_SYS_RAWIO to read and access
+                 * can't check it.
                  */
-                fd = open("/proc/kcore", O_RDONLY);
-                if (fd != -1) {
-                        close(fd);
-                        /* If module maps match go with /proc/kallsyms */
-                        if (!validate_kcore_addresses("/proc/kallsyms", map))
-                                goto proc_kallsyms;
-                }
-
-                /* Find kallsyms in build-id cache with kcore */
-                if (!find_matching_kcore(map, path, sizeof(path)))
-                        return strdup(path);
-
-                goto proc_kallsyms;
+                if (filename__readable("/proc/kcore") &&
+                    !validate_kcore_addresses("/proc/kallsyms", map))
+                        goto proc_kallsyms;
         }
 
+        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
+
         /* Find kallsyms in build-id cache with kcore */
+        scnprintf(path, sizeof(path), "%s/%s/%s",
+                  buildid_dir, DSO__NAME_KCORE, sbuild_id);
+
         if (!find_matching_kcore(map, path, sizeof(path)))
                 return strdup(path);
 
-        scnprintf(path, sizeof(path), "%s/%s/%s",
-                  buildid_dir, DSO__NAME_KALLSYMS, sbuild_id);
+        /* Use current /proc/kallsyms if possible */
+        if (is_host) {
+proc_kallsyms:
+                return strdup("/proc/kallsyms");
+        }
 
-        if (access(path, F_OK)) {
+        /* Finally, find a cache of kallsyms */
+        if (!build_id_cache__kallsyms_path(sbuild_id, path, sizeof(path))) {
                 pr_err("No kallsyms or vmlinux with build-id %s was found\n",
                        sbuild_id);
                 return NULL;
         }
 
         return strdup(path);
-
-proc_kallsyms:
-        return strdup("/proc/kallsyms");
 }
 
-static int dso__load_kernel_sym(struct dso *dso, struct map *map,
-                                symbol_filter_t filter)
+static int dso__load_kernel_sym(struct dso *dso, struct map *map)
 {
         int err;
         const char *kallsyms_filename = NULL;
@@ -1741,12 +1766,11 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
         }
 
         if (!symbol_conf.ignore_vmlinux && symbol_conf.vmlinux_name != NULL) {
-                return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name,
-                                         false, filter);
+                return dso__load_vmlinux(dso, map, symbol_conf.vmlinux_name, false);
         }
 
         if (!symbol_conf.ignore_vmlinux && vmlinux_path != NULL) {
-                err = dso__load_vmlinux_path(dso, map, filter);
+                err = dso__load_vmlinux_path(dso, map);
                 if (err > 0)
                         return err;
         }
@@ -1762,7 +1786,7 @@ static int dso__load_kernel_sym(struct dso *dso, struct map *map,
         kallsyms_filename = kallsyms_allocated_filename;
 
 do_kallsyms:
-        err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
+        err = dso__load_kallsyms(dso, kallsyms_filename, map);
         if (err > 0)
                 pr_debug("Using %s for symbols\n", kallsyms_filename);
         free(kallsyms_allocated_filename);
@@ -1777,8 +1801,7 @@ do_kallsyms:
         return err;
 }
 
-static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
-                                      symbol_filter_t filter)
+static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map)
 {
         int err;
         const char *kallsyms_filename = NULL;
@@ -1800,7 +1823,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,
-                                                false, filter);
+                                                false);
                         return err;
                 }
 
@@ -1812,7 +1835,7 @@ static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
                 kallsyms_filename = path;
         }
 
-        err = dso__load_kallsyms(dso, kallsyms_filename, map, filter);
+        err = dso__load_kallsyms(dso, kallsyms_filename, map);
         if (err > 0)
                 pr_debug("Using %s for symbols\n", kallsyms_filename);
         if (err > 0 && !dso__is_kcore(dso)) {
@@ -1933,22 +1956,39 @@ int setup_intlist(struct intlist **list, const char *list_str,
 static bool symbol__read_kptr_restrict(void)
 {
         bool value = false;
+        FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
 
-        if (geteuid() != 0) {
-                FILE *fp = fopen("/proc/sys/kernel/kptr_restrict", "r");
-                if (fp != NULL) {
-                        char line[8];
+        if (fp != NULL) {
+                char line[8];
 
-                        if (fgets(line, sizeof(line), fp) != NULL)
-                                value = atoi(line) != 0;
+                if (fgets(line, sizeof(line), fp) != NULL)
+                        value = (geteuid() != 0) ?
+                                        (atoi(line) != 0) :
+                                        (atoi(line) == 2);
 
-                        fclose(fp);
-                }
+                fclose(fp);
         }
 
         return value;
 }
 
+int symbol__annotation_init(void)
+{
+        if (symbol_conf.initialized) {
+                pr_err("Annotation needs to be init before symbol__init()\n");
+                return -1;
+        }
+
+        if (symbol_conf.init_annotation) {
+                pr_warning("Annotation being initialized multiple times\n");
+                return 0;
+        }
+
+        symbol_conf.priv_size += sizeof(struct annotation);
+        symbol_conf.init_annotation = true;
+        return 0;
+}
+
 int symbol__init(struct perf_env *env)
 {
         const char *symfs;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index b10d558a8803..d964844eb314 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -57,7 +57,7 @@ struct symbol {
         u64             end;
         u16             namelen;
         u8              binding;
-        bool            ignore;
+        u8              idle:1;
         u8              arch_sym;
         char            name[0];
 };
@@ -88,6 +88,7 @@ struct symbol_conf {
         unsigned short  priv_size;
         unsigned short  nr_events;
         bool            try_vmlinux_path,
+                        init_annotation,
                         force,
                         ignore_vmlinux,
                         ignore_vmlinux_buildid,
@@ -240,16 +241,13 @@ int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
 bool symsrc__has_symtab(struct symsrc *ss);
 bool symsrc__possibly_runtime(struct symsrc *ss);
 
-int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter);
+int dso__load(struct dso *dso, struct map *map);
 int dso__load_vmlinux(struct dso *dso, struct map *map,
-                      const char *vmlinux, bool vmlinux_allocated,
-                      symbol_filter_t filter);
-int dso__load_vmlinux_path(struct dso *dso, struct map *map,
-                           symbol_filter_t filter);
+                      const char *vmlinux, bool vmlinux_allocated);
+int dso__load_vmlinux_path(struct dso *dso, struct map *map);
 int __dso__load_kallsyms(struct dso *dso, const char *filename, struct map *map,
-                         bool no_kcore, symbol_filter_t filter);
-int dso__load_kallsyms(struct dso *dso, const char *filename, struct map *map,
-                       symbol_filter_t filter);
+                         bool no_kcore);
+int dso__load_kallsyms(struct dso *dso, const char *filename, struct map *map);
 
 void dso__insert_symbol(struct dso *dso, enum map_type type,
                         struct symbol *sym);
@@ -261,6 +259,7 @@ struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
 struct symbol *symbol__next_by_name(struct symbol *sym);
 
 struct symbol *dso__first_symbol(struct dso *dso, enum map_type type);
+struct symbol *dso__last_symbol(struct dso *dso, enum map_type type);
 struct symbol *dso__next_symbol(struct symbol *sym);
 
 enum dso_type dso__type_fd(int fd);
@@ -277,6 +276,8 @@ struct perf_env;
 int symbol__init(struct perf_env *env);
 void symbol__exit(void);
 void symbol__elf_init(void);
+int symbol__annotation_init(void);
+
 struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name);
 size_t __symbol__fprintf_symname_offs(const struct symbol *sym,
                                       const struct addr_location *al,
@@ -291,16 +292,15 @@ size_t symbol__fprintf(struct symbol *sym, FILE *fp);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 bool symbol__restricted_filename(const char *filename,
                                  const char *restricted_filename);
-bool symbol__is_idle(struct symbol *sym);
 int symbol__config_symfs(const struct option *opt __maybe_unused,
                          const char *dir, int unset __maybe_unused);
 
 int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
-                  struct symsrc *runtime_ss, symbol_filter_t filter,
-                  int kmodule);
+                  struct symsrc *runtime_ss, int kmodule);
 int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss,
-                                struct map *map, symbol_filter_t filter);
+                                struct map *map);
 
+void __symbols__insert(struct rb_root *symbols, struct symbol *sym, bool kernel);
 void symbols__insert(struct rb_root *symbols, struct symbol *sym);
 void symbols__fixup_duplicate(struct rb_root *symbols);
 void symbols__fixup_end(struct rb_root *symbols);
@@ -342,4 +342,26 @@ void arch__sym_update(struct symbol *s, GElf_Sym *sym);
 
 int arch__choose_best_symbol(struct symbol *syma, struct symbol *symb);
 
+/* structure containing an SDT note's info */
+struct sdt_note {
+        char *name;                     /* name of the note*/
+        char *provider;                 /* provider name */
+        bool bit32;                     /* whether the location is 32 bits? */
+        union {                         /* location, base and semaphore addrs */
+                Elf64_Addr a64[3];
+                Elf32_Addr a32[3];
+        } addr;
+        struct list_head note_list;     /* SDT notes' list */
+};
+
+int get_sdt_note_list(struct list_head *head, const char *target);
+int cleanup_sdt_note_list(struct list_head *sdt_notes);
+int sdt_notes__get_count(struct list_head *start);
+
+#define SDT_BASE_SCN ".stapsdt.base"
+#define SDT_NOTE_SCN  ".note.stapsdt"
+#define SDT_NOTE_TYPE 3
+#define SDT_NOTE_NAME "stapsdt"
+#define NR_ADDR 3
+
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
index a53603b27e52..21c4d9b23c24 100644
--- a/tools/perf/util/target.c
+++ b/tools/perf/util/target.c
@@ -7,6 +7,7 @@
  */
 
 #include "target.h"
+#include "util.h"
 #include "debug.h"
 
 #include <pwd.h>
@@ -121,11 +122,7 @@ int target__strerror(struct target *target, int errnum,
         BUG_ON(buflen == 0);
 
         if (errnum >= 0) {
-                const char *err = strerror_r(errnum, buf, buflen);
-
-                if (err != buf)
-                        scnprintf(buf, buflen, "%s", err);
-
+                str_error_r(errnum, buf, buflen);
                 return 0;
         }
 
diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index 825086aa9a08..d3301529f6a7 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -616,3 +616,10 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
 
         return err;
 }
+
+size_t thread_stack__depth(struct thread *thread)
+{
+        if (!thread->ts)
+                return 0;
+        return thread->ts->cnt;
+}
diff --git a/tools/perf/util/thread-stack.h b/tools/perf/util/thread-stack.h
index ad44c7944b8e..b7e41c4ebfdd 100644
--- a/tools/perf/util/thread-stack.h
+++ b/tools/perf/util/thread-stack.h
@@ -87,6 +87,7 @@ void thread_stack__sample(struct thread *thread, struct ip_callchain *chain,
                           size_t sz, u64 ip);
 int thread_stack__flush(struct thread *thread);
 void thread_stack__free(struct thread *thread);
+size_t thread_stack__depth(struct thread *thread);
 
 struct call_return_processor *
 call_return_processor__new(int (*process)(struct call_return *cr, void *data),
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 45fcb715a36b..f5af87f66663 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -14,13 +14,12 @@
 
 int thread__init_map_groups(struct thread *thread, struct machine *machine)
 {
-        struct thread *leader;
         pid_t pid = thread->pid_;
 
         if (pid == thread->tid || pid == -1) {
                 thread->mg = map_groups__new(machine);
         } else {
-                leader = __machine__findnew_thread(machine, pid, pid);
+                struct thread *leader = __machine__findnew_thread(machine, pid, pid);
                 if (leader) {
                         thread->mg = map_groups__get(leader->mg);
                         thread__put(leader);
@@ -43,9 +42,6 @@ struct thread *thread__new(pid_t pid, pid_t tid)
                 thread->cpu = -1;
                 INIT_LIST_HEAD(&thread->comm_list);
 
-                if (unwind__prepare_access(thread) < 0)
-                        goto err_thread;
-
                 comm_str = malloc(32);
                 if (!comm_str)
                         goto err_thread;
@@ -133,11 +129,10 @@ int __thread__set_comm(struct thread *thread, const char *str, u64 timestamp,
                        bool exec)
 {
         struct comm *new, *curr = thread__comm(thread);
-        int err;
 
         /* Override the default :tid entry */
         if (!thread->comm_set) {
-                err = comm__override(curr, str, timestamp, exec);
+                int err = comm__override(curr, str, timestamp, exec);
                 if (err)
                         return err;
         } else {
@@ -201,10 +196,51 @@ size_t thread__fprintf(struct thread *thread, FILE *fp)
                map_groups__fprintf(thread->mg, fp);
 }
 
-void thread__insert_map(struct thread *thread, struct map *map)
+int thread__insert_map(struct thread *thread, struct map *map)
 {
+        int ret;
+
+        ret = unwind__prepare_access(thread, map, NULL);
+        if (ret)
+                return ret;
+
         map_groups__fixup_overlappings(thread->mg, map, stderr);
         map_groups__insert(thread->mg, map);
+
+        return 0;
+}
+
+static int __thread__prepare_access(struct thread *thread)
+{
+        bool initialized = false;
+        int i, err = 0;
+
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                struct maps *maps = &thread->mg->maps[i];
+                struct map *map;
+
+                pthread_rwlock_rdlock(&maps->lock);
+
+                for (map = maps__first(maps); map; map = map__next(map)) {
+                        err = unwind__prepare_access(thread, map, &initialized);
+                        if (err || initialized)
+                                break;
+                }
+
+                pthread_rwlock_unlock(&maps->lock);
+        }
+
+        return err;
+}
+
+static int thread__prepare_access(struct thread *thread)
+{
+        int err = 0;
+
+        if (symbol_conf.use_callchain)
+                err = __thread__prepare_access(thread);
+
+        return err;
 }
 
 static int thread__clone_map_groups(struct thread *thread,
@@ -214,7 +250,7 @@ static int thread__clone_map_groups(struct thread *thread,
 
         /* This is new thread, we share map groups for process. */
         if (thread->pid_ == parent->pid_)
-                return 0;
+                return thread__prepare_access(thread);
 
         if (thread->mg == parent->mg) {
                 pr_debug("broken map groups on thread %d/%d parent %d/%d\n",
@@ -224,7 +260,7 @@ static int thread__clone_map_groups(struct thread *thread,
 
         /* But this one is new process, copy maps. */
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                if (map_groups__clone(thread->mg, parent->mg, i) < 0)
+                if (map_groups__clone(thread, parent->mg, i) < 0)
                         return -ENOMEM;
 
         return 0;
@@ -232,10 +268,9 @@ static int thread__clone_map_groups(struct thread *thread,
 
 int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp)
 {
-        int err;
-
         if (parent->comm_set) {
                 const char *comm = thread__comm_str(parent);
+                int err;
                 if (!comm)
                         return -ENOMEM;
                 err = thread__set_comm(thread, comm, timestamp);
@@ -265,3 +300,14 @@ void thread__find_cpumode_addr_location(struct thread *thread,
                         break;
         }
 }
+
+struct thread *thread__main_thread(struct machine *machine, struct thread *thread)
+{
+        if (thread->pid_ == thread->tid)
+                return thread__get(thread);
+
+        if (thread->pid_ == -1)
+                return NULL;
+
+        return machine__find_thread(machine, thread->pid_, thread->pid_);
+}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 45fba13c800b..99263cb6e6b6 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -9,11 +9,9 @@
 #include "symbol.h"
 #include <strlist.h>
 #include <intlist.h>
-#ifdef HAVE_LIBUNWIND_SUPPORT
-#include <libunwind.h>
-#endif
 
 struct thread_stack;
+struct unwind_libunwind_ops;
 
 struct thread {
         union {
@@ -36,7 +34,8 @@ struct thread {
         void                    *priv;
         struct thread_stack     *ts;
 #ifdef HAVE_LIBUNWIND_SUPPORT
-        unw_addr_space_t        addr_space;
+        void                            *addr_space;
+        struct unwind_libunwind_ops     *unwind_libunwind_ops;
 #endif
 };
 
@@ -77,10 +76,12 @@ int thread__comm_len(struct thread *thread);
 struct comm *thread__comm(const struct thread *thread);
 struct comm *thread__exec_comm(const struct thread *thread);
 const char *thread__comm_str(const struct thread *thread);
-void thread__insert_map(struct thread *thread, struct map *map);
+int thread__insert_map(struct thread *thread, struct map *map);
 int thread__fork(struct thread *thread, struct thread *parent, u64 timestamp);
 size_t thread__fprintf(struct thread *thread, FILE *fp);
 
+struct thread *thread__main_thread(struct machine *machine, struct thread *thread);
+
 void thread__find_addr_map(struct thread *thread,
                            u8 cpumode, enum map_type type, u64 addr,
                            struct addr_location *al);
diff --git a/tools/perf/util/thread_map.c b/tools/perf/util/thread_map.c
index 5654fe15e036..40585f5b7027 100644
--- a/tools/perf/util/thread_map.c
+++ b/tools/perf/util/thread_map.c
@@ -202,7 +202,7 @@ static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
         if (!slist)
                 return NULL;
 
-        strlist__for_each(pos, slist) {
+        strlist__for_each_entry(pos, slist) {
                 pid = strtol(pos->s, &end_ptr, 10);
 
                 if (pid == INT_MIN || pid == INT_MAX ||
@@ -278,7 +278,7 @@ struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
         if (!slist)
                 return NULL;
 
-        strlist__for_each(pos, slist) {
+        strlist__for_each_entry(pos, slist) {
                 tid = strtol(pos->s, &end_ptr, 10);
 
                 if (tid == INT_MIN || tid == INT_MAX ||
diff --git a/tools/perf/util/trace-event.c b/tools/perf/util/trace-event.c
index 8ae051e0ec79..c330780674fc 100644
--- a/tools/perf/util/trace-event.c
+++ b/tools/perf/util/trace-event.c
@@ -105,3 +105,11 @@ trace_event__tp_format(const char *sys, const char *name)
 
         return tp_format(sys, name);
 }
+
+struct event_format *trace_event__tp_format_id(int id)
+{
+        if (!tevent_initialized && trace_event__init2())
+                return ERR_PTR(-ENOMEM);
+
+        return pevent_find_event(tevent.pevent, id);
+}
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index bce5b1dac268..b0af9c81bb0d 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -23,6 +23,8 @@ int trace_event__register_resolver(struct machine *machine,
 struct event_format*
 trace_event__tp_format(const char *sys, const char *name);
 
+struct event_format *trace_event__tp_format_id(int id);
+
 int bigendian(void);
 
 void event_format__fprintf(struct event_format *event,
diff --git a/tools/perf/util/unwind-libdw.c b/tools/perf/util/unwind-libdw.c
index cf5e250bc78e..783a53fb7a4e 100644
--- a/tools/perf/util/unwind-libdw.c
+++ b/tools/perf/util/unwind-libdw.c
@@ -66,7 +66,7 @@ static int entry(u64 ip, struct unwind_info *ui)
         if (__report_module(&al, ip, ui))
                 return -1;
 
-        e->ip  = ip;
+        e->ip  = al.addr;
         e->map = al.map;
         e->sym = al.sym;
 
diff --git a/tools/perf/util/unwind-libunwind-local.c b/tools/perf/util/unwind-libunwind-local.c
new file mode 100644
index 000000000000..20c2e5743903
--- /dev/null
+++ b/tools/perf/util/unwind-libunwind-local.c
@@ -0,0 +1,699 @@
+/*
+ * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps.
+ *
+ * Lots of this code have been borrowed or heavily inspired from parts of
+ * the libunwind 0.99 code which are (amongst other contributors I may have
+ * forgotten):
+ *
+ * Copyright (C) 2002-2007 Hewlett-Packard Co
+ *      Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
+ *
+ * And the bugs have been added by:
+ *
+ * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com>
+ * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com>
+ *
+ */
+
+#include <elf.h>
+#include <gelf.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <linux/list.h>
+#ifndef REMOTE_UNWIND_LIBUNWIND
+#include <libunwind.h>
+#include <libunwind-ptrace.h>
+#endif
+#include "callchain.h"
+#include "thread.h"
+#include "session.h"
+#include "perf_regs.h"
+#include "unwind.h"
+#include "symbol.h"
+#include "util.h"
+#include "debug.h"
+#include "asm/bug.h"
+
+extern int
+UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
+                                    unw_word_t ip,
+                                    unw_dyn_info_t *di,
+                                    unw_proc_info_t *pi,
+                                    int need_unwind_info, void *arg);
+
+#define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
+
+extern int
+UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug,
+                                 unw_word_t ip,
+                                 unw_word_t segbase,
+                                 const char *obj_name, unw_word_t start,
+                                 unw_word_t end);
+
+#define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame)
+
+#define DW_EH_PE_FORMAT_MASK    0x0f    /* format of the encoded value */
+#define DW_EH_PE_APPL_MASK      0x70    /* how the value is to be applied */
+
+/* Pointer-encoding formats: */
+#define DW_EH_PE_omit           0xff
+#define DW_EH_PE_ptr            0x00    /* pointer-sized unsigned value */
+#define DW_EH_PE_udata4         0x03    /* unsigned 32-bit value */
+#define DW_EH_PE_udata8         0x04    /* unsigned 64-bit value */
+#define DW_EH_PE_sdata4         0x0b    /* signed 32-bit value */
+#define DW_EH_PE_sdata8         0x0c    /* signed 64-bit value */
+
+/* Pointer-encoding application: */
+#define DW_EH_PE_absptr         0x00    /* absolute value */
+#define DW_EH_PE_pcrel          0x10    /* rel. to addr. of encoded value */
+
+/*
+ * The following are not documented by LSB v1.3, yet they are used by
+ * GCC, presumably they aren't documented by LSB since they aren't
+ * used on Linux:
+ */
+#define DW_EH_PE_funcrel        0x40    /* start-of-procedure-relative */
+#define DW_EH_PE_aligned        0x50    /* aligned pointer */
+
+/* Flags intentionaly not handled, since they're not needed:
+ * #define DW_EH_PE_indirect      0x80
+ * #define DW_EH_PE_uleb128       0x01
+ * #define DW_EH_PE_udata2        0x02
+ * #define DW_EH_PE_sleb128       0x09
+ * #define DW_EH_PE_sdata2        0x0a
+ * #define DW_EH_PE_textrel       0x20
+ * #define DW_EH_PE_datarel       0x30
+ */
+
+struct unwind_info {
+        struct perf_sample      *sample;
+        struct machine          *machine;
+        struct thread           *thread;
+};
+
+#define dw_read(ptr, type, end) ({      \
+        type *__p = (type *) ptr;       \
+        type  __v;                      \
+        if ((__p + 1) > (type *) end)   \
+                return -EINVAL;         \
+        __v = *__p++;                   \
+        ptr = (typeof(ptr)) __p;        \
+        __v;                            \
+        })
+
+static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val,
+                                   u8 encoding)
+{
+        u8 *cur = *p;
+        *val = 0;
+
+        switch (encoding) {
+        case DW_EH_PE_omit:
+                *val = 0;
+                goto out;
+        case DW_EH_PE_ptr:
+                *val = dw_read(cur, unsigned long, end);
+                goto out;
+        default:
+                break;
+        }
+
+        switch (encoding & DW_EH_PE_APPL_MASK) {
+        case DW_EH_PE_absptr:
+                break;
+        case DW_EH_PE_pcrel:
+                *val = (unsigned long) cur;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if ((encoding & 0x07) == 0x00)
+                encoding |= DW_EH_PE_udata4;
+
+        switch (encoding & DW_EH_PE_FORMAT_MASK) {
+        case DW_EH_PE_sdata4:
+                *val += dw_read(cur, s32, end);
+                break;
+        case DW_EH_PE_udata4:
+                *val += dw_read(cur, u32, end);
+                break;
+        case DW_EH_PE_sdata8:
+                *val += dw_read(cur, s64, end);
+                break;
+        case DW_EH_PE_udata8:
+                *val += dw_read(cur, u64, end);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+ out:
+        *p = cur;
+        return 0;
+}
+
+#define dw_read_encoded_value(ptr, end, enc) ({                 \
+        u64 __v;                                                \
+        if (__dw_read_encoded_value(&ptr, end, &__v, enc)) {    \
+                return -EINVAL;                                 \
+        }                                                       \
+        __v;                                                    \
+        })
+
+static u64 elf_section_offset(int fd, const char *name)
+{
+        Elf *elf;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        u64 offset = 0;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                return 0;
+
+        do {
+                if (gelf_getehdr(elf, &ehdr) == NULL)
+                        break;
+
+                if (!elf_section_by_name(elf, &ehdr, &shdr, name, NULL))
+                        break;
+
+                offset = shdr.sh_offset;
+        } while (0);
+
+        elf_end(elf);
+        return offset;
+}
+
+#ifndef NO_LIBUNWIND_DEBUG_FRAME
+static int elf_is_exec(int fd, const char *name)
+{
+        Elf *elf;
+        GElf_Ehdr ehdr;
+        int retval = 0;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                return 0;
+        if (gelf_getehdr(elf, &ehdr) == NULL)
+                goto out;
+
+        retval = (ehdr.e_type == ET_EXEC);
+
+out:
+        elf_end(elf);
+        pr_debug("unwind: elf_is_exec(%s): %d\n", name, retval);
+        return retval;
+}
+#endif
+
+struct table_entry {
+        u32 start_ip_offset;
+        u32 fde_offset;
+};
+
+struct eh_frame_hdr {
+        unsigned char version;
+        unsigned char eh_frame_ptr_enc;
+        unsigned char fde_count_enc;
+        unsigned char table_enc;
+
+        /*
+         * The rest of the header is variable-length and consists of the
+         * following members:
+         *
+         *      encoded_t eh_frame_ptr;
+         *      encoded_t fde_count;
+         */
+
+        /* A single encoded pointer should not be more than 8 bytes. */
+        u64 enc[2];
+
+        /*
+         * struct {
+         *    encoded_t start_ip;
+         *    encoded_t fde_addr;
+         * } binary_search_table[fde_count];
+         */
+        char data[0];
+} __packed;
+
+static int unwind_spec_ehframe(struct dso *dso, struct machine *machine,
+                               u64 offset, u64 *table_data, u64 *segbase,
+                               u64 *fde_count)
+{
+        struct eh_frame_hdr hdr;
+        u8 *enc = (u8 *) &hdr.enc;
+        u8 *end = (u8 *) &hdr.data;
+        ssize_t r;
+
+        r = dso__data_read_offset(dso, machine, offset,
+                                  (u8 *) &hdr, sizeof(hdr));
+        if (r != sizeof(hdr))
+                return -EINVAL;
+
+        /* We dont need eh_frame_ptr, just skip it. */
+        dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc);
+
+        *fde_count  = dw_read_encoded_value(enc, end, hdr.fde_count_enc);
+        *segbase    = offset;
+        *table_data = (enc - (u8 *) &hdr) + offset;
+        return 0;
+}
+
+static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
+                                     u64 *table_data, u64 *segbase,
+                                     u64 *fde_count)
+{
+        int ret = -EINVAL, fd;
+        u64 offset = dso->data.eh_frame_hdr_offset;
+
+        if (offset == 0) {
+                fd = dso__data_get_fd(dso, machine);
+                if (fd < 0)
+                        return -EINVAL;
+
+                /* Check the .eh_frame section for unwinding info */
+                offset = elf_section_offset(fd, ".eh_frame_hdr");
+                dso->data.eh_frame_hdr_offset = offset;
+                dso__data_put_fd(dso);
+        }
+
+        if (offset)
+                ret = unwind_spec_ehframe(dso, machine, offset,
+                                          table_data, segbase,
+                                          fde_count);
+
+        return ret;
+}
+
+#ifndef NO_LIBUNWIND_DEBUG_FRAME
+static int read_unwind_spec_debug_frame(struct dso *dso,
+                                        struct machine *machine, u64 *offset)
+{
+        int fd;
+        u64 ofs = dso->data.debug_frame_offset;
+
+        if (ofs == 0) {
+                fd = dso__data_get_fd(dso, machine);
+                if (fd < 0)
+                        return -EINVAL;
+
+                /* Check the .debug_frame section for unwinding info */
+                ofs = elf_section_offset(fd, ".debug_frame");
+                dso->data.debug_frame_offset = ofs;
+                dso__data_put_fd(dso);
+        }
+
+        *offset = ofs;
+        if (*offset)
+                return 0;
+
+        return -EINVAL;
+}
+#endif
+
+static struct map *find_map(unw_word_t ip, struct unwind_info *ui)
+{
+        struct addr_location al;
+
+        thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
+                              MAP__FUNCTION, ip, &al);
+        if (!al.map) {
+                /*
+                 * We've seen cases (softice) where DWARF unwinder went
+                 * through non executable mmaps, which we need to lookup
+                 * in MAP__VARIABLE tree.
+                 */
+                thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
+                                      MAP__VARIABLE, ip, &al);
+        }
+        return al.map;
+}
+
+static int
+find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
+               int need_unwind_info, void *arg)
+{
+        struct unwind_info *ui = arg;
+        struct map *map;
+        unw_dyn_info_t di;
+        u64 table_data, segbase, fde_count;
+        int ret = -EINVAL;
+
+        map = find_map(ip, ui);
+        if (!map || !map->dso)
+                return -EINVAL;
+
+        pr_debug("unwind: find_proc_info dso %s\n", map->dso->name);
+
+        /* Check the .eh_frame section for unwinding info */
+        if (!read_unwind_spec_eh_frame(map->dso, ui->machine,
+                                       &table_data, &segbase, &fde_count)) {
+                memset(&di, 0, sizeof(di));
+                di.format   = UNW_INFO_FORMAT_REMOTE_TABLE;
+                di.start_ip = map->start;
+                di.end_ip   = map->end;
+                di.u.rti.segbase    = map->start + segbase;
+                di.u.rti.table_data = map->start + table_data;
+                di.u.rti.table_len  = fde_count * sizeof(struct table_entry)
+                                      / sizeof(unw_word_t);
+                ret = dwarf_search_unwind_table(as, ip, &di, pi,
+                                                need_unwind_info, arg);
+        }
+
+#ifndef NO_LIBUNWIND_DEBUG_FRAME
+        /* Check the .debug_frame section for unwinding info */
+        if (ret < 0 &&
+            !read_unwind_spec_debug_frame(map->dso, ui->machine, &segbase)) {
+                int fd = dso__data_get_fd(map->dso, ui->machine);
+                int is_exec = elf_is_exec(fd, map->dso->name);
+                unw_word_t base = is_exec ? 0 : map->start;
+                const char *symfile;
+
+                if (fd >= 0)
+                        dso__data_put_fd(map->dso);
+
+                symfile = map->dso->symsrc_filename ?: map->dso->name;
+
+                memset(&di, 0, sizeof(di));
+                if (dwarf_find_debug_frame(0, &di, ip, base, symfile,
+                                           map->start, map->end))
+                        return dwarf_search_unwind_table(as, ip, &di, pi,
+                                                         need_unwind_info, arg);
+        }
+#endif
+
+        return ret;
+}
+
+static int access_fpreg(unw_addr_space_t __maybe_unused as,
+                        unw_regnum_t __maybe_unused num,
+                        unw_fpreg_t __maybe_unused *val,
+                        int __maybe_unused __write,
+                        void __maybe_unused *arg)
+{
+        pr_err("unwind: access_fpreg unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as,
+                                  unw_word_t __maybe_unused *dil_addr,
+                                  void __maybe_unused *arg)
+{
+        return -UNW_ENOINFO;
+}
+
+static int resume(unw_addr_space_t __maybe_unused as,
+                  unw_cursor_t __maybe_unused *cu,
+                  void __maybe_unused *arg)
+{
+        pr_err("unwind: resume unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int
+get_proc_name(unw_addr_space_t __maybe_unused as,
+              unw_word_t __maybe_unused addr,
+                char __maybe_unused *bufp, size_t __maybe_unused buf_len,
+                unw_word_t __maybe_unused *offp, void __maybe_unused *arg)
+{
+        pr_err("unwind: get_proc_name unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int access_dso_mem(struct unwind_info *ui, unw_word_t addr,
+                          unw_word_t *data)
+{
+        struct map *map;
+        ssize_t size;
+
+        map = find_map(addr, ui);
+        if (!map) {
+                pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
+                return -1;
+        }
+
+        if (!map->dso)
+                return -1;
+
+        size = dso__data_read_addr(map->dso, map, ui->machine,
+                                   addr, (u8 *) data, sizeof(*data));
+
+        return !(size == sizeof(*data));
+}
+
+static int access_mem(unw_addr_space_t __maybe_unused as,
+                      unw_word_t addr, unw_word_t *valp,
+                      int __write, void *arg)
+{
+        struct unwind_info *ui = arg;
+        struct stack_dump *stack = &ui->sample->user_stack;
+        u64 start, end;
+        int offset;
+        int ret;
+
+        /* Don't support write, probably not needed. */
+        if (__write || !stack || !ui->sample->user_regs.regs) {
+                *valp = 0;
+                return 0;
+        }
+
+        ret = perf_reg_value(&start, &ui->sample->user_regs,
+                             LIBUNWIND__ARCH_REG_SP);
+        if (ret)
+                return ret;
+
+        end = start + stack->size;
+
+        /* Check overflow. */
+        if (addr + sizeof(unw_word_t) < addr)
+                return -EINVAL;
+
+        if (addr < start || addr + sizeof(unw_word_t) >= end) {
+                ret = access_dso_mem(ui, addr, valp);
+                if (ret) {
+                        pr_debug("unwind: access_mem %p not inside range"
+                                 " 0x%" PRIx64 "-0x%" PRIx64 "\n",
+                                 (void *) (uintptr_t) addr, start, end);
+                        *valp = 0;
+                        return ret;
+                }
+                return 0;
+        }
+
+        offset = addr - start;
+        *valp  = *(unw_word_t *)&stack->data[offset];
+        pr_debug("unwind: access_mem addr %p val %lx, offset %d\n",
+                 (void *) (uintptr_t) addr, (unsigned long)*valp, offset);
+        return 0;
+}
+
+static int access_reg(unw_addr_space_t __maybe_unused as,
+                      unw_regnum_t regnum, unw_word_t *valp,
+                      int __write, void *arg)
+{
+        struct unwind_info *ui = arg;
+        int id, ret;
+        u64 val;
+
+        /* Don't support write, I suspect we don't need it. */
+        if (__write) {
+                pr_err("unwind: access_reg w %d\n", regnum);
+                return 0;
+        }
+
+        if (!ui->sample->user_regs.regs) {
+                *valp = 0;
+                return 0;
+        }
+
+        id = LIBUNWIND__ARCH_REG_ID(regnum);
+        if (id < 0)
+                return -EINVAL;
+
+        ret = perf_reg_value(&val, &ui->sample->user_regs, id);
+        if (ret) {
+                pr_err("unwind: can't read reg %d\n", regnum);
+                return ret;
+        }
+
+        *valp = (unw_word_t) val;
+        pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp);
+        return 0;
+}
+
+static void put_unwind_info(unw_addr_space_t __maybe_unused as,
+                            unw_proc_info_t *pi __maybe_unused,
+                            void *arg __maybe_unused)
+{
+        pr_debug("unwind: put_unwind_info called\n");
+}
+
+static int entry(u64 ip, struct thread *thread,
+                 unwind_entry_cb_t cb, void *arg)
+{
+        struct unwind_entry e;
+        struct addr_location al;
+
+        thread__find_addr_location(thread, PERF_RECORD_MISC_USER,
+                                   MAP__FUNCTION, ip, &al);
+
+        e.ip = al.addr;
+        e.map = al.map;
+        e.sym = al.sym;
+
+        pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
+                 al.sym ? al.sym->name : "''",
+                 ip,
+                 al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
+
+        return cb(&e, arg);
+}
+
+static void display_error(int err)
+{
+        switch (err) {
+        case UNW_EINVAL:
+                pr_err("unwind: Only supports local.\n");
+                break;
+        case UNW_EUNSPEC:
+                pr_err("unwind: Unspecified error.\n");
+                break;
+        case UNW_EBADREG:
+                pr_err("unwind: Register unavailable.\n");
+                break;
+        default:
+                break;
+        }
+}
+
+static unw_accessors_t accessors = {
+        .find_proc_info         = find_proc_info,
+        .put_unwind_info        = put_unwind_info,
+        .get_dyn_info_list_addr = get_dyn_info_list_addr,
+        .access_mem             = access_mem,
+        .access_reg             = access_reg,
+        .access_fpreg           = access_fpreg,
+        .resume                 = resume,
+        .get_proc_name          = get_proc_name,
+};
+
+static int _unwind__prepare_access(struct thread *thread)
+{
+        if (callchain_param.record_mode != CALLCHAIN_DWARF)
+                return 0;
+
+        thread->addr_space = unw_create_addr_space(&accessors, 0);
+        if (!thread->addr_space) {
+                pr_err("unwind: Can't create unwind address space.\n");
+                return -ENOMEM;
+        }
+
+        unw_set_caching_policy(thread->addr_space, UNW_CACHE_GLOBAL);
+        return 0;
+}
+
+static void _unwind__flush_access(struct thread *thread)
+{
+        if (callchain_param.record_mode != CALLCHAIN_DWARF)
+                return;
+
+        unw_flush_cache(thread->addr_space, 0, 0);
+}
+
+static void _unwind__finish_access(struct thread *thread)
+{
+        if (callchain_param.record_mode != CALLCHAIN_DWARF)
+                return;
+
+        unw_destroy_addr_space(thread->addr_space);
+}
+
+static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
+                       void *arg, int max_stack)
+{
+        u64 val;
+        unw_word_t ips[max_stack];
+        unw_addr_space_t addr_space;
+        unw_cursor_t c;
+        int ret, i = 0;
+
+        ret = perf_reg_value(&val, &ui->sample->user_regs,
+                             LIBUNWIND__ARCH_REG_IP);
+        if (ret)
+                return ret;
+
+        ips[i++] = (unw_word_t) val;
+
+        /*
+         * If we need more than one entry, do the DWARF
+         * unwind itself.
+         */
+        if (max_stack - 1 > 0) {
+                WARN_ONCE(!ui->thread, "WARNING: ui->thread is NULL");
+                addr_space = ui->thread->addr_space;
+
+                if (addr_space == NULL)
+                        return -1;
+
+                ret = unw_init_remote(&c, addr_space, ui);
+                if (ret)
+                        display_error(ret);
+
+                while (!ret && (unw_step(&c) > 0) && i < max_stack) {
+                        unw_get_reg(&c, UNW_REG_IP, &ips[i]);
+                        ++i;
+                }
+
+                max_stack = i;
+        }
+
+        /*
+         * Display what we got based on the order setup.
+         */
+        for (i = 0; i < max_stack && !ret; i++) {
+                int j = i;
+
+                if (callchain_param.order == ORDER_CALLER)
+                        j = max_stack - i - 1;
+                ret = ips[j] ? entry(ips[j], ui->thread, cb, arg) : 0;
+        }
+
+        return ret;
+}
+
+static int _unwind__get_entries(unwind_entry_cb_t cb, void *arg,
+                        struct thread *thread,
+                        struct perf_sample *data, int max_stack)
+{
+        struct unwind_info ui = {
+                .sample       = data,
+                .thread       = thread,
+                .machine      = thread->mg->machine,
+        };
+
+        if (!data->user_regs.regs)
+                return -EINVAL;
+
+        if (max_stack <= 0)
+                return -EINVAL;
+
+        return get_entries(&ui, cb, arg, max_stack);
+}
+
+static struct unwind_libunwind_ops
+_unwind_libunwind_ops = {
+        .prepare_access = _unwind__prepare_access,
+        .flush_access   = _unwind__flush_access,
+        .finish_access  = _unwind__finish_access,
+        .get_entries    = _unwind__get_entries,
+};
+
+#ifndef REMOTE_UNWIND_LIBUNWIND
+struct unwind_libunwind_ops *
+local_unwind_libunwind_ops = &_unwind_libunwind_ops;
+#endif
diff --git a/tools/perf/util/unwind-libunwind.c b/tools/perf/util/unwind-libunwind.c
index 63687d3a344e..6d542a4e0648 100644
--- a/tools/perf/util/unwind-libunwind.c
+++ b/tools/perf/util/unwind-libunwind.c
@@ -1,682 +1,83 @@
-/*
- * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps.
- *
- * Lots of this code have been borrowed or heavily inspired from parts of
- * the libunwind 0.99 code which are (amongst other contributors I may have
- * forgotten):
- *
- * Copyright (C) 2002-2007 Hewlett-Packard Co
- *      Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
- *
- * And the bugs have been added by:
- *
- * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com>
- * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com>
- *
- */
-
-#include <elf.h>
-#include <gelf.h>
-#include <fcntl.h>
-#include <string.h>
-#include <unistd.h>
-#include <sys/mman.h>
-#include <linux/list.h>
-#include <libunwind.h>
-#include <libunwind-ptrace.h>
-#include "callchain.h"
+#include "unwind.h"
 #include "thread.h"
 #include "session.h"
-#include "perf_regs.h"
-#include "unwind.h"
-#include "symbol.h"
-#include "util.h"
 #include "debug.h"
-#include "asm/bug.h"
-
-extern int
-UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
-                                    unw_word_t ip,
-                                    unw_dyn_info_t *di,
-                                    unw_proc_info_t *pi,
-                                    int need_unwind_info, void *arg);
-
-#define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
-
-extern int
-UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug,
-                                 unw_word_t ip,
-                                 unw_word_t segbase,
-                                 const char *obj_name, unw_word_t start,
-                                 unw_word_t end);
-
-#define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame)
-
-#define DW_EH_PE_FORMAT_MASK    0x0f    /* format of the encoded value */
-#define DW_EH_PE_APPL_MASK      0x70    /* how the value is to be applied */
-
-/* Pointer-encoding formats: */
-#define DW_EH_PE_omit           0xff
-#define DW_EH_PE_ptr            0x00    /* pointer-sized unsigned value */
-#define DW_EH_PE_udata4         0x03    /* unsigned 32-bit value */
-#define DW_EH_PE_udata8         0x04    /* unsigned 64-bit value */
-#define DW_EH_PE_sdata4         0x0b    /* signed 32-bit value */
-#define DW_EH_PE_sdata8         0x0c    /* signed 64-bit value */
-
-/* Pointer-encoding application: */
-#define DW_EH_PE_absptr         0x00    /* absolute value */
-#define DW_EH_PE_pcrel          0x10    /* rel. to addr. of encoded value */
-
-/*
- * The following are not documented by LSB v1.3, yet they are used by
- * GCC, presumably they aren't documented by LSB since they aren't
- * used on Linux:
- */
-#define DW_EH_PE_funcrel        0x40    /* start-of-procedure-relative */
-#define DW_EH_PE_aligned        0x50    /* aligned pointer */
+#include "arch/common.h"
 
-/* Flags intentionaly not handled, since they're not needed:
- * #define DW_EH_PE_indirect      0x80
- * #define DW_EH_PE_uleb128       0x01
- * #define DW_EH_PE_udata2        0x02
- * #define DW_EH_PE_sleb128       0x09
- * #define DW_EH_PE_sdata2        0x0a
- * #define DW_EH_PE_textrel       0x20
- * #define DW_EH_PE_datarel       0x30
- */
+struct unwind_libunwind_ops __weak *local_unwind_libunwind_ops;
+struct unwind_libunwind_ops __weak *x86_32_unwind_libunwind_ops;
+struct unwind_libunwind_ops __weak *arm64_unwind_libunwind_ops;
 
-struct unwind_info {
-        struct perf_sample      *sample;
-        struct machine          *machine;
-        struct thread           *thread;
-};
-
-#define dw_read(ptr, type, end) ({      \
-        type *__p = (type *) ptr;       \
-        type  __v;                      \
-        if ((__p + 1) > (type *) end)   \
-                return -EINVAL;         \
-        __v = *__p++;                   \
-        ptr = (typeof(ptr)) __p;        \
-        __v;                            \
-        })
-
-static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val,
-                                   u8 encoding)
+static void unwind__register_ops(struct thread *thread,
+                          struct unwind_libunwind_ops *ops)
 {
-        u8 *cur = *p;
-        *val = 0;
-
-        switch (encoding) {
-        case DW_EH_PE_omit:
-                *val = 0;
-                goto out;
-        case DW_EH_PE_ptr:
-                *val = dw_read(cur, unsigned long, end);
-                goto out;
-        default:
-                break;
-        }
-
-        switch (encoding & DW_EH_PE_APPL_MASK) {
-        case DW_EH_PE_absptr:
-                break;
-        case DW_EH_PE_pcrel:
-                *val = (unsigned long) cur;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if ((encoding & 0x07) == 0x00)
-                encoding |= DW_EH_PE_udata4;
-
-        switch (encoding & DW_EH_PE_FORMAT_MASK) {
-        case DW_EH_PE_sdata4:
-                *val += dw_read(cur, s32, end);
-                break;
-        case DW_EH_PE_udata4:
-                *val += dw_read(cur, u32, end);
-                break;
-        case DW_EH_PE_sdata8:
-                *val += dw_read(cur, s64, end);
-                break;
-        case DW_EH_PE_udata8:
-                *val += dw_read(cur, u64, end);
-                break;
-        default:
-                return -EINVAL;
-        }
-
- out:
-        *p = cur;
-        return 0;
-}
-
-#define dw_read_encoded_value(ptr, end, enc) ({                 \
-        u64 __v;                                                \
-        if (__dw_read_encoded_value(&ptr, end, &__v, enc)) {    \
-                return -EINVAL;                                 \
-        }                                                       \
-        __v;                                                    \
-        })
-
-static u64 elf_section_offset(int fd, const char *name)
-{
-        Elf *elf;
-        GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
-        u64 offset = 0;
-
-        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-        if (elf == NULL)
-                return 0;
-
-        do {
-                if (gelf_getehdr(elf, &ehdr) == NULL)
-                        break;
-
-                if (!elf_section_by_name(elf, &ehdr, &shdr, name, NULL))
-                        break;
-
-                offset = shdr.sh_offset;
-        } while (0);
-
-        elf_end(elf);
-        return offset;
+        thread->unwind_libunwind_ops = ops;
 }
 
-#ifndef NO_LIBUNWIND_DEBUG_FRAME
-static int elf_is_exec(int fd, const char *name)
+int unwind__prepare_access(struct thread *thread, struct map *map,
+                           bool *initialized)
 {
-        Elf *elf;
-        GElf_Ehdr ehdr;
-        int retval = 0;
+        const char *arch;
+        enum dso_type dso_type;
+        struct unwind_libunwind_ops *ops = local_unwind_libunwind_ops;
+        int err;
 
-        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-        if (elf == NULL)
+        if (thread->addr_space) {
+                pr_debug("unwind: thread map already set, dso=%s\n",
+                         map->dso->name);
+                if (initialized)
+                        *initialized = true;
                 return 0;
-        if (gelf_getehdr(elf, &ehdr) == NULL)
-                goto out;
-
-        retval = (ehdr.e_type == ET_EXEC);
-
-out:
-        elf_end(elf);
-        pr_debug("unwind: elf_is_exec(%s): %d\n", name, retval);
-        return retval;
-}
-#endif
-
-struct table_entry {
-        u32 start_ip_offset;
-        u32 fde_offset;
-};
-
-struct eh_frame_hdr {
-        unsigned char version;
-        unsigned char eh_frame_ptr_enc;
-        unsigned char fde_count_enc;
-        unsigned char table_enc;
-
-        /*
-         * The rest of the header is variable-length and consists of the
-         * following members:
-         *
-         *      encoded_t eh_frame_ptr;
-         *      encoded_t fde_count;
-         */
-
-        /* A single encoded pointer should not be more than 8 bytes. */
-        u64 enc[2];
-
-        /*
-         * struct {
-         *    encoded_t start_ip;
-         *    encoded_t fde_addr;
-         * } binary_search_table[fde_count];
-         */
-        char data[0];
-} __packed;
-
-static int unwind_spec_ehframe(struct dso *dso, struct machine *machine,
-                               u64 offset, u64 *table_data, u64 *segbase,
-                               u64 *fde_count)
-{
-        struct eh_frame_hdr hdr;
-        u8 *enc = (u8 *) &hdr.enc;
-        u8 *end = (u8 *) &hdr.data;
-        ssize_t r;
-
-        r = dso__data_read_offset(dso, machine, offset,
-                                  (u8 *) &hdr, sizeof(hdr));
-        if (r != sizeof(hdr))
-                return -EINVAL;
-
-        /* We dont need eh_frame_ptr, just skip it. */
-        dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc);
-
-        *fde_count  = dw_read_encoded_value(enc, end, hdr.fde_count_enc);
-        *segbase    = offset;
-        *table_data = (enc - (u8 *) &hdr) + offset;
-        return 0;
-}
-
-static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
-                                     u64 *table_data, u64 *segbase,
-                                     u64 *fde_count)
-{
-        int ret = -EINVAL, fd;
-        u64 offset = dso->data.eh_frame_hdr_offset;
-
-        if (offset == 0) {
-                fd = dso__data_get_fd(dso, machine);
-                if (fd < 0)
-                        return -EINVAL;
-
-                /* Check the .eh_frame section for unwinding info */
-                offset = elf_section_offset(fd, ".eh_frame_hdr");
-                dso->data.eh_frame_hdr_offset = offset;
-                dso__data_put_fd(dso);
         }
 
-        if (offset)
-                ret = unwind_spec_ehframe(dso, machine, offset,
-                                          table_data, segbase,
-                                          fde_count);
+        /* env->arch is NULL for live-mode (i.e. perf top) */
+        if (!thread->mg->machine->env || !thread->mg->machine->env->arch)
+                goto out_register;
 
-        return ret;
-}
-
-#ifndef NO_LIBUNWIND_DEBUG_FRAME
-static int read_unwind_spec_debug_frame(struct dso *dso,
-                                        struct machine *machine, u64 *offset)
-{
-        int fd;
-        u64 ofs = dso->data.debug_frame_offset;
-
-        if (ofs == 0) {
-                fd = dso__data_get_fd(dso, machine);
-                if (fd < 0)
-                        return -EINVAL;
-
-                /* Check the .debug_frame section for unwinding info */
-                ofs = elf_section_offset(fd, ".debug_frame");
-                dso->data.debug_frame_offset = ofs;
-                dso__data_put_fd(dso);
-        }
-
-        *offset = ofs;
-        if (*offset)
+        dso_type = dso__type(map->dso, thread->mg->machine);
+        if (dso_type == DSO__TYPE_UNKNOWN)
                 return 0;
 
-        return -EINVAL;
-}
-#endif
-
-static struct map *find_map(unw_word_t ip, struct unwind_info *ui)
-{
-        struct addr_location al;
-
-        thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
-                              MAP__FUNCTION, ip, &al);
-        if (!al.map) {
-                /*
-                 * We've seen cases (softice) where DWARF unwinder went
-                 * through non executable mmaps, which we need to lookup
-                 * in MAP__VARIABLE tree.
-                 */
-                thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
-                                      MAP__VARIABLE, ip, &al);
-        }
-        return al.map;
-}
-
-static int
-find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
-               int need_unwind_info, void *arg)
-{
-        struct unwind_info *ui = arg;
-        struct map *map;
-        unw_dyn_info_t di;
-        u64 table_data, segbase, fde_count;
-        int ret = -EINVAL;
-
-        map = find_map(ip, ui);
-        if (!map || !map->dso)
-                return -EINVAL;
-
-        pr_debug("unwind: find_proc_info dso %s\n", map->dso->name);
-
-        /* Check the .eh_frame section for unwinding info */
-        if (!read_unwind_spec_eh_frame(map->dso, ui->machine,
-                                       &table_data, &segbase, &fde_count)) {
-                memset(&di, 0, sizeof(di));
-                di.format   = UNW_INFO_FORMAT_REMOTE_TABLE;
-                di.start_ip = map->start;
-                di.end_ip   = map->end;
-                di.u.rti.segbase    = map->start + segbase;
-                di.u.rti.table_data = map->start + table_data;
-                di.u.rti.table_len  = fde_count * sizeof(struct table_entry)
-                                      / sizeof(unw_word_t);
-                ret = dwarf_search_unwind_table(as, ip, &di, pi,
-                                                need_unwind_info, arg);
-        }
-
-#ifndef NO_LIBUNWIND_DEBUG_FRAME
-        /* Check the .debug_frame section for unwinding info */
-        if (ret < 0 &&
-            !read_unwind_spec_debug_frame(map->dso, ui->machine, &segbase)) {
-                int fd = dso__data_get_fd(map->dso, ui->machine);
-                int is_exec = elf_is_exec(fd, map->dso->name);
-                unw_word_t base = is_exec ? 0 : map->start;
-                const char *symfile;
-
-                if (fd >= 0)
-                        dso__data_put_fd(map->dso);
-
-                symfile = map->dso->symsrc_filename ?: map->dso->name;
-
-                memset(&di, 0, sizeof(di));
-                if (dwarf_find_debug_frame(0, &di, ip, base, symfile,
-                                           map->start, map->end))
-                        return dwarf_search_unwind_table(as, ip, &di, pi,
-                                                         need_unwind_info, arg);
-        }
-#endif
-
-        return ret;
-}
-
-static int access_fpreg(unw_addr_space_t __maybe_unused as,
-                        unw_regnum_t __maybe_unused num,
-                        unw_fpreg_t __maybe_unused *val,
-                        int __maybe_unused __write,
-                        void __maybe_unused *arg)
-{
-        pr_err("unwind: access_fpreg unsupported\n");
-        return -UNW_EINVAL;
-}
-
-static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as,
-                                  unw_word_t __maybe_unused *dil_addr,
-                                  void __maybe_unused *arg)
-{
-        return -UNW_ENOINFO;
-}
-
-static int resume(unw_addr_space_t __maybe_unused as,
-                  unw_cursor_t __maybe_unused *cu,
-                  void __maybe_unused *arg)
-{
-        pr_err("unwind: resume unsupported\n");
-        return -UNW_EINVAL;
-}
+        arch = normalize_arch(thread->mg->machine->env->arch);
 
-static int
-get_proc_name(unw_addr_space_t __maybe_unused as,
-              unw_word_t __maybe_unused addr,
-                char __maybe_unused *bufp, size_t __maybe_unused buf_len,
-                unw_word_t __maybe_unused *offp, void __maybe_unused *arg)
-{
-        pr_err("unwind: get_proc_name unsupported\n");
-        return -UNW_EINVAL;
-}
-
-static int access_dso_mem(struct unwind_info *ui, unw_word_t addr,
-                          unw_word_t *data)
-{
-        struct map *map;
-        ssize_t size;
-
-        map = find_map(addr, ui);
-        if (!map) {
-                pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
-                return -1;
+        if (!strcmp(arch, "x86")) {
+                if (dso_type != DSO__TYPE_64BIT)
+                        ops = x86_32_unwind_libunwind_ops;
+        } else if (!strcmp(arch, "arm64") || !strcmp(arch, "arm")) {
+                if (dso_type == DSO__TYPE_64BIT)
+                        ops = arm64_unwind_libunwind_ops;
         }
 
-        if (!map->dso)
+        if (!ops) {
+                pr_err("unwind: target platform=%s is not supported\n", arch);
                 return -1;
-
-        size = dso__data_read_addr(map->dso, map, ui->machine,
-                                   addr, (u8 *) data, sizeof(*data));
-
-        return !(size == sizeof(*data));
-}
-
-static int access_mem(unw_addr_space_t __maybe_unused as,
-                      unw_word_t addr, unw_word_t *valp,
-                      int __write, void *arg)
-{
-        struct unwind_info *ui = arg;
-        struct stack_dump *stack = &ui->sample->user_stack;
-        u64 start, end;
-        int offset;
-        int ret;
-
-        /* Don't support write, probably not needed. */
-        if (__write || !stack || !ui->sample->user_regs.regs) {
-                *valp = 0;
-                return 0;
-        }
-
-        ret = perf_reg_value(&start, &ui->sample->user_regs, PERF_REG_SP);
-        if (ret)
-                return ret;
-
-        end = start + stack->size;
-
-        /* Check overflow. */
-        if (addr + sizeof(unw_word_t) < addr)
-                return -EINVAL;
-
-        if (addr < start || addr + sizeof(unw_word_t) >= end) {
-                ret = access_dso_mem(ui, addr, valp);
-                if (ret) {
-                        pr_debug("unwind: access_mem %p not inside range"
-                                 " 0x%" PRIx64 "-0x%" PRIx64 "\n",
-                                 (void *) (uintptr_t) addr, start, end);
-                        *valp = 0;
-                        return ret;
-                }
-                return 0;
-        }
-
-        offset = addr - start;
-        *valp  = *(unw_word_t *)&stack->data[offset];
-        pr_debug("unwind: access_mem addr %p val %lx, offset %d\n",
-                 (void *) (uintptr_t) addr, (unsigned long)*valp, offset);
-        return 0;
-}
-
-static int access_reg(unw_addr_space_t __maybe_unused as,
-                      unw_regnum_t regnum, unw_word_t *valp,
-                      int __write, void *arg)
-{
-        struct unwind_info *ui = arg;
-        int id, ret;
-        u64 val;
-
-        /* Don't support write, I suspect we don't need it. */
-        if (__write) {
-                pr_err("unwind: access_reg w %d\n", regnum);
-                return 0;
-        }
-
-        if (!ui->sample->user_regs.regs) {
-                *valp = 0;
-                return 0;
-        }
-
-        id = libunwind__arch_reg_id(regnum);
-        if (id < 0)
-                return -EINVAL;
-
-        ret = perf_reg_value(&val, &ui->sample->user_regs, id);
-        if (ret) {
-                pr_err("unwind: can't read reg %d\n", regnum);
-                return ret;
-        }
-
-        *valp = (unw_word_t) val;
-        pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp);
-        return 0;
-}
-
-static void put_unwind_info(unw_addr_space_t __maybe_unused as,
-                            unw_proc_info_t *pi __maybe_unused,
-                            void *arg __maybe_unused)
-{
-        pr_debug("unwind: put_unwind_info called\n");
-}
-
-static int entry(u64 ip, struct thread *thread,
-                 unwind_entry_cb_t cb, void *arg)
-{
-        struct unwind_entry e;
-        struct addr_location al;
-
-        thread__find_addr_location(thread, PERF_RECORD_MISC_USER,
-                                   MAP__FUNCTION, ip, &al);
-
-        e.ip = ip;
-        e.map = al.map;
-        e.sym = al.sym;
-
-        pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
-                 al.sym ? al.sym->name : "''",
-                 ip,
-                 al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
-
-        return cb(&e, arg);
-}
-
-static void display_error(int err)
-{
-        switch (err) {
-        case UNW_EINVAL:
-                pr_err("unwind: Only supports local.\n");
-                break;
-        case UNW_EUNSPEC:
-                pr_err("unwind: Unspecified error.\n");
-                break;
-        case UNW_EBADREG:
-                pr_err("unwind: Register unavailable.\n");
-                break;
-        default:
-                break;
-        }
-}
-
-static unw_accessors_t accessors = {
-        .find_proc_info         = find_proc_info,
-        .put_unwind_info        = put_unwind_info,
-        .get_dyn_info_list_addr = get_dyn_info_list_addr,
-        .access_mem             = access_mem,
-        .access_reg             = access_reg,
-        .access_fpreg           = access_fpreg,
-        .resume                 = resume,
-        .get_proc_name          = get_proc_name,
-};
-
-int unwind__prepare_access(struct thread *thread)
-{
-        if (callchain_param.record_mode != CALLCHAIN_DWARF)
-                return 0;
-
-        thread->addr_space = unw_create_addr_space(&accessors, 0);
-        if (!thread->addr_space) {
-                pr_err("unwind: Can't create unwind address space.\n");
-                return -ENOMEM;
         }
+out_register:
+        unwind__register_ops(thread, ops);
 
-        unw_set_caching_policy(thread->addr_space, UNW_CACHE_GLOBAL);
-        return 0;
+        err = thread->unwind_libunwind_ops->prepare_access(thread);
+        if (initialized)
+                *initialized = err ? false : true;
+        return err;
 }
 
 void unwind__flush_access(struct thread *thread)
 {
-        if (callchain_param.record_mode != CALLCHAIN_DWARF)
-                return;
-
-        unw_flush_cache(thread->addr_space, 0, 0);
+        if (thread->unwind_libunwind_ops)
+                thread->unwind_libunwind_ops->flush_access(thread);
 }
 
 void unwind__finish_access(struct thread *thread)
 {
-        if (callchain_param.record_mode != CALLCHAIN_DWARF)
-                return;
-
-        unw_destroy_addr_space(thread->addr_space);
-}
-
-static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
-                       void *arg, int max_stack)
-{
-        u64 val;
-        unw_word_t ips[max_stack];
-        unw_addr_space_t addr_space;
-        unw_cursor_t c;
-        int ret, i = 0;
-
-        ret = perf_reg_value(&val, &ui->sample->user_regs, PERF_REG_IP);
-        if (ret)
-                return ret;
-
-        ips[i++] = (unw_word_t) val;
-
-        /*
-         * If we need more than one entry, do the DWARF
-         * unwind itself.
-         */
-        if (max_stack - 1 > 0) {
-                WARN_ONCE(!ui->thread, "WARNING: ui->thread is NULL");
-                addr_space = ui->thread->addr_space;
-
-                if (addr_space == NULL)
-                        return -1;
-
-                ret = unw_init_remote(&c, addr_space, ui);
-                if (ret)
-                        display_error(ret);
-
-                while (!ret && (unw_step(&c) > 0) && i < max_stack) {
-                        unw_get_reg(&c, UNW_REG_IP, &ips[i]);
-                        ++i;
-                }
-
-                max_stack = i;
-        }
-
-        /*
-         * Display what we got based on the order setup.
-         */
-        for (i = 0; i < max_stack && !ret; i++) {
-                int j = i;
-
-                if (callchain_param.order == ORDER_CALLER)
-                        j = max_stack - i - 1;
-                ret = ips[j] ? entry(ips[j], ui->thread, cb, arg) : 0;
-        }
-
-        return ret;
+        if (thread->unwind_libunwind_ops)
+                thread->unwind_libunwind_ops->finish_access(thread);
 }
 
 int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
-                        struct thread *thread,
-                        struct perf_sample *data, int max_stack)
+                         struct thread *thread,
+                         struct perf_sample *data, int max_stack)
 {
-        struct unwind_info ui = {
-                .sample       = data,
-                .thread       = thread,
-                .machine      = thread->mg->machine,
-        };
-
-        if (!data->user_regs.regs)
-                return -EINVAL;
-
-        if (max_stack <= 0)
-                return -EINVAL;
-
-        return get_entries(&ui, cb, arg, max_stack);
+        if (thread->unwind_libunwind_ops)
+                return thread->unwind_libunwind_ops->get_entries(cb, arg, thread, data, max_stack);
+        return 0;
 }
diff --git a/tools/perf/util/unwind.h b/tools/perf/util/unwind.h
index 12790cf94618..61fb1e90ff51 100644
--- a/tools/perf/util/unwind.h
+++ b/tools/perf/util/unwind.h
@@ -14,18 +14,42 @@ struct unwind_entry {
 
 typedef int (*unwind_entry_cb_t)(struct unwind_entry *entry, void *arg);
 
+struct unwind_libunwind_ops {
+        int (*prepare_access)(struct thread *thread);
+        void (*flush_access)(struct thread *thread);
+        void (*finish_access)(struct thread *thread);
+        int (*get_entries)(unwind_entry_cb_t cb, void *arg,
+                           struct thread *thread,
+                           struct perf_sample *data, int max_stack);
+};
+
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
 int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
                         struct thread *thread,
                         struct perf_sample *data, int max_stack);
 /* libunwind specific */
 #ifdef HAVE_LIBUNWIND_SUPPORT
-int libunwind__arch_reg_id(int regnum);
-int unwind__prepare_access(struct thread *thread);
+#ifndef LIBUNWIND__ARCH_REG_ID
+#define LIBUNWIND__ARCH_REG_ID(regnum) libunwind__arch_reg_id(regnum)
+#endif
+
+#ifndef LIBUNWIND__ARCH_REG_SP
+#define LIBUNWIND__ARCH_REG_SP PERF_REG_SP
+#endif
+
+#ifndef LIBUNWIND__ARCH_REG_IP
+#define LIBUNWIND__ARCH_REG_IP PERF_REG_IP
+#endif
+
+int LIBUNWIND__ARCH_REG_ID(int regnum);
+int unwind__prepare_access(struct thread *thread, struct map *map,
+                           bool *initialized);
 void unwind__flush_access(struct thread *thread);
 void unwind__finish_access(struct thread *thread);
 #else
-static inline int unwind__prepare_access(struct thread *thread __maybe_unused)
+static inline int unwind__prepare_access(struct thread *thread __maybe_unused,
+                                         struct map *map __maybe_unused,
+                                         bool *initialized __maybe_unused)
 {
         return 0;
 }
@@ -44,7 +68,9 @@ unwind__get_entries(unwind_entry_cb_t cb __maybe_unused,
         return 0;
 }
 
-static inline int unwind__prepare_access(struct thread *thread __maybe_unused)
+static inline int unwind__prepare_access(struct thread *thread __maybe_unused,
+                                         struct map *map __maybe_unused,
+                                         bool *initialized __maybe_unused)
 {
         return 0;
 }
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 23504ad5d6dd..85c56800f17a 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -15,16 +15,24 @@
 #include <byteswap.h>
 #include <linux/kernel.h>
 #include <linux/log2.h>
+#include <linux/time64.h>
 #include <unistd.h>
 #include "callchain.h"
 #include "strlist.h"
 
-struct callchain_param  callchain_param = {
-        .mode   = CHAIN_GRAPH_ABS,
-        .min_percent = 0.5,
-        .order  = ORDER_CALLEE,
-        .key    = CCKEY_FUNCTION,
-        .value  = CCVAL_PERCENT,
+#define CALLCHAIN_PARAM_DEFAULT                 \
+        .mode           = CHAIN_GRAPH_ABS,      \
+        .min_percent    = 0.5,                  \
+        .order          = ORDER_CALLEE,         \
+        .key            = CCKEY_FUNCTION,       \
+        .value          = CCVAL_PERCENT,        \
+
+struct callchain_param callchain_param = {
+        CALLCHAIN_PARAM_DEFAULT
+};
+
+struct callchain_param callchain_param_default = {
+        CALLCHAIN_PARAM_DEFAULT
 };
 
 /*
@@ -97,20 +105,17 @@ int rm_rf(char *path)
                 scnprintf(namebuf, sizeof(namebuf), "%s/%s",
                           path, d->d_name);
 
-                ret = stat(namebuf, &statbuf);
+                /* We have to check symbolic link itself */
+                ret = lstat(namebuf, &statbuf);
                 if (ret < 0) {
                         pr_debug("stat failed: %s\n", namebuf);
                         break;
                 }
 
-                if (S_ISREG(statbuf.st_mode))
-                        ret = unlink(namebuf);
-                else if (S_ISDIR(statbuf.st_mode))
+                if (S_ISDIR(statbuf.st_mode))
                         ret = rm_rf(namebuf);
-                else {
-                        pr_debug("unknown file: %s\n", namebuf);
-                        ret = -1;
-                }
+                else
+                        ret = unlink(namebuf);
         }
         closedir(dir);
 
@@ -742,3 +747,19 @@ void print_binary(unsigned char *data, size_t len,
         }
         printer(BINARY_PRINT_DATA_END, -1, extra);
 }
+
+int is_printable_array(char *p, unsigned int len)
+{
+        unsigned int i;
+
+        if (!p || !len || p[len - 1] != 0)
+                return 0;
+
+        len--;
+
+        for (i = 0; i < len; i++) {
+                if (!isprint(p[i]) && !isspace(p[i]))
+                        return 0;
+        }
+        return 1;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 1e8c3167b9fb..43899e0d6fa1 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -72,7 +72,6 @@
 #include <sys/ioctl.h>
 #include <inttypes.h>
 #include <linux/kernel.h>
-#include <linux/magic.h>
 #include <linux/types.h>
 #include <sys/ttydefaults.h>
 #include <api/fs/tracing_path.h>
@@ -180,10 +179,6 @@ static inline void *zalloc(size_t size)
 #undef tolower
 #undef toupper
 
-#ifndef NSEC_PER_MSEC
-#define NSEC_PER_MSEC   1000000L
-#endif
-
 int parse_nsec_time(const char *str, u64 *ptime);
 
 extern unsigned char sane_ctype[256];
@@ -360,4 +355,10 @@ typedef void (*print_binary_t)(enum binary_printer_ops,
 void print_binary(unsigned char *data, size_t len,
                   size_t bytes_per_line, print_binary_t printer,
                   void *extra);
+
+#if !defined(__GLIBC__) && !defined(__ANDROID__)
+extern int sched_getcpu(void);
+#endif
+
+int is_printable_array(char *p, unsigned int len);
 #endif /* GIT_COMPAT_UTIL_H */
diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c
index 44d440da15dc..7bdcad484225 100644
--- a/tools/perf/util/vdso.c
+++ b/tools/perf/util/vdso.c
@@ -134,8 +134,6 @@ static struct dso *__machine__addnew_vdso(struct machine *machine, const char *s
         return dso;
 }
 
-#if BITS_PER_LONG == 64
-
 static enum dso_type machine__thread_dso_type(struct machine *machine,
                                               struct thread *thread)
 {
@@ -156,6 +154,8 @@ static enum dso_type machine__thread_dso_type(struct machine *machine,
         return dso_type;
 }
 
+#if BITS_PER_LONG == 64
+
 static int vdso__do_copy_compat(FILE *f, int fd)
 {
         char buf[4096];
@@ -283,8 +283,38 @@ static int __machine__findnew_vdso_compat(struct machine *machine,
 
 #endif
 
+static struct dso *machine__find_vdso(struct machine *machine,
+                                      struct thread *thread)
+{
+        struct dso *dso = NULL;
+        enum dso_type dso_type;
+
+        dso_type = machine__thread_dso_type(machine, thread);
+        switch (dso_type) {
+        case DSO__TYPE_32BIT:
+                dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO32, true);
+                if (!dso) {
+                        dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO,
+                                           true);
+                        if (dso && dso_type != dso__type(dso, machine))
+                                dso = NULL;
+                }
+                break;
+        case DSO__TYPE_X32BIT:
+                dso = __dsos__find(&machine->dsos, DSO__NAME_VDSOX32, true);
+                break;
+        case DSO__TYPE_64BIT:
+        case DSO__TYPE_UNKNOWN:
+        default:
+                dso = __dsos__find(&machine->dsos, DSO__NAME_VDSO, true);
+                break;
+        }
+
+        return dso;
+}
+
 struct dso *machine__findnew_vdso(struct machine *machine,
-                                  struct thread *thread __maybe_unused)
+                                  struct thread *thread)
 {
         struct vdso_info *vdso_info;
         struct dso *dso = NULL;
@@ -297,6 +327,10 @@ struct dso *machine__findnew_vdso(struct machine *machine,
         if (!vdso_info)
                 goto out_unlock;
 
+        dso = machine__find_vdso(machine, thread);
+        if (dso)
+                goto out_unlock;
+
 #if BITS_PER_LONG == 64
         if (__machine__findnew_vdso_compat(machine, thread, vdso_info, &dso))
                 goto out_unlock;
diff --git a/tools/power/acpi/Makefile.config b/tools/power/acpi/Makefile.config
index 552af68d5414..a538ff44b108 100644
--- a/tools/power/acpi/Makefile.config
+++ b/tools/power/acpi/Makefile.config
@@ -54,9 +54,10 @@ INSTALL_SCRIPT = ${INSTALL_PROGRAM}
 # to something more interesting, like "arm-linux-".  If you want
 # to compile vs uClibc, that can be done here as well.
 CROSS = #/usr/i386-linux-uclibc/usr/bin/i386-uclibc-
-CC = $(CROSS)gcc
-LD = $(CROSS)gcc
-STRIP = $(CROSS)strip
+CROSS_COMPILE ?= $(CROSS)
+CC = $(CROSS_COMPILE)gcc
+LD = $(CROSS_COMPILE)gcc
+STRIP = $(CROSS_COMPILE)strip
 HOSTCC = gcc
 
 # check if compiler option is supported
diff --git a/tools/power/acpi/common/cmfsize.c b/tools/power/acpi/common/cmfsize.c
index e73a79fce015..bc82596d7354 100644
--- a/tools/power/acpi/common/cmfsize.c
+++ b/tools/power/acpi/common/cmfsize.c
@@ -44,7 +44,6 @@
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "acapps.h"
-#include <stdio.h>
 
 #define _COMPONENT          ACPI_TOOLS
 ACPI_MODULE_NAME("cmfsize")
@@ -69,24 +68,24 @@ u32 cm_get_file_size(ACPI_FILE file)
 
         /* Save the current file pointer, seek to EOF to obtain file size */
 
-        current_offset = acpi_os_get_file_offset(file);
+        current_offset = ftell(file);
         if (current_offset < 0) {
                 goto offset_error;
         }
 
-        status = acpi_os_set_file_offset(file, 0, ACPI_FILE_END);
+        status = fseek(file, 0, SEEK_END);
         if (ACPI_FAILURE(status)) {
                 goto seek_error;
         }
 
-        file_size = acpi_os_get_file_offset(file);
+        file_size = ftell(file);
         if (file_size < 0) {
                 goto offset_error;
         }
 
         /* Restore original file pointer */
 
-        status = acpi_os_set_file_offset(file, current_offset, ACPI_FILE_BEGIN);
+        status = fseek(file, current_offset, SEEK_SET);
         if (ACPI_FAILURE(status)) {
                 goto seek_error;
         }
@@ -94,10 +93,10 @@ u32 cm_get_file_size(ACPI_FILE file)
         return ((u32)file_size);
 
 offset_error:
-        acpi_log_error("Could not get file offset");
+        fprintf(stderr, "Could not get file offset\n");
         return (ACPI_UINT32_MAX);
 
 seek_error:
-        acpi_log_error("Could not set file offset");
+        fprintf(stderr, "Could not set file offset\n");
         return (ACPI_UINT32_MAX);
 }
diff --git a/tools/power/acpi/common/getopt.c b/tools/power/acpi/common/getopt.c
index 0bd343f136a4..3919970f5aea 100644
--- a/tools/power/acpi/common/getopt.c
+++ b/tools/power/acpi/common/getopt.c
@@ -57,7 +57,7 @@
 #include "acapps.h"
 
 #define ACPI_OPTION_ERROR(msg, badchar) \
-        if (acpi_gbl_opterr) {acpi_log_error ("%s%c\n", msg, badchar);}
+        if (acpi_gbl_opterr) {fprintf (stderr, "%s%c\n", msg, badchar);}
 
 int acpi_gbl_opterr = 1;
 int acpi_gbl_optind = 1;
@@ -94,7 +94,7 @@ int acpi_getopt_argument(int argc, char **argv)
                 acpi_gbl_optarg =
                     &argv[acpi_gbl_optind++][(int)(current_char_ptr + 1)];
         } else if (++acpi_gbl_optind >= argc) {
-                ACPI_OPTION_ERROR("Option requires an argument: -", 'v');
+                ACPI_OPTION_ERROR("\nOption requires an argument", 0);
 
                 current_char_ptr = 1;
                 return (-1);
diff --git a/tools/power/acpi/os_specific/service_layers/oslibcfs.c b/tools/power/acpi/os_specific/service_layers/oslibcfs.c
deleted file mode 100644
index 11f4aba55aab..000000000000
--- a/tools/power/acpi/os_specific/service_layers/oslibcfs.c
+++ /dev/null
@@ -1,217 +0,0 @@
-/******************************************************************************
- *
- * Module Name: oslibcfs - C library OSL for file I/O
- *
- *****************************************************************************/
-
-/*
- * Copyright (C) 2000 - 2016, Intel Corp.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions, and the following disclaimer,
- *    without modification.
- * 2. Redistributions in binary form must reproduce at minimum a disclaimer
- *    substantially similar to the "NO WARRANTY" disclaimer below
- *    ("Disclaimer") and any redistribution must be conditioned upon
- *    including a substantially similar Disclaimer requirement for further
- *    binary redistribution.
- * 3. Neither the names of the above-listed copyright holders nor the names
- *    of any contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * Alternatively, this software may be distributed under the terms of the
- * GNU General Public License ("GPL") version 2 as published by the Free
- * Software Foundation.
- *
- * NO WARRANTY
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGES.
- */
-
-#include <acpi/acpi.h>
-#include <stdio.h>
-#include <stdarg.h>
-
-#define _COMPONENT          ACPI_OS_SERVICES
-ACPI_MODULE_NAME("oslibcfs")
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_open_file
- *
- * PARAMETERS:  path                - File path
- *              modes               - File operation type
- *
- * RETURN:      File descriptor.
- *
- * DESCRIPTION: Open a file for reading (ACPI_FILE_READING) or/and writing
- *              (ACPI_FILE_WRITING).
- *
- ******************************************************************************/
-ACPI_FILE acpi_os_open_file(const char *path, u8 modes)
-{
-        ACPI_FILE file;
-        u32 i = 0;
-        char modes_str[4];
-
-        if (modes & ACPI_FILE_READING) {
-                modes_str[i++] = 'r';
-        }
-        if (modes & ACPI_FILE_WRITING) {
-                modes_str[i++] = 'w';
-        }
-
-        if (modes & ACPI_FILE_BINARY) {
-                modes_str[i++] = 'b';
-        }
-
-        modes_str[i++] = '\0';
-
-        file = fopen(path, modes_str);
-        if (!file) {
-                perror("Could not open file");
-        }
-
-        return (file);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_close_file
- *
- * PARAMETERS:  file                - An open file descriptor
- *
- * RETURN:      None.
- *
- * DESCRIPTION: Close a file opened via acpi_os_open_file.
- *
- ******************************************************************************/
-
-void acpi_os_close_file(ACPI_FILE file)
-{
-
-        fclose(file);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_read_file
- *
- * PARAMETERS:  file                - An open file descriptor
- *              buffer              - Data buffer
- *              size                - Data block size
- *              count               - Number of data blocks
- *
- * RETURN:      Number of bytes actually read.
- *
- * DESCRIPTION: Read from a file.
- *
- ******************************************************************************/
-
-int
-acpi_os_read_file(ACPI_FILE file, void *buffer, acpi_size size, acpi_size count)
-{
-        int length;
-
-        length = fread(buffer, size, count, file);
-        if (length < 0) {
-                perror("Error reading file");
-        }
-
-        return (length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_write_file
- *
- * PARAMETERS:  file                - An open file descriptor
- *              buffer              - Data buffer
- *              size                - Data block size
- *              count               - Number of data blocks
- *
- * RETURN:      Number of bytes actually written.
- *
- * DESCRIPTION: Write to a file.
- *
- ******************************************************************************/
-
-int
-acpi_os_write_file(ACPI_FILE file,
-                   void *buffer, acpi_size size, acpi_size count)
-{
-        int length;
-
-        length = fwrite(buffer, size, count, file);
-        if (length < 0) {
-                perror("Error writing file");
-        }
-
-        return (length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_get_file_offset
- *
- * PARAMETERS:  file                - An open file descriptor
- *
- * RETURN:      Current file pointer position.
- *
- * DESCRIPTION: Get current file offset.
- *
- ******************************************************************************/
-
-long acpi_os_get_file_offset(ACPI_FILE file)
-{
-        long offset;
-
-        offset = ftell(file);
-        return (offset);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_os_set_file_offset
- *
- * PARAMETERS:  file                - An open file descriptor
- *              offset              - New file offset
- *              from                - From begin/end of file
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Set current file offset.
- *
- ******************************************************************************/
-
-acpi_status acpi_os_set_file_offset(ACPI_FILE file, long offset, u8 from)
-{
-        int ret = 0;
-
-        if (from == ACPI_FILE_BEGIN) {
-                ret = fseek(file, offset, SEEK_SET);
-        }
-
-        if (from == ACPI_FILE_END) {
-                ret = fseek(file, offset, SEEK_END);
-        }
-
-        if (ret < 0) {
-                return (AE_ERROR);
-        } else {
-                return (AE_OK);
-        }
-}
diff --git a/tools/power/acpi/os_specific/service_layers/osunixxf.c b/tools/power/acpi/os_specific/service_layers/osunixxf.c
index 88aa66ef4ad5..8d8003c919d4 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixxf.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixxf.c
@@ -63,10 +63,7 @@
 #define _COMPONENT          ACPI_OS_SERVICES
 ACPI_MODULE_NAME("osunixxf")
 
-u8 acpi_gbl_debug_timeout = FALSE;
-
 /* Upcalls to acpi_exec */
-
 void
 ae_table_override(struct acpi_table_header *existing_table,
                   struct acpi_table_header **new_table);
diff --git a/tools/power/acpi/tools/acpidump/Makefile b/tools/power/acpi/tools/acpidump/Makefile
index 2942cdced2ad..04b5db7c7c0b 100644
--- a/tools/power/acpi/tools/acpidump/Makefile
+++ b/tools/power/acpi/tools/acpidump/Makefile
@@ -36,12 +36,13 @@ TOOL_OBJS = \
         utdebug.o\
         utexcep.o\
         utglobal.o\
+        uthex.o\
         utmath.o\
         utnonansi.o\
         utprint.o\
         utstring.o\
+        utstrtoul64.o\
         utxferror.o\
-        oslibcfs.o\
         oslinuxtbl.o\
         cmfsize.o\
         getopt.o
diff --git a/tools/power/acpi/tools/acpidump/acpidump.h b/tools/power/acpi/tools/acpidump/acpidump.h
index 025c232e920d..00423fc45e7c 100644
--- a/tools/power/acpi/tools/acpidump/acpidump.h
+++ b/tools/power/acpi/tools/acpidump/acpidump.h
@@ -55,11 +55,7 @@
 #include <acpi/acpi.h>
 #include "accommon.h"
 #include "actables.h"
-
-#include <stdio.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <sys/stat.h>
+#include "acapps.h"
 
 /* Globals */
 
@@ -72,12 +68,6 @@ EXTERN ACPI_FILE INIT_GLOBAL(gbl_output_file, NULL);
 EXTERN char INIT_GLOBAL(*gbl_output_filename, NULL);
 EXTERN u64 INIT_GLOBAL(gbl_rsdp_base, 0);
 
-/* Globals required for use with ACPICA modules */
-
-#ifdef _DECLARE_GLOBALS
-u8 acpi_gbl_integer_byte_width = 8;
-#endif
-
 /* Action table used to defer requested options */
 
 struct ap_dump_action {
diff --git a/tools/power/acpi/tools/acpidump/apdump.c b/tools/power/acpi/tools/acpidump/apdump.c
index fb8f1d9e3b1b..9031be1afe63 100644
--- a/tools/power/acpi/tools/acpidump/apdump.c
+++ b/tools/power/acpi/tools/acpidump/apdump.c
@@ -69,16 +69,17 @@ u8 ap_is_valid_header(struct acpi_table_header *table)
                 /* Make sure signature is all ASCII and a valid ACPI name */
 
                 if (!acpi_ut_valid_nameseg(table->signature)) {
-                        acpi_log_error("Table signature (0x%8.8X) is invalid\n",
-                                       *(u32 *)table->signature);
+                        fprintf(stderr,
+                                "Table signature (0x%8.8X) is invalid\n",
+                                *(u32 *)table->signature);
                         return (FALSE);
                 }
 
                 /* Check for minimum table length */
 
                 if (table->length < sizeof(struct acpi_table_header)) {
-                        acpi_log_error("Table length (0x%8.8X) is invalid\n",
-                                       table->length);
+                        fprintf(stderr, "Table length (0x%8.8X) is invalid\n",
+                                table->length);
                         return (FALSE);
                 }
         }
@@ -115,8 +116,8 @@ u8 ap_is_valid_checksum(struct acpi_table_header *table)
         }
 
         if (ACPI_FAILURE(status)) {
-                acpi_log_error("%4.4s: Warning: wrong checksum in table\n",
-                               table->signature);
+                fprintf(stderr, "%4.4s: Warning: wrong checksum in table\n",
+                        table->signature);
         }
 
         return (AE_OK);
@@ -195,13 +196,13 @@ ap_dump_table_buffer(struct acpi_table_header *table,
          * Note: simplest to just always emit a 64-bit address. acpi_xtract
          * utility can handle this.
          */
-        acpi_ut_file_printf(gbl_output_file, "%4.4s @ 0x%8.8X%8.8X\n",
-                            table->signature, ACPI_FORMAT_UINT64(address));
+        fprintf(gbl_output_file, "%4.4s @ 0x%8.8X%8.8X\n",
+                table->signature, ACPI_FORMAT_UINT64(address));
 
         acpi_ut_dump_buffer_to_file(gbl_output_file,
                                     ACPI_CAST_PTR(u8, table), table_length,
                                     DB_BYTE_DISPLAY, 0);
-        acpi_ut_file_printf(gbl_output_file, "\n");
+        fprintf(gbl_output_file, "\n");
         return (0);
 }
 
@@ -239,14 +240,14 @@ int ap_dump_all_tables(void)
                         if (status == AE_LIMIT) {
                                 return (0);
                         } else if (i == 0) {
-                                acpi_log_error
-                                    ("Could not get ACPI tables, %s\n",
-                                     acpi_format_exception(status));
+                                fprintf(stderr,
+                                        "Could not get ACPI tables, %s\n",
+                                        acpi_format_exception(status));
                                 return (-1);
                         } else {
-                                acpi_log_error
-                                    ("Could not get ACPI table at index %u, %s\n",
-                                     i, acpi_format_exception(status));
+                                fprintf(stderr,
+                                        "Could not get ACPI table at index %u, %s\n",
+                                        i, acpi_format_exception(status));
                                 continue;
                         }
                 }
@@ -286,20 +287,20 @@ int ap_dump_table_by_address(char *ascii_address)
 
         /* Convert argument to an integer physical address */
 
-        status = acpi_ut_strtoul64(ascii_address, ACPI_ANY_BASE,
-                                   ACPI_MAX64_BYTE_WIDTH, &long_address);
+        status = acpi_ut_strtoul64(ascii_address, ACPI_STRTOUL_64BIT,
+                                   &long_address);
         if (ACPI_FAILURE(status)) {
-                acpi_log_error("%s: Could not convert to a physical address\n",
-                               ascii_address);
+                fprintf(stderr, "%s: Could not convert to a physical address\n",
+                        ascii_address);
                 return (-1);
         }
 
         address = (acpi_physical_address)long_address;
         status = acpi_os_get_table_by_address(address, &table);
         if (ACPI_FAILURE(status)) {
-                acpi_log_error("Could not get table at 0x%8.8X%8.8X, %s\n",
-                               ACPI_FORMAT_UINT64(address),
-                               acpi_format_exception(status));
+                fprintf(stderr, "Could not get table at 0x%8.8X%8.8X, %s\n",
+                        ACPI_FORMAT_UINT64(address),
+                        acpi_format_exception(status));
                 return (-1);
         }
 
@@ -331,9 +332,9 @@ int ap_dump_table_by_name(char *signature)
         int table_status;
 
         if (strlen(signature) != ACPI_NAME_SIZE) {
-                acpi_log_error
-                    ("Invalid table signature [%s]: must be exactly 4 characters\n",
-                     signature);
+                fprintf(stderr,
+                        "Invalid table signature [%s]: must be exactly 4 characters\n",
+                        signature);
                 return (-1);
         }
 
@@ -363,9 +364,9 @@ int ap_dump_table_by_name(char *signature)
                                 return (0);
                         }
 
-                        acpi_log_error
-                            ("Could not get ACPI table with signature [%s], %s\n",
-                             local_signature, acpi_format_exception(status));
+                        fprintf(stderr,
+                                "Could not get ACPI table with signature [%s], %s\n",
+                                local_signature, acpi_format_exception(status));
                         return (-1);
                 }
 
@@ -408,24 +409,24 @@ int ap_dump_table_from_file(char *pathname)
         }
 
         if (!acpi_ut_valid_nameseg(table->signature)) {
-                acpi_log_error
-                    ("No valid ACPI signature was found in input file %s\n",
-                     pathname);
+                fprintf(stderr,
+                        "No valid ACPI signature was found in input file %s\n",
+                        pathname);
         }
 
         /* File must be at least as long as the table length */
 
         if (table->length > file_size) {
-                acpi_log_error
-                    ("Table length (0x%X) is too large for input file (0x%X) %s\n",
-                     table->length, file_size, pathname);
+                fprintf(stderr,
+                        "Table length (0x%X) is too large for input file (0x%X) %s\n",
+                        table->length, file_size, pathname);
                 goto exit;
         }
 
         if (gbl_verbose_mode) {
-                acpi_log_error
-                    ("Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
-                     pathname, table->signature, file_size, file_size);
+                fprintf(stderr,
+                        "Input file:  %s contains table [%4.4s], 0x%X (%u) bytes\n",
+                        pathname, table->signature, file_size, file_size);
         }
 
         table_status = ap_dump_table_buffer(table, 0, 0);
diff --git a/tools/power/acpi/tools/acpidump/apfiles.c b/tools/power/acpi/tools/acpidump/apfiles.c
index 5fcd9700ac18..dd5b861dc4a8 100644
--- a/tools/power/acpi/tools/acpidump/apfiles.c
+++ b/tools/power/acpi/tools/acpidump/apfiles.c
@@ -42,7 +42,6 @@
  */
 
 #include "acpidump.h"
-#include "acapps.h"
 
 /* Local prototypes */
 
@@ -66,7 +65,8 @@ static int ap_is_existing_file(char *pathname)
         struct stat stat_info;
 
         if (!stat(pathname, &stat_info)) {
-                acpi_log_error("Target path already exists, overwrite? [y|n] ");
+                fprintf(stderr,
+                        "Target path already exists, overwrite? [y|n] ");
 
                 if (getchar() != 'y') {
                         return (-1);
@@ -102,9 +102,9 @@ int ap_open_output_file(char *pathname)
 
         /* Point stdout to the file */
 
-        file = acpi_os_open_file(pathname, ACPI_FILE_WRITING);
+        file = fopen(pathname, "w");
         if (!file) {
-                acpi_log_error("Could not open output file: %s\n", pathname);
+                fprintf(stderr, "Could not open output file: %s\n", pathname);
                 return (-1);
         }
 
@@ -134,7 +134,7 @@ int ap_write_to_binary_file(struct acpi_table_header *table, u32 instance)
         char filename[ACPI_NAME_SIZE + 16];
         char instance_str[16];
         ACPI_FILE file;
-        size_t actual;
+        acpi_size actual;
         u32 table_length;
 
         /* Obtain table length */
@@ -158,37 +158,36 @@ int ap_write_to_binary_file(struct acpi_table_header *table, u32 instance)
         /* Handle multiple SSDts - create different filenames for each */
 
         if (instance > 0) {
-                acpi_ut_snprintf(instance_str, sizeof(instance_str), "%u",
-                                 instance);
+                snprintf(instance_str, sizeof(instance_str), "%u", instance);
                 strcat(filename, instance_str);
         }
 
         strcat(filename, FILE_SUFFIX_BINARY_TABLE);
 
         if (gbl_verbose_mode) {
-                acpi_log_error
-                    ("Writing [%4.4s] to binary file: %s 0x%X (%u) bytes\n",
-                     table->signature, filename, table->length, table->length);
+                fprintf(stderr,
+                        "Writing [%4.4s] to binary file: %s 0x%X (%u) bytes\n",
+                        table->signature, filename, table->length,
+                        table->length);
         }
 
         /* Open the file and dump the entire table in binary mode */
 
-        file = acpi_os_open_file(filename,
-                                 ACPI_FILE_WRITING | ACPI_FILE_BINARY);
+        file = fopen(filename, "wb");
         if (!file) {
-                acpi_log_error("Could not open output file: %s\n", filename);
+                fprintf(stderr, "Could not open output file: %s\n", filename);
                 return (-1);
         }
 
-        actual = acpi_os_write_file(file, table, 1, table_length);
+        actual = fwrite(table, 1, table_length, file);
         if (actual != table_length) {
-                acpi_log_error("Error writing binary output file: %s\n",
-                               filename);
-                acpi_os_close_file(file);
+                fprintf(stderr, "Error writing binary output file: %s\n",
+                        filename);
+                fclose(file);
                 return (-1);
         }
 
-        acpi_os_close_file(file);
+        fclose(file);
         return (0);
 }
 
@@ -211,14 +210,13 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
         struct acpi_table_header *buffer = NULL;
         ACPI_FILE file;
         u32 file_size;
-        size_t actual;
+        acpi_size actual;
 
         /* Must use binary mode */
 
-        file =
-            acpi_os_open_file(pathname, ACPI_FILE_READING | ACPI_FILE_BINARY);
+        file = fopen(pathname, "rb");
         if (!file) {
-                acpi_log_error("Could not open input file: %s\n", pathname);
+                fprintf(stderr, "Could not open input file: %s\n", pathname);
                 return (NULL);
         }
 
@@ -226,7 +224,8 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
 
         file_size = cm_get_file_size(file);
         if (file_size == ACPI_UINT32_MAX) {
-                acpi_log_error("Could not get input file size: %s\n", pathname);
+                fprintf(stderr,
+                        "Could not get input file size: %s\n", pathname);
                 goto cleanup;
         }
 
@@ -234,16 +233,17 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
 
         buffer = ACPI_ALLOCATE_ZEROED(file_size);
         if (!buffer) {
-                acpi_log_error("Could not allocate file buffer of size: %u\n",
-                               file_size);
+                fprintf(stderr,
+                        "Could not allocate file buffer of size: %u\n",
+                        file_size);
                 goto cleanup;
         }
 
         /* Read the entire file */
 
-        actual = acpi_os_read_file(file, buffer, 1, file_size);
+        actual = fread(buffer, 1, file_size, file);
         if (actual != file_size) {
-                acpi_log_error("Could not read input file: %s\n", pathname);
+                fprintf(stderr, "Could not read input file: %s\n", pathname);
                 ACPI_FREE(buffer);
                 buffer = NULL;
                 goto cleanup;
@@ -252,6 +252,6 @@ struct acpi_table_header *ap_get_table_from_file(char *pathname,
         *out_file_size = file_size;
 
 cleanup:
-        acpi_os_close_file(file);
+        fclose(file);
         return (buffer);
 }
diff --git a/tools/power/acpi/tools/acpidump/apmain.c b/tools/power/acpi/tools/acpidump/apmain.c
index 7692e6b887e1..7ff46be908f0 100644
--- a/tools/power/acpi/tools/acpidump/apmain.c
+++ b/tools/power/acpi/tools/acpidump/apmain.c
@@ -43,7 +43,6 @@
 
 #define _DECLARE_GLOBALS
 #include "acpidump.h"
-#include "acapps.h"
 
 /*
  * acpidump - A portable utility for obtaining system ACPI tables and dumping
@@ -140,8 +139,8 @@ static int ap_insert_action(char *argument, u32 to_be_done)
 
         current_action++;
         if (current_action > AP_MAX_ACTIONS) {
-                acpi_log_error("Too many table options (max %u)\n",
-                               AP_MAX_ACTIONS);
+                fprintf(stderr, "Too many table options (max %u)\n",
+                        AP_MAX_ACTIONS);
                 return (-1);
         }
 
@@ -186,9 +185,9 @@ static int ap_do_options(int argc, char **argv)
                         } else if (!strcmp(acpi_gbl_optarg, "off")) {
                                 gbl_dump_customized_tables = FALSE;
                         } else {
-                                acpi_log_error
-                                    ("%s: Cannot handle this switch, please use on|off\n",
-                                     acpi_gbl_optarg);
+                                fprintf(stderr,
+                                        "%s: Cannot handle this switch, please use on|off\n",
+                                        acpi_gbl_optarg);
                                 return (-1);
                         }
                         continue;
@@ -209,13 +208,13 @@ static int ap_do_options(int argc, char **argv)
                 case 'r':       /* Dump tables from specified RSDP */
 
                         status =
-                            acpi_ut_strtoul64(acpi_gbl_optarg, ACPI_ANY_BASE,
-                                              ACPI_MAX64_BYTE_WIDTH,
+                            acpi_ut_strtoul64(acpi_gbl_optarg,
+                                              ACPI_STRTOUL_64BIT,
                                               &gbl_rsdp_base);
                         if (ACPI_FAILURE(status)) {
-                                acpi_log_error
-                                    ("%s: Could not convert to a physical address\n",
-                                     acpi_gbl_optarg);
+                                fprintf(stderr,
+                                        "%s: Could not convert to a physical address\n",
+                                        acpi_gbl_optarg);
                                 return (-1);
                         }
                         continue;
@@ -242,7 +241,7 @@ static int ap_do_options(int argc, char **argv)
                 case 'z':       /* Verbose mode */
 
                         gbl_verbose_mode = TRUE;
-                        acpi_log_error(ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
+                        fprintf(stderr, ACPI_COMMON_SIGNON(AP_UTILITY_NAME));
                         continue;
 
                         /*
@@ -315,6 +314,7 @@ int ACPI_SYSTEM_XFACE acpi_main(int argc, char *argv[])
         ACPI_DEBUG_INITIALIZE();        /* For debug version only */
         acpi_os_initialize();
         gbl_output_file = ACPI_FILE_OUT;
+        acpi_gbl_integer_byte_width = 8;
 
         /* Process command line options */
 
@@ -353,8 +353,9 @@ int ACPI_SYSTEM_XFACE acpi_main(int argc, char *argv[])
 
                 default:
 
-                        acpi_log_error("Internal error, invalid action: 0x%X\n",
-                                       action->to_be_done);
+                        fprintf(stderr,
+                                "Internal error, invalid action: 0x%X\n",
+                                action->to_be_done);
                         return (-1);
                 }
 
@@ -369,12 +370,12 @@ int ACPI_SYSTEM_XFACE acpi_main(int argc, char *argv[])
                         /* Summary for the output file */
 
                         file_size = cm_get_file_size(gbl_output_file);
-                        acpi_log_error
-                            ("Output file %s contains 0x%X (%u) bytes\n\n",
-                             gbl_output_filename, file_size, file_size);
+                        fprintf(stderr,
+                                "Output file %s contains 0x%X (%u) bytes\n\n",
+                                gbl_output_filename, file_size, file_size);
                 }
 
-                acpi_os_close_file(gbl_output_file);
+                fclose(gbl_output_file);
         }
 
         return (status);
diff --git a/tools/power/x86/turbostat/Makefile b/tools/power/x86/turbostat/Makefile
index e367b1a85d70..8561e7ddca59 100644
--- a/tools/power/x86/turbostat/Makefile
+++ b/tools/power/x86/turbostat/Makefile
@@ -1,7 +1,7 @@
 CC              = $(CROSS_COMPILE)gcc
 BUILD_OUTPUT    := $(CURDIR)
-PREFIX          := /usr
-DESTDIR         :=
+PREFIX          ?= /usr
+DESTDIR         ?=
 
 ifeq ("$(origin O)", "command line")
         BUILD_OUTPUT := $(O)
diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8
index 89a55d5e32f3..492e84fbebfa 100644
--- a/tools/power/x86/turbostat/turbostat.8
+++ b/tools/power/x86/turbostat/turbostat.8
@@ -123,7 +123,7 @@ cpu0: MSR_NHM_PLATFORM_INFO: 0x80838f3012300
 35 * 100 = 3500 MHz TSC frequency
 cpu0: MSR_IA32_POWER_CTL: 0x0004005d (C1E auto-promotion: DISabled)
 cpu0: MSR_NHM_SNB_PKG_CST_CFG_CTL: 0x1e000400 (UNdemote-C3, UNdemote-C1, demote-C3, demote-C1, UNlocked: pkg-cstate-limit=0: pc0)
-cpu0: MSR_NHM_TURBO_RATIO_LIMIT: 0x25262727
+cpu0: MSR_TURBO_RATIO_LIMIT: 0x25262727
 37 * 100 = 3700 MHz max turbo 4 active cores
 38 * 100 = 3800 MHz max turbo 3 active cores
 39 * 100 = 3900 MHz max turbo 2 active cores
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index acbf7ff2ee6e..3e199b508a96 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -1480,7 +1480,7 @@ dump_knl_turbo_ratio_limits(void)
         unsigned int cores[buckets_no];
         unsigned int ratio[buckets_no];
 
-        get_msr(base_cpu, MSR_NHM_TURBO_RATIO_LIMIT, &msr);
+        get_msr(base_cpu, MSR_TURBO_RATIO_LIMIT, &msr);
 
         fprintf(outf, "cpu%d: MSR_TURBO_RATIO_LIMIT: 0x%08llx\n",
                 base_cpu, msr);
diff --git a/tools/scripts/Makefile.arch b/tools/scripts/Makefile.arch
index e11fbd6fae78..ad85b921a607 100644
--- a/tools/scripts/Makefile.arch
+++ b/tools/scripts/Makefile.arch
@@ -1,8 +1,4 @@
-ifndef ARCH
-ARCH := $(shell uname -m 2>/dev/null || echo not)
-endif
-
-ARCH := $(shell echo $(ARCH) | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
+HOSTARCH := $(shell uname -m | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
                                   -e s/sun4u/sparc/ -e s/sparc64/sparc/ \
                                   -e /arm64/!s/arm.*/arm/ -e s/sa110/arm/ \
                                   -e s/s390x/s390/ -e s/parisc64/parisc/ \
@@ -10,6 +6,41 @@ ARCH := $(shell echo $(ARCH) | sed -e s/i.86/x86/ -e s/x86_64/x86/ \
                                   -e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ \
                                   -e s/tile.*/tile/ )
 
+ifndef ARCH
+ARCH := $(HOSTARCH)
+endif
+
+SRCARCH := $(ARCH)
+
+# Additional ARCH settings for x86
+ifeq ($(ARCH),i386)
+        SRCARCH := x86
+endif
+ifeq ($(ARCH),x86_64)
+        SRCARCH := x86
+endif
+
+# Additional ARCH settings for sparc
+ifeq ($(ARCH),sparc32)
+       SRCARCH := sparc
+endif
+ifeq ($(ARCH),sparc64)
+       SRCARCH := sparc
+endif
+
+# Additional ARCH settings for sh
+ifeq ($(ARCH),sh64)
+       SRCARCH := sh
+endif
+
+# Additional ARCH settings for tile
+ifeq ($(ARCH),tilepro)
+       SRCARCH := tile
+endif
+ifeq ($(ARCH),tilegx)
+       SRCARCH := tile
+endif
+
 LP64 := $(shell echo __LP64__ | ${CC} ${CFLAGS} -E -x c - | tail -n 1)
 ifeq ($(LP64), 1)
   IS_64_BIT := 1
diff --git a/tools/spi/Makefile b/tools/spi/Makefile
index cd0db62e4d9d..3815b18ba070 100644
--- a/tools/spi/Makefile
+++ b/tools/spi/Makefile
@@ -1,3 +1,5 @@
+CC = $(CROSS_COMPILE)gcc
+
 all: spidev_test spidev_fdx
 
 clean:
diff --git a/tools/spi/spidev_test.c b/tools/spi/spidev_test.c
index 8a73d8185316..f046b77cfefe 100644
--- a/tools/spi/spidev_test.c
+++ b/tools/spi/spidev_test.c
@@ -19,6 +19,7 @@
 #include <getopt.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
+#include <linux/ioctl.h>
 #include <sys/stat.h>
 #include <linux/types.h>
 #include <linux/spi/spidev.h>
@@ -284,7 +285,7 @@ static void parse_opts(int argc, char *argv[])
 
 static void transfer_escaped_string(int fd, char *str)
 {
-        size_t size = strlen(str + 1);
+        size_t size = strlen(str);
         uint8_t *tx;
         uint8_t *rx;
 
diff --git a/tools/testing/nvdimm/Kbuild b/tools/testing/nvdimm/Kbuild
index 785985677159..582db95127ed 100644
--- a/tools/testing/nvdimm/Kbuild
+++ b/tools/testing/nvdimm/Kbuild
@@ -11,12 +11,15 @@ ldflags-y += --wrap=__devm_release_region
 ldflags-y += --wrap=__request_region
 ldflags-y += --wrap=__release_region
 ldflags-y += --wrap=devm_memremap_pages
-ldflags-y += --wrap=phys_to_pfn_t
+ldflags-y += --wrap=insert_resource
+ldflags-y += --wrap=remove_resource
+ldflags-y += --wrap=acpi_evaluate_object
 
 DRIVERS := ../../../drivers
 NVDIMM_SRC := $(DRIVERS)/nvdimm
-ACPI_SRC := $(DRIVERS)/acpi
+ACPI_SRC := $(DRIVERS)/acpi/nfit
 DAX_SRC := $(DRIVERS)/dax
+ccflags-y := -I$(src)/$(NVDIMM_SRC)/
 
 obj-$(CONFIG_LIBNVDIMM) += libnvdimm.o
 obj-$(CONFIG_BLK_DEV_PMEM) += nd_pmem.o
@@ -27,10 +30,12 @@ obj-$(CONFIG_ACPI_NFIT) += nfit.o
 obj-$(CONFIG_DEV_DAX) += dax.o
 obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o
 
-nfit-y := $(ACPI_SRC)/nfit.o
+nfit-y := $(ACPI_SRC)/core.o
+nfit-$(CONFIG_X86_MCE) += $(ACPI_SRC)/mce.o
 nfit-y += config_check.o
 
 nd_pmem-y := $(NVDIMM_SRC)/pmem.o
+nd_pmem-y += pmem-dax.o
 nd_pmem-y += config_check.o
 
 nd_btt-y := $(NVDIMM_SRC)/btt.o
diff --git a/tools/testing/nvdimm/config_check.c b/tools/testing/nvdimm/config_check.c
index adf18bfeca00..7dc5a0af9b54 100644
--- a/tools/testing/nvdimm/config_check.c
+++ b/tools/testing/nvdimm/config_check.c
@@ -1,4 +1,3 @@
-#include <linux/kconfig.h>
 #include <linux/bug.h>
 
 void check(void)
@@ -10,6 +9,7 @@ void check(void)
         BUILD_BUG_ON(!IS_MODULE(CONFIG_LIBNVDIMM));
         BUILD_BUG_ON(!IS_MODULE(CONFIG_BLK_DEV_PMEM));
         BUILD_BUG_ON(!IS_MODULE(CONFIG_ND_BTT));
+        BUILD_BUG_ON(!IS_MODULE(CONFIG_ND_PFN));
         BUILD_BUG_ON(!IS_MODULE(CONFIG_ND_BLK));
         BUILD_BUG_ON(!IS_MODULE(CONFIG_ACPI_NFIT));
         BUILD_BUG_ON(!IS_MODULE(CONFIG_DEV_DAX));
diff --git a/tools/testing/nvdimm/pmem-dax.c b/tools/testing/nvdimm/pmem-dax.c
new file mode 100644
index 000000000000..c9b8c48f85fc
--- /dev/null
+++ b/tools/testing/nvdimm/pmem-dax.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2014-2016, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include "test/nfit_test.h"
+#include <linux/blkdev.h>
+#include <pmem.h>
+#include <nd.h>
+
+long pmem_direct_access(struct block_device *bdev, sector_t sector,
+                void **kaddr, pfn_t *pfn, long size)
+{
+        struct pmem_device *pmem = bdev->bd_queue->queuedata;
+        resource_size_t offset = sector * 512 + pmem->data_offset;
+
+        if (unlikely(is_bad_pmem(&pmem->bb, sector, size)))
+                return -EIO;
+
+        /*
+         * Limit dax to a single page at a time given vmalloc()-backed
+         * in the nfit_test case.
+         */
+        if (get_nfit_res(pmem->phys_addr + offset)) {
+                struct page *page;
+
+                *kaddr = pmem->virt_addr + offset;
+                page = vmalloc_to_page(pmem->virt_addr + offset);
+                *pfn = page_to_pfn_t(page);
+                dev_dbg_ratelimited(disk_to_dev(bdev->bd_disk)->parent,
+                                "%s: sector: %#llx pfn: %#lx\n", __func__,
+                                (unsigned long long) sector, page_to_pfn(page));
+
+                return PAGE_SIZE;
+        }
+
+        *kaddr = pmem->virt_addr + offset;
+        *pfn = phys_to_pfn_t(pmem->phys_addr + offset, pmem->pfn_flags);
+
+        /*
+         * If badblocks are present, limit known good range to the
+         * requested range.
+         */
+        if (unlikely(pmem->bb.count))
+                return size;
+        return pmem->size - pmem->pfn_pad - offset;
+}
diff --git a/tools/testing/nvdimm/test/Kbuild b/tools/testing/nvdimm/test/Kbuild
index 9241064970fe..d32f25bba42a 100644
--- a/tools/testing/nvdimm/test/Kbuild
+++ b/tools/testing/nvdimm/test/Kbuild
@@ -1,5 +1,5 @@
 ccflags-y := -I$(src)/../../../../drivers/nvdimm/
-ccflags-y += -I$(src)/../../../../drivers/acpi/
+ccflags-y += -I$(src)/../../../../drivers/acpi/nfit/
 
 obj-m += nfit_test.o
 obj-m += nfit_test_iomap.o
diff --git a/tools/testing/nvdimm/test/iomap.c b/tools/testing/nvdimm/test/iomap.c
index c842095f2801..3ccef732fce9 100644
--- a/tools/testing/nvdimm/test/iomap.c
+++ b/tools/testing/nvdimm/test/iomap.c
@@ -10,11 +10,14 @@
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  */
+#include <linux/memremap.h>
 #include <linux/rculist.h>
 #include <linux/export.h>
 #include <linux/ioport.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <linux/pfn_t.h>
+#include <linux/acpi.h>
 #include <linux/io.h>
 #include <linux/mm.h>
 #include "nfit_test.h"
@@ -52,7 +55,7 @@ static struct nfit_test_resource *__get_nfit_res(resource_size_t resource)
         return NULL;
 }
 
-static struct nfit_test_resource *get_nfit_res(resource_size_t resource)
+struct nfit_test_resource *get_nfit_res(resource_size_t resource)
 {
         struct nfit_test_resource *res;
 
@@ -62,6 +65,7 @@ static struct nfit_test_resource *get_nfit_res(resource_size_t resource)
 
         return res;
 }
+EXPORT_SYMBOL(get_nfit_res);
 
 void __iomem *__nfit_test_ioremap(resource_size_t offset, unsigned long size,
                 void __iomem *(*fallback_fn)(resource_size_t, unsigned long))
@@ -70,7 +74,7 @@ void __iomem *__nfit_test_ioremap(resource_size_t offset, unsigned long size,
 
         if (nfit_res)
                 return (void __iomem *) nfit_res->buf + offset
-                        - nfit_res->res->start;
+                        - nfit_res->res.start;
         return fallback_fn(offset, size);
 }
 
@@ -81,7 +85,7 @@ void __iomem *__wrap_devm_ioremap_nocache(struct device *dev,
 
         if (nfit_res)
                 return (void __iomem *) nfit_res->buf + offset
-                        - nfit_res->res->start;
+                        - nfit_res->res.start;
         return devm_ioremap_nocache(dev, offset, size);
 }
 EXPORT_SYMBOL(__wrap_devm_ioremap_nocache);
@@ -92,15 +96,11 @@ void *__wrap_devm_memremap(struct device *dev, resource_size_t offset,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return devm_memremap(dev, offset, size, flags);
 }
 EXPORT_SYMBOL(__wrap_devm_memremap);
 
-#ifdef __HAVE_ARCH_PTE_DEVMAP
-#include <linux/memremap.h>
-#include <linux/pfn_t.h>
-
 void *__wrap_devm_memremap_pages(struct device *dev, struct resource *res,
                 struct percpu_ref *ref, struct vmem_altmap *altmap)
 {
@@ -108,7 +108,7 @@ void *__wrap_devm_memremap_pages(struct device *dev, struct resource *res,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return devm_memremap_pages(dev, res, ref, altmap);
 }
 EXPORT_SYMBOL(__wrap_devm_memremap_pages);
@@ -122,19 +122,6 @@ pfn_t __wrap_phys_to_pfn_t(phys_addr_t addr, unsigned long flags)
         return phys_to_pfn_t(addr, flags);
 }
 EXPORT_SYMBOL(__wrap_phys_to_pfn_t);
-#else
-/* to be removed post 4.5-rc1 */
-void *__wrap_devm_memremap_pages(struct device *dev, struct resource *res)
-{
-        resource_size_t offset = res->start;
-        struct nfit_test_resource *nfit_res = get_nfit_res(offset);
-
-        if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
-        return devm_memremap_pages(dev, res);
-}
-EXPORT_SYMBOL(__wrap_devm_memremap_pages);
-#endif
 
 void *__wrap_memremap(resource_size_t offset, size_t size,
                 unsigned long flags)
@@ -142,7 +129,7 @@ void *__wrap_memremap(resource_size_t offset, size_t size,
         struct nfit_test_resource *nfit_res = get_nfit_res(offset);
 
         if (nfit_res)
-                return nfit_res->buf + offset - nfit_res->res->start;
+                return nfit_res->buf + offset - nfit_res->res.start;
         return memremap(offset, size, flags);
 }
 EXPORT_SYMBOL(__wrap_memremap);
@@ -188,6 +175,63 @@ void __wrap_memunmap(void *addr)
 }
 EXPORT_SYMBOL(__wrap_memunmap);
 
+static bool nfit_test_release_region(struct device *dev,
+                struct resource *parent, resource_size_t start,
+                resource_size_t n);
+
+static void nfit_devres_release(struct device *dev, void *data)
+{
+        struct resource *res = *((struct resource **) data);
+
+        WARN_ON(!nfit_test_release_region(NULL, &iomem_resource, res->start,
+                        resource_size(res)));
+}
+
+static int match(struct device *dev, void *__res, void *match_data)
+{
+        struct resource *res = *((struct resource **) __res);
+        resource_size_t start = *((resource_size_t *) match_data);
+
+        return res->start == start;
+}
+
+static bool nfit_test_release_region(struct device *dev,
+                struct resource *parent, resource_size_t start,
+                resource_size_t n)
+{
+        if (parent == &iomem_resource) {
+                struct nfit_test_resource *nfit_res = get_nfit_res(start);
+
+                if (nfit_res) {
+                        struct nfit_test_request *req;
+                        struct resource *res = NULL;
+
+                        if (dev) {
+                                devres_release(dev, nfit_devres_release, match,
+                                                &start);
+                                return true;
+                        }
+
+                        spin_lock(&nfit_res->lock);
+                        list_for_each_entry(req, &nfit_res->requests, list)
+                                if (req->res.start == start) {
+                                        res = &req->res;
+                                        list_del(&req->list);
+                                        break;
+                                }
+                        spin_unlock(&nfit_res->lock);
+
+                        WARN(!res || resource_size(res) != n,
+                                        "%s: start: %llx n: %llx mismatch: %pr\n",
+                                                __func__, start, n, res);
+                        if (res)
+                                kfree(req);
+                        return true;
+                }
+        }
+        return false;
+}
+
 static struct resource *nfit_test_request_region(struct device *dev,
                 struct resource *parent, resource_size_t start,
                 resource_size_t n, const char *name, int flags)
@@ -197,21 +241,57 @@ static struct resource *nfit_test_request_region(struct device *dev,
         if (parent == &iomem_resource) {
                 nfit_res = get_nfit_res(start);
                 if (nfit_res) {
-                        struct resource *res = nfit_res->res + 1;
+                        struct nfit_test_request *req;
+                        struct resource *res = NULL;
 
-                        if (start + n > nfit_res->res->start
-                                        + resource_size(nfit_res->res)) {
+                        if (start + n > nfit_res->res.start
+                                        + resource_size(&nfit_res->res)) {
                                 pr_debug("%s: start: %llx n: %llx overflow: %pr\n",
                                                 __func__, start, n,
-                                                nfit_res->res);
+                                                &nfit_res->res);
                                 return NULL;
                         }
 
+                        spin_lock(&nfit_res->lock);
+                        list_for_each_entry(req, &nfit_res->requests, list)
+                                if (start == req->res.start) {
+                                        res = &req->res;
+                                        break;
+                                }
+                        spin_unlock(&nfit_res->lock);
+
+                        if (res) {
+                                WARN(1, "%pr already busy\n", res);
+                                return NULL;
+                        }
+
+                        req = kzalloc(sizeof(*req), GFP_KERNEL);
+                        if (!req)
+                                return NULL;
+                        INIT_LIST_HEAD(&req->list);
+                        res = &req->res;
+
                         res->start = start;
                         res->end = start + n - 1;
                         res->name = name;
                         res->flags = resource_type(parent);
                         res->flags |= IORESOURCE_BUSY | flags;
+                        spin_lock(&nfit_res->lock);
+                        list_add(&req->list, &nfit_res->requests);
+                        spin_unlock(&nfit_res->lock);
+
+                        if (dev) {
+                                struct resource **d;
+
+                                d = devres_alloc(nfit_devres_release,
+                                                sizeof(struct resource *),
+                                                GFP_KERNEL);
+                                if (!d)
+                                        return NULL;
+                                *d = res;
+                                devres_add(dev, d);
+                        }
+
                         pr_debug("%s: %pr\n", __func__, res);
                         return res;
                 }
@@ -229,6 +309,22 @@ struct resource *__wrap___request_region(struct resource *parent,
 }
 EXPORT_SYMBOL(__wrap___request_region);
 
+int __wrap_insert_resource(struct resource *parent, struct resource *res)
+{
+        if (get_nfit_res(res->start))
+                return 0;
+        return insert_resource(parent, res);
+}
+EXPORT_SYMBOL(__wrap_insert_resource);
+
+int __wrap_remove_resource(struct resource *res)
+{
+        if (get_nfit_res(res->start))
+                return 0;
+        return remove_resource(res);
+}
+EXPORT_SYMBOL(__wrap_remove_resource);
+
 struct resource *__wrap___devm_request_region(struct device *dev,
                 struct resource *parent, resource_size_t start,
                 resource_size_t n, const char *name)
@@ -239,29 +335,10 @@ struct resource *__wrap___devm_request_region(struct device *dev,
 }
 EXPORT_SYMBOL(__wrap___devm_request_region);
 
-static bool nfit_test_release_region(struct resource *parent,
-                resource_size_t start, resource_size_t n)
-{
-        if (parent == &iomem_resource) {
-                struct nfit_test_resource *nfit_res = get_nfit_res(start);
-                if (nfit_res) {
-                        struct resource *res = nfit_res->res + 1;
-
-                        if (start != res->start || resource_size(res) != n)
-                                pr_info("%s: start: %llx n: %llx mismatch: %pr\n",
-                                                __func__, start, n, res);
-                        else
-                                memset(res, 0, sizeof(*res));
-                        return true;
-                }
-        }
-        return false;
-}
-
 void __wrap___release_region(struct resource *parent, resource_size_t start,
                 resource_size_t n)
 {
-        if (!nfit_test_release_region(parent, start, n))
+        if (!nfit_test_release_region(NULL, parent, start, n))
                 __release_region(parent, start, n);
 }
 EXPORT_SYMBOL(__wrap___release_region);
@@ -269,9 +346,25 @@ EXPORT_SYMBOL(__wrap___release_region);
 void __wrap___devm_release_region(struct device *dev, struct resource *parent,
                 resource_size_t start, resource_size_t n)
 {
-        if (!nfit_test_release_region(parent, start, n))
+        if (!nfit_test_release_region(dev, parent, start, n))
                 __devm_release_region(dev, parent, start, n);
 }
 EXPORT_SYMBOL(__wrap___devm_release_region);
 
+acpi_status __wrap_acpi_evaluate_object(acpi_handle handle, acpi_string path,
+                struct acpi_object_list *p, struct acpi_buffer *buf)
+{
+        struct nfit_test_resource *nfit_res = get_nfit_res((long) handle);
+        union acpi_object **obj;
+
+        if (!nfit_res || strcmp(path, "_FIT") || !buf)
+                return acpi_evaluate_object(handle, path, p, buf);
+
+        obj = nfit_res->buf;
+        buf->length = sizeof(union acpi_object);
+        buf->pointer = *obj;
+        return AE_OK;
+}
+EXPORT_SYMBOL(__wrap_acpi_evaluate_object);
+
 MODULE_LICENSE("GPL v2");
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index c919866853a0..c9a6458cb63e 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -13,6 +13,7 @@
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/workqueue.h>
 #include <linux/libnvdimm.h>
 #include <linux/vmalloc.h>
 #include <linux/device.h>
@@ -98,11 +99,13 @@
 enum {
         NUM_PM  = 3,
         NUM_DCR = 5,
+        NUM_HINTS = 8,
         NUM_BDW = NUM_DCR,
         NUM_SPA = NUM_PM + NUM_DCR + NUM_BDW,
         NUM_MEM = NUM_DCR + NUM_BDW + 2 /* spa0 iset */ + 4 /* spa1 iset */,
         DIMM_SIZE = SZ_32M,
         LABEL_SIZE = SZ_128K,
+        SPA_VCD_SIZE = SZ_4M,
         SPA0_SIZE = DIMM_SIZE,
         SPA1_SIZE = DIMM_SIZE*2,
         SPA2_SIZE = DIMM_SIZE,
@@ -129,6 +132,8 @@ static u32 handle[NUM_DCR] = {
         [4] = NFIT_DIMM_HANDLE(0, 1, 0, 0, 0),
 };
 
+static unsigned long dimm_fail_cmd_flags[NUM_DCR];
+
 struct nfit_test {
         struct acpi_nfit_desc acpi_desc;
         struct platform_device pdev;
@@ -151,11 +156,14 @@ struct nfit_test {
         int (*alloc)(struct nfit_test *t);
         void (*setup)(struct nfit_test *t);
         int setup_hotplug;
+        union acpi_object **_fit;
+        dma_addr_t _fit_dma;
         struct ars_state {
                 struct nd_cmd_ars_status *ars_status;
                 unsigned long deadline;
                 spinlock_t lock;
         } ars_state;
+        struct device *dimm_dev[NUM_DCR];
 };
 
 static struct nfit_test *to_nfit_test(struct device *dev)
@@ -408,6 +416,9 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                 if (i >= ARRAY_SIZE(handle))
                         return -ENXIO;
 
+                if ((1 << func) & dimm_fail_cmd_flags[i])
+                        return -EIO;
+
                 switch (func) {
                 case ND_CMD_GET_CONFIG_SIZE:
                         rc = nfit_test_cmd_get_config_size(buf, buf_len);
@@ -425,6 +436,9 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                         break;
                 case ND_CMD_SMART_THRESHOLD:
                         rc = nfit_test_cmd_smart_threshold(buf, buf_len);
+                        device_lock(&t->pdev.dev);
+                        __acpi_nvdimm_notify(t->dimm_dev[i], 0x81);
+                        device_unlock(&t->pdev.dev);
                         break;
                 default:
                         return -ENOTTY;
@@ -464,18 +478,12 @@ static struct nfit_test *instances[NUM_NFITS];
 static void release_nfit_res(void *data)
 {
         struct nfit_test_resource *nfit_res = data;
-        struct resource *res = nfit_res->res;
 
         spin_lock(&nfit_test_lock);
         list_del(&nfit_res->list);
         spin_unlock(&nfit_test_lock);
 
-        if (is_vmalloc_addr(nfit_res->buf))
-                vfree(nfit_res->buf);
-        else
-                dma_free_coherent(nfit_res->dev, resource_size(res),
-                                nfit_res->buf, res->start);
-        kfree(res);
+        vfree(nfit_res->buf);
         kfree(nfit_res);
 }
 
@@ -483,12 +491,11 @@ static void *__test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma,
                 void *buf)
 {
         struct device *dev = &t->pdev.dev;
-        struct resource *res = kzalloc(sizeof(*res) * 2, GFP_KERNEL);
         struct nfit_test_resource *nfit_res = kzalloc(sizeof(*nfit_res),
                         GFP_KERNEL);
         int rc;
 
-        if (!res || !buf || !nfit_res)
+        if (!buf || !nfit_res)
                 goto err;
         rc = devm_add_action(dev, release_nfit_res, nfit_res);
         if (rc)
@@ -497,21 +504,19 @@ static void *__test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma,
         memset(buf, 0, size);
         nfit_res->dev = dev;
         nfit_res->buf = buf;
-        nfit_res->res = res;
-        res->start = *dma;
-        res->end = *dma + size - 1;
-        res->name = "NFIT";
+        nfit_res->res.start = *dma;
+        nfit_res->res.end = *dma + size - 1;
+        nfit_res->res.name = "NFIT";
+        spin_lock_init(&nfit_res->lock);
+        INIT_LIST_HEAD(&nfit_res->requests);
         spin_lock(&nfit_test_lock);
         list_add(&nfit_res->list, &t->resources);
         spin_unlock(&nfit_test_lock);
 
         return nfit_res->buf;
  err:
-        if (buf && !is_vmalloc_addr(buf))
-                dma_free_coherent(dev, size, buf, *dma);
-        else if (buf)
+        if (buf)
                 vfree(buf);
-        kfree(res);
         kfree(nfit_res);
         return NULL;
 }
@@ -524,15 +529,6 @@ static void *test_alloc(struct nfit_test *t, size_t size, dma_addr_t *dma)
         return __test_alloc(t, size, dma, buf);
 }
 
-static void *test_alloc_coherent(struct nfit_test *t, size_t size,
-                dma_addr_t *dma)
-{
-        struct device *dev = &t->pdev.dev;
-        void *buf = dma_alloc_coherent(dev, size, dma, GFP_KERNEL);
-
-        return __test_alloc(t, size, dma, buf);
-}
-
 static struct nfit_test_resource *nfit_test_lookup(resource_size_t addr)
 {
         int i;
@@ -545,13 +541,13 @@ static struct nfit_test_resource *nfit_test_lookup(resource_size_t addr)
                         continue;
                 spin_lock(&nfit_test_lock);
                 list_for_each_entry(n, &t->resources, list) {
-                        if (addr >= n->res->start && (addr < n->res->start
-                                                + resource_size(n->res))) {
+                        if (addr >= n->res.start && (addr < n->res.start
+                                                + resource_size(&n->res))) {
                                 nfit_res = n;
                                 break;
                         } else if (addr >= (unsigned long) n->buf
                                         && (addr < (unsigned long) n->buf
-                                                + resource_size(n->res))) {
+                                                + resource_size(&n->res))) {
                                 nfit_res = n;
                                 break;
                         }
@@ -576,6 +572,86 @@ static int ars_state_init(struct device *dev, struct ars_state *ars_state)
         return 0;
 }
 
+static void put_dimms(void *data)
+{
+        struct device **dimm_dev = data;
+        int i;
+
+        for (i = 0; i < NUM_DCR; i++)
+                if (dimm_dev[i])
+                        device_unregister(dimm_dev[i]);
+}
+
+static struct class *nfit_test_dimm;
+
+static int dimm_name_to_id(struct device *dev)
+{
+        int dimm;
+
+        if (sscanf(dev_name(dev), "test_dimm%d", &dimm) != 1
+                        || dimm >= NUM_DCR || dimm < 0)
+                return -ENXIO;
+        return dimm;
+}
+
+
+static ssize_t handle_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+        int dimm = dimm_name_to_id(dev);
+
+        if (dimm < 0)
+                return dimm;
+
+        return sprintf(buf, "%#x", handle[dimm]);
+}
+DEVICE_ATTR_RO(handle);
+
+static ssize_t fail_cmd_show(struct device *dev, struct device_attribute *attr,
+                char *buf)
+{
+        int dimm = dimm_name_to_id(dev);
+
+        if (dimm < 0)
+                return dimm;
+
+        return sprintf(buf, "%#lx\n", dimm_fail_cmd_flags[dimm]);
+}
+
+static ssize_t fail_cmd_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t size)
+{
+        int dimm = dimm_name_to_id(dev);
+        unsigned long val;
+        ssize_t rc;
+
+        if (dimm < 0)
+                return dimm;
+
+        rc = kstrtol(buf, 0, &val);
+        if (rc)
+                return rc;
+
+        dimm_fail_cmd_flags[dimm] = val;
+        return size;
+}
+static DEVICE_ATTR_RW(fail_cmd);
+
+static struct attribute *nfit_test_dimm_attributes[] = {
+        &dev_attr_fail_cmd.attr,
+        &dev_attr_handle.attr,
+        NULL,
+};
+
+static struct attribute_group nfit_test_dimm_attribute_group = {
+        .attrs = nfit_test_dimm_attributes,
+};
+
+static const struct attribute_group *nfit_test_dimm_attribute_groups[] = {
+        &nfit_test_dimm_attribute_group,
+        NULL,
+};
+
 static int nfit_test0_alloc(struct nfit_test *t)
 {
         size_t nfit_size = sizeof(struct acpi_nfit_system_address) * NUM_SPA
@@ -584,7 +660,8 @@ static int nfit_test0_alloc(struct nfit_test *t)
                         + offsetof(struct acpi_nfit_control_region,
                                         window_size) * NUM_DCR
                         + sizeof(struct acpi_nfit_data_region) * NUM_BDW
-                        + sizeof(struct acpi_nfit_flush_address) * NUM_DCR;
+                        + (sizeof(struct acpi_nfit_flush_address)
+                                        + sizeof(u64) * NUM_HINTS) * NUM_DCR;
         int i;
 
         t->nfit_buf = test_alloc(t, nfit_size, &t->nfit_dma);
@@ -592,15 +669,15 @@ static int nfit_test0_alloc(struct nfit_test *t)
                 return -ENOMEM;
         t->nfit_size = nfit_size;
 
-        t->spa_set[0] = test_alloc_coherent(t, SPA0_SIZE, &t->spa_set_dma[0]);
+        t->spa_set[0] = test_alloc(t, SPA0_SIZE, &t->spa_set_dma[0]);
         if (!t->spa_set[0])
                 return -ENOMEM;
 
-        t->spa_set[1] = test_alloc_coherent(t, SPA1_SIZE, &t->spa_set_dma[1]);
+        t->spa_set[1] = test_alloc(t, SPA1_SIZE, &t->spa_set_dma[1]);
         if (!t->spa_set[1])
                 return -ENOMEM;
 
-        t->spa_set[2] = test_alloc_coherent(t, SPA0_SIZE, &t->spa_set_dma[2]);
+        t->spa_set[2] = test_alloc(t, SPA0_SIZE, &t->spa_set_dma[2]);
         if (!t->spa_set[2])
                 return -ENOMEM;
 
@@ -614,7 +691,9 @@ static int nfit_test0_alloc(struct nfit_test *t)
                         return -ENOMEM;
                 sprintf(t->label[i], "label%d", i);
 
-                t->flush[i] = test_alloc(t, 8, &t->flush_dma[i]);
+                t->flush[i] = test_alloc(t, max(PAGE_SIZE,
+                                        sizeof(u64) * NUM_HINTS),
+                                &t->flush_dma[i]);
                 if (!t->flush[i])
                         return -ENOMEM;
         }
@@ -625,12 +704,27 @@ static int nfit_test0_alloc(struct nfit_test *t)
                         return -ENOMEM;
         }
 
+        t->_fit = test_alloc(t, sizeof(union acpi_object **), &t->_fit_dma);
+        if (!t->_fit)
+                return -ENOMEM;
+
+        if (devm_add_action_or_reset(&t->pdev.dev, put_dimms, t->dimm_dev))
+                return -ENOMEM;
+        for (i = 0; i < NUM_DCR; i++) {
+                t->dimm_dev[i] = device_create_with_groups(nfit_test_dimm,
+                                &t->pdev.dev, 0, NULL,
+                                nfit_test_dimm_attribute_groups,
+                                "test_dimm%d", i);
+                if (!t->dimm_dev[i])
+                        return -ENOMEM;
+        }
+
         return ars_state_init(&t->pdev.dev, &t->ars_state);
 }
 
 static int nfit_test1_alloc(struct nfit_test *t)
 {
-        size_t nfit_size = sizeof(struct acpi_nfit_system_address)
+        size_t nfit_size = sizeof(struct acpi_nfit_system_address) * 2
                 + sizeof(struct acpi_nfit_memory_map)
                 + offsetof(struct acpi_nfit_control_region, window_size);
 
@@ -639,15 +733,31 @@ static int nfit_test1_alloc(struct nfit_test *t)
                 return -ENOMEM;
         t->nfit_size = nfit_size;
 
-        t->spa_set[0] = test_alloc_coherent(t, SPA2_SIZE, &t->spa_set_dma[0]);
+        t->spa_set[0] = test_alloc(t, SPA2_SIZE, &t->spa_set_dma[0]);
         if (!t->spa_set[0])
                 return -ENOMEM;
 
+        t->spa_set[1] = test_alloc(t, SPA_VCD_SIZE, &t->spa_set_dma[1]);
+        if (!t->spa_set[1])
+                return -ENOMEM;
+
         return ars_state_init(&t->pdev.dev, &t->ars_state);
 }
 
+static void dcr_common_init(struct acpi_nfit_control_region *dcr)
+{
+        dcr->vendor_id = 0xabcd;
+        dcr->device_id = 0;
+        dcr->revision_id = 1;
+        dcr->valid_fields = 1;
+        dcr->manufacturing_location = 0xa;
+        dcr->manufacturing_date = cpu_to_be16(2016);
+}
+
 static void nfit_test0_setup(struct nfit_test *t)
 {
+        const int flush_hint_size = sizeof(struct acpi_nfit_flush_address)
+                + (sizeof(u64) * NUM_HINTS);
         struct acpi_nfit_desc *acpi_desc;
         struct acpi_nfit_memory_map *memdev;
         void *nfit_buf = t->nfit_buf;
@@ -655,7 +765,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         struct acpi_nfit_control_region *dcr;
         struct acpi_nfit_data_region *bdw;
         struct acpi_nfit_flush_address *flush;
-        unsigned int offset;
+        unsigned int offset, i;
 
         /*
          * spa0 (interleave first half of dimm0 and dimm1, note storage
@@ -972,9 +1082,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
         dcr->header.length = sizeof(struct acpi_nfit_control_region);
         dcr->region_index = 0+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[0];
         dcr->code = NFIT_FIC_BLK;
         dcr->windows = 1;
@@ -989,9 +1097,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
         dcr->header.length = sizeof(struct acpi_nfit_control_region);
         dcr->region_index = 1+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[1];
         dcr->code = NFIT_FIC_BLK;
         dcr->windows = 1;
@@ -1006,9 +1112,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
         dcr->header.length = sizeof(struct acpi_nfit_control_region);
         dcr->region_index = 2+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[2];
         dcr->code = NFIT_FIC_BLK;
         dcr->windows = 1;
@@ -1023,9 +1127,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
         dcr->header.length = sizeof(struct acpi_nfit_control_region);
         dcr->region_index = 3+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[3];
         dcr->code = NFIT_FIC_BLK;
         dcr->windows = 1;
@@ -1042,9 +1144,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.length = offsetof(struct acpi_nfit_control_region,
                         window_size);
         dcr->region_index = 4+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[0];
         dcr->code = NFIT_FIC_BYTEN;
         dcr->windows = 0;
@@ -1056,9 +1156,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.length = offsetof(struct acpi_nfit_control_region,
                         window_size);
         dcr->region_index = 5+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[1];
         dcr->code = NFIT_FIC_BYTEN;
         dcr->windows = 0;
@@ -1070,9 +1168,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.length = offsetof(struct acpi_nfit_control_region,
                         window_size);
         dcr->region_index = 6+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[2];
         dcr->code = NFIT_FIC_BYTEN;
         dcr->windows = 0;
@@ -1084,9 +1180,7 @@ static void nfit_test0_setup(struct nfit_test *t)
         dcr->header.length = offsetof(struct acpi_nfit_control_region,
                         window_size);
         dcr->region_index = 7+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~handle[3];
         dcr->code = NFIT_FIC_BYTEN;
         dcr->windows = 0;
@@ -1141,45 +1235,47 @@ static void nfit_test0_setup(struct nfit_test *t)
         /* flush0 (dimm0) */
         flush = nfit_buf + offset;
         flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
-        flush->header.length = sizeof(struct acpi_nfit_flush_address);
+        flush->header.length = flush_hint_size;
         flush->device_handle = handle[0];
-        flush->hint_count = 1;
-        flush->hint_address[0] = t->flush_dma[0];
+        flush->hint_count = NUM_HINTS;
+        for (i = 0; i < NUM_HINTS; i++)
+                flush->hint_address[i] = t->flush_dma[0] + i * sizeof(u64);
 
         /* flush1 (dimm1) */
-        flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 1;
+        flush = nfit_buf + offset + flush_hint_size * 1;
         flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
-        flush->header.length = sizeof(struct acpi_nfit_flush_address);
+        flush->header.length = flush_hint_size;
         flush->device_handle = handle[1];
-        flush->hint_count = 1;
-        flush->hint_address[0] = t->flush_dma[1];
+        flush->hint_count = NUM_HINTS;
+        for (i = 0; i < NUM_HINTS; i++)
+                flush->hint_address[i] = t->flush_dma[1] + i * sizeof(u64);
 
         /* flush2 (dimm2) */
-        flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 2;
+        flush = nfit_buf + offset + flush_hint_size  * 2;
         flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
-        flush->header.length = sizeof(struct acpi_nfit_flush_address);
+        flush->header.length = flush_hint_size;
         flush->device_handle = handle[2];
-        flush->hint_count = 1;
-        flush->hint_address[0] = t->flush_dma[2];
+        flush->hint_count = NUM_HINTS;
+        for (i = 0; i < NUM_HINTS; i++)
+                flush->hint_address[i] = t->flush_dma[2] + i * sizeof(u64);
 
         /* flush3 (dimm3) */
-        flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 3;
+        flush = nfit_buf + offset + flush_hint_size * 3;
         flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
-        flush->header.length = sizeof(struct acpi_nfit_flush_address);
+        flush->header.length = flush_hint_size;
         flush->device_handle = handle[3];
-        flush->hint_count = 1;
-        flush->hint_address[0] = t->flush_dma[3];
+        flush->hint_count = NUM_HINTS;
+        for (i = 0; i < NUM_HINTS; i++)
+                flush->hint_address[i] = t->flush_dma[3] + i * sizeof(u64);
 
         if (t->setup_hotplug) {
-                offset = offset + sizeof(struct acpi_nfit_flush_address) * 4;
+                offset = offset + flush_hint_size * 4;
                 /* dcr-descriptor4: blk */
                 dcr = nfit_buf + offset;
                 dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
                 dcr->header.length = sizeof(struct acpi_nfit_control_region);
                 dcr->region_index = 8+1;
-                dcr->vendor_id = 0xabcd;
-                dcr->device_id = 0;
-                dcr->revision_id = 1;
+                dcr_common_init(dcr);
                 dcr->serial_number = ~handle[4];
                 dcr->code = NFIT_FIC_BLK;
                 dcr->windows = 1;
@@ -1196,9 +1292,7 @@ static void nfit_test0_setup(struct nfit_test *t)
                 dcr->header.length = offsetof(struct acpi_nfit_control_region,
                                 window_size);
                 dcr->region_index = 9+1;
-                dcr->vendor_id = 0xabcd;
-                dcr->device_id = 0;
-                dcr->revision_id = 1;
+                dcr_common_init(dcr);
                 dcr->serial_number = ~handle[4];
                 dcr->code = NFIT_FIC_BYTEN;
                 dcr->windows = 0;
@@ -1300,10 +1394,12 @@ static void nfit_test0_setup(struct nfit_test *t)
                 /* flush3 (dimm4) */
                 flush = nfit_buf + offset;
                 flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
-                flush->header.length = sizeof(struct acpi_nfit_flush_address);
+                flush->header.length = flush_hint_size;
                 flush->device_handle = handle[4];
-                flush->hint_count = 1;
-                flush->hint_address[0] = t->flush_dma[4];
+                flush->hint_count = NUM_HINTS;
+                for (i = 0; i < NUM_HINTS; i++)
+                        flush->hint_address[i] = t->flush_dma[4]
+                                + i * sizeof(u64);
         }
 
         post_ars_status(&t->ars_state, t->spa_set_dma[0], SPA0_SIZE);
@@ -1339,7 +1435,16 @@ static void nfit_test1_setup(struct nfit_test *t)
         spa->address = t->spa_set_dma[0];
         spa->length = SPA2_SIZE;
 
-        offset += sizeof(*spa);
+        /* virtual cd region */
+        spa = nfit_buf + sizeof(*spa);
+        spa->header.type = ACPI_NFIT_TYPE_SYSTEM_ADDRESS;
+        spa->header.length = sizeof(*spa);
+        memcpy(spa->range_guid, to_nfit_uuid(NFIT_SPA_VCD), 16);
+        spa->range_index = 0;
+        spa->address = t->spa_set_dma[1];
+        spa->length = SPA_VCD_SIZE;
+
+        offset += sizeof(*spa) * 2;
         /* mem-region0 (spa0, dimm0) */
         memdev = nfit_buf + offset;
         memdev->header.type = ACPI_NFIT_TYPE_MEMORY_MAP;
@@ -1365,9 +1470,7 @@ static void nfit_test1_setup(struct nfit_test *t)
         dcr->header.length = offsetof(struct acpi_nfit_control_region,
                         window_size);
         dcr->region_index = 0+1;
-        dcr->vendor_id = 0xabcd;
-        dcr->device_id = 0;
-        dcr->revision_id = 1;
+        dcr_common_init(dcr);
         dcr->serial_number = ~0;
         dcr->code = NFIT_FIC_BYTE;
         dcr->windows = 0;
@@ -1409,6 +1512,8 @@ static int nfit_test_probe(struct platform_device *pdev)
         struct acpi_nfit_desc *acpi_desc;
         struct device *dev = &pdev->dev;
         struct nfit_test *nfit_test;
+        struct nfit_mem *nfit_mem;
+        union acpi_object *obj;
         int rc;
 
         nfit_test = to_nfit_test(&pdev->dev);
@@ -1462,20 +1567,16 @@ static int nfit_test_probe(struct platform_device *pdev)
         nfit_test->setup(nfit_test);
         acpi_desc = &nfit_test->acpi_desc;
         acpi_nfit_desc_init(acpi_desc, &pdev->dev);
-        acpi_desc->nfit = nfit_test->nfit_buf;
         acpi_desc->blk_do_io = nfit_test_blk_do_io;
         nd_desc = &acpi_desc->nd_desc;
         nd_desc->provider_name = NULL;
+        nd_desc->module = THIS_MODULE;
         nd_desc->ndctl = nfit_test_ctl;
-        acpi_desc->nvdimm_bus = nvdimm_bus_register(&pdev->dev, nd_desc);
-        if (!acpi_desc->nvdimm_bus)
-                return -ENXIO;
 
-        rc = acpi_nfit_init(acpi_desc, nfit_test->nfit_size);
-        if (rc) {
-                nvdimm_bus_unregister(acpi_desc->nvdimm_bus);
+        rc = acpi_nfit_init(acpi_desc, nfit_test->nfit_buf,
+                        nfit_test->nfit_size);
+        if (rc)
                 return rc;
-        }
 
         if (nfit_test->setup != nfit_test0_setup)
                 return 0;
@@ -1483,22 +1584,33 @@ static int nfit_test_probe(struct platform_device *pdev)
         nfit_test->setup_hotplug = 1;
         nfit_test->setup(nfit_test);
 
-        rc = acpi_nfit_init(acpi_desc, nfit_test->nfit_size);
-        if (rc) {
-                nvdimm_bus_unregister(acpi_desc->nvdimm_bus);
-                return rc;
+        obj = kzalloc(sizeof(*obj), GFP_KERNEL);
+        if (!obj)
+                return -ENOMEM;
+        obj->type = ACPI_TYPE_BUFFER;
+        obj->buffer.length = nfit_test->nfit_size;
+        obj->buffer.pointer = nfit_test->nfit_buf;
+        *(nfit_test->_fit) = obj;
+        __acpi_nfit_notify(&pdev->dev, nfit_test, 0x80);
+
+        /* associate dimm devices with nfit_mem data for notification testing */
+        mutex_lock(&acpi_desc->init_mutex);
+        list_for_each_entry(nfit_mem, &acpi_desc->dimms, list) {
+                u32 nfit_handle = __to_nfit_memdev(nfit_mem)->device_handle;
+                int i;
+
+                for (i = 0; i < NUM_DCR; i++)
+                        if (nfit_handle == handle[i])
+                                dev_set_drvdata(nfit_test->dimm_dev[i],
+                                                nfit_mem);
         }
+        mutex_unlock(&acpi_desc->init_mutex);
 
         return 0;
 }
 
 static int nfit_test_remove(struct platform_device *pdev)
 {
-        struct nfit_test *nfit_test = to_nfit_test(&pdev->dev);
-        struct acpi_nfit_desc *acpi_desc = &nfit_test->acpi_desc;
-
-        nvdimm_bus_unregister(acpi_desc->nvdimm_bus);
-
         return 0;
 }
 
@@ -1523,22 +1635,19 @@ static struct platform_driver nfit_test_driver = {
         .id_table = nfit_test_id,
 };
 
-#ifdef CONFIG_CMA_SIZE_MBYTES
-#define CMA_SIZE_MBYTES CONFIG_CMA_SIZE_MBYTES
-#else
-#define CMA_SIZE_MBYTES 0
-#endif
-
 static __init int nfit_test_init(void)
 {
         int rc, i;
 
+        nfit_test_dimm = class_create(THIS_MODULE, "nfit_test_dimm");
+        if (IS_ERR(nfit_test_dimm))
+                return PTR_ERR(nfit_test_dimm);
+
         nfit_test_setup(nfit_test_lookup);
 
         for (i = 0; i < NUM_NFITS; i++) {
                 struct nfit_test *nfit_test;
                 struct platform_device *pdev;
-                static int once;
 
                 nfit_test = kzalloc(sizeof(*nfit_test), GFP_KERNEL);
                 if (!nfit_test) {
@@ -1577,20 +1686,6 @@ static __init int nfit_test_init(void)
                         goto err_register;
 
                 instances[i] = nfit_test;
-
-                if (!once++) {
-                        dma_addr_t dma;
-                        void *buf;
-
-                        buf = dma_alloc_coherent(&pdev->dev, SZ_128M, &dma,
-                                        GFP_KERNEL);
-                        if (!buf) {
-                                rc = -ENOMEM;
-                                dev_warn(&pdev->dev, "need 128M of free cma\n");
-                                goto err_register;
-                        }
-                        dma_free_coherent(&pdev->dev, SZ_128M, buf, dma);
-                }
         }
 
         rc = platform_driver_register(&nfit_test_driver);
@@ -1614,6 +1709,7 @@ static __exit void nfit_test_exit(void)
         for (i = 0; i < NUM_NFITS; i++)
                 platform_device_unregister(&instances[i]->pdev);
         nfit_test_teardown();
+        class_destroy(nfit_test_dimm);
 }
 
 module_init(nfit_test_init);
diff --git a/tools/testing/nvdimm/test/nfit_test.h b/tools/testing/nvdimm/test/nfit_test.h
index 96c5e16d7db9..c281dd2e5e2d 100644
--- a/tools/testing/nvdimm/test/nfit_test.h
+++ b/tools/testing/nvdimm/test/nfit_test.h
@@ -12,11 +12,22 @@
  */
 #ifndef __NFIT_TEST_H__
 #define __NFIT_TEST_H__
+#include <linux/list.h>
+#include <linux/ioport.h>
+#include <linux/spinlock_types.h>
+
+struct nfit_test_request {
+        struct list_head list;
+        struct resource res;
+};
 
 struct nfit_test_resource {
+        struct list_head requests;
         struct list_head list;
-        struct resource *res;
+        struct resource res;
         struct device *dev;
+        spinlock_t lock;
+        int req_count;
         void *buf;
 };
 
@@ -26,4 +37,5 @@ void __iomem *__wrap_ioremap_nocache(resource_size_t offset,
 void __wrap_iounmap(volatile void __iomem *addr);
 void nfit_test_setup(nfit_test_lookup_fn lookup);
 void nfit_test_teardown(void);
+struct nfit_test_resource *get_nfit_res(resource_size_t resource);
 #endif
diff --git a/tools/testing/radix-tree/Makefile b/tools/testing/radix-tree/Makefile
index 3b530467148e..f2e07f2fd4b4 100644
--- a/tools/testing/radix-tree/Makefile
+++ b/tools/testing/radix-tree/Makefile
@@ -1,9 +1,10 @@
 
-CFLAGS += -I. -g -Wall -D_LGPL_SOURCE
+CFLAGS += -I. -g -O2 -Wall -D_LGPL_SOURCE
 LDFLAGS += -lpthread -lurcu
 TARGETS = main
 OFILES = main.o radix-tree.o linux.o test.o tag_check.o find_next_bit.o \
-         regression1.o regression2.o regression3.o multiorder.o
+         regression1.o regression2.o regression3.o multiorder.o \
+         iteration_check.o
 
 targets: $(TARGETS)
 
diff --git a/tools/testing/radix-tree/iteration_check.c b/tools/testing/radix-tree/iteration_check.c
new file mode 100644
index 000000000000..9adb8e7415a6
--- /dev/null
+++ b/tools/testing/radix-tree/iteration_check.c
@@ -0,0 +1,180 @@
+/*
+ * iteration_check.c: test races having to do with radix tree iteration
+ * Copyright (c) 2016 Intel Corporation
+ * Author: Ross Zwisler <ross.zwisler@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include <linux/radix-tree.h>
+#include <pthread.h>
+#include "test.h"
+
+#define NUM_THREADS 4
+#define TAG 0
+static pthread_mutex_t tree_lock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_t threads[NUM_THREADS];
+RADIX_TREE(tree, GFP_KERNEL);
+bool test_complete;
+
+/* relentlessly fill the tree with tagged entries */
+static void *add_entries_fn(void *arg)
+{
+        int pgoff;
+
+        while (!test_complete) {
+                for (pgoff = 0; pgoff < 100; pgoff++) {
+                        pthread_mutex_lock(&tree_lock);
+                        if (item_insert(&tree, pgoff) == 0)
+                                item_tag_set(&tree, pgoff, TAG);
+                        pthread_mutex_unlock(&tree_lock);
+                }
+        }
+
+        return NULL;
+}
+
+/*
+ * Iterate over the tagged entries, doing a radix_tree_iter_retry() as we find
+ * things that have been removed and randomly resetting our iteration to the
+ * next chunk with radix_tree_iter_next().  Both radix_tree_iter_retry() and
+ * radix_tree_iter_next() cause radix_tree_next_slot() to be called with a
+ * NULL 'slot' variable.
+ */
+static void *tagged_iteration_fn(void *arg)
+{
+        struct radix_tree_iter iter;
+        void **slot;
+
+        while (!test_complete) {
+                rcu_read_lock();
+                radix_tree_for_each_tagged(slot, &tree, &iter, 0, TAG) {
+                        void *entry;
+                        int i;
+
+                        /* busy wait to let removals happen */
+                        for (i = 0; i < 1000000; i++)
+                                ;
+
+                        entry = radix_tree_deref_slot(slot);
+                        if (unlikely(!entry))
+                                continue;
+
+                        if (radix_tree_deref_retry(entry)) {
+                                slot = radix_tree_iter_retry(&iter);
+                                continue;
+                        }
+
+                        if (rand() % 50 == 0)
+                                slot = radix_tree_iter_next(&iter);
+                }
+                rcu_read_unlock();
+        }
+
+        return NULL;
+}
+
+/*
+ * Iterate over the entries, doing a radix_tree_iter_retry() as we find things
+ * that have been removed and randomly resetting our iteration to the next
+ * chunk with radix_tree_iter_next().  Both radix_tree_iter_retry() and
+ * radix_tree_iter_next() cause radix_tree_next_slot() to be called with a
+ * NULL 'slot' variable.
+ */
+static void *untagged_iteration_fn(void *arg)
+{
+        struct radix_tree_iter iter;
+        void **slot;
+
+        while (!test_complete) {
+                rcu_read_lock();
+                radix_tree_for_each_slot(slot, &tree, &iter, 0) {
+                        void *entry;
+                        int i;
+
+                        /* busy wait to let removals happen */
+                        for (i = 0; i < 1000000; i++)
+                                ;
+
+                        entry = radix_tree_deref_slot(slot);
+                        if (unlikely(!entry))
+                                continue;
+
+                        if (radix_tree_deref_retry(entry)) {
+                                slot = radix_tree_iter_retry(&iter);
+                                continue;
+                        }
+
+                        if (rand() % 50 == 0)
+                                slot = radix_tree_iter_next(&iter);
+                }
+                rcu_read_unlock();
+        }
+
+        return NULL;
+}
+
+/*
+ * Randomly remove entries to help induce radix_tree_iter_retry() calls in the
+ * two iteration functions.
+ */
+static void *remove_entries_fn(void *arg)
+{
+        while (!test_complete) {
+                int pgoff;
+
+                pgoff = rand() % 100;
+
+                pthread_mutex_lock(&tree_lock);
+                item_delete(&tree, pgoff);
+                pthread_mutex_unlock(&tree_lock);
+        }
+
+        return NULL;
+}
+
+/* This is a unit test for a bug found by the syzkaller tester */
+void iteration_test(void)
+{
+        int i;
+
+        printf("Running iteration tests for 10 seconds\n");
+
+        srand(time(0));
+        test_complete = false;
+
+        if (pthread_create(&threads[0], NULL, tagged_iteration_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[1], NULL, untagged_iteration_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[2], NULL, add_entries_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+        if (pthread_create(&threads[3], NULL, remove_entries_fn, NULL)) {
+                perror("pthread_create");
+                exit(1);
+        }
+
+        sleep(10);
+        test_complete = true;
+
+        for (i = 0; i < NUM_THREADS; i++) {
+                if (pthread_join(threads[i], NULL)) {
+                        perror("pthread_join");
+                        exit(1);
+                }
+        }
+
+        item_kill_tree(&tree);
+}
diff --git a/tools/testing/radix-tree/linux/cpu.h b/tools/testing/radix-tree/linux/cpu.h
index 60a40459f269..7cf412103205 100644
--- a/tools/testing/radix-tree/linux/cpu.h
+++ b/tools/testing/radix-tree/linux/cpu.h
@@ -7,19 +7,8 @@
 #define CPU_DOWN_PREPARE        0x0005 /* CPU (unsigned)v going down */
 #define CPU_DOWN_FAILED         0x0006 /* CPU (unsigned)v NOT going down */
 #define CPU_DEAD                0x0007 /* CPU (unsigned)v dead */
-#define CPU_DYING               0x0008 /* CPU (unsigned)v not running any task,
-                                        * not handling interrupts, soon dead.
-                                        * Called on the dying cpu, interrupts
-                                        * are already disabled. Must not
-                                        * sleep, must not fail */
 #define CPU_POST_DEAD           0x0009 /* CPU (unsigned)v dead, cpu_hotplug
                                         * lock is dropped */
-#define CPU_STARTING            0x000A /* CPU (unsigned)v soon running.
-                                        * Called on the new cpu, just before
-                                        * enabling interrupts. Must not sleep,
-                                        * must not fail */
-#define CPU_DYING_IDLE          0x000B /* CPU (unsigned)v dying, reached
-                                        * idle loop. */
 #define CPU_BROKEN              0x000C /* CPU (unsigned)v did not die properly,
                                         * perhaps due to preemption. */
 #define CPU_TASKS_FROZEN        0x0010
@@ -30,5 +19,3 @@
 #define CPU_DOWN_PREPARE_FROZEN (CPU_DOWN_PREPARE | CPU_TASKS_FROZEN)
 #define CPU_DOWN_FAILED_FROZEN  (CPU_DOWN_FAILED | CPU_TASKS_FROZEN)
 #define CPU_DEAD_FROZEN         (CPU_DEAD | CPU_TASKS_FROZEN)
-#define CPU_DYING_FROZEN        (CPU_DYING | CPU_TASKS_FROZEN)
-#define CPU_STARTING_FROZEN     (CPU_STARTING | CPU_TASKS_FROZEN)
diff --git a/tools/testing/radix-tree/linux/gfp.h b/tools/testing/radix-tree/linux/gfp.h
index 0e37f7a760eb..5201b915f631 100644
--- a/tools/testing/radix-tree/linux/gfp.h
+++ b/tools/testing/radix-tree/linux/gfp.h
@@ -1,7 +1,7 @@
 #ifndef _GFP_H
 #define _GFP_H
 
-#define __GFP_BITS_SHIFT 22
+#define __GFP_BITS_SHIFT 26
 #define __GFP_BITS_MASK ((gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 #define __GFP_WAIT 1
 #define __GFP_ACCOUNT 0
diff --git a/tools/testing/radix-tree/main.c b/tools/testing/radix-tree/main.c
index b7619ff3b552..daa9010693e8 100644
--- a/tools/testing/radix-tree/main.c
+++ b/tools/testing/radix-tree/main.c
@@ -332,6 +332,7 @@ int main(int argc, char **argv)
         regression1_test();
         regression2_test();
         regression3_test();
+        iteration_test();
         single_thread_tests(long_run);
 
         sleep(1);
diff --git a/tools/testing/radix-tree/multiorder.c b/tools/testing/radix-tree/multiorder.c
index 39d9b9568fe2..05d7bc488971 100644
--- a/tools/testing/radix-tree/multiorder.c
+++ b/tools/testing/radix-tree/multiorder.c
@@ -124,6 +124,8 @@ static void multiorder_check(unsigned long index, int order)
         unsigned long i;
         unsigned long min = index & ~((1UL << order) - 1);
         unsigned long max = min + (1UL << order);
+        void **slot;
+        struct item *item2 = item_create(min);
         RADIX_TREE(tree, GFP_KERNEL);
 
         printf("Multiorder index %ld, order %d\n", index, order);
@@ -139,13 +141,19 @@ static void multiorder_check(unsigned long index, int order)
                 item_check_absent(&tree, i);
         for (i = max; i < 2*max; i++)
                 item_check_absent(&tree, i);
+        for (i = min; i < max; i++)
+                assert(radix_tree_insert(&tree, i, item2) == -EEXIST);
+
+        slot = radix_tree_lookup_slot(&tree, index);
+        free(*slot);
+        radix_tree_replace_slot(slot, item2);
         for (i = min; i < max; i++) {
-                static void *entry = (void *)
-                                        (0xA0 | RADIX_TREE_EXCEPTIONAL_ENTRY);
-                assert(radix_tree_insert(&tree, i, entry) == -EEXIST);
+                struct item *item = item_lookup(&tree, i);
+                assert(item != 0);
+                assert(item->index == min);
         }
 
-        assert(item_delete(&tree, index) != 0);
+        assert(item_delete(&tree, min) != 0);
 
         for (i = 0; i < 2*max; i++)
                 item_check_absent(&tree, i);
diff --git a/tools/testing/radix-tree/regression1.c b/tools/testing/radix-tree/regression1.c
index 2d03a63bb79c..0d6813a61b37 100644
--- a/tools/testing/radix-tree/regression1.c
+++ b/tools/testing/radix-tree/regression1.c
@@ -43,7 +43,7 @@
 #include "regression.h"
 
 static RADIX_TREE(mt_tree, GFP_KERNEL);
-static pthread_mutex_t mt_lock;
+static pthread_mutex_t mt_lock = PTHREAD_MUTEX_INITIALIZER;
 
 struct page {
         pthread_mutex_t lock;
diff --git a/tools/testing/radix-tree/tag_check.c b/tools/testing/radix-tree/tag_check.c
index b7447ceb75e9..b0ac05741750 100644
--- a/tools/testing/radix-tree/tag_check.c
+++ b/tools/testing/radix-tree/tag_check.c
@@ -122,7 +122,7 @@ enum {
         NODE_TAGGED = 2,
 };
 
-#define THRASH_SIZE             1000 * 1000
+#define THRASH_SIZE             (1000 * 1000)
 #define N 127
 #define BATCH   33
 
diff --git a/tools/testing/radix-tree/test.h b/tools/testing/radix-tree/test.h
index e85131369723..217fb2403f09 100644
--- a/tools/testing/radix-tree/test.h
+++ b/tools/testing/radix-tree/test.h
@@ -27,6 +27,7 @@ void item_kill_tree(struct radix_tree_root *root);
 
 void tag_check(void);
 void multiorder_checks(void);
+void iteration_test(void);
 
 struct item *
 item_tag_set(struct radix_tree_root *root, unsigned long index, int tag);
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index ff9e5f20a5a7..f770dba2a6f6 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -15,6 +15,7 @@ TARGETS += memory-hotplug
 TARGETS += mount
 TARGETS += mqueue
 TARGETS += net
+TARGETS += nsfs
 TARGETS += powerpc
 TARGETS += pstore
 TARGETS += ptrace
diff --git a/tools/testing/selftests/exec/Makefile b/tools/testing/selftests/exec/Makefile
index 4e400eb83657..d4300602bf37 100644
--- a/tools/testing/selftests/exec/Makefile
+++ b/tools/testing/selftests/exec/Makefile
@@ -18,7 +18,8 @@ execveat.denatured: execveat
         $(CC) $(CFLAGS) -o $@ $^
 
 TEST_PROGS := execveat
-TEST_FILES := $(DEPS)
+# Makefile is a run-time dependency, since it's accessed by the execveat test
+TEST_FILES := $(DEPS) Makefile
 
 include ../lib.mk
 
diff --git a/tools/testing/selftests/filesystems/.gitignore b/tools/testing/selftests/filesystems/.gitignore
new file mode 100644
index 000000000000..31d6e426b6d4
--- /dev/null
+++ b/tools/testing/selftests/filesystems/.gitignore
@@ -0,0 +1 @@
+dnotify_test
diff --git a/tools/testing/selftests/filesystems/Makefile b/tools/testing/selftests/filesystems/Makefile
new file mode 100644
index 000000000000..0ab11307b414
--- /dev/null
+++ b/tools/testing/selftests/filesystems/Makefile
@@ -0,0 +1,7 @@
+TEST_PROGS := dnotify_test
+all: $(TEST_PROGS)
+
+include ../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
diff --git a/tools/testing/selftests/filesystems/dnotify_test.c b/tools/testing/selftests/filesystems/dnotify_test.c
new file mode 100644
index 000000000000..8b37b4a1e18d
--- /dev/null
+++ b/tools/testing/selftests/filesystems/dnotify_test.c
@@ -0,0 +1,34 @@
+#define _GNU_SOURCE     /* needed to get the defines */
+#include <fcntl.h>      /* in glibc 2.2 this has the needed
+                                   values defined */
+#include <signal.h>
+#include <stdio.h>
+#include <unistd.h>
+
+static volatile int event_fd;
+
+static void handler(int sig, siginfo_t *si, void *data)
+{
+        event_fd = si->si_fd;
+}
+
+int main(void)
+{
+        struct sigaction act;
+        int fd;
+
+        act.sa_sigaction = handler;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = SA_SIGINFO;
+        sigaction(SIGRTMIN + 1, &act, NULL);
+
+        fd = open(".", O_RDONLY);
+        fcntl(fd, F_SETSIG, SIGRTMIN + 1);
+        fcntl(fd, F_NOTIFY, DN_MODIFY|DN_CREATE|DN_MULTISHOT);
+        /* we will now be notified if any of the files
+           in "." is modified or new files are created */
+        while (1) {
+                pause();
+                printf("Got event on fd=%d\n", event_fd);
+        }
+}
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
index c2b61c4fda11..0bf5085281f3 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
@@ -23,15 +23,14 @@ if [ ! -f events/sched/sched_process_fork/trigger ]; then
     exit_unsupported
 fi
 
-reset_tracer
-do_reset
-
-FEATURE=`grep hist events/sched/sched_process_fork/trigger`
-if [ -z "$FEATURE" ]; then
+if [ ! -f events/sched/sched_process_fork/hist ]; then
     echo "hist trigger is not supported"
     exit_unsupported
 fi
 
+reset_tracer
+do_reset
+
 echo "Test histogram with execname modifier"
 
 echo 'hist:keys=common_pid.execname' > events/sched/sched_process_fork/trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
index b2902d42a537..a00184cd9c95 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
@@ -23,15 +23,14 @@ if [ ! -f events/sched/sched_process_fork/trigger ]; then
     exit_unsupported
 fi
 
-reset_tracer
-do_reset
-
-FEATURE=`grep hist events/sched/sched_process_fork/trigger`
-if [ -z "$FEATURE" ]; then
+if [ ! -f events/sched/sched_process_fork/hist ]; then
     echo "hist trigger is not supported"
     exit_unsupported
 fi
 
+reset_tracer
+do_reset
+
 echo "Test histogram basic tigger"
 
 echo 'hist:keys=parent_pid:vals=child_pid' > events/sched/sched_process_fork/trigger
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
index 03c4a46561fc..3478b00ead57 100644
--- a/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
@@ -23,15 +23,14 @@ if [ ! -f events/sched/sched_process_fork/trigger ]; then
     exit_unsupported
 fi
 
-reset_tracer
-do_reset
-
-FEATURE=`grep hist events/sched/sched_process_fork/trigger`
-if [ -z "$FEATURE" ]; then
+if [ ! -f events/sched/sched_process_fork/hist ]; then
     echo "hist trigger is not supported"
     exit_unsupported
 fi
 
+reset_tracer
+do_reset
+
 reset_trigger
 
 echo "Test histogram multiple tiggers"
diff --git a/tools/testing/selftests/futex/functional/run.sh b/tools/testing/selftests/futex/functional/run.sh
index e87dbe2a0b0d..7ff002eed624 100755
--- a/tools/testing/selftests/futex/functional/run.sh
+++ b/tools/testing/selftests/futex/functional/run.sh
@@ -24,7 +24,7 @@
 
 # Test for a color capable console
 if [ -z "$USE_COLOR" ]; then
-    tput setf 7
+    tput setf 7 || tput setaf 7
     if [ $? -eq 0 ]; then
         USE_COLOR=1
         tput sgr0
diff --git a/tools/testing/selftests/futex/run.sh b/tools/testing/selftests/futex/run.sh
index 4126312ad64e..88bcb1767362 100755
--- a/tools/testing/selftests/futex/run.sh
+++ b/tools/testing/selftests/futex/run.sh
@@ -23,7 +23,7 @@
 
 # Test for a color capable shell and pass the result to the subdir scripts
 USE_COLOR=0
-tput setf 7
+tput setf 7 || tput setaf 7
 if [ $? -eq 0 ]; then
     USE_COLOR=1
     tput sgr0
diff --git a/tools/testing/selftests/ia64/.gitignore b/tools/testing/selftests/ia64/.gitignore
new file mode 100644
index 000000000000..ab806edc8732
--- /dev/null
+++ b/tools/testing/selftests/ia64/.gitignore
@@ -0,0 +1 @@
+aliasing-test
diff --git a/tools/testing/selftests/ia64/Makefile b/tools/testing/selftests/ia64/Makefile
new file mode 100644
index 000000000000..2b3de2d3e945
--- /dev/null
+++ b/tools/testing/selftests/ia64/Makefile
@@ -0,0 +1,8 @@
+TEST_PROGS := aliasing-test
+
+all: $(TEST_PROGS)
+
+include ../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
diff --git a/tools/testing/selftests/ia64/aliasing-test.c b/tools/testing/selftests/ia64/aliasing-test.c
new file mode 100644
index 000000000000..62a190d45f38
--- /dev/null
+++ b/tools/testing/selftests/ia64/aliasing-test.c
@@ -0,0 +1,263 @@
+/*
+ * Exercise /dev/mem mmap cases that have been troublesome in the past
+ *
+ * (c) Copyright 2007 Hewlett-Packard Development Company, L.P.
+ *      Bjorn Helgaas <bjorn.helgaas@hp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <linux/pci.h>
+
+int sum;
+
+static int map_mem(char *path, off_t offset, size_t length, int touch)
+{
+        int fd, rc;
+        void *addr;
+        int *c;
+
+        fd = open(path, O_RDWR);
+        if (fd == -1) {
+                perror(path);
+                return -1;
+        }
+
+        if (fnmatch("/proc/bus/pci/*", path, 0) == 0) {
+                rc = ioctl(fd, PCIIOC_MMAP_IS_MEM);
+                if (rc == -1)
+                        perror("PCIIOC_MMAP_IS_MEM ioctl");
+        }
+
+        addr = mmap(NULL, length, PROT_READ|PROT_WRITE, MAP_SHARED, fd, offset);
+        if (addr == MAP_FAILED)
+                return 1;
+
+        if (touch) {
+                c = (int *) addr;
+                while (c < (int *) (addr + length))
+                        sum += *c++;
+        }
+
+        rc = munmap(addr, length);
+        if (rc == -1) {
+                perror("munmap");
+                return -1;
+        }
+
+        close(fd);
+        return 0;
+}
+
+static int scan_tree(char *path, char *file, off_t offset, size_t length, int touch)
+{
+        struct dirent **namelist;
+        char *name, *path2;
+        int i, n, r, rc = 0, result = 0;
+        struct stat buf;
+
+        n = scandir(path, &namelist, 0, alphasort);
+        if (n < 0) {
+                perror("scandir");
+                return -1;
+        }
+
+        for (i = 0; i < n; i++) {
+                name = namelist[i]->d_name;
+
+                if (fnmatch(".", name, 0) == 0)
+                        goto skip;
+                if (fnmatch("..", name, 0) == 0)
+                        goto skip;
+
+                path2 = malloc(strlen(path) + strlen(name) + 3);
+                strcpy(path2, path);
+                strcat(path2, "/");
+                strcat(path2, name);
+
+                if (fnmatch(file, name, 0) == 0) {
+                        rc = map_mem(path2, offset, length, touch);
+                        if (rc == 0)
+                                fprintf(stderr, "PASS: %s 0x%lx-0x%lx is %s\n", path2, offset, offset + length, touch ? "readable" : "mappable");
+                        else if (rc > 0)
+                                fprintf(stderr, "PASS: %s 0x%lx-0x%lx not mappable\n", path2, offset, offset + length);
+                        else {
+                                fprintf(stderr, "FAIL: %s 0x%lx-0x%lx not accessible\n", path2, offset, offset + length);
+                                return rc;
+                        }
+                } else {
+                        r = lstat(path2, &buf);
+                        if (r == 0 && S_ISDIR(buf.st_mode)) {
+                                rc = scan_tree(path2, file, offset, length, touch);
+                                if (rc < 0)
+                                        return rc;
+                        }
+                }
+
+                result |= rc;
+                free(path2);
+
+skip:
+                free(namelist[i]);
+        }
+        free(namelist);
+        return result;
+}
+
+char buf[1024];
+
+static int read_rom(char *path)
+{
+        int fd, rc;
+        size_t size = 0;
+
+        fd = open(path, O_RDWR);
+        if (fd == -1) {
+                perror(path);
+                return -1;
+        }
+
+        rc = write(fd, "1", 2);
+        if (rc <= 0) {
+                close(fd);
+                perror("write");
+                return -1;
+        }
+
+        do {
+                rc = read(fd, buf, sizeof(buf));
+                if (rc > 0)
+                        size += rc;
+        } while (rc > 0);
+
+        close(fd);
+        return size;
+}
+
+static int scan_rom(char *path, char *file)
+{
+        struct dirent **namelist;
+        char *name, *path2;
+        int i, n, r, rc = 0, result = 0;
+        struct stat buf;
+
+        n = scandir(path, &namelist, 0, alphasort);
+        if (n < 0) {
+                perror("scandir");
+                return -1;
+        }
+
+        for (i = 0; i < n; i++) {
+                name = namelist[i]->d_name;
+
+                if (fnmatch(".", name, 0) == 0)
+                        goto skip;
+                if (fnmatch("..", name, 0) == 0)
+                        goto skip;
+
+                path2 = malloc(strlen(path) + strlen(name) + 3);
+                strcpy(path2, path);
+                strcat(path2, "/");
+                strcat(path2, name);
+
+                if (fnmatch(file, name, 0) == 0) {
+                        rc = read_rom(path2);
+
+                        /*
+                         * It's OK if the ROM is unreadable.  Maybe there
+                         * is no ROM, or some other error occurred.  The
+                         * important thing is that no MCA happened.
+                         */
+                        if (rc > 0)
+                                fprintf(stderr, "PASS: %s read %d bytes\n", path2, rc);
+                        else {
+                                fprintf(stderr, "PASS: %s not readable\n", path2);
+                                return rc;
+                        }
+                } else {
+                        r = lstat(path2, &buf);
+                        if (r == 0 && S_ISDIR(buf.st_mode)) {
+                                rc = scan_rom(path2, file);
+                                if (rc < 0)
+                                        return rc;
+                        }
+                }
+
+                result |= rc;
+                free(path2);
+
+skip:
+                free(namelist[i]);
+        }
+        free(namelist);
+        return result;
+}
+
+int main(void)
+{
+        int rc;
+
+        if (map_mem("/dev/mem", 0, 0xA0000, 1) == 0)
+                fprintf(stderr, "PASS: /dev/mem 0x0-0xa0000 is readable\n");
+        else
+                fprintf(stderr, "FAIL: /dev/mem 0x0-0xa0000 not accessible\n");
+
+        /*
+         * It's not safe to blindly read the VGA frame buffer.  If you know
+         * how to poke the card the right way, it should respond, but it's
+         * not safe in general.  Many machines, e.g., Intel chipsets, cover
+         * up a non-responding card by just returning -1, but others will
+         * report the failure as a machine check.
+         */
+        if (map_mem("/dev/mem", 0xA0000, 0x20000, 0) == 0)
+                fprintf(stderr, "PASS: /dev/mem 0xa0000-0xc0000 is mappable\n");
+        else
+                fprintf(stderr, "FAIL: /dev/mem 0xa0000-0xc0000 not accessible\n");
+
+        if (map_mem("/dev/mem", 0xC0000, 0x40000, 1) == 0)
+                fprintf(stderr, "PASS: /dev/mem 0xc0000-0x100000 is readable\n");
+        else
+                fprintf(stderr, "FAIL: /dev/mem 0xc0000-0x100000 not accessible\n");
+
+        /*
+         * Often you can map all the individual pieces above (0-0xA0000,
+         * 0xA0000-0xC0000, and 0xC0000-0x100000), but can't map the whole
+         * thing at once.  This is because the individual pieces use different
+         * attributes, and there's no single attribute supported over the
+         * whole region.
+         */
+        rc = map_mem("/dev/mem", 0, 1024*1024, 0);
+        if (rc == 0)
+                fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 is mappable\n");
+        else if (rc > 0)
+                fprintf(stderr, "PASS: /dev/mem 0x0-0x100000 not mappable\n");
+        else
+                fprintf(stderr, "FAIL: /dev/mem 0x0-0x100000 not accessible\n");
+
+        scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 0xA0000, 1);
+        scan_tree("/sys/class/pci_bus", "legacy_mem", 0xA0000, 0x20000, 0);
+        scan_tree("/sys/class/pci_bus", "legacy_mem", 0xC0000, 0x40000, 1);
+        scan_tree("/sys/class/pci_bus", "legacy_mem", 0, 1024*1024, 0);
+
+        scan_rom("/sys/devices", "rom");
+
+        scan_tree("/proc/bus/pci", "??.?", 0, 0xA0000, 1);
+        scan_tree("/proc/bus/pci", "??.?", 0xA0000, 0x20000, 0);
+        scan_tree("/proc/bus/pci", "??.?", 0xC0000, 0x40000, 1);
+        scan_tree("/proc/bus/pci", "??.?", 0, 1024*1024, 0);
+
+        return rc;
+}
diff --git a/tools/testing/selftests/lib/printf.sh b/tools/testing/selftests/lib/printf.sh
index 4fdc70fe6980..4fdc70fe6980 100644..100755
--- a/tools/testing/selftests/lib/printf.sh
+++ b/tools/testing/selftests/lib/printf.sh
diff --git a/tools/testing/selftests/media_tests/.gitignore b/tools/testing/selftests/media_tests/.gitignore
index 1c0711708b98..8745eba39012 100644
--- a/tools/testing/selftests/media_tests/.gitignore
+++ b/tools/testing/selftests/media_tests/.gitignore
@@ -1 +1,3 @@
 media_device_test
+media_device_open
+video_device_test
diff --git a/tools/testing/selftests/media_tests/Makefile b/tools/testing/selftests/media_tests/Makefile
index 7071bcc1d066..6b34a0199468 100644
--- a/tools/testing/selftests/media_tests/Makefile
+++ b/tools/testing/selftests/media_tests/Makefile
@@ -1,7 +1,7 @@
-TEST_PROGS := media_device_test
+TEST_PROGS := media_device_test media_device_open video_device_test
 all: $(TEST_PROGS)
 
 include ../lib.mk
 
 clean:
-        rm -fr media_device_test
+        rm -fr media_device_test media_device_open video_device_test
diff --git a/tools/testing/selftests/media_tests/bind_unbind_sample.sh b/tools/testing/selftests/media_tests/bind_unbind_sample.sh
new file mode 100755
index 000000000000..9f362f10631a
--- /dev/null
+++ b/tools/testing/selftests/media_tests/bind_unbind_sample.sh
@@ -0,0 +1,12 @@
+#!/bin/bash
+# Find device number in /sys/bus/usb/drivers/drivername
+# Edit this file to update the driver numer and name
+# Example test for uvcvideo driver
+#i=0
+# while :; do
+#  i=$((i+1))
+#  echo 1-5:1.0 > /sys/bus/usb/drivers/uvcvideo/unbind;
+#  echo 1-5:1.0 > /sys/bus/usb/drivers/uvcvideo/bind;
+#  clear
+#       echo $i
+#done
diff --git a/tools/testing/selftests/media_tests/media_device_open.c b/tools/testing/selftests/media_tests/media_device_open.c
new file mode 100644
index 000000000000..44343c091a20
--- /dev/null
+++ b/tools/testing/selftests/media_tests/media_device_open.c
@@ -0,0 +1,81 @@
+/*
+ * media_device_open.c - Media Controller Device Open Test
+ *
+ * Copyright (c) 2016 Shuah Khan <shuahkh@osg.samsung.com>
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * This file is released under the GPLv2.
+ */
+
+/*
+ * This file adds a test for Media Controller API.
+ * This test should be run as root and should not be
+ * included in the Kselftest run. This test should be
+ * run when hardware and driver that makes use Media
+ * Controller API are present in the system.
+ *
+ * This test opens user specified Media Device and calls
+ * MEDIA_IOC_DEVICE_INFO ioctl, closes the file, and exits.
+ *
+ * Usage:
+ *      sudo ./media_device_open -d /dev/mediaX
+ *
+ *      Run this test is a loop and run bind/unbind on the driver.
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <linux/media.h>
+
+int main(int argc, char **argv)
+{
+        int opt;
+        char media_device[256];
+        int count = 0;
+        struct media_device_info mdi;
+        int ret;
+        int fd;
+
+        if (argc < 2) {
+                printf("Usage: %s [-d </dev/mediaX>]\n", argv[0]);
+                exit(-1);
+        }
+
+        /* Process arguments */
+        while ((opt = getopt(argc, argv, "d:")) != -1) {
+                switch (opt) {
+                case 'd':
+                        strncpy(media_device, optarg, sizeof(media_device) - 1);
+                        media_device[sizeof(media_device)-1] = '\0';
+                        break;
+                default:
+                        printf("Usage: %s [-d </dev/mediaX>]\n", argv[0]);
+                        exit(-1);
+                }
+        }
+
+        if (getuid() != 0) {
+                printf("Please run the test as root - Exiting.\n");
+                exit(-1);
+        }
+
+        /* Open Media device and keep it open */
+        fd = open(media_device, O_RDWR);
+        if (fd == -1) {
+                printf("Media Device open errno %s\n", strerror(errno));
+                exit(-1);
+        }
+
+        ret = ioctl(fd, MEDIA_IOC_DEVICE_INFO, &mdi);
+        if (ret < 0)
+                printf("Media Device Info errno %s\n", strerror(errno));
+        else
+                printf("Media device model %s driver %s\n",
+                        mdi.model, mdi.driver);
+}
diff --git a/tools/testing/selftests/media_tests/media_device_test.c b/tools/testing/selftests/media_tests/media_device_test.c
index cbf53a032ab5..5d49943e77d0 100644
--- a/tools/testing/selftests/media_tests/media_device_test.c
+++ b/tools/testing/selftests/media_tests/media_device_test.c
@@ -1,5 +1,5 @@
 /*
- * media_devkref_test.c - Media Controller Device Kref API Test
+ * media_device_test.c - Media Controller Device ioctl loop Test
  *
  * Copyright (c) 2016 Shuah Khan <shuahkh@osg.samsung.com>
  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
@@ -35,13 +35,14 @@
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
+#include <time.h>
 #include <linux/media.h>
 
 int main(int argc, char **argv)
 {
         int opt;
         char media_device[256];
-        int count = 0;
+        int count;
         struct media_device_info mdi;
         int ret;
         int fd;
@@ -69,6 +70,10 @@ int main(int argc, char **argv)
                 exit(-1);
         }
 
+        /* Generate random number of interations */
+        srand((unsigned int) time(NULL));
+        count = rand();
+
         /* Open Media device and keep it open */
         fd = open(media_device, O_RDWR);
         if (fd == -1) {
@@ -82,14 +87,16 @@ int main(int argc, char **argv)
                "other Oops in the dmesg. Enable KaSan kernel\n"
                "config option for use-after-free error detection.\n\n");
 
-        while (count < 100) {
+        printf("Running test for %d iternations\n", count);
+
+        while (count > 0) {
                 ret = ioctl(fd, MEDIA_IOC_DEVICE_INFO, &mdi);
                 if (ret < 0)
                         printf("Media Device Info errno %s\n", strerror(errno));
                 else
-                        printf("Media device model %s driver %s\n",
-                                mdi.model, mdi.driver);
+                        printf("Media device model %s driver %s - count %d\n",
+                                mdi.model, mdi.driver, count);
                 sleep(10);
-                count++;
+                count--;
         }
 }
diff --git a/tools/testing/selftests/media_tests/open_loop_test.sh b/tools/testing/selftests/media_tests/open_loop_test.sh
new file mode 100755
index 000000000000..dcd3c17efc17
--- /dev/null
+++ b/tools/testing/selftests/media_tests/open_loop_test.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+ i=0
+file=/dev/media$1
+ while :; do
+  echo $file
+  i=$((i+1))
+  R=$(./media_device_open -d $file);
+ # clear
+  echo -e "Loop $i\n$R"
+ done
diff --git a/tools/testing/selftests/media_tests/regression_test.txt b/tools/testing/selftests/media_tests/regression_test.txt
new file mode 100644
index 000000000000..2627367681f7
--- /dev/null
+++ b/tools/testing/selftests/media_tests/regression_test.txt
@@ -0,0 +1,43 @@
+Testing for regressions in Media Controller API register, ioctl, syscall,
+and unregister paths. There have a few problems that result in user-after
+free on media_device, media_devnode, and cdev pointers when the driver is
+unbound while ioctl is in progress.
+
+Test Procedure:
+
+Run bin/unbind loop while ioctls are in progress.
+Run rmmod and modprobe.
+Disconnect the device.
+
+Setup:
+
+Build media_device_test
+cd tools/testing/selftests/media_tests
+make
+
+Regressions test for cdev user-after free error on /dev/mediaX when driver
+is unbound:
+
+Start media_device_test to regression test media devnode dynamic alloc
+and cdev user-after-free fixes. This opens media dev files and sits in
+a loop running media ioctl MEDIA_IOC_DEVICE_INFO command once every 10
+seconds. The idea is when device file goes away, media devnode and cdev
+should stick around until this test exits.
+
+The test for a random number of iterations or until user kills it with a
+sleep 10 in between the ioctl calls.
+
+sudo ./media_device_test -d /dev/mediaX
+
+Regression test for media_devnode unregister race with ioctl_syscall:
+
+Start 6 open_loop_test.sh tests with different /dev/mediaX files. When
+device file goes away after unbind, device file name changes. Start the
+test with possible device names. If we start with /dev/media0 for example,
+after unbind, /dev/media1 or /dev/media2 could get created. The idea is
+keep ioctls going while bind/unbind runs.
+
+Copy bind_unbind_sample.txt and make changes to specify the driver name
+and number to run bind and unbind. Start the bind_unbind.sh
+
+Run dmesg looking for any user-after free errors or mutex lock errors.
diff --git a/tools/testing/selftests/media_tests/video_device_test.c b/tools/testing/selftests/media_tests/video_device_test.c
new file mode 100644
index 000000000000..66d419c28653
--- /dev/null
+++ b/tools/testing/selftests/media_tests/video_device_test.c
@@ -0,0 +1,100 @@
+/*
+ * video_device_test - Video Device Test
+ *
+ * Copyright (c) 2016 Shuah Khan <shuahkh@osg.samsung.com>
+ * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ *
+ * This file is released under the GPLv2.
+ */
+
+/*
+ * This file adds a test for Video Device. This test should not be included
+ * in the Kselftest run. This test should be run when hardware and driver
+ * that makes use of V4L2 API is present.
+ *
+ * This test opens user specified Video Device and calls video ioctls in a
+ * loop once every 10 seconds.
+ *
+ * Usage:
+ *      sudo ./video_device_test -d /dev/videoX
+ *
+ *      While test is running, remove the device or unbind the driver and
+ *      ensure there are no use after free errors and other Oops in the
+ *      dmesg.
+ *      When possible, enable KaSan kernel config option for use-after-free
+ *      error detection.
+*/
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <time.h>
+#include <linux/videodev2.h>
+
+int main(int argc, char **argv)
+{
+        int opt;
+        char video_dev[256];
+        int count;
+        struct v4l2_tuner vtuner;
+        struct v4l2_capability vcap;
+        int ret;
+        int fd;
+
+        if (argc < 2) {
+                printf("Usage: %s [-d </dev/videoX>]\n", argv[0]);
+                exit(-1);
+        }
+
+        /* Process arguments */
+        while ((opt = getopt(argc, argv, "d:")) != -1) {
+                switch (opt) {
+                case 'd':
+                        strncpy(video_dev, optarg, sizeof(video_dev) - 1);
+                        video_dev[sizeof(video_dev)-1] = '\0';
+                        break;
+                default:
+                        printf("Usage: %s [-d </dev/videoX>]\n", argv[0]);
+                        exit(-1);
+                }
+        }
+
+        /* Generate random number of interations */
+        srand((unsigned int) time(NULL));
+        count = rand();
+
+        /* Open Video device and keep it open */
+        fd = open(video_dev, O_RDWR);
+        if (fd == -1) {
+                printf("Video Device open errno %s\n", strerror(errno));
+                exit(-1);
+        }
+
+        printf("\nNote:\n"
+               "While test is running, remove the device or unbind\n"
+               "driver and ensure there are no use after free errors\n"
+               "and other Oops in the dmesg. When possible, enable KaSan\n"
+               "kernel config option for use-after-free error detection.\n\n");
+
+        while (count > 0) {
+                ret = ioctl(fd, VIDIOC_QUERYCAP, &vcap);
+                if (ret < 0)
+                        printf("VIDIOC_QUERYCAP errno %s\n", strerror(errno));
+                else
+                        printf("Video device driver %s\n", vcap.driver);
+
+                ret = ioctl(fd, VIDIOC_G_TUNER, &vtuner);
+                if (ret < 0)
+                        printf("VIDIOC_G_TUNER, errno %s\n", strerror(errno));
+                else
+                        printf("type %d rangelow %d rangehigh %d\n",
+                                vtuner.type, vtuner.rangelow, vtuner.rangehigh);
+                sleep(10);
+                count--;
+        }
+}
diff --git a/tools/testing/selftests/net/reuseport_bpf.c b/tools/testing/selftests/net/reuseport_bpf.c
index 96ba386b1b7b..4a8217448f20 100644
--- a/tools/testing/selftests/net/reuseport_bpf.c
+++ b/tools/testing/selftests/net/reuseport_bpf.c
@@ -111,9 +111,9 @@ static void attach_ebpf(int fd, uint16_t mod)
         memset(&attr, 0, sizeof(attr));
         attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
         attr.insn_cnt = ARRAY_SIZE(prog);
-        attr.insns = (uint64_t)prog;
-        attr.license = (uint64_t)bpf_license;
-        attr.log_buf = (uint64_t)bpf_log_buf;
+        attr.insns = (unsigned long) &prog;
+        attr.license = (unsigned long) &bpf_license;
+        attr.log_buf = (unsigned long) &bpf_log_buf;
         attr.log_size = sizeof(bpf_log_buf);
         attr.log_level = 1;
         attr.kern_version = 0;
@@ -351,8 +351,8 @@ static void test_filter_no_reuseport(const struct test_params p)
         memset(&eprog, 0, sizeof(eprog));
         eprog.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
         eprog.insn_cnt = ARRAY_SIZE(ecode);
-        eprog.insns = (uint64_t)ecode;
-        eprog.license = (uint64_t)bpf_license;
+        eprog.insns = (unsigned long) &ecode;
+        eprog.license = (unsigned long) &bpf_license;
         eprog.kern_version = 0;
 
         memset(&cprog, 0, sizeof(cprog));
diff --git a/tools/testing/selftests/networking/timestamping/.gitignore b/tools/testing/selftests/networking/timestamping/.gitignore
new file mode 100644
index 000000000000..9e69e982fb38
--- /dev/null
+++ b/tools/testing/selftests/networking/timestamping/.gitignore
@@ -0,0 +1,3 @@
+timestamping
+txtimestamp
+hwtstamp_config
diff --git a/tools/testing/selftests/networking/timestamping/Makefile b/tools/testing/selftests/networking/timestamping/Makefile
new file mode 100644
index 000000000000..ccbb9edbbbb9
--- /dev/null
+++ b/tools/testing/selftests/networking/timestamping/Makefile
@@ -0,0 +1,8 @@
+TEST_PROGS := hwtstamp_config timestamping txtimestamp
+
+all: $(TEST_PROGS)
+
+include ../../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
diff --git a/tools/testing/selftests/networking/timestamping/hwtstamp_config.c b/tools/testing/selftests/networking/timestamping/hwtstamp_config.c
new file mode 100644
index 000000000000..e8b685a7f15f
--- /dev/null
+++ b/tools/testing/selftests/networking/timestamping/hwtstamp_config.c
@@ -0,0 +1,134 @@
+/* Test program for SIOC{G,S}HWTSTAMP
+ * Copyright 2013 Solarflare Communications
+ * Author: Ben Hutchings
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+
+#include <linux/if.h>
+#include <linux/net_tstamp.h>
+#include <linux/sockios.h>
+
+static int
+lookup_value(const char **names, int size, const char *name)
+{
+        int value;
+
+        for (value = 0; value < size; value++)
+                if (names[value] && strcasecmp(names[value], name) == 0)
+                        return value;
+
+        return -1;
+}
+
+static const char *
+lookup_name(const char **names, int size, int value)
+{
+        return (value >= 0 && value < size) ? names[value] : NULL;
+}
+
+static void list_names(FILE *f, const char **names, int size)
+{
+        int value;
+
+        for (value = 0; value < size; value++)
+                if (names[value])
+                        fprintf(f, "    %s\n", names[value]);
+}
+
+static const char *tx_types[] = {
+#define TX_TYPE(name) [HWTSTAMP_TX_ ## name] = #name
+        TX_TYPE(OFF),
+        TX_TYPE(ON),
+        TX_TYPE(ONESTEP_SYNC)
+#undef TX_TYPE
+};
+#define N_TX_TYPES ((int)(sizeof(tx_types) / sizeof(tx_types[0])))
+
+static const char *rx_filters[] = {
+#define RX_FILTER(name) [HWTSTAMP_FILTER_ ## name] = #name
+        RX_FILTER(NONE),
+        RX_FILTER(ALL),
+        RX_FILTER(SOME),
+        RX_FILTER(PTP_V1_L4_EVENT),
+        RX_FILTER(PTP_V1_L4_SYNC),
+        RX_FILTER(PTP_V1_L4_DELAY_REQ),
+        RX_FILTER(PTP_V2_L4_EVENT),
+        RX_FILTER(PTP_V2_L4_SYNC),
+        RX_FILTER(PTP_V2_L4_DELAY_REQ),
+        RX_FILTER(PTP_V2_L2_EVENT),
+        RX_FILTER(PTP_V2_L2_SYNC),
+        RX_FILTER(PTP_V2_L2_DELAY_REQ),
+        RX_FILTER(PTP_V2_EVENT),
+        RX_FILTER(PTP_V2_SYNC),
+        RX_FILTER(PTP_V2_DELAY_REQ),
+#undef RX_FILTER
+};
+#define N_RX_FILTERS ((int)(sizeof(rx_filters) / sizeof(rx_filters[0])))
+
+static void usage(void)
+{
+        fputs("Usage: hwtstamp_config if_name [tx_type rx_filter]\n"
+              "tx_type is any of (case-insensitive):\n",
+              stderr);
+        list_names(stderr, tx_types, N_TX_TYPES);
+        fputs("rx_filter is any of (case-insensitive):\n", stderr);
+        list_names(stderr, rx_filters, N_RX_FILTERS);
+}
+
+int main(int argc, char **argv)
+{
+        struct ifreq ifr;
+        struct hwtstamp_config config;
+        const char *name;
+        int sock;
+
+        if ((argc != 2 && argc != 4) || (strlen(argv[1]) >= IFNAMSIZ)) {
+                usage();
+                return 2;
+        }
+
+        if (argc == 4) {
+                config.flags = 0;
+                config.tx_type = lookup_value(tx_types, N_TX_TYPES, argv[2]);
+                config.rx_filter = lookup_value(rx_filters, N_RX_FILTERS, argv[3]);
+                if (config.tx_type < 0 || config.rx_filter < 0) {
+                        usage();
+                        return 2;
+                }
+        }
+
+        sock = socket(AF_INET, SOCK_DGRAM, 0);
+        if (sock < 0) {
+                perror("socket");
+                return 1;
+        }
+
+        strcpy(ifr.ifr_name, argv[1]);
+        ifr.ifr_data = (caddr_t)&config;
+
+        if (ioctl(sock, (argc == 2) ? SIOCGHWTSTAMP : SIOCSHWTSTAMP, &ifr)) {
+                perror("ioctl");
+                return 1;
+        }
+
+        printf("flags = %#x\n", config.flags);
+        name = lookup_name(tx_types, N_TX_TYPES, config.tx_type);
+        if (name)
+                printf("tx_type = %s\n", name);
+        else
+                printf("tx_type = %d\n", config.tx_type);
+        name = lookup_name(rx_filters, N_RX_FILTERS, config.rx_filter);
+        if (name)
+                printf("rx_filter = %s\n", name);
+        else
+                printf("rx_filter = %d\n", config.rx_filter);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/networking/timestamping/timestamping.c b/tools/testing/selftests/networking/timestamping/timestamping.c
new file mode 100644
index 000000000000..5cdfd743447b
--- /dev/null
+++ b/tools/testing/selftests/networking/timestamping/timestamping.c
@@ -0,0 +1,528 @@
+/*
+ * This program demonstrates how the various time stamping features in
+ * the Linux kernel work. It emulates the behavior of a PTP
+ * implementation in stand-alone master mode by sending PTPv1 Sync
+ * multicasts once every second. It looks for similar packets, but
+ * beyond that doesn't actually implement PTP.
+ *
+ * Outgoing packets are time stamped with SO_TIMESTAMPING with or
+ * without hardware support.
+ *
+ * Incoming packets are time stamped with SO_TIMESTAMPING with or
+ * without hardware support, SIOCGSTAMP[NS] (per-socket time stamp) and
+ * SO_TIMESTAMP[NS].
+ *
+ * Copyright (C) 2009 Intel Corporation.
+ * Author: Patrick Ohly <patrick.ohly@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/select.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+
+#include <asm/types.h>
+#include <linux/net_tstamp.h>
+#include <linux/errqueue.h>
+
+#ifndef SO_TIMESTAMPING
+# define SO_TIMESTAMPING         37
+# define SCM_TIMESTAMPING        SO_TIMESTAMPING
+#endif
+
+#ifndef SO_TIMESTAMPNS
+# define SO_TIMESTAMPNS 35
+#endif
+
+#ifndef SIOCGSTAMPNS
+# define SIOCGSTAMPNS 0x8907
+#endif
+
+#ifndef SIOCSHWTSTAMP
+# define SIOCSHWTSTAMP 0x89b0
+#endif
+
+static void usage(const char *error)
+{
+        if (error)
+                printf("invalid option: %s\n", error);
+        printf("timestamping interface option*\n\n"
+               "Options:\n"
+               "  IP_MULTICAST_LOOP - looping outgoing multicasts\n"
+               "  SO_TIMESTAMP - normal software time stamping, ms resolution\n"
+               "  SO_TIMESTAMPNS - more accurate software time stamping\n"
+               "  SOF_TIMESTAMPING_TX_HARDWARE - hardware time stamping of outgoing packets\n"
+               "  SOF_TIMESTAMPING_TX_SOFTWARE - software fallback for outgoing packets\n"
+               "  SOF_TIMESTAMPING_RX_HARDWARE - hardware time stamping of incoming packets\n"
+               "  SOF_TIMESTAMPING_RX_SOFTWARE - software fallback for incoming packets\n"
+               "  SOF_TIMESTAMPING_SOFTWARE - request reporting of software time stamps\n"
+               "  SOF_TIMESTAMPING_RAW_HARDWARE - request reporting of raw HW time stamps\n"
+               "  SIOCGSTAMP - check last socket time stamp\n"
+               "  SIOCGSTAMPNS - more accurate socket time stamp\n");
+        exit(1);
+}
+
+static void bail(const char *error)
+{
+        printf("%s: %s\n", error, strerror(errno));
+        exit(1);
+}
+
+static const unsigned char sync[] = {
+        0x00, 0x01, 0x00, 0x01,
+        0x5f, 0x44, 0x46, 0x4c,
+        0x54, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x01, 0x01,
+
+        /* fake uuid */
+        0x00, 0x01,
+        0x02, 0x03, 0x04, 0x05,
+
+        0x00, 0x01, 0x00, 0x37,
+        0x00, 0x00, 0x00, 0x08,
+        0x00, 0x00, 0x00, 0x00,
+        0x49, 0x05, 0xcd, 0x01,
+        0x29, 0xb1, 0x8d, 0xb0,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x01,
+
+        /* fake uuid */
+        0x00, 0x01,
+        0x02, 0x03, 0x04, 0x05,
+
+        0x00, 0x00, 0x00, 0x37,
+        0x00, 0x00, 0x00, 0x04,
+        0x44, 0x46, 0x4c, 0x54,
+        0x00, 0x00, 0xf0, 0x60,
+        0x00, 0x01, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x01,
+        0x00, 0x00, 0xf0, 0x60,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x04,
+        0x44, 0x46, 0x4c, 0x54,
+        0x00, 0x01,
+
+        /* fake uuid */
+        0x00, 0x01,
+        0x02, 0x03, 0x04, 0x05,
+
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00
+};
+
+static void sendpacket(int sock, struct sockaddr *addr, socklen_t addr_len)
+{
+        struct timeval now;
+        int res;
+
+        res = sendto(sock, sync, sizeof(sync), 0,
+                addr, addr_len);
+        gettimeofday(&now, 0);
+        if (res < 0)
+                printf("%s: %s\n", "send", strerror(errno));
+        else
+                printf("%ld.%06ld: sent %d bytes\n",
+                       (long)now.tv_sec, (long)now.tv_usec,
+                       res);
+}
+
+static void printpacket(struct msghdr *msg, int res,
+                        char *data,
+                        int sock, int recvmsg_flags,
+                        int siocgstamp, int siocgstampns)
+{
+        struct sockaddr_in *from_addr = (struct sockaddr_in *)msg->msg_name;
+        struct cmsghdr *cmsg;
+        struct timeval tv;
+        struct timespec ts;
+        struct timeval now;
+
+        gettimeofday(&now, 0);
+
+        printf("%ld.%06ld: received %s data, %d bytes from %s, %zu bytes control messages\n",
+               (long)now.tv_sec, (long)now.tv_usec,
+               (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular",
+               res,
+               inet_ntoa(from_addr->sin_addr),
+               msg->msg_controllen);
+        for (cmsg = CMSG_FIRSTHDR(msg);
+             cmsg;
+             cmsg = CMSG_NXTHDR(msg, cmsg)) {
+                printf("   cmsg len %zu: ", cmsg->cmsg_len);
+                switch (cmsg->cmsg_level) {
+                case SOL_SOCKET:
+                        printf("SOL_SOCKET ");
+                        switch (cmsg->cmsg_type) {
+                        case SO_TIMESTAMP: {
+                                struct timeval *stamp =
+                                        (struct timeval *)CMSG_DATA(cmsg);
+                                printf("SO_TIMESTAMP %ld.%06ld",
+                                       (long)stamp->tv_sec,
+                                       (long)stamp->tv_usec);
+                                break;
+                        }
+                        case SO_TIMESTAMPNS: {
+                                struct timespec *stamp =
+                                        (struct timespec *)CMSG_DATA(cmsg);
+                                printf("SO_TIMESTAMPNS %ld.%09ld",
+                                       (long)stamp->tv_sec,
+                                       (long)stamp->tv_nsec);
+                                break;
+                        }
+                        case SO_TIMESTAMPING: {
+                                struct timespec *stamp =
+                                        (struct timespec *)CMSG_DATA(cmsg);
+                                printf("SO_TIMESTAMPING ");
+                                printf("SW %ld.%09ld ",
+                                       (long)stamp->tv_sec,
+                                       (long)stamp->tv_nsec);
+                                stamp++;
+                                /* skip deprecated HW transformed */
+                                stamp++;
+                                printf("HW raw %ld.%09ld",
+                                       (long)stamp->tv_sec,
+                                       (long)stamp->tv_nsec);
+                                break;
+                        }
+                        default:
+                                printf("type %d", cmsg->cmsg_type);
+                                break;
+                        }
+                        break;
+                case IPPROTO_IP:
+                        printf("IPPROTO_IP ");
+                        switch (cmsg->cmsg_type) {
+                        case IP_RECVERR: {
+                                struct sock_extended_err *err =
+                                        (struct sock_extended_err *)CMSG_DATA(cmsg);
+                                printf("IP_RECVERR ee_errno '%s' ee_origin %d => %s",
+                                        strerror(err->ee_errno),
+                                        err->ee_origin,
+#ifdef SO_EE_ORIGIN_TIMESTAMPING
+                                        err->ee_origin == SO_EE_ORIGIN_TIMESTAMPING ?
+                                        "bounced packet" : "unexpected origin"
+#else
+                                        "probably SO_EE_ORIGIN_TIMESTAMPING"
+#endif
+                                        );
+                                if (res < sizeof(sync))
+                                        printf(" => truncated data?!");
+                                else if (!memcmp(sync, data + res - sizeof(sync),
+                                                        sizeof(sync)))
+                                        printf(" => GOT OUR DATA BACK (HURRAY!)");
+                                break;
+                        }
+                        case IP_PKTINFO: {
+                                struct in_pktinfo *pktinfo =
+                                        (struct in_pktinfo *)CMSG_DATA(cmsg);
+                                printf("IP_PKTINFO interface index %u",
+                                        pktinfo->ipi_ifindex);
+                                break;
+                        }
+                        default:
+                                printf("type %d", cmsg->cmsg_type);
+                                break;
+                        }
+                        break;
+                default:
+                        printf("level %d type %d",
+                                cmsg->cmsg_level,
+                                cmsg->cmsg_type);
+                        break;
+                }
+                printf("\n");
+        }
+
+        if (siocgstamp) {
+                if (ioctl(sock, SIOCGSTAMP, &tv))
+                        printf("   %s: %s\n", "SIOCGSTAMP", strerror(errno));
+                else
+                        printf("SIOCGSTAMP %ld.%06ld\n",
+                               (long)tv.tv_sec,
+                               (long)tv.tv_usec);
+        }
+        if (siocgstampns) {
+                if (ioctl(sock, SIOCGSTAMPNS, &ts))
+                        printf("   %s: %s\n", "SIOCGSTAMPNS", strerror(errno));
+                else
+                        printf("SIOCGSTAMPNS %ld.%09ld\n",
+                               (long)ts.tv_sec,
+                               (long)ts.tv_nsec);
+        }
+}
+
+static void recvpacket(int sock, int recvmsg_flags,
+                       int siocgstamp, int siocgstampns)
+{
+        char data[256];
+        struct msghdr msg;
+        struct iovec entry;
+        struct sockaddr_in from_addr;
+        struct {
+                struct cmsghdr cm;
+                char control[512];
+        } control;
+        int res;
+
+        memset(&msg, 0, sizeof(msg));
+        msg.msg_iov = &entry;
+        msg.msg_iovlen = 1;
+        entry.iov_base = data;
+        entry.iov_len = sizeof(data);
+        msg.msg_name = (caddr_t)&from_addr;
+        msg.msg_namelen = sizeof(from_addr);
+        msg.msg_control = &control;
+        msg.msg_controllen = sizeof(control);
+
+        res = recvmsg(sock, &msg, recvmsg_flags|MSG_DONTWAIT);
+        if (res < 0) {
+                printf("%s %s: %s\n",
+                       "recvmsg",
+                       (recvmsg_flags & MSG_ERRQUEUE) ? "error" : "regular",
+                       strerror(errno));
+        } else {
+                printpacket(&msg, res, data,
+                            sock, recvmsg_flags,
+                            siocgstamp, siocgstampns);
+        }
+}
+
+int main(int argc, char **argv)
+{
+        int so_timestamping_flags = 0;
+        int so_timestamp = 0;
+        int so_timestampns = 0;
+        int siocgstamp = 0;
+        int siocgstampns = 0;
+        int ip_multicast_loop = 0;
+        char *interface;
+        int i;
+        int enabled = 1;
+        int sock;
+        struct ifreq device;
+        struct ifreq hwtstamp;
+        struct hwtstamp_config hwconfig, hwconfig_requested;
+        struct sockaddr_in addr;
+        struct ip_mreq imr;
+        struct in_addr iaddr;
+        int val;
+        socklen_t len;
+        struct timeval next;
+
+        if (argc < 2)
+                usage(0);
+        interface = argv[1];
+
+        for (i = 2; i < argc; i++) {
+                if (!strcasecmp(argv[i], "SO_TIMESTAMP"))
+                        so_timestamp = 1;
+                else if (!strcasecmp(argv[i], "SO_TIMESTAMPNS"))
+                        so_timestampns = 1;
+                else if (!strcasecmp(argv[i], "SIOCGSTAMP"))
+                        siocgstamp = 1;
+                else if (!strcasecmp(argv[i], "SIOCGSTAMPNS"))
+                        siocgstampns = 1;
+                else if (!strcasecmp(argv[i], "IP_MULTICAST_LOOP"))
+                        ip_multicast_loop = 1;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_TX_HARDWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_TX_HARDWARE;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_TX_SOFTWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_TX_SOFTWARE;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RX_HARDWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_RX_HARDWARE;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RX_SOFTWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_RX_SOFTWARE;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_SOFTWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_SOFTWARE;
+                else if (!strcasecmp(argv[i], "SOF_TIMESTAMPING_RAW_HARDWARE"))
+                        so_timestamping_flags |= SOF_TIMESTAMPING_RAW_HARDWARE;
+                else
+                        usage(argv[i]);
+        }
+
+        sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+        if (sock < 0)
+                bail("socket");
+
+        memset(&device, 0, sizeof(device));
+        strncpy(device.ifr_name, interface, sizeof(device.ifr_name));
+        if (ioctl(sock, SIOCGIFADDR, &device) < 0)
+                bail("getting interface IP address");
+
+        memset(&hwtstamp, 0, sizeof(hwtstamp));
+        strncpy(hwtstamp.ifr_name, interface, sizeof(hwtstamp.ifr_name));
+        hwtstamp.ifr_data = (void *)&hwconfig;
+        memset(&hwconfig, 0, sizeof(hwconfig));
+        hwconfig.tx_type =
+                (so_timestamping_flags & SOF_TIMESTAMPING_TX_HARDWARE) ?
+                HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF;
+        hwconfig.rx_filter =
+                (so_timestamping_flags & SOF_TIMESTAMPING_RX_HARDWARE) ?
+                HWTSTAMP_FILTER_PTP_V1_L4_SYNC : HWTSTAMP_FILTER_NONE;
+        hwconfig_requested = hwconfig;
+        if (ioctl(sock, SIOCSHWTSTAMP, &hwtstamp) < 0) {
+                if ((errno == EINVAL || errno == ENOTSUP) &&
+                    hwconfig_requested.tx_type == HWTSTAMP_TX_OFF &&
+                    hwconfig_requested.rx_filter == HWTSTAMP_FILTER_NONE)
+                        printf("SIOCSHWTSTAMP: disabling hardware time stamping not possible\n");
+                else
+                        bail("SIOCSHWTSTAMP");
+        }
+        printf("SIOCSHWTSTAMP: tx_type %d requested, got %d; rx_filter %d requested, got %d\n",
+               hwconfig_requested.tx_type, hwconfig.tx_type,
+               hwconfig_requested.rx_filter, hwconfig.rx_filter);
+
+        /* bind to PTP port */
+        addr.sin_family = AF_INET;
+        addr.sin_addr.s_addr = htonl(INADDR_ANY);
+        addr.sin_port = htons(319 /* PTP event port */);
+        if (bind(sock,
+                 (struct sockaddr *)&addr,
+                 sizeof(struct sockaddr_in)) < 0)
+                bail("bind");
+
+        /* set multicast group for outgoing packets */
+        inet_aton("224.0.1.130", &iaddr); /* alternate PTP domain 1 */
+        addr.sin_addr = iaddr;
+        imr.imr_multiaddr.s_addr = iaddr.s_addr;
+        imr.imr_interface.s_addr =
+                ((struct sockaddr_in *)&device.ifr_addr)->sin_addr.s_addr;
+        if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_IF,
+                       &imr.imr_interface.s_addr, sizeof(struct in_addr)) < 0)
+                bail("set multicast");
+
+        /* join multicast group, loop our own packet */
+        if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+                       &imr, sizeof(struct ip_mreq)) < 0)
+                bail("join multicast group");
+
+        if (setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP,
+                       &ip_multicast_loop, sizeof(enabled)) < 0) {
+                bail("loop multicast");
+        }
+
+        /* set socket options for time stamping */
+        if (so_timestamp &&
+                setsockopt(sock, SOL_SOCKET, SO_TIMESTAMP,
+                           &enabled, sizeof(enabled)) < 0)
+                bail("setsockopt SO_TIMESTAMP");
+
+        if (so_timestampns &&
+                setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS,
+                           &enabled, sizeof(enabled)) < 0)
+                bail("setsockopt SO_TIMESTAMPNS");
+
+        if (so_timestamping_flags &&
+                setsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING,
+                           &so_timestamping_flags,
+                           sizeof(so_timestamping_flags)) < 0)
+                bail("setsockopt SO_TIMESTAMPING");
+
+        /* request IP_PKTINFO for debugging purposes */
+        if (setsockopt(sock, SOL_IP, IP_PKTINFO,
+                       &enabled, sizeof(enabled)) < 0)
+                printf("%s: %s\n", "setsockopt IP_PKTINFO", strerror(errno));
+
+        /* verify socket options */
+        len = sizeof(val);
+        if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMP, &val, &len) < 0)
+                printf("%s: %s\n", "getsockopt SO_TIMESTAMP", strerror(errno));
+        else
+                printf("SO_TIMESTAMP %d\n", val);
+
+        if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPNS, &val, &len) < 0)
+                printf("%s: %s\n", "getsockopt SO_TIMESTAMPNS",
+                       strerror(errno));
+        else
+                printf("SO_TIMESTAMPNS %d\n", val);
+
+        if (getsockopt(sock, SOL_SOCKET, SO_TIMESTAMPING, &val, &len) < 0) {
+                printf("%s: %s\n", "getsockopt SO_TIMESTAMPING",
+                       strerror(errno));
+        } else {
+                printf("SO_TIMESTAMPING %d\n", val);
+                if (val != so_timestamping_flags)
+                        printf("   not the expected value %d\n",
+                               so_timestamping_flags);
+        }
+
+        /* send packets forever every five seconds */
+        gettimeofday(&next, 0);
+        next.tv_sec = (next.tv_sec + 1) / 5 * 5;
+        next.tv_usec = 0;
+        while (1) {
+                struct timeval now;
+                struct timeval delta;
+                long delta_us;
+                int res;
+                fd_set readfs, errorfs;
+
+                gettimeofday(&now, 0);
+                delta_us = (long)(next.tv_sec - now.tv_sec) * 1000000 +
+                        (long)(next.tv_usec - now.tv_usec);
+                if (delta_us > 0) {
+                        /* continue waiting for timeout or data */
+                        delta.tv_sec = delta_us / 1000000;
+                        delta.tv_usec = delta_us % 1000000;
+
+                        FD_ZERO(&readfs);
+                        FD_ZERO(&errorfs);
+                        FD_SET(sock, &readfs);
+                        FD_SET(sock, &errorfs);
+                        printf("%ld.%06ld: select %ldus\n",
+                               (long)now.tv_sec, (long)now.tv_usec,
+                               delta_us);
+                        res = select(sock + 1, &readfs, 0, &errorfs, &delta);
+                        gettimeofday(&now, 0);
+                        printf("%ld.%06ld: select returned: %d, %s\n",
+                               (long)now.tv_sec, (long)now.tv_usec,
+                               res,
+                               res < 0 ? strerror(errno) : "success");
+                        if (res > 0) {
+                                if (FD_ISSET(sock, &readfs))
+                                        printf("ready for reading\n");
+                                if (FD_ISSET(sock, &errorfs))
+                                        printf("has error\n");
+                                recvpacket(sock, 0,
+                                           siocgstamp,
+                                           siocgstampns);
+                                recvpacket(sock, MSG_ERRQUEUE,
+                                           siocgstamp,
+                                           siocgstampns);
+                        }
+                } else {
+                        /* write one packet */
+                        sendpacket(sock,
+                                   (struct sockaddr *)&addr,
+                                   sizeof(addr));
+                        next.tv_sec += 5;
+                        continue;
+                }
+        }
+
+        return 0;
+}
diff --git a/tools/testing/selftests/networking/timestamping/txtimestamp.c b/tools/testing/selftests/networking/timestamping/txtimestamp.c
new file mode 100644
index 000000000000..5df07047ca86
--- /dev/null
+++ b/tools/testing/selftests/networking/timestamping/txtimestamp.c
@@ -0,0 +1,549 @@
+/*
+ * Copyright 2014 Google Inc.
+ * Author: willemb@google.com (Willem de Bruijn)
+ *
+ * Test software tx timestamping, including
+ *
+ * - SCHED, SND and ACK timestamps
+ * - RAW, UDP and TCP
+ * - IPv4 and IPv6
+ * - various packet sizes (to test GSO and TSO)
+ *
+ * Consult the command line arguments for help on running
+ * the various testcases.
+ *
+ * This test requires a dummy TCP server.
+ * A simple `nc6 [-u] -l -p $DESTPORT` will do
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#define _GNU_SOURCE
+
+#include <arpa/inet.h>
+#include <asm/types.h>
+#include <error.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <linux/errqueue.h>
+#include <linux/if_ether.h>
+#include <linux/net_tstamp.h>
+#include <netdb.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+#include <netinet/tcp.h>
+#include <netpacket/packet.h>
+#include <poll.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+/* command line parameters */
+static int cfg_proto = SOCK_STREAM;
+static int cfg_ipproto = IPPROTO_TCP;
+static int cfg_num_pkts = 4;
+static int do_ipv4 = 1;
+static int do_ipv6 = 1;
+static int cfg_payload_len = 10;
+static bool cfg_show_payload;
+static bool cfg_do_pktinfo;
+static bool cfg_loop_nodata;
+static uint16_t dest_port = 9000;
+
+static struct sockaddr_in daddr;
+static struct sockaddr_in6 daddr6;
+static struct timespec ts_prev;
+
+static void __print_timestamp(const char *name, struct timespec *cur,
+                              uint32_t key, int payload_len)
+{
+        if (!(cur->tv_sec | cur->tv_nsec))
+                return;
+
+        fprintf(stderr, "  %s: %lu s %lu us (seq=%u, len=%u)",
+                        name, cur->tv_sec, cur->tv_nsec / 1000,
+                        key, payload_len);
+
+        if ((ts_prev.tv_sec | ts_prev.tv_nsec)) {
+                int64_t cur_ms, prev_ms;
+
+                cur_ms = (long) cur->tv_sec * 1000 * 1000;
+                cur_ms += cur->tv_nsec / 1000;
+
+                prev_ms = (long) ts_prev.tv_sec * 1000 * 1000;
+                prev_ms += ts_prev.tv_nsec / 1000;
+
+                fprintf(stderr, "  (%+" PRId64 " us)", cur_ms - prev_ms);
+        }
+
+        ts_prev = *cur;
+        fprintf(stderr, "\n");
+}
+
+static void print_timestamp_usr(void)
+{
+        struct timespec ts;
+        struct timeval tv;      /* avoid dependency on -lrt */
+
+        gettimeofday(&tv, NULL);
+        ts.tv_sec = tv.tv_sec;
+        ts.tv_nsec = tv.tv_usec * 1000;
+
+        __print_timestamp("  USR", &ts, 0, 0);
+}
+
+static void print_timestamp(struct scm_timestamping *tss, int tstype,
+                            int tskey, int payload_len)
+{
+        const char *tsname;
+
+        switch (tstype) {
+        case SCM_TSTAMP_SCHED:
+                tsname = "  ENQ";
+                break;
+        case SCM_TSTAMP_SND:
+                tsname = "  SND";
+                break;
+        case SCM_TSTAMP_ACK:
+                tsname = "  ACK";
+                break;
+        default:
+                error(1, 0, "unknown timestamp type: %u",
+                tstype);
+        }
+        __print_timestamp(tsname, &tss->ts[0], tskey, payload_len);
+}
+
+/* TODO: convert to check_and_print payload once API is stable */
+static void print_payload(char *data, int len)
+{
+        int i;
+
+        if (!len)
+                return;
+
+        if (len > 70)
+                len = 70;
+
+        fprintf(stderr, "payload: ");
+        for (i = 0; i < len; i++)
+                fprintf(stderr, "%02hhx ", data[i]);
+        fprintf(stderr, "\n");
+}
+
+static void print_pktinfo(int family, int ifindex, void *saddr, void *daddr)
+{
+        char sa[INET6_ADDRSTRLEN], da[INET6_ADDRSTRLEN];
+
+        fprintf(stderr, "         pktinfo: ifindex=%u src=%s dst=%s\n",
+                ifindex,
+                saddr ? inet_ntop(family, saddr, sa, sizeof(sa)) : "unknown",
+                daddr ? inet_ntop(family, daddr, da, sizeof(da)) : "unknown");
+}
+
+static void __poll(int fd)
+{
+        struct pollfd pollfd;
+        int ret;
+
+        memset(&pollfd, 0, sizeof(pollfd));
+        pollfd.fd = fd;
+        ret = poll(&pollfd, 1, 100);
+        if (ret != 1)
+                error(1, errno, "poll");
+}
+
+static void __recv_errmsg_cmsg(struct msghdr *msg, int payload_len)
+{
+        struct sock_extended_err *serr = NULL;
+        struct scm_timestamping *tss = NULL;
+        struct cmsghdr *cm;
+        int batch = 0;
+
+        for (cm = CMSG_FIRSTHDR(msg);
+             cm && cm->cmsg_len;
+             cm = CMSG_NXTHDR(msg, cm)) {
+                if (cm->cmsg_level == SOL_SOCKET &&
+                    cm->cmsg_type == SCM_TIMESTAMPING) {
+                        tss = (void *) CMSG_DATA(cm);
+                } else if ((cm->cmsg_level == SOL_IP &&
+                            cm->cmsg_type == IP_RECVERR) ||
+                           (cm->cmsg_level == SOL_IPV6 &&
+                            cm->cmsg_type == IPV6_RECVERR)) {
+                        serr = (void *) CMSG_DATA(cm);
+                        if (serr->ee_errno != ENOMSG ||
+                            serr->ee_origin != SO_EE_ORIGIN_TIMESTAMPING) {
+                                fprintf(stderr, "unknown ip error %d %d\n",
+                                                serr->ee_errno,
+                                                serr->ee_origin);
+                                serr = NULL;
+                        }
+                } else if (cm->cmsg_level == SOL_IP &&
+                           cm->cmsg_type == IP_PKTINFO) {
+                        struct in_pktinfo *info = (void *) CMSG_DATA(cm);
+                        print_pktinfo(AF_INET, info->ipi_ifindex,
+                                      &info->ipi_spec_dst, &info->ipi_addr);
+                } else if (cm->cmsg_level == SOL_IPV6 &&
+                           cm->cmsg_type == IPV6_PKTINFO) {
+                        struct in6_pktinfo *info6 = (void *) CMSG_DATA(cm);
+                        print_pktinfo(AF_INET6, info6->ipi6_ifindex,
+                                      NULL, &info6->ipi6_addr);
+                } else
+                        fprintf(stderr, "unknown cmsg %d,%d\n",
+                                        cm->cmsg_level, cm->cmsg_type);
+
+                if (serr && tss) {
+                        print_timestamp(tss, serr->ee_info, serr->ee_data,
+                                        payload_len);
+                        serr = NULL;
+                        tss = NULL;
+                        batch++;
+                }
+        }
+
+        if (batch > 1)
+                fprintf(stderr, "batched %d timestamps\n", batch);
+}
+
+static int recv_errmsg(int fd)
+{
+        static char ctrl[1024 /* overprovision*/];
+        static struct msghdr msg;
+        struct iovec entry;
+        static char *data;
+        int ret = 0;
+
+        data = malloc(cfg_payload_len);
+        if (!data)
+                error(1, 0, "malloc");
+
+        memset(&msg, 0, sizeof(msg));
+        memset(&entry, 0, sizeof(entry));
+        memset(ctrl, 0, sizeof(ctrl));
+
+        entry.iov_base = data;
+        entry.iov_len = cfg_payload_len;
+        msg.msg_iov = &entry;
+        msg.msg_iovlen = 1;
+        msg.msg_name = NULL;
+        msg.msg_namelen = 0;
+        msg.msg_control = ctrl;
+        msg.msg_controllen = sizeof(ctrl);
+
+        ret = recvmsg(fd, &msg, MSG_ERRQUEUE);
+        if (ret == -1 && errno != EAGAIN)
+                error(1, errno, "recvmsg");
+
+        if (ret >= 0) {
+                __recv_errmsg_cmsg(&msg, ret);
+                if (cfg_show_payload)
+                        print_payload(data, cfg_payload_len);
+        }
+
+        free(data);
+        return ret == -1;
+}
+
+static void do_test(int family, unsigned int opt)
+{
+        char *buf;
+        int fd, i, val = 1, total_len;
+
+        if (family == AF_INET6 && cfg_proto != SOCK_STREAM) {
+                /* due to lack of checksum generation code */
+                fprintf(stderr, "test: skipping datagram over IPv6\n");
+                return;
+        }
+
+        total_len = cfg_payload_len;
+        if (cfg_proto == SOCK_RAW) {
+                total_len += sizeof(struct udphdr);
+                if (cfg_ipproto == IPPROTO_RAW)
+                        total_len += sizeof(struct iphdr);
+        }
+
+        buf = malloc(total_len);
+        if (!buf)
+                error(1, 0, "malloc");
+
+        fd = socket(family, cfg_proto, cfg_ipproto);
+        if (fd < 0)
+                error(1, errno, "socket");
+
+        if (cfg_proto == SOCK_STREAM) {
+                if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
+                               (char*) &val, sizeof(val)))
+                        error(1, 0, "setsockopt no nagle");
+
+                if (family == PF_INET) {
+                        if (connect(fd, (void *) &daddr, sizeof(daddr)))
+                                error(1, errno, "connect ipv4");
+                } else {
+                        if (connect(fd, (void *) &daddr6, sizeof(daddr6)))
+                                error(1, errno, "connect ipv6");
+                }
+        }
+
+        if (cfg_do_pktinfo) {
+                if (family == AF_INET6) {
+                        if (setsockopt(fd, SOL_IPV6, IPV6_RECVPKTINFO,
+                                       &val, sizeof(val)))
+                                error(1, errno, "setsockopt pktinfo ipv6");
+                } else {
+                        if (setsockopt(fd, SOL_IP, IP_PKTINFO,
+                                       &val, sizeof(val)))
+                                error(1, errno, "setsockopt pktinfo ipv4");
+                }
+        }
+
+        opt |= SOF_TIMESTAMPING_SOFTWARE |
+               SOF_TIMESTAMPING_OPT_CMSG |
+               SOF_TIMESTAMPING_OPT_ID;
+        if (cfg_loop_nodata)
+                opt |= SOF_TIMESTAMPING_OPT_TSONLY;
+
+        if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING,
+                       (char *) &opt, sizeof(opt)))
+                error(1, 0, "setsockopt timestamping");
+
+        for (i = 0; i < cfg_num_pkts; i++) {
+                memset(&ts_prev, 0, sizeof(ts_prev));
+                memset(buf, 'a' + i, total_len);
+
+                if (cfg_proto == SOCK_RAW) {
+                        struct udphdr *udph;
+                        int off = 0;
+
+                        if (cfg_ipproto == IPPROTO_RAW) {
+                                struct iphdr *iph = (void *) buf;
+
+                                memset(iph, 0, sizeof(*iph));
+                                iph->ihl      = 5;
+                                iph->version  = 4;
+                                iph->ttl      = 2;
+                                iph->daddr    = daddr.sin_addr.s_addr;
+                                iph->protocol = IPPROTO_UDP;
+                                /* kernel writes saddr, csum, len */
+
+                                off = sizeof(*iph);
+                        }
+
+                        udph = (void *) buf + off;
+                        udph->source = ntohs(9000);     /* random spoof */
+                        udph->dest   = ntohs(dest_port);
+                        udph->len    = ntohs(sizeof(*udph) + cfg_payload_len);
+                        udph->check  = 0;       /* not allowed for IPv6 */
+                }
+
+                print_timestamp_usr();
+                if (cfg_proto != SOCK_STREAM) {
+                        if (family == PF_INET)
+                                val = sendto(fd, buf, total_len, 0, (void *) &daddr, sizeof(daddr));
+                        else
+                                val = sendto(fd, buf, total_len, 0, (void *) &daddr6, sizeof(daddr6));
+                } else {
+                        val = send(fd, buf, cfg_payload_len, 0);
+                }
+                if (val != total_len)
+                        error(1, errno, "send");
+
+                /* wait for all errors to be queued, else ACKs arrive OOO */
+                usleep(50 * 1000);
+
+                __poll(fd);
+
+                while (!recv_errmsg(fd)) {}
+        }
+
+        if (close(fd))
+                error(1, errno, "close");
+
+        free(buf);
+        usleep(400 * 1000);
+}
+
+static void __attribute__((noreturn)) usage(const char *filepath)
+{
+        fprintf(stderr, "\nUsage: %s [options] hostname\n"
+                        "\nwhere options are:\n"
+                        "  -4:   only IPv4\n"
+                        "  -6:   only IPv6\n"
+                        "  -h:   show this message\n"
+                        "  -I:   request PKTINFO\n"
+                        "  -l N: send N bytes at a time\n"
+                        "  -n:   set no-payload option\n"
+                        "  -r:   use raw\n"
+                        "  -R:   use raw (IP_HDRINCL)\n"
+                        "  -p N: connect to port N\n"
+                        "  -u:   use udp\n"
+                        "  -x:   show payload (up to 70 bytes)\n",
+                        filepath);
+        exit(1);
+}
+
+static void parse_opt(int argc, char **argv)
+{
+        int proto_count = 0;
+        char c;
+
+        while ((c = getopt(argc, argv, "46hIl:np:rRux")) != -1) {
+                switch (c) {
+                case '4':
+                        do_ipv6 = 0;
+                        break;
+                case '6':
+                        do_ipv4 = 0;
+                        break;
+                case 'I':
+                        cfg_do_pktinfo = true;
+                        break;
+                case 'n':
+                        cfg_loop_nodata = true;
+                        break;
+                case 'r':
+                        proto_count++;
+                        cfg_proto = SOCK_RAW;
+                        cfg_ipproto = IPPROTO_UDP;
+                        break;
+                case 'R':
+                        proto_count++;
+                        cfg_proto = SOCK_RAW;
+                        cfg_ipproto = IPPROTO_RAW;
+                        break;
+                case 'u':
+                        proto_count++;
+                        cfg_proto = SOCK_DGRAM;
+                        cfg_ipproto = IPPROTO_UDP;
+                        break;
+                case 'l':
+                        cfg_payload_len = strtoul(optarg, NULL, 10);
+                        break;
+                case 'p':
+                        dest_port = strtoul(optarg, NULL, 10);
+                        break;
+                case 'x':
+                        cfg_show_payload = true;
+                        break;
+                case 'h':
+                default:
+                        usage(argv[0]);
+                }
+        }
+
+        if (!cfg_payload_len)
+                error(1, 0, "payload may not be nonzero");
+        if (cfg_proto != SOCK_STREAM && cfg_payload_len > 1472)
+                error(1, 0, "udp packet might exceed expected MTU");
+        if (!do_ipv4 && !do_ipv6)
+                error(1, 0, "pass -4 or -6, not both");
+        if (proto_count > 1)
+                error(1, 0, "pass -r, -R or -u, not multiple");
+
+        if (optind != argc - 1)
+                error(1, 0, "missing required hostname argument");
+}
+
+static void resolve_hostname(const char *hostname)
+{
+        struct addrinfo *addrs, *cur;
+        int have_ipv4 = 0, have_ipv6 = 0;
+
+        if (getaddrinfo(hostname, NULL, NULL, &addrs))
+                error(1, errno, "getaddrinfo");
+
+        cur = addrs;
+        while (cur && !have_ipv4 && !have_ipv6) {
+                if (!have_ipv4 && cur->ai_family == AF_INET) {
+                        memcpy(&daddr, cur->ai_addr, sizeof(daddr));
+                        daddr.sin_port = htons(dest_port);
+                        have_ipv4 = 1;
+                }
+                else if (!have_ipv6 && cur->ai_family == AF_INET6) {
+                        memcpy(&daddr6, cur->ai_addr, sizeof(daddr6));
+                        daddr6.sin6_port = htons(dest_port);
+                        have_ipv6 = 1;
+                }
+                cur = cur->ai_next;
+        }
+        if (addrs)
+                freeaddrinfo(addrs);
+
+        do_ipv4 &= have_ipv4;
+        do_ipv6 &= have_ipv6;
+}
+
+static void do_main(int family)
+{
+        fprintf(stderr, "family:       %s\n",
+                        family == PF_INET ? "INET" : "INET6");
+
+        fprintf(stderr, "test SND\n");
+        do_test(family, SOF_TIMESTAMPING_TX_SOFTWARE);
+
+        fprintf(stderr, "test ENQ\n");
+        do_test(family, SOF_TIMESTAMPING_TX_SCHED);
+
+        fprintf(stderr, "test ENQ + SND\n");
+        do_test(family, SOF_TIMESTAMPING_TX_SCHED |
+                        SOF_TIMESTAMPING_TX_SOFTWARE);
+
+        if (cfg_proto == SOCK_STREAM) {
+                fprintf(stderr, "\ntest ACK\n");
+                do_test(family, SOF_TIMESTAMPING_TX_ACK);
+
+                fprintf(stderr, "\ntest SND + ACK\n");
+                do_test(family, SOF_TIMESTAMPING_TX_SOFTWARE |
+                                SOF_TIMESTAMPING_TX_ACK);
+
+                fprintf(stderr, "\ntest ENQ + SND + ACK\n");
+                do_test(family, SOF_TIMESTAMPING_TX_SCHED |
+                                SOF_TIMESTAMPING_TX_SOFTWARE |
+                                SOF_TIMESTAMPING_TX_ACK);
+        }
+}
+
+const char *sock_names[] = { NULL, "TCP", "UDP", "RAW" };
+
+int main(int argc, char **argv)
+{
+        if (argc == 1)
+                usage(argv[0]);
+
+        parse_opt(argc, argv);
+        resolve_hostname(argv[argc - 1]);
+
+        fprintf(stderr, "protocol:     %s\n", sock_names[cfg_proto]);
+        fprintf(stderr, "payload:      %u\n", cfg_payload_len);
+        fprintf(stderr, "server port:  %u\n", dest_port);
+        fprintf(stderr, "\n");
+
+        if (do_ipv4)
+                do_main(PF_INET);
+        if (do_ipv6)
+                do_main(PF_INET6);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/nsfs/Makefile b/tools/testing/selftests/nsfs/Makefile
new file mode 100644
index 000000000000..2306054a901a
--- /dev/null
+++ b/tools/testing/selftests/nsfs/Makefile
@@ -0,0 +1,12 @@
+TEST_PROGS := owner pidns
+
+CFLAGS := -Wall -Werror
+
+all: owner pidns
+owner: owner.c
+pidns: pidns.c
+
+clean:
+        $(RM) owner pidns
+
+include ../lib.mk
diff --git a/tools/testing/selftests/nsfs/owner.c b/tools/testing/selftests/nsfs/owner.c
new file mode 100644
index 000000000000..437205f8b714
--- /dev/null
+++ b/tools/testing/selftests/nsfs/owner.c
@@ -0,0 +1,91 @@
+#define _GNU_SOURCE
+#include <sched.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include <sys/wait.h>
+
+#define NSIO    0xb7
+#define NS_GET_USERNS   _IO(NSIO, 0x1)
+
+#define pr_err(fmt, ...) \
+                ({ \
+                        fprintf(stderr, "%s:%d:" fmt ": %m\n", \
+                                __func__, __LINE__, ##__VA_ARGS__); \
+                        1; \
+                })
+
+int main(int argc, char *argvp[])
+{
+        int pfd[2], ns, uns, init_uns;
+        struct stat st1, st2;
+        char path[128];
+        pid_t pid;
+        char c;
+
+        if (pipe(pfd))
+                return 1;
+
+        pid = fork();
+        if (pid < 0)
+                return pr_err("fork");
+        if (pid == 0) {
+                prctl(PR_SET_PDEATHSIG, SIGKILL);
+                if (unshare(CLONE_NEWUTS | CLONE_NEWUSER))
+                        return pr_err("unshare");
+                close(pfd[0]);
+                close(pfd[1]);
+                while (1)
+                        sleep(1);
+                return 0;
+        }
+        close(pfd[1]);
+        if (read(pfd[0], &c, 1) != 0)
+                return pr_err("Unable to read from pipe");
+        close(pfd[0]);
+
+        snprintf(path, sizeof(path), "/proc/%d/ns/uts", pid);
+        ns = open(path, O_RDONLY);
+        if (ns < 0)
+                return pr_err("Unable to open %s", path);
+
+        uns = ioctl(ns, NS_GET_USERNS);
+        if (uns < 0)
+                return pr_err("Unable to get an owning user namespace");
+
+        if (fstat(uns, &st1))
+                return pr_err("fstat");
+
+        snprintf(path, sizeof(path), "/proc/%d/ns/user", pid);
+        if (stat(path, &st2))
+                return pr_err("stat");
+
+        if (st1.st_ino != st2.st_ino)
+                return pr_err("NS_GET_USERNS returned a wrong namespace");
+
+        init_uns = ioctl(uns, NS_GET_USERNS);
+        if (uns < 0)
+                return pr_err("Unable to get an owning user namespace");
+
+        if (ioctl(init_uns, NS_GET_USERNS) >= 0 || errno != EPERM)
+                return pr_err("Don't get EPERM");
+
+        if (unshare(CLONE_NEWUSER))
+                return pr_err("unshare");
+
+        if (ioctl(ns, NS_GET_USERNS) >= 0 || errno != EPERM)
+                return pr_err("Don't get EPERM");
+        if (ioctl(init_uns, NS_GET_USERNS) >= 0 || errno != EPERM)
+                return pr_err("Don't get EPERM");
+
+        kill(pid, SIGKILL);
+        wait(NULL);
+        return 0;
+}
diff --git a/tools/testing/selftests/nsfs/pidns.c b/tools/testing/selftests/nsfs/pidns.c
new file mode 100644
index 000000000000..ae3a0d68e966
--- /dev/null
+++ b/tools/testing/selftests/nsfs/pidns.c
@@ -0,0 +1,78 @@
+#define _GNU_SOURCE
+#include <sched.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+#include <sys/wait.h>
+
+#define pr_err(fmt, ...) \
+                ({ \
+                        fprintf(stderr, "%s:%d:" fmt ": %m\n", \
+                                __func__, __LINE__, ##__VA_ARGS__); \
+                        1; \
+                })
+
+#define NSIO    0xb7
+#define NS_GET_USERNS   _IO(NSIO, 0x1)
+#define NS_GET_PARENT   _IO(NSIO, 0x2)
+
+#define __stack_aligned__       __attribute__((aligned(16)))
+struct cr_clone_arg {
+        char stack[128] __stack_aligned__;
+        char stack_ptr[0];
+};
+
+static int child(void *args)
+{
+        prctl(PR_SET_PDEATHSIG, SIGKILL);
+        while (1)
+                sleep(1);
+        exit(0);
+}
+
+int main(int argc, char *argv[])
+{
+        char *ns_strs[] = {"pid", "user"};
+        char path[] = "/proc/0123456789/ns/pid";
+        struct cr_clone_arg ca;
+        struct stat st1, st2;
+        int ns, pns, i;
+        pid_t pid;
+
+        pid = clone(child, ca.stack_ptr, CLONE_NEWUSER | CLONE_NEWPID | SIGCHLD, NULL);
+        if (pid < 0)
+                return pr_err("clone");
+
+        for (i = 0; i < 2; i++) {
+                snprintf(path, sizeof(path), "/proc/%d/ns/%s", pid, ns_strs[i]);
+                ns = open(path, O_RDONLY);
+                if (ns < 0)
+                        return pr_err("Unable to open %s", path);
+
+                pns = ioctl(ns, NS_GET_PARENT);
+                if (pns < 0)
+                        return pr_err("Unable to get a parent pidns");
+
+                snprintf(path, sizeof(path), "/proc/self/ns/%s", ns_strs[i]);
+                if (stat(path, &st2))
+                        return pr_err("Unable to stat %s", path);
+                if (fstat(pns, &st1))
+                        return pr_err("Unable to stat the parent pidns");
+                if (st1.st_ino != st2.st_ino)
+                        return pr_err("NS_GET_PARENT returned a wrong namespace");
+
+                if (ioctl(pns, NS_GET_PARENT) >= 0 || errno != EPERM)
+                        return pr_err("Don't get EPERM");;
+        }
+
+        kill(pid, SIGKILL);
+        wait(NULL);
+        return 0;
+}
diff --git a/tools/testing/selftests/ntb/ntb_test.sh b/tools/testing/selftests/ntb/ntb_test.sh
new file mode 100755
index 000000000000..a676d3eefefb
--- /dev/null
+++ b/tools/testing/selftests/ntb/ntb_test.sh
@@ -0,0 +1,422 @@
+#!/bin/bash
+# Copyright (c) 2016 Microsemi. All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation; either version 2 of
+# the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it would be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# Author: Logan Gunthorpe <logang@deltatee.com>
+
+REMOTE_HOST=
+LIST_DEVS=FALSE
+
+DEBUGFS=${DEBUGFS-/sys/kernel/debug}
+
+PERF_RUN_ORDER=32
+MAX_MW_SIZE=0
+RUN_DMA_TESTS=
+DONT_CLEANUP=
+MW_SIZE=65536
+
+function show_help()
+{
+        echo "Usage: $0 [OPTIONS] LOCAL_DEV REMOTE_DEV"
+        echo "Run tests on a pair of NTB endpoints."
+        echo
+        echo "If the NTB device loops back to the same host then,"
+        echo "just specifying the two PCI ids on the command line is"
+        echo "sufficient. Otherwise, if the NTB link spans two hosts"
+        echo "use the -r option to specify the hostname for the remote"
+        echo "device. SSH will then be used to test the remote side."
+        echo "An SSH key between the root users of the host would then"
+        echo "be highly recommended."
+        echo
+        echo "Options:"
+        echo "  -C              don't cleanup ntb modules on exit"
+        echo "  -d              run dma tests"
+        echo "  -h              show this help message"
+        echo "  -l              list available local and remote PCI ids"
+        echo "  -r REMOTE_HOST  specify the remote's hostname to connect"
+        echo "                  to for the test (using ssh)"
+        echo "  -p NUM          ntb_perf run order (default: $PERF_RUN_ORDER)"
+        echo "  -w max_mw_size  maxmium memory window size"
+        echo
+}
+
+function parse_args()
+{
+        OPTIND=0
+        while getopts "Cdhlm:r:p:w:" opt; do
+                case "$opt" in
+                C)  DONT_CLEANUP=1 ;;
+                d)  RUN_DMA_TESTS=1 ;;
+                h)  show_help; exit 0 ;;
+                l)  LIST_DEVS=TRUE ;;
+                m)  MW_SIZE=${OPTARG} ;;
+                r)  REMOTE_HOST=${OPTARG} ;;
+                p)  PERF_RUN_ORDER=${OPTARG} ;;
+                w)  MAX_MW_SIZE=${OPTARG} ;;
+                \?)
+                    echo "Invalid option: -$OPTARG" >&2
+                    exit 1
+                    ;;
+                esac
+        done
+}
+
+parse_args "$@"
+shift $((OPTIND-1))
+LOCAL_DEV=$1
+shift
+parse_args "$@"
+shift $((OPTIND-1))
+REMOTE_DEV=$1
+shift
+parse_args "$@"
+
+set -e
+
+function _modprobe()
+{
+        modprobe "$@"
+}
+
+function split_remote()
+{
+        VPATH=$1
+        REMOTE=
+
+        if [[ "$VPATH" == *":/"* ]]; then
+                REMOTE=${VPATH%%:*}
+                VPATH=${VPATH#*:}
+        fi
+}
+
+function read_file()
+{
+        split_remote $1
+        if [[ "$REMOTE" != "" ]]; then
+                ssh "$REMOTE" cat "$VPATH"
+        else
+                cat "$VPATH"
+        fi
+}
+
+function write_file()
+{
+        split_remote $2
+        VALUE=$1
+
+        if [[ "$REMOTE" != "" ]]; then
+                ssh "$REMOTE" "echo \"$VALUE\" > \"$VPATH\""
+        else
+                echo "$VALUE" > "$VPATH"
+        fi
+}
+
+function link_test()
+{
+        LOC=$1
+        REM=$2
+        EXP=0
+
+        echo "Running link tests on: $(basename $LOC) / $(basename $REM)"
+
+        if ! write_file "N" "$LOC/link" 2> /dev/null; then
+                echo "  Unsupported"
+                return
+        fi
+
+        write_file "N" "$LOC/link_event"
+
+        if [[ $(read_file "$REM/link") != "N" ]]; then
+                echo "Expected remote link to be down in $REM/link" >&2
+                exit -1
+        fi
+
+        write_file "Y" "$LOC/link"
+        write_file "Y" "$LOC/link_event"
+
+        echo "  Passed"
+}
+
+function doorbell_test()
+{
+        LOC=$1
+        REM=$2
+        EXP=0
+
+        echo "Running db tests on: $(basename $LOC) / $(basename $REM)"
+
+        write_file "c 0xFFFFFFFF" "$REM/db"
+
+        for ((i=1; i <= 8; i++)); do
+                let DB=$(read_file "$REM/db") || true
+                if [[ "$DB" != "$EXP" ]]; then
+                        echo "Doorbell doesn't match expected value $EXP " \
+                             "in $REM/db" >&2
+                        exit -1
+                fi
+
+                let "MASK=1 << ($i-1)" || true
+                let "EXP=$EXP | $MASK" || true
+                write_file "s $MASK" "$LOC/peer_db"
+        done
+
+        echo "  Passed"
+}
+
+function read_spad()
+{
+       VPATH=$1
+       IDX=$2
+
+       ROW=($(read_file "$VPATH" | grep -e "^$IDX"))
+       let VAL=${ROW[1]} || true
+       echo $VAL
+}
+
+function scratchpad_test()
+{
+        LOC=$1
+        REM=$2
+        CNT=$(read_file "$LOC/spad" | wc -l)
+
+        echo "Running spad tests on: $(basename $LOC) / $(basename $REM)"
+
+        for ((i = 0; i < $CNT; i++)); do
+                VAL=$RANDOM
+                write_file "$i $VAL" "$LOC/peer_spad"
+                RVAL=$(read_spad "$REM/spad" $i)
+
+                if [[ "$VAL" != "$RVAL" ]]; then
+                        echo "Scratchpad doesn't match expected value $VAL " \
+                             "in $REM/spad, got $RVAL" >&2
+                        exit -1
+                fi
+
+        done
+
+        echo "  Passed"
+}
+
+function write_mw()
+{
+        split_remote $2
+
+        if [[ "$REMOTE" != "" ]]; then
+                ssh "$REMOTE" \
+                        dd if=/dev/urandom "of=$VPATH" 2> /dev/null || true
+        else
+                dd if=/dev/urandom "of=$VPATH" 2> /dev/null || true
+        fi
+}
+
+function mw_test()
+{
+        IDX=$1
+        LOC=$2
+        REM=$3
+
+        echo "Running $IDX tests on: $(basename $LOC) / $(basename $REM)"
+
+        write_mw "$LOC/$IDX"
+
+        split_remote "$LOC/$IDX"
+        if [[ "$REMOTE" == "" ]]; then
+                A=$VPATH
+        else
+                A=/tmp/ntb_test.$$.A
+                ssh "$REMOTE" cat "$VPATH" > "$A"
+        fi
+
+        split_remote "$REM/peer_$IDX"
+        if [[ "$REMOTE" == "" ]]; then
+                B=$VPATH
+        else
+                B=/tmp/ntb_test.$$.B
+                ssh "$REMOTE" cat "$VPATH" > "$B"
+        fi
+
+        cmp -n $MW_SIZE "$A" "$B"
+        if [[ $? != 0 ]]; then
+                echo "Memory window $MW did not match!" >&2
+        fi
+
+        if [[ "$A" == "/tmp/*" ]]; then
+                rm "$A"
+        fi
+
+        if [[ "$B" == "/tmp/*" ]]; then
+                rm "$B"
+        fi
+
+        echo "  Passed"
+}
+
+function pingpong_test()
+{
+        LOC=$1
+        REM=$2
+
+        echo "Running ping pong tests on: $(basename $LOC) / $(basename $REM)"
+
+        LOC_START=$(read_file $LOC/count)
+        REM_START=$(read_file $REM/count)
+
+        sleep 7
+
+        LOC_END=$(read_file $LOC/count)
+        REM_END=$(read_file $REM/count)
+
+        if [[ $LOC_START == $LOC_END ]] || [[ $REM_START == $REM_END ]]; then
+                echo "Ping pong counter not incrementing!" >&2
+                exit 1
+        fi
+
+        echo "  Passed"
+}
+
+function perf_test()
+{
+        USE_DMA=$1
+
+        if [[ $USE_DMA == "1" ]]; then
+                WITH="with"
+        else
+                WITH="without"
+        fi
+
+        _modprobe ntb_perf run_order=$PERF_RUN_ORDER \
+                max_mw_size=$MAX_MW_SIZE use_dma=$USE_DMA
+
+        echo "Running local perf test $WITH DMA"
+        write_file "" $LOCAL_PERF/run
+        echo -n "  "
+        read_file $LOCAL_PERF/run
+        echo "  Passed"
+
+        echo "Running remote perf test $WITH DMA"
+        write_file "" $REMOTE_PERF/run
+        echo -n "  "
+        read_file $LOCAL_PERF/run
+        echo "  Passed"
+
+        _modprobe -r ntb_perf
+}
+
+function ntb_tool_tests()
+{
+        LOCAL_TOOL=$DEBUGFS/ntb_tool/$LOCAL_DEV
+        REMOTE_TOOL=$REMOTE_HOST:$DEBUGFS/ntb_tool/$REMOTE_DEV
+
+        echo "Starting ntb_tool tests..."
+
+        _modprobe ntb_tool
+
+        write_file Y $LOCAL_TOOL/link_event
+        write_file Y $REMOTE_TOOL/link_event
+
+        link_test $LOCAL_TOOL $REMOTE_TOOL
+        link_test $REMOTE_TOOL $LOCAL_TOOL
+
+        for PEER_TRANS in $(ls $LOCAL_TOOL/peer_trans*); do
+                PT=$(basename $PEER_TRANS)
+                write_file $MW_SIZE $LOCAL_TOOL/$PT
+                write_file $MW_SIZE $REMOTE_TOOL/$PT
+        done
+
+        doorbell_test $LOCAL_TOOL $REMOTE_TOOL
+        doorbell_test $REMOTE_TOOL $LOCAL_TOOL
+        scratchpad_test $LOCAL_TOOL $REMOTE_TOOL
+        scratchpad_test $REMOTE_TOOL $LOCAL_TOOL
+
+        for MW in $(ls $LOCAL_TOOL/mw*); do
+                MW=$(basename $MW)
+
+                mw_test $MW $LOCAL_TOOL $REMOTE_TOOL
+                mw_test $MW $REMOTE_TOOL $LOCAL_TOOL
+        done
+
+        _modprobe -r ntb_tool
+}
+
+function ntb_pingpong_tests()
+{
+        LOCAL_PP=$DEBUGFS/ntb_pingpong/$LOCAL_DEV
+        REMOTE_PP=$REMOTE_HOST:$DEBUGFS/ntb_pingpong/$REMOTE_DEV
+
+        echo "Starting ntb_pingpong tests..."
+
+        _modprobe ntb_pingpong
+
+        pingpong_test $LOCAL_PP $REMOTE_PP
+
+        _modprobe -r ntb_pingpong
+}
+
+function ntb_perf_tests()
+{
+        LOCAL_PERF=$DEBUGFS/ntb_perf/$LOCAL_DEV
+        REMOTE_PERF=$REMOTE_HOST:$DEBUGFS/ntb_perf/$REMOTE_DEV
+
+        echo "Starting ntb_perf tests..."
+
+        perf_test 0
+
+        if [[ $RUN_DMA_TESTS ]]; then
+                perf_test 1
+        fi
+}
+
+function cleanup()
+{
+        set +e
+        _modprobe -r ntb_tool 2> /dev/null
+        _modprobe -r ntb_perf 2> /dev/null
+        _modprobe -r ntb_pingpong 2> /dev/null
+        _modprobe -r ntb_transport 2> /dev/null
+        set -e
+}
+
+cleanup
+
+if ! [[ $$DONT_CLEANUP ]]; then
+        trap cleanup EXIT
+fi
+
+if [ "$(id -u)" != "0" ]; then
+        echo "This script must be run as root" 1>&2
+        exit 1
+fi
+
+if [[ "$LIST_DEVS" == TRUE ]]; then
+        echo "Local Devices:"
+        ls -1 /sys/bus/ntb/devices
+        echo
+
+        if [[ "$REMOTE_HOST" != "" ]]; then
+                echo "Remote Devices:"
+                ssh $REMOTE_HOST ls -1 /sys/bus/ntb/devices
+        fi
+
+        exit 0
+fi
+
+if [[ "$LOCAL_DEV" == $"" ]] || [[ "$REMOTE_DEV" == $"" ]]; then
+        show_help
+        exit 1
+fi
+
+ntb_tool_tests
+echo
+ntb_pingpong_tests
+echo
+ntb_perf_tests
+echo
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index 4ca83fe80654..db54a33f850f 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -8,16 +8,18 @@ ifeq ($(ARCH),powerpc)
 
 GIT_VERSION = $(shell git describe --always --long --dirty || echo "unknown")
 
-CFLAGS := -Wall -O2 -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR) $(CFLAGS)
+CFLAGS := -std=gnu99 -Wall -O2 -Wall -Werror -DGIT_VERSION='"$(GIT_VERSION)"' -I$(CURDIR) $(CFLAGS)
 
 export CFLAGS
 
-SUB_DIRS = benchmarks           \
+SUB_DIRS = alignment            \
+           benchmarks           \
            copyloops            \
            context_switch       \
            dscr                 \
            mm                   \
            pmu                  \
+           signal               \
            primitives           \
            stringloops          \
            switch_endian        \
diff --git a/tools/testing/selftests/powerpc/alignment/.gitignore b/tools/testing/selftests/powerpc/alignment/.gitignore
new file mode 100644
index 000000000000..1d980e3d7039
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/.gitignore
@@ -0,0 +1,5 @@
+copy_unaligned
+copy_first_unaligned
+paste_unaligned
+paste_last_unaligned
+copy_paste_unaligned_common
diff --git a/tools/testing/selftests/powerpc/alignment/Makefile b/tools/testing/selftests/powerpc/alignment/Makefile
new file mode 100644
index 000000000000..ad6a4e49da91
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/Makefile
@@ -0,0 +1,10 @@
+TEST_PROGS := copy_unaligned copy_first_unaligned paste_unaligned paste_last_unaligned
+
+all: $(TEST_PROGS)
+
+$(TEST_PROGS): ../harness.c ../utils.c copy_paste_unaligned_common.c
+
+include ../../lib.mk
+
+clean:
+        rm -f $(TEST_PROGS)
diff --git a/tools/testing/selftests/powerpc/alignment/copy_first_unaligned.c b/tools/testing/selftests/powerpc/alignment/copy_first_unaligned.c
new file mode 100644
index 000000000000..47b73b3a08bd
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/copy_first_unaligned.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Calls to copy_first which are not 128-byte aligned should be
+ * caught and sent a SIGBUS.
+ *
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include "utils.h"
+#include "instructions.h"
+#include "copy_paste_unaligned_common.h"
+
+unsigned int expected_instruction = PPC_INST_COPY_FIRST;
+unsigned int instruction_mask = 0xfc2007fe;
+
+int test_copy_first_unaligned(void)
+{
+        /* Only run this test on a P9 or later */
+        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
+
+        /* Register our signal handler with SIGBUS */
+        setup_signal_handler();
+
+        /* +1 makes buf unaligned */
+        copy_first(cacheline_buf+1);
+
+        /* We should not get here */
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(test_copy_first_unaligned, "test_copy_first_unaligned");
+}
diff --git a/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.c b/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.c
new file mode 100644
index 000000000000..d35fa5f5d2d3
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.c
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Common code for copy, copy_first, paste and paste_last unaligned
+ * tests.
+ *
+ */
+
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+#include "utils.h"
+#include "instructions.h"
+#include "copy_paste_unaligned_common.h"
+
+unsigned int expected_instruction;
+unsigned int instruction_mask;
+
+char cacheline_buf[128] __cacheline_aligned;
+
+void signal_action_handler(int signal_num, siginfo_t *info, void *ptr)
+{
+        ucontext_t *ctx = ptr;
+#if defined(__powerpc64__)
+        unsigned int *pc = (unsigned int *)ctx->uc_mcontext.gp_regs[PT_NIP];
+#else
+        unsigned int *pc = (unsigned int *)ctx->uc_mcontext.uc_regs->gregs[PT_NIP];
+#endif
+
+        /*
+         * Check that the signal was on the correct instruction, using a
+         * mask because the compiler assigns the register at RB.
+         */
+        if ((*pc & instruction_mask) == expected_instruction)
+                _exit(0); /* We hit the right instruction */
+
+        _exit(1);
+}
+
+void setup_signal_handler(void)
+{
+        struct sigaction signal_action;
+
+        memset(&signal_action, 0, sizeof(signal_action));
+        signal_action.sa_sigaction = signal_action_handler;
+        signal_action.sa_flags = SA_SIGINFO;
+        sigaction(SIGBUS, &signal_action, NULL);
+}
diff --git a/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.h b/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.h
new file mode 100644
index 000000000000..053899fe506e
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/copy_paste_unaligned_common.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Declarations for common code for copy, copy_first, paste and
+ * paste_last unaligned tests.
+ *
+ */
+
+#ifndef _SELFTESTS_POWERPC_COPY_PASTE_H
+#define _SELFTESTS_POWERPC_COPY_PASTE_H
+
+#include <signal.h>
+
+int main(int argc, char *argv[]);
+void signal_action_handler(int signal_num, siginfo_t *info, void *ptr);
+void setup_signal_handler(void);
+extern char cacheline_buf[128] __cacheline_aligned;
+extern unsigned int expected_instruction;
+extern unsigned int instruction_mask;
+
+#endif /* _SELFTESTS_POWERPC_COPY_PASTE_H */
diff --git a/tools/testing/selftests/powerpc/alignment/copy_unaligned.c b/tools/testing/selftests/powerpc/alignment/copy_unaligned.c
new file mode 100644
index 000000000000..3a4e26461554
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/copy_unaligned.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Calls to copy which are not 128-byte aligned should be caught
+ * and sent a SIGBUS.
+ *
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include "utils.h"
+#include "instructions.h"
+#include "copy_paste_unaligned_common.h"
+
+unsigned int expected_instruction = PPC_INST_COPY;
+unsigned int instruction_mask = 0xfc0007fe;
+
+int test_copy_unaligned(void)
+{
+        /* Only run this test on a P9 or later */
+        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
+
+        /* Register our signal handler with SIGBUS */
+        setup_signal_handler();
+
+        /* +1 makes buf unaligned */
+        copy(cacheline_buf+1);
+
+        /* We should not get here */
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(test_copy_unaligned, "test_copy_unaligned");
+}
diff --git a/tools/testing/selftests/powerpc/alignment/paste_last_unaligned.c b/tools/testing/selftests/powerpc/alignment/paste_last_unaligned.c
new file mode 100644
index 000000000000..6e0ad045fcc3
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/paste_last_unaligned.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Calls to paste_last which are not 128-byte aligned should be
+ * caught and sent a SIGBUS.
+ *
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include "utils.h"
+#include "instructions.h"
+#include "copy_paste_unaligned_common.h"
+
+unsigned int expected_instruction = PPC_INST_PASTE_LAST;
+unsigned int instruction_mask = 0xfc2007ff;
+
+int test_paste_last_unaligned(void)
+{
+        /* Only run this test on a P9 or later */
+        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
+
+        /* Register our signal handler with SIGBUS */
+        setup_signal_handler();
+
+        copy(cacheline_buf);
+
+        /* +1 makes buf unaligned */
+        paste_last(cacheline_buf+1);
+
+        /* We should not get here */
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(test_paste_last_unaligned, "test_paste_last_unaligned");
+}
diff --git a/tools/testing/selftests/powerpc/alignment/paste_unaligned.c b/tools/testing/selftests/powerpc/alignment/paste_unaligned.c
new file mode 100644
index 000000000000..6f982b45e4bd
--- /dev/null
+++ b/tools/testing/selftests/powerpc/alignment/paste_unaligned.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Calls to paste which are not 128-byte aligned should be caught
+ * and sent a SIGBUS.
+ *
+ */
+
+#include <string.h>
+#include <unistd.h>
+#include "utils.h"
+#include "instructions.h"
+#include "copy_paste_unaligned_common.h"
+
+unsigned int expected_instruction = PPC_INST_PASTE;
+unsigned int instruction_mask = 0xfc0007fe;
+
+int test_paste_unaligned(void)
+{
+        /* Only run this test on a P9 or later */
+        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
+
+        /* Register our signal handler with SIGBUS */
+        setup_signal_handler();
+
+        copy(cacheline_buf);
+
+        /* +1 makes buf unaligned */
+        paste(cacheline_buf+1);
+
+        /* We should not get here */
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(test_paste_unaligned, "test_paste_unaligned");
+}
diff --git a/tools/testing/selftests/powerpc/benchmarks/.gitignore b/tools/testing/selftests/powerpc/benchmarks/.gitignore
index 6fa673316ac2..bce49ebd869e 100644
--- a/tools/testing/selftests/powerpc/benchmarks/.gitignore
+++ b/tools/testing/selftests/powerpc/benchmarks/.gitignore
@@ -1,2 +1,4 @@
 gettimeofday
 context_switch
+mmap_bench
+futex_bench
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/benchmarks/Makefile b/tools/testing/selftests/powerpc/benchmarks/Makefile
index 912445ff7ce7..a9adfb7de78f 100644
--- a/tools/testing/selftests/powerpc/benchmarks/Makefile
+++ b/tools/testing/selftests/powerpc/benchmarks/Makefile
@@ -1,4 +1,4 @@
-TEST_PROGS := gettimeofday context_switch
+TEST_PROGS := gettimeofday context_switch mmap_bench futex_bench
 
 CFLAGS += -O2
 
@@ -7,6 +7,7 @@ all: $(TEST_PROGS)
 $(TEST_PROGS): ../harness.c
 
 context_switch: ../utils.c
+context_switch: CFLAGS += -maltivec -mvsx -mabi=altivec
 context_switch: LDLIBS += -lpthread
 
 include ../../lib.mk
diff --git a/tools/testing/selftests/powerpc/benchmarks/context_switch.c b/tools/testing/selftests/powerpc/benchmarks/context_switch.c
index 7b785941adec..a36883ad48a4 100644
--- a/tools/testing/selftests/powerpc/benchmarks/context_switch.c
+++ b/tools/testing/selftests/powerpc/benchmarks/context_switch.c
@@ -25,7 +25,9 @@
 #include <sys/types.h>
 #include <sys/shm.h>
 #include <linux/futex.h>
-
+#ifdef __powerpc__
+#include <altivec.h>
+#endif
 #include "../utils.h"
 
 static unsigned int timeout = 30;
@@ -37,12 +39,15 @@ static int touch_fp = 1;
 double fp;
 
 static int touch_vector = 1;
-typedef int v4si __attribute__ ((vector_size (16)));
-v4si a, b, c;
+vector int a, b, c;
 
 #ifdef __powerpc__
 static int touch_altivec = 1;
 
+/*
+ * Note: LTO (Link Time Optimisation) doesn't play well with this function
+ * attribute. Be very careful enabling LTO for this test.
+ */
 static void __attribute__((__target__("no-vsx"))) altivec_touch_fn(void)
 {
         c = a + b;
@@ -369,11 +374,11 @@ static void usage(void)
         fprintf(stderr, "\t\t--process\tUse processes (default threads)\n");
         fprintf(stderr, "\t\t--timeout=X\tDuration in seconds to run (default 30)\n");
         fprintf(stderr, "\t\t--vdso\t\ttouch VDSO\n");
-        fprintf(stderr, "\t\t--fp\t\ttouch FP\n");
+        fprintf(stderr, "\t\t--no-fp\t\tDon't touch FP\n");
 #ifdef __powerpc__
-        fprintf(stderr, "\t\t--altivec\ttouch altivec\n");
+        fprintf(stderr, "\t\t--no-altivec\tDon't touch altivec\n");
 #endif
-        fprintf(stderr, "\t\t--vector\ttouch vector\n");
+        fprintf(stderr, "\t\t--no-vector\tDon't touch vector\n");
 }
 
 int main(int argc, char *argv[])
diff --git a/tools/testing/selftests/powerpc/benchmarks/futex_bench.c b/tools/testing/selftests/powerpc/benchmarks/futex_bench.c
new file mode 100644
index 000000000000..2fc711d9150d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/benchmarks/futex_bench.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2016, Anton Blanchard, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <sys/syscall.h>
+#include <time.h>
+#include <unistd.h>
+#include <linux/futex.h>
+
+#include "utils.h"
+
+#define ITERATIONS 100000000
+
+#define futex(A, B, C, D, E, F)  syscall(__NR_futex, A, B, C, D, E, F)
+
+int test_futex(void)
+{
+        struct timespec ts_start, ts_end;
+        unsigned long i = ITERATIONS;
+
+        clock_gettime(CLOCK_MONOTONIC, &ts_start);
+
+        while (i--) {
+                unsigned int addr = 0;
+                futex(&addr, FUTEX_WAKE, 1, NULL, NULL, 0);
+        }
+
+        clock_gettime(CLOCK_MONOTONIC, &ts_end);
+
+        printf("time = %.6f\n", ts_end.tv_sec - ts_start.tv_sec + (ts_end.tv_nsec - ts_start.tv_nsec) / 1e9);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_futex, "futex_bench");
+}
diff --git a/tools/testing/selftests/powerpc/benchmarks/mmap_bench.c b/tools/testing/selftests/powerpc/benchmarks/mmap_bench.c
new file mode 100644
index 000000000000..8d084a2d6e74
--- /dev/null
+++ b/tools/testing/selftests/powerpc/benchmarks/mmap_bench.c
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016, Anton Blanchard, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <time.h>
+
+#include "utils.h"
+
+#define ITERATIONS 5000000
+
+#define MEMSIZE (128 * 1024 * 1024)
+
+int test_mmap(void)
+{
+        struct timespec ts_start, ts_end;
+        unsigned long i = ITERATIONS;
+
+        clock_gettime(CLOCK_MONOTONIC, &ts_start);
+
+        while (i--) {
+                char *c = mmap(NULL, MEMSIZE, PROT_READ|PROT_WRITE,
+                               MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+                FAIL_IF(c == MAP_FAILED);
+                munmap(c, MEMSIZE);
+        }
+
+        clock_gettime(CLOCK_MONOTONIC, &ts_end);
+
+        printf("time = %.6f\n", ts_end.tv_sec - ts_start.tv_sec + (ts_end.tv_nsec - ts_start.tv_nsec) / 1e9);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_mmap, "mmap_bench");
+}
diff --git a/tools/testing/selftests/powerpc/copyloops/asm/export.h b/tools/testing/selftests/powerpc/copyloops/asm/export.h
new file mode 100644
index 000000000000..2d14a9b4248c
--- /dev/null
+++ b/tools/testing/selftests/powerpc/copyloops/asm/export.h
@@ -0,0 +1 @@
+#define EXPORT_SYMBOL(x)
diff --git a/tools/testing/selftests/powerpc/fpu_asm.h b/tools/testing/selftests/powerpc/fpu_asm.h
new file mode 100644
index 000000000000..6a387d255e27
--- /dev/null
+++ b/tools/testing/selftests/powerpc/fpu_asm.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _SELFTESTS_POWERPC_FPU_ASM_H
+#define _SELFTESTS_POWERPC_FPU_ASM_H
+#include "basic_asm.h"
+
+#define PUSH_FPU(stack_size) \
+        stfd    f31,(stack_size + STACK_FRAME_MIN_SIZE)(%r1); \
+        stfd    f30,(stack_size + STACK_FRAME_MIN_SIZE - 8)(%r1); \
+        stfd    f29,(stack_size + STACK_FRAME_MIN_SIZE - 16)(%r1); \
+        stfd    f28,(stack_size + STACK_FRAME_MIN_SIZE - 24)(%r1); \
+        stfd    f27,(stack_size + STACK_FRAME_MIN_SIZE - 32)(%r1); \
+        stfd    f26,(stack_size + STACK_FRAME_MIN_SIZE - 40)(%r1); \
+        stfd    f25,(stack_size + STACK_FRAME_MIN_SIZE - 48)(%r1); \
+        stfd    f24,(stack_size + STACK_FRAME_MIN_SIZE - 56)(%r1); \
+        stfd    f23,(stack_size + STACK_FRAME_MIN_SIZE - 64)(%r1); \
+        stfd    f22,(stack_size + STACK_FRAME_MIN_SIZE - 72)(%r1); \
+        stfd    f21,(stack_size + STACK_FRAME_MIN_SIZE - 80)(%r1); \
+        stfd    f20,(stack_size + STACK_FRAME_MIN_SIZE - 88)(%r1); \
+        stfd    f19,(stack_size + STACK_FRAME_MIN_SIZE - 96)(%r1); \
+        stfd    f18,(stack_size + STACK_FRAME_MIN_SIZE - 104)(%r1); \
+        stfd    f17,(stack_size + STACK_FRAME_MIN_SIZE - 112)(%r1); \
+        stfd    f16,(stack_size + STACK_FRAME_MIN_SIZE - 120)(%r1); \
+        stfd    f15,(stack_size + STACK_FRAME_MIN_SIZE - 128)(%r1); \
+        stfd    f14,(stack_size + STACK_FRAME_MIN_SIZE - 136)(%r1);
+
+#define POP_FPU(stack_size) \
+        lfd     f31,(stack_size + STACK_FRAME_MIN_SIZE)(%r1); \
+        lfd     f30,(stack_size + STACK_FRAME_MIN_SIZE - 8)(%r1); \
+        lfd     f29,(stack_size + STACK_FRAME_MIN_SIZE - 16)(%r1); \
+        lfd     f28,(stack_size + STACK_FRAME_MIN_SIZE - 24)(%r1); \
+        lfd     f27,(stack_size + STACK_FRAME_MIN_SIZE - 32)(%r1); \
+        lfd     f26,(stack_size + STACK_FRAME_MIN_SIZE - 40)(%r1); \
+        lfd     f25,(stack_size + STACK_FRAME_MIN_SIZE - 48)(%r1); \
+        lfd     f24,(stack_size + STACK_FRAME_MIN_SIZE - 56)(%r1); \
+        lfd     f23,(stack_size + STACK_FRAME_MIN_SIZE - 64)(%r1); \
+        lfd     f22,(stack_size + STACK_FRAME_MIN_SIZE - 72)(%r1); \
+        lfd     f21,(stack_size + STACK_FRAME_MIN_SIZE - 80)(%r1); \
+        lfd     f20,(stack_size + STACK_FRAME_MIN_SIZE - 88)(%r1); \
+        lfd     f19,(stack_size + STACK_FRAME_MIN_SIZE - 96)(%r1); \
+        lfd     f18,(stack_size + STACK_FRAME_MIN_SIZE - 104)(%r1); \
+        lfd     f17,(stack_size + STACK_FRAME_MIN_SIZE - 112)(%r1); \
+        lfd     f16,(stack_size + STACK_FRAME_MIN_SIZE - 120)(%r1); \
+        lfd     f15,(stack_size + STACK_FRAME_MIN_SIZE - 128)(%r1); \
+        lfd     f14,(stack_size + STACK_FRAME_MIN_SIZE - 136)(%r1);
+
+/*
+ * Careful calling this, it will 'clobber' fpu (by design)
+ * Don't call this from C
+ */
+FUNC_START(load_fpu)
+        lfd     f14,0(r3)
+        lfd     f15,8(r3)
+        lfd     f16,16(r3)
+        lfd     f17,24(r3)
+        lfd     f18,32(r3)
+        lfd     f19,40(r3)
+        lfd     f20,48(r3)
+        lfd     f21,56(r3)
+        lfd     f22,64(r3)
+        lfd     f23,72(r3)
+        lfd     f24,80(r3)
+        lfd     f25,88(r3)
+        lfd     f26,96(r3)
+        lfd     f27,104(r3)
+        lfd     f28,112(r3)
+        lfd     f29,120(r3)
+        lfd     f30,128(r3)
+        lfd     f31,136(r3)
+        blr
+FUNC_END(load_fpu)
+
+#endif /* _SELFTESTS_POWERPC_FPU_ASM_H */
diff --git a/tools/testing/selftests/powerpc/gpr_asm.h b/tools/testing/selftests/powerpc/gpr_asm.h
new file mode 100644
index 000000000000..f6f38852d3a0
--- /dev/null
+++ b/tools/testing/selftests/powerpc/gpr_asm.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#ifndef _SELFTESTS_POWERPC_GPR_ASM_H
+#define _SELFTESTS_POWERPC_GPR_ASM_H
+
+#include "basic_asm.h"
+
+#define __PUSH_NVREGS(top_pos); \
+        std r31,(top_pos)(%r1); \
+        std r30,(top_pos - 8)(%r1); \
+        std r29,(top_pos - 16)(%r1); \
+        std r28,(top_pos - 24)(%r1); \
+        std r27,(top_pos - 32)(%r1); \
+        std r26,(top_pos - 40)(%r1); \
+        std r25,(top_pos - 48)(%r1); \
+        std r24,(top_pos - 56)(%r1); \
+        std r23,(top_pos - 64)(%r1); \
+        std r22,(top_pos - 72)(%r1); \
+        std r21,(top_pos - 80)(%r1); \
+        std r20,(top_pos - 88)(%r1); \
+        std r19,(top_pos - 96)(%r1); \
+        std r18,(top_pos - 104)(%r1); \
+        std r17,(top_pos - 112)(%r1); \
+        std r16,(top_pos - 120)(%r1); \
+        std r15,(top_pos - 128)(%r1); \
+        std r14,(top_pos - 136)(%r1)
+
+#define __POP_NVREGS(top_pos); \
+        ld r31,(top_pos)(%r1); \
+        ld r30,(top_pos - 8)(%r1); \
+        ld r29,(top_pos - 16)(%r1); \
+        ld r28,(top_pos - 24)(%r1); \
+        ld r27,(top_pos - 32)(%r1); \
+        ld r26,(top_pos - 40)(%r1); \
+        ld r25,(top_pos - 48)(%r1); \
+        ld r24,(top_pos - 56)(%r1); \
+        ld r23,(top_pos - 64)(%r1); \
+        ld r22,(top_pos - 72)(%r1); \
+        ld r21,(top_pos - 80)(%r1); \
+        ld r20,(top_pos - 88)(%r1); \
+        ld r19,(top_pos - 96)(%r1); \
+        ld r18,(top_pos - 104)(%r1); \
+        ld r17,(top_pos - 112)(%r1); \
+        ld r16,(top_pos - 120)(%r1); \
+        ld r15,(top_pos - 128)(%r1); \
+        ld r14,(top_pos - 136)(%r1)
+
+#define PUSH_NVREGS(stack_size) \
+        __PUSH_NVREGS(stack_size + STACK_FRAME_MIN_SIZE)
+
+/* 18 NV FPU REGS */
+#define PUSH_NVREGS_BELOW_FPU(stack_size) \
+        __PUSH_NVREGS(stack_size + STACK_FRAME_MIN_SIZE - (18 * 8))
+
+#define POP_NVREGS(stack_size) \
+        __POP_NVREGS(stack_size + STACK_FRAME_MIN_SIZE)
+
+/* 18 NV FPU REGS */
+#define POP_NVREGS_BELOW_FPU(stack_size) \
+        __POP_NVREGS(stack_size + STACK_FRAME_MIN_SIZE - (18 * 8))
+
+/*
+ * Careful calling this, it will 'clobber' NVGPRs (by design)
+ * Don't call this from C
+ */
+FUNC_START(load_gpr)
+        ld      r14,0(r3)
+        ld      r15,8(r3)
+        ld      r16,16(r3)
+        ld      r17,24(r3)
+        ld      r18,32(r3)
+        ld      r19,40(r3)
+        ld      r20,48(r3)
+        ld      r21,56(r3)
+        ld      r22,64(r3)
+        ld      r23,72(r3)
+        ld      r24,80(r3)
+        ld      r25,88(r3)
+        ld      r26,96(r3)
+        ld      r27,104(r3)
+        ld      r28,112(r3)
+        ld      r29,120(r3)
+        ld      r30,128(r3)
+        ld      r31,136(r3)
+        blr
+FUNC_END(load_gpr)
+
+
+#endif /* _SELFTESTS_POWERPC_GPR_ASM_H */
diff --git a/tools/testing/selftests/powerpc/harness.c b/tools/testing/selftests/powerpc/harness.c
index 52f9be7f61f0..248a820048df 100644
--- a/tools/testing/selftests/powerpc/harness.c
+++ b/tools/testing/selftests/powerpc/harness.c
@@ -19,9 +19,9 @@
 #include "subunit.h"
 #include "utils.h"
 
-#define TIMEOUT         120
 #define KILL_TIMEOUT    5
 
+static uint64_t timeout = 120;
 
 int run_test(int (test_function)(void), char *name)
 {
@@ -44,7 +44,7 @@ int run_test(int (test_function)(void), char *name)
         setpgid(pid, pid);
 
         /* Wake us up in timeout seconds */
-        alarm(TIMEOUT);
+        alarm(timeout);
         terminated = false;
 
 wait:
@@ -94,6 +94,11 @@ static struct sigaction alarm_action = {
         .sa_handler = alarm_handler,
 };
 
+void test_harness_set_timeout(uint64_t time)
+{
+        timeout = time;
+}
+
 int test_harness(int (test_function)(void), char *name)
 {
         int rc;
diff --git a/tools/testing/selftests/powerpc/instructions.h b/tools/testing/selftests/powerpc/instructions.h
new file mode 100644
index 000000000000..0fb0bd3b28c9
--- /dev/null
+++ b/tools/testing/selftests/powerpc/instructions.h
@@ -0,0 +1,68 @@
+#ifndef _SELFTESTS_POWERPC_INSTRUCTIONS_H
+#define _SELFTESTS_POWERPC_INSTRUCTIONS_H
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/* This defines the "copy" instruction from Power ISA 3.0 Book II, section 4.4. */
+#define __COPY(RA, RB, L) \
+        (0x7c00060c | (RA) << (31-15) | (RB) << (31-20) | (L) << (31-10))
+#define COPY(RA, RB, L) \
+        .long __COPY((RA), (RB), (L))
+
+static inline void copy(void *i)
+{
+        asm volatile(str(COPY(0, %0, 0))";"
+                        :
+                        : "b" (i)
+                        : "memory"
+                    );
+}
+
+static inline void copy_first(void *i)
+{
+        asm volatile(str(COPY(0, %0, 1))";"
+                        :
+                        : "b" (i)
+                        : "memory"
+                    );
+}
+
+/* This defines the "paste" instruction from Power ISA 3.0 Book II, section 4.4. */
+#define __PASTE(RA, RB, L, RC) \
+        (0x7c00070c | (RA) << (31-15) | (RB) << (31-20) | (L) << (31-10) | (RC) << (31-31))
+#define PASTE(RA, RB, L, RC) \
+        .long __PASTE((RA), (RB), (L), (RC))
+
+static inline int paste(void *i)
+{
+        int cr;
+
+        asm volatile(str(PASTE(0, %1, 0, 0))";"
+                        "mfcr %0;"
+                        : "=r" (cr)
+                        : "b" (i)
+                        : "memory"
+                    );
+        return cr;
+}
+
+static inline int paste_last(void *i)
+{
+        int cr;
+
+        asm volatile(str(PASTE(0, %1, 1, 1))";"
+                        "mfcr %0;"
+                        : "=r" (cr)
+                        : "b" (i)
+                        : "memory"
+                    );
+        return cr;
+}
+
+#define PPC_INST_COPY                  __COPY(0, 0, 0)
+#define PPC_INST_COPY_FIRST            __COPY(0, 0, 1)
+#define PPC_INST_PASTE                 __PASTE(0, 0, 0, 0)
+#define PPC_INST_PASTE_LAST            __PASTE(0, 0, 1, 1)
+
+#endif /* _SELFTESTS_POWERPC_INSTRUCTIONS_H */
diff --git a/tools/testing/selftests/powerpc/math/.gitignore b/tools/testing/selftests/powerpc/math/.gitignore
index 4fe13a439fd7..50ded63e25b7 100644
--- a/tools/testing/selftests/powerpc/math/.gitignore
+++ b/tools/testing/selftests/powerpc/math/.gitignore
@@ -4,3 +4,4 @@ fpu_preempt
 vmx_preempt
 fpu_signal
 vmx_signal
+vsx_preempt
diff --git a/tools/testing/selftests/powerpc/math/Makefile b/tools/testing/selftests/powerpc/math/Makefile
index 5b88875d5955..a505b66d408a 100644
--- a/tools/testing/selftests/powerpc/math/Makefile
+++ b/tools/testing/selftests/powerpc/math/Makefile
@@ -1,4 +1,4 @@
-TEST_PROGS := fpu_syscall fpu_preempt fpu_signal vmx_syscall vmx_preempt vmx_signal
+TEST_PROGS := fpu_syscall fpu_preempt fpu_signal vmx_syscall vmx_preempt vmx_signal vsx_preempt
 
 all: $(TEST_PROGS)
 
@@ -13,6 +13,9 @@ vmx_syscall: vmx_asm.S
 vmx_preempt: vmx_asm.S
 vmx_signal: vmx_asm.S
 
+vsx_preempt: CFLAGS += -mvsx
+vsx_preempt: vsx_asm.S
+
 include ../../lib.mk
 
 clean:
diff --git a/tools/testing/selftests/powerpc/math/fpu_asm.S b/tools/testing/selftests/powerpc/math/fpu_asm.S
index f3711d80e709..241f067a510f 100644
--- a/tools/testing/selftests/powerpc/math/fpu_asm.S
+++ b/tools/testing/selftests/powerpc/math/fpu_asm.S
@@ -8,70 +8,7 @@
  */
 
 #include "../basic_asm.h"
-
-#define PUSH_FPU(pos) \
-        stfd    f14,pos(sp); \
-        stfd    f15,pos+8(sp); \
-        stfd    f16,pos+16(sp); \
-        stfd    f17,pos+24(sp); \
-        stfd    f18,pos+32(sp); \
-        stfd    f19,pos+40(sp); \
-        stfd    f20,pos+48(sp); \
-        stfd    f21,pos+56(sp); \
-        stfd    f22,pos+64(sp); \
-        stfd    f23,pos+72(sp); \
-        stfd    f24,pos+80(sp); \
-        stfd    f25,pos+88(sp); \
-        stfd    f26,pos+96(sp); \
-        stfd    f27,pos+104(sp); \
-        stfd    f28,pos+112(sp); \
-        stfd    f29,pos+120(sp); \
-        stfd    f30,pos+128(sp); \
-        stfd    f31,pos+136(sp);
-
-#define POP_FPU(pos) \
-        lfd     f14,pos(sp); \
-        lfd     f15,pos+8(sp); \
-        lfd     f16,pos+16(sp); \
-        lfd     f17,pos+24(sp); \
-        lfd     f18,pos+32(sp); \
-        lfd     f19,pos+40(sp); \
-        lfd     f20,pos+48(sp); \
-        lfd     f21,pos+56(sp); \
-        lfd     f22,pos+64(sp); \
-        lfd     f23,pos+72(sp); \
-        lfd     f24,pos+80(sp); \
-        lfd     f25,pos+88(sp); \
-        lfd     f26,pos+96(sp); \
-        lfd     f27,pos+104(sp); \
-        lfd     f28,pos+112(sp); \
-        lfd     f29,pos+120(sp); \
-        lfd     f30,pos+128(sp); \
-        lfd     f31,pos+136(sp);
-
-# Careful calling this, it will 'clobber' fpu (by design)
-# Don't call this from C
-FUNC_START(load_fpu)
-        lfd     f14,0(r3)
-        lfd     f15,8(r3)
-        lfd     f16,16(r3)
-        lfd     f17,24(r3)
-        lfd     f18,32(r3)
-        lfd     f19,40(r3)
-        lfd     f20,48(r3)
-        lfd     f21,56(r3)
-        lfd     f22,64(r3)
-        lfd     f23,72(r3)
-        lfd     f24,80(r3)
-        lfd     f25,88(r3)
-        lfd     f26,96(r3)
-        lfd     f27,104(r3)
-        lfd     f28,112(r3)
-        lfd     f29,120(r3)
-        lfd     f30,128(r3)
-        lfd     f31,136(r3)
-        blr
-FUNC_END(load_fpu)
+#include "../fpu_asm.h"
 
 FUNC_START(check_fpu)
         mr r4,r3
@@ -138,9 +75,9 @@ FUNC_START(test_fpu)
         # r4 holds pointer to the pid
         # f14-f31 are non volatiles
         PUSH_BASIC_STACK(256)
+        PUSH_FPU(256)
         std     r3,STACK_FRAME_PARAM(0)(sp) # Address of darray
         std r4,STACK_FRAME_PARAM(1)(sp) # Address of pid
-        PUSH_FPU(STACK_FRAME_LOCAL(2,0))
 
         bl load_fpu
         nop
@@ -155,7 +92,7 @@ FUNC_START(test_fpu)
         bl check_fpu
         nop
 
-        POP_FPU(STACK_FRAME_LOCAL(2,0))
+        POP_FPU(256)
         POP_BASIC_STACK(256)
         blr
 FUNC_END(test_fpu)
@@ -166,10 +103,10 @@ FUNC_END(test_fpu)
 # registers while running is not zero.
 FUNC_START(preempt_fpu)
         PUSH_BASIC_STACK(256)
+        PUSH_FPU(256)
         std r3,STACK_FRAME_PARAM(0)(sp) # double *darray
         std r4,STACK_FRAME_PARAM(1)(sp) # int *threads_starting
         std r5,STACK_FRAME_PARAM(2)(sp) # int *running
-        PUSH_FPU(STACK_FRAME_LOCAL(3,0))
 
         bl load_fpu
         nop
@@ -192,7 +129,7 @@ FUNC_START(preempt_fpu)
         cmpwi r5,0
         bne 2b
 
-3:      POP_FPU(STACK_FRAME_LOCAL(3,0))
+3:      POP_FPU(256)
         POP_BASIC_STACK(256)
         blr
 FUNC_END(preempt_fpu)
diff --git a/tools/testing/selftests/powerpc/math/vmx_asm.S b/tools/testing/selftests/powerpc/math/vmx_asm.S
index 1b8c248b3ac1..fd74da488625 100644
--- a/tools/testing/selftests/powerpc/math/vmx_asm.S
+++ b/tools/testing/selftests/powerpc/math/vmx_asm.S
@@ -8,90 +8,7 @@
  */
 
 #include "../basic_asm.h"
-
-# POS MUST BE 16 ALIGNED!
-#define PUSH_VMX(pos,reg) \
-        li      reg,pos; \
-        stvx    v20,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v21,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v22,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v23,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v24,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v25,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v26,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v27,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v28,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v29,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v30,reg,sp; \
-        addi    reg,reg,16; \
-        stvx    v31,reg,sp;
-
-# POS MUST BE 16 ALIGNED!
-#define POP_VMX(pos,reg) \
-        li      reg,pos; \
-        lvx     v20,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v21,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v22,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v23,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v24,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v25,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v26,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v27,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v28,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v29,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v30,reg,sp; \
-        addi    reg,reg,16; \
-        lvx     v31,reg,sp;
-
-# Carefull this will 'clobber' vmx (by design)
-# Don't call this from C
-FUNC_START(load_vmx)
-        li      r5,0
-        lvx     v20,r5,r3
-        addi    r5,r5,16
-        lvx     v21,r5,r3
-        addi    r5,r5,16
-        lvx     v22,r5,r3
-        addi    r5,r5,16
-        lvx     v23,r5,r3
-        addi    r5,r5,16
-        lvx     v24,r5,r3
-        addi    r5,r5,16
-        lvx     v25,r5,r3
-        addi    r5,r5,16
-        lvx     v26,r5,r3
-        addi    r5,r5,16
-        lvx     v27,r5,r3
-        addi    r5,r5,16
-        lvx     v28,r5,r3
-        addi    r5,r5,16
-        lvx     v29,r5,r3
-        addi    r5,r5,16
-        lvx     v30,r5,r3
-        addi    r5,r5,16
-        lvx     v31,r5,r3
-        blr
-FUNC_END(load_vmx)
+#include "../vmx_asm.h"
 
 # Should be safe from C, only touches r4, r5 and v0,v1,v2
 FUNC_START(check_vmx)
diff --git a/tools/testing/selftests/powerpc/math/vsx_asm.S b/tools/testing/selftests/powerpc/math/vsx_asm.S
new file mode 100644
index 000000000000..a110dd882d5e
--- /dev/null
+++ b/tools/testing/selftests/powerpc/math/vsx_asm.S
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include "../basic_asm.h"
+#include "../vsx_asm.h"
+
+#long check_vsx(vector int *r3);
+#This function wraps storeing VSX regs to the end of an array and a
+#call to a comparison function in C which boils down to a memcmp()
+FUNC_START(check_vsx)
+        PUSH_BASIC_STACK(32)
+        std     r3,STACK_FRAME_PARAM(0)(sp)
+        addi r3, r3, 16 * 12 #Second half of array
+        bl store_vsx
+        ld r3,STACK_FRAME_PARAM(0)(sp)
+        bl vsx_memcmp
+        POP_BASIC_STACK(32)
+        blr
+FUNC_END(check_vsx)
+
+# int preempt_vmx(vector int *varray, int *threads_starting,
+#                 int *running);
+# On starting will (atomically) decrement threads_starting as a signal
+# that the VMX have been loaded with varray. Will proceed to check the
+# validity of the VMX registers while running is not zero.
+FUNC_START(preempt_vsx)
+        PUSH_BASIC_STACK(512)
+        std r3,STACK_FRAME_PARAM(0)(sp) # vector int *varray
+        std r4,STACK_FRAME_PARAM(1)(sp) # int *threads_starting
+        std r5,STACK_FRAME_PARAM(2)(sp) # int *running
+
+        bl load_vsx
+        nop
+
+        sync
+        # Atomic DEC
+        ld r3,STACK_FRAME_PARAM(1)(sp)
+1:      lwarx r4,0,r3
+        addi r4,r4,-1
+        stwcx. r4,0,r3
+        bne- 1b
+
+2:      ld r3,STACK_FRAME_PARAM(0)(sp)
+        bl check_vsx
+        nop
+        cmpdi r3,0
+        bne 3f
+        ld r4,STACK_FRAME_PARAM(2)(sp)
+        ld r5,0(r4)
+        cmpwi r5,0
+        bne 2b
+
+3:      POP_BASIC_STACK(512)
+        blr
+FUNC_END(preempt_vsx)
diff --git a/tools/testing/selftests/powerpc/math/vsx_preempt.c b/tools/testing/selftests/powerpc/math/vsx_preempt.c
new file mode 100644
index 000000000000..6387f03a0a6a
--- /dev/null
+++ b/tools/testing/selftests/powerpc/math/vsx_preempt.c
@@ -0,0 +1,147 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * This test attempts to see if the VSX registers change across preemption.
+ * There is no way to be sure preemption happened so this test just
+ * uses many threads and a long wait. As such, a successful test
+ * doesn't mean much but a failure is bad.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+#include "utils.h"
+
+/* Time to wait for workers to get preempted (seconds) */
+#define PREEMPT_TIME 20
+/*
+ * Factor by which to multiply number of online CPUs for total number of
+ * worker threads
+ */
+#define THREAD_FACTOR 8
+
+/*
+ * Ensure there is twice the number of non-volatile VMX regs!
+ * check_vmx() is going to use the other half as space to put the live
+ * registers before calling vsx_memcmp()
+ */
+__thread vector int varray[24] = {
+        {1, 2, 3, 4 }, {5, 6, 7, 8 }, {9, 10,11,12},
+        {13,14,15,16}, {17,18,19,20}, {21,22,23,24},
+        {25,26,27,28}, {29,30,31,32}, {33,34,35,36},
+        {37,38,39,40}, {41,42,43,44}, {45,46,47,48}
+};
+
+int threads_starting;
+int running;
+
+extern long preempt_vsx(vector int *varray, int *threads_starting, int *running);
+
+long vsx_memcmp(vector int *a) {
+        vector int zero = {0, 0, 0, 0};
+        int i;
+
+        FAIL_IF(a != varray);
+
+        for(i = 0; i < 12; i++) {
+                if (memcmp(&a[i + 12], &zero, sizeof(vector int)) == 0) {
+                        fprintf(stderr, "Detected zero from the VSX reg %d\n", i + 12);
+                        return 2;
+                }
+        }
+
+        if (memcmp(a, &a[12], 12 * sizeof(vector int))) {
+                long *p = (long *)a;
+                fprintf(stderr, "VSX mismatch\n");
+                for (i = 0; i < 24; i=i+2)
+                        fprintf(stderr, "%d: 0x%08lx%08lx | 0x%08lx%08lx\n",
+                                        i/2 + i%2 + 20, p[i], p[i + 1], p[i + 24], p[i + 25]);
+                return 1;
+        }
+        return 0;
+}
+
+void *preempt_vsx_c(void *p)
+{
+        int i, j;
+        long rc;
+        srand(pthread_self());
+        for (i = 0; i < 12; i++)
+                for (j = 0; j < 4; j++) {
+                        varray[i][j] = rand();
+                        /* Don't want zero because it hides kernel problems */
+                        if (varray[i][j] == 0)
+                                j--;
+                }
+        rc = preempt_vsx(varray, &threads_starting, &running);
+        if (rc == 2)
+                fprintf(stderr, "Caught zeros in VSX compares\n");
+        return (void *)rc;
+}
+
+int test_preempt_vsx(void)
+{
+        int i, rc, threads;
+        pthread_t *tids;
+
+        threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;
+        tids = malloc(threads * sizeof(pthread_t));
+        FAIL_IF(!tids);
+
+        running = true;
+        threads_starting = threads;
+        for (i = 0; i < threads; i++) {
+                rc = pthread_create(&tids[i], NULL, preempt_vsx_c, NULL);
+                FAIL_IF(rc);
+        }
+
+        setbuf(stdout, NULL);
+        /* Not really nessesary but nice to wait for every thread to start */
+        printf("\tWaiting for %d workers to start...", threads_starting);
+        while(threads_starting)
+                asm volatile("": : :"memory");
+        printf("done\n");
+
+        printf("\tWaiting for %d seconds to let some workers get preempted...", PREEMPT_TIME);
+        sleep(PREEMPT_TIME);
+        printf("done\n");
+
+        printf("\tStopping workers...");
+        /*
+         * Working are checking this value every loop. In preempt_vsx 'cmpwi r5,0; bne 2b'.
+         * r5 will have loaded the value of running.
+         */
+        running = 0;
+        for (i = 0; i < threads; i++) {
+                void *rc_p;
+                pthread_join(tids[i], &rc_p);
+
+                /*
+                 * Harness will say the fail was here, look at why preempt_vsx
+                 * returned
+                 */
+                if ((long) rc_p)
+                        printf("oops\n");
+                FAIL_IF((long) rc_p);
+        }
+        printf("done\n");
+
+        return 0;
+}
+
+int main(int argc, char *argv[])
+{
+        return test_harness(test_preempt_vsx, "vsx_preempt");
+}
diff --git a/tools/testing/selftests/powerpc/mm/.gitignore b/tools/testing/selftests/powerpc/mm/.gitignore
index b43ade0ec861..e715a3f2fbf4 100644
--- a/tools/testing/selftests/powerpc/mm/.gitignore
+++ b/tools/testing/selftests/powerpc/mm/.gitignore
@@ -1,3 +1,4 @@
 hugetlb_vs_thp_test
 subpage_prot
 tempfile
+prot_sao
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/mm/Makefile b/tools/testing/selftests/powerpc/mm/Makefile
index ee179e22308c..3bdb96eae558 100644
--- a/tools/testing/selftests/powerpc/mm/Makefile
+++ b/tools/testing/selftests/powerpc/mm/Makefile
@@ -1,13 +1,15 @@
 noarg:
         $(MAKE) -C ../
 
-TEST_PROGS := hugetlb_vs_thp_test subpage_prot
+TEST_PROGS := hugetlb_vs_thp_test subpage_prot prot_sao
 TEST_FILES := tempfile
 
 all: $(TEST_PROGS) $(TEST_FILES)
 
 $(TEST_PROGS): ../harness.c
 
+prot_sao: ../utils.c
+
 include ../../lib.mk
 
 tempfile:
diff --git a/tools/testing/selftests/powerpc/mm/prot_sao.c b/tools/testing/selftests/powerpc/mm/prot_sao.c
new file mode 100644
index 000000000000..611530d43fa9
--- /dev/null
+++ b/tools/testing/selftests/powerpc/mm/prot_sao.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2016, Michael Ellerman, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+
+#include <asm/cputable.h>
+
+#include "utils.h"
+
+#define SIZE (64 * 1024)
+
+int test_prot_sao(void)
+{
+        char *p;
+
+        /* 2.06 or later should support SAO */
+        SKIP_IF(!have_hwcap(PPC_FEATURE_ARCH_2_06));
+
+        /*
+         * Ensure we can ask for PROT_SAO.
+         * We can't really verify that it does the right thing, but at least we
+         * confirm the kernel will accept it.
+         */
+        p = mmap(NULL, SIZE, PROT_READ | PROT_WRITE | PROT_SAO,
+                 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+        FAIL_IF(p == MAP_FAILED);
+
+        /* Write to the mapping, to at least cause a fault */
+        memset(p, 0xaa, SIZE);
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_prot_sao, "prot-sao");
+}
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/.gitignore b/tools/testing/selftests/powerpc/pmu/ebb/.gitignore
index 42bddbed8b64..44b7df14a936 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/.gitignore
+++ b/tools/testing/selftests/powerpc/pmu/ebb/.gitignore
@@ -20,3 +20,5 @@ back_to_back_ebbs_test
 lost_exception_test
 no_handler_test
 cycles_with_mmcr2_test
+ebb_lmr
+ebb_lmr_regs
\ No newline at end of file
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/Makefile b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
index 8d2279c4bb4b..6b0453e60d53 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/Makefile
+++ b/tools/testing/selftests/powerpc/pmu/ebb/Makefile
@@ -14,7 +14,7 @@ TEST_PROGS := reg_access_test event_attributes_test cycles_test	\
          fork_cleanup_test ebb_on_child_test                    \
          ebb_on_willing_child_test back_to_back_ebbs_test       \
          lost_exception_test no_handler_test                    \
-         cycles_with_mmcr2_test
+         cycles_with_mmcr2_test ebb_lmr ebb_lmr_regs
 
 all: $(TEST_PROGS)
 
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.c b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.c
new file mode 100644
index 000000000000..c47ebd55ba4d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2016, Jack Miller, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "ebb.h"
+#include "ebb_lmr.h"
+
+#define SIZE            (32 * 1024 * 1024)      /* 32M */
+#define LM_SIZE         0       /* Smallest encoding, 32M */
+
+#define SECTIONS        64      /* 1 per bit in LMSER */
+#define SECTION_SIZE    (SIZE / SECTIONS)
+#define SECTION_LONGS   (SECTION_SIZE / sizeof(long))
+
+static unsigned long *test_mem;
+
+static int lmr_count = 0;
+
+void ebb_lmr_handler(void)
+{
+        lmr_count++;
+}
+
+void ldmx_full_section(unsigned long *mem, int section)
+{
+        unsigned long *ptr;
+        int i;
+
+        for (i = 0; i < SECTION_LONGS; i++) {
+                ptr = &mem[(SECTION_LONGS * section) + i];
+                ldmx((unsigned long) &ptr);
+                ebb_lmr_reset();
+        }
+}
+
+unsigned long section_masks[] = {
+        0x8000000000000000,
+        0xFF00000000000000,
+        0x0000000F70000000,
+        0x8000000000000001,
+        0xF0F0F0F0F0F0F0F0,
+        0x0F0F0F0F0F0F0F0F,
+        0x0
+};
+
+int ebb_lmr_section_test(unsigned long *mem)
+{
+        unsigned long *mask = section_masks;
+        int i;
+
+        for (; *mask; mask++) {
+                mtspr(SPRN_LMSER, *mask);
+                printf("Testing mask 0x%016lx\n", mfspr(SPRN_LMSER));
+
+                for (i = 0; i < 64; i++) {
+                        lmr_count = 0;
+                        ldmx_full_section(mem, i);
+                        if (*mask & (1UL << (63 - i)))
+                                FAIL_IF(lmr_count != SECTION_LONGS);
+                        else
+                                FAIL_IF(lmr_count);
+                }
+        }
+
+        return 0;
+}
+
+int ebb_lmr(void)
+{
+        int i;
+
+        SKIP_IF(!lmr_is_supported());
+
+        setup_ebb_handler(ebb_lmr_handler);
+
+        ebb_global_enable();
+
+        FAIL_IF(posix_memalign((void **)&test_mem, SIZE, SIZE) != 0);
+
+        mtspr(SPRN_LMSER, 0);
+
+        FAIL_IF(mfspr(SPRN_LMSER) != 0);
+
+        mtspr(SPRN_LMRR, ((unsigned long)test_mem | LM_SIZE));
+
+        FAIL_IF(mfspr(SPRN_LMRR) != ((unsigned long)test_mem | LM_SIZE));
+
+        /* Read every single byte to ensure we get no false positives */
+        for (i = 0; i < SECTIONS; i++)
+                ldmx_full_section(test_mem, i);
+
+        FAIL_IF(lmr_count != 0);
+
+        /* Turn on the first section */
+
+        mtspr(SPRN_LMSER, (1UL << 63));
+        FAIL_IF(mfspr(SPRN_LMSER) != (1UL << 63));
+
+        /* Enable LM (BESCR) */
+
+        mtspr(SPRN_BESCR, mfspr(SPRN_BESCR) | BESCR_LME);
+        FAIL_IF(!(mfspr(SPRN_BESCR) & BESCR_LME));
+
+        ldmx((unsigned long)&test_mem);
+
+        FAIL_IF(lmr_count != 1);        // exactly one exception
+        FAIL_IF(mfspr(SPRN_BESCR) & BESCR_LME); // LM now disabled
+        FAIL_IF(!(mfspr(SPRN_BESCR) & BESCR_LMEO));     // occurred bit set
+
+        printf("Simple LMR EBB OK\n");
+
+        /* This shouldn't cause an EBB since it's been disabled */
+        ldmx((unsigned long)&test_mem);
+        FAIL_IF(lmr_count != 1);
+
+        printf("LMR disable on EBB OK\n");
+
+        ebb_lmr_reset();
+
+        /* This should cause an EBB or reset is broken */
+        ldmx((unsigned long)&test_mem);
+        FAIL_IF(lmr_count != 2);
+
+        printf("LMR reset EBB OK\n");
+
+        ebb_lmr_reset();
+
+        return ebb_lmr_section_test(test_mem);
+}
+
+int main(void)
+{
+        int ret = test_harness(ebb_lmr, "ebb_lmr");
+
+        if (test_mem)
+                free(test_mem);
+
+        return ret;
+}
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.h b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.h
new file mode 100644
index 000000000000..ef50abd557cd
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr.h
@@ -0,0 +1,39 @@
+#ifndef _SELFTESTS_POWERPC_PMU_EBB_LMR_H
+#define _SELFTESTS_POWERPC_PMU_EBB_LMR_H
+
+#include "reg.h"
+
+#ifndef PPC_FEATURE2_ARCH_3_00
+#define PPC_FEATURE2_ARCH_3_00 0x00800000
+#endif
+
+#define lmr_is_supported() have_hwcap2(PPC_FEATURE2_ARCH_3_00)
+
+static inline void ebb_lmr_reset(void)
+{
+        unsigned long bescr = mfspr(SPRN_BESCR);
+        bescr &= ~(BESCR_LMEO);
+        bescr |= BESCR_LME;
+        mtspr(SPRN_BESCR, bescr);
+}
+
+#define LDMX(t, a, b)\
+        (0x7c00026a |                           \
+         (((t) & 0x1f) << 21) |                 \
+         (((a) & 0x1f) << 16) |                 \
+         (((b) & 0x1f) << 11))
+
+static inline unsigned long ldmx(unsigned long address)
+{
+        unsigned long ret;
+
+        asm volatile ("mr 9, %1\r\n"
+                      ".long " __stringify(LDMX(9, 0, 9)) "\r\n"
+                      "mr %0, 9\r\n":"=r"(ret)
+                      :"r"(address)
+                      :"r9");
+
+        return ret;
+}
+
+#endif
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr_regs.c b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr_regs.c
new file mode 100644
index 000000000000..aff4241fd88a
--- /dev/null
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb_lmr_regs.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2016, Jack Miller, IBM Corp.
+ * Licensed under GPLv2.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "ebb.h"
+#include "ebb_lmr.h"
+
+#define CHECKS 10000
+
+int ebb_lmr_regs(void)
+{
+        int i;
+
+        SKIP_IF(!lmr_is_supported());
+
+        ebb_global_enable();
+
+        for (i = 0; i < CHECKS; i++) {
+                mtspr(SPRN_LMRR, i << 25);      // skip size and rsvd bits
+                mtspr(SPRN_LMSER, i);
+
+                FAIL_IF(mfspr(SPRN_LMRR) != (i << 25));
+                FAIL_IF(mfspr(SPRN_LMSER) != i);
+        }
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(ebb_lmr_regs, "ebb_lmr_regs");
+}
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c b/tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c
index 5da355135df2..ae9a79086111 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c
+++ b/tools/testing/selftests/powerpc/pmu/ebb/instruction_count_test.c
@@ -51,7 +51,7 @@ static int do_count_loop(struct event *event, uint64_t instructions,
                 printf("Looped for %lu instructions, overhead %lu\n", instructions, overhead);
                 printf("Expected %lu\n", expected);
                 printf("Actual   %llu\n", event->result.value);
-                printf("Error    %ld, %f%%\n", difference, percentage);
+                printf("Delta    %ld, %f%%\n", difference, percentage);
                 printf("Took %d EBBs\n", ebb_state.stats.ebb_count);
         }
 
diff --git a/tools/testing/selftests/powerpc/pmu/lib.c b/tools/testing/selftests/powerpc/pmu/lib.c
index a361ad3334ce..8b992fa5b478 100644
--- a/tools/testing/selftests/powerpc/pmu/lib.c
+++ b/tools/testing/selftests/powerpc/pmu/lib.c
@@ -190,7 +190,7 @@ int parse_proc_maps(void)
 
 bool require_paranoia_below(int level)
 {
-        unsigned long current;
+        long current;
         char *end, buf[16];
         FILE *f;
         int rc;
@@ -208,7 +208,7 @@ bool require_paranoia_below(int level)
                 goto out_close;
         }
 
-        current = strtoul(buf, &end, 10);
+        current = strtol(buf, &end, 10);
 
         if (end == buf) {
                 printf("Couldn't parse " PARANOID_PATH "?\n");
@@ -216,7 +216,7 @@ bool require_paranoia_below(int level)
         }
 
         if (current >= level)
-                goto out;
+                goto out_close;
 
         rc = 0;
 out_close:
diff --git a/tools/testing/selftests/powerpc/reg.h b/tools/testing/selftests/powerpc/reg.h
index 65bfdeeebdee..fddf368ed82f 100644
--- a/tools/testing/selftests/powerpc/reg.h
+++ b/tools/testing/selftests/powerpc/reg.h
@@ -34,6 +34,11 @@
 
 #define BESCR_PMEO     0x1     /* PMU Event-based exception Occurred */
 #define BESCR_PME      (0x1ul << 32) /* PMU Event-based exception Enable */
+#define BESCR_LME      (0x1ul << 34) /* Load Monitor Enable */
+#define BESCR_LMEO     (0x1ul << 2)  /* Load Monitor Exception Occurred */
+
+#define SPRN_LMRR      813     /* Load Monitor Region Register */
+#define SPRN_LMSER     814     /* Load Monitor Section Enable Register */
 
 #define SPRN_PMC1      771
 #define SPRN_PMC2      772
diff --git a/tools/testing/selftests/powerpc/signal/.gitignore b/tools/testing/selftests/powerpc/signal/.gitignore
new file mode 100644
index 000000000000..1b89224a8aab
--- /dev/null
+++ b/tools/testing/selftests/powerpc/signal/.gitignore
@@ -0,0 +1,2 @@
+signal
+signal_tm
diff --git a/tools/testing/selftests/powerpc/signal/Makefile b/tools/testing/selftests/powerpc/signal/Makefile
new file mode 100644
index 000000000000..f0eef27458e2
--- /dev/null
+++ b/tools/testing/selftests/powerpc/signal/Makefile
@@ -0,0 +1,13 @@
+TEST_PROGS := signal signal_tm
+
+all: $(TEST_PROGS)
+
+$(TEST_PROGS): ../harness.c ../utils.c signal.S
+
+CFLAGS += -maltivec
+signal_tm: CFLAGS += -mhtm
+
+include ../../lib.mk
+
+clean:
+        rm -f $(TEST_PROGS) *.o
diff --git a/tools/testing/selftests/powerpc/signal/signal.S b/tools/testing/selftests/powerpc/signal/signal.S
new file mode 100644
index 000000000000..7043d521df0a
--- /dev/null
+++ b/tools/testing/selftests/powerpc/signal/signal.S
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include "../basic_asm.h"
+
+/* long signal_self(pid_t pid, int sig); */
+FUNC_START(signal_self)
+        li      r0,37 /* sys_kill */
+        /* r3 already has our pid in it */
+        /* r4 already has signal type in it */
+        sc
+        bc      4,3,1f
+        subfze  r3,r3
+1:      blr
+FUNC_END(signal_self)
+
+/* long tm_signal_self(pid_t pid, int sig, int *ret); */
+FUNC_START(tm_signal_self)
+        PUSH_BASIC_STACK(8)
+        std     r5,STACK_FRAME_PARAM(0)(sp) /* ret */
+        tbegin.
+        beq     1f
+        tsuspend.
+        li      r0,37 /* sys_kill */
+        /* r3 already has our pid in it */
+        /* r4 already has signal type in it */
+        sc
+        ld      r5,STACK_FRAME_PARAM(0)(sp) /* ret */
+        bc      4,3,2f
+        subfze  r3,r3
+2:      std     r3,0(r5)
+        tabort. 0
+        tresume. /* Be nice to some cleanup, jumps back to tbegin then to 1: */
+        /*
+         * Transaction should be proper doomed and we should never get
+         * here
+         */
+        li      r3,1
+        POP_BASIC_STACK(8)
+        blr
+1:      li      r3,0
+        POP_BASIC_STACK(8)
+        blr
+FUNC_END(tm_signal_self)
diff --git a/tools/testing/selftests/powerpc/signal/signal.c b/tools/testing/selftests/powerpc/signal/signal.c
new file mode 100644
index 000000000000..e7dedd28b3c2
--- /dev/null
+++ b/tools/testing/selftests/powerpc/signal/signal.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Sending one self a signal should always get delivered.
+ */
+
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+
+#define MAX_ATTEMPT 500000
+#define TIMEOUT 5
+
+extern long signal_self(pid_t pid, int sig);
+
+static sig_atomic_t signaled;
+static sig_atomic_t fail;
+
+static void signal_handler(int sig)
+{
+        if (sig == SIGUSR1)
+                signaled = 1;
+        else
+                fail = 1;
+}
+
+static int test_signal()
+{
+        int i;
+        struct sigaction act;
+        pid_t ppid = getpid();
+        pid_t pid;
+
+        act.sa_handler = signal_handler;
+        act.sa_flags = 0;
+        sigemptyset(&act.sa_mask);
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction SIGUSR1");
+                exit(1);
+        }
+        if (sigaction(SIGALRM, &act, NULL) < 0) {
+                perror("sigaction SIGALRM");
+                exit(1);
+        }
+
+        /* Don't do this for MAX_ATTEMPT, its simply too long */
+        for(i  = 0; i < 1000; i++) {
+                pid = fork();
+                if (pid == -1) {
+                        perror("fork");
+                        exit(1);
+                }
+                if (pid == 0) {
+                        signal_self(ppid, SIGUSR1);
+                        exit(1);
+                } else {
+                        alarm(0); /* Disable any pending */
+                        alarm(2);
+                        while (!signaled && !fail)
+                                asm volatile("": : :"memory");
+                        if (!signaled) {
+                                fprintf(stderr, "Didn't get signal from child\n");
+                                FAIL_IF(1); /* For the line number */
+                        }
+                        /* Otherwise we'll loop too fast and fork() will eventually fail */
+                        waitpid(pid, NULL, 0);
+                }
+        }
+
+        for (i = 0; i < MAX_ATTEMPT; i++) {
+                long rc;
+
+                alarm(0); /* Disable any pending */
+                signaled = 0;
+                alarm(TIMEOUT);
+                rc = signal_self(ppid, SIGUSR1);
+                if (rc) {
+                        fprintf(stderr, "(%d) Fail reason: %d rc=0x%lx",
+                                        i, fail, rc);
+                        FAIL_IF(1); /* For the line number */
+                }
+                while (!signaled && !fail)
+                        asm volatile("": : :"memory");
+                if (!signaled) {
+                        fprintf(stderr, "(%d) Fail reason: %d rc=0x%lx",
+                                        i, fail, rc);
+                        FAIL_IF(1); /* For the line number */
+                }
+        }
+
+        return 0;
+}
+
+int main(void)
+{
+        test_harness_set_timeout(300);
+        return test_harness(test_signal, "signal");
+}
diff --git a/tools/testing/selftests/powerpc/signal/signal_tm.c b/tools/testing/selftests/powerpc/signal/signal_tm.c
new file mode 100644
index 000000000000..2e7451a37cc6
--- /dev/null
+++ b/tools/testing/selftests/powerpc/signal/signal_tm.c
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Sending one self a signal should always get delivered.
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+#include "../tm/tm.h"
+
+#define MAX_ATTEMPT 500000
+#define TIMEOUT 10
+
+extern long tm_signal_self(pid_t pid, int sig, long *ret);
+
+static sig_atomic_t signaled;
+static sig_atomic_t fail;
+
+static void signal_handler(int sig)
+{
+        if (tcheck_active()) {
+                fail = 2;
+                return;
+        }
+
+        if (sig == SIGUSR1)
+                signaled = 1;
+        else
+                fail = 1;
+}
+
+static int test_signal_tm()
+{
+        int i;
+        struct sigaction act;
+
+        act.sa_handler = signal_handler;
+        act.sa_flags = 0;
+        sigemptyset(&act.sa_mask);
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction SIGUSR1");
+                exit(1);
+        }
+        if (sigaction(SIGALRM, &act, NULL) < 0) {
+                perror("sigaction SIGALRM");
+                exit(1);
+        }
+
+        SKIP_IF(!have_htm());
+
+        for (i = 0; i < MAX_ATTEMPT; i++) {
+                /*
+                 * If anything bad happens in ASM and we fail to set ret
+                 * because *handwave* TM this will cause failure
+                 */
+                long ret = 0xdead;
+                long rc = 0xbeef;
+
+                alarm(0); /* Disable any pending */
+                signaled = 0;
+                alarm(TIMEOUT);
+                FAIL_IF(tcheck_transactional());
+                rc = tm_signal_self(getpid(), SIGUSR1, &ret);
+                if (ret == 0xdead)
+                        /*
+                         * This basically means the transaction aborted before we
+                         * even got to the suspend... this is crazy but it
+                         * happens.
+                         * Yes this also means we might never make forward
+                         * progress... the alarm() will trip eventually...
+                         */
+                        continue;
+
+                if (rc || ret) {
+                        /* Ret is actually an errno */
+                        printf("TEXASR 0x%016lx, TFIAR 0x%016lx\n",
+                                        __builtin_get_texasr(), __builtin_get_tfiar());
+                        fprintf(stderr, "(%d) Fail reason: %d rc=0x%lx ret=0x%lx\n",
+                                        i, fail, rc, ret);
+                        FAIL_IF(ret);
+                }
+                while(!signaled && !fail)
+                        asm volatile("": : :"memory");
+                if (!signaled) {
+                        fprintf(stderr, "(%d) Fail reason: %d rc=0x%lx ret=0x%lx\n",
+                                        i, fail, rc, ret);
+                        FAIL_IF(fail); /* For the line number */
+                }
+        }
+
+        return 0;
+}
+
+int main(void)
+{
+        return test_harness(test_signal_tm, "signal_tm");
+}
diff --git a/tools/testing/selftests/powerpc/stringloops/asm/export.h b/tools/testing/selftests/powerpc/stringloops/asm/export.h
new file mode 100644
index 000000000000..2d14a9b4248c
--- /dev/null
+++ b/tools/testing/selftests/powerpc/stringloops/asm/export.h
@@ -0,0 +1 @@
+#define EXPORT_SYMBOL(x)
diff --git a/tools/testing/selftests/powerpc/tm/.gitignore b/tools/testing/selftests/powerpc/tm/.gitignore
index bb942db845bf..427621792229 100644
--- a/tools/testing/selftests/powerpc/tm/.gitignore
+++ b/tools/testing/selftests/powerpc/tm/.gitignore
@@ -6,3 +6,8 @@ tm-vmxcopy
 tm-fork
 tm-tar
 tm-tmspr
+tm-exec
+tm-signal-context-chk-fpu
+tm-signal-context-chk-gpr
+tm-signal-context-chk-vmx
+tm-signal-context-chk-vsx
diff --git a/tools/testing/selftests/powerpc/tm/Makefile b/tools/testing/selftests/powerpc/tm/Makefile
index d0505dbd22d5..c6c53c82fdd6 100644
--- a/tools/testing/selftests/powerpc/tm/Makefile
+++ b/tools/testing/selftests/powerpc/tm/Makefile
@@ -1,13 +1,22 @@
-TEST_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack tm-vmxcopy tm-fork tm-tar tm-tmspr
+SIGNAL_CONTEXT_CHK_TESTS := tm-signal-context-chk-gpr tm-signal-context-chk-fpu \
+        tm-signal-context-chk-vmx tm-signal-context-chk-vsx
+
+TEST_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack \
+        tm-vmxcopy tm-fork tm-tar tm-tmspr $(SIGNAL_CONTEXT_CHK_TESTS)
 
 all: $(TEST_PROGS)
 
 $(TEST_PROGS): ../harness.c ../utils.c
 
+CFLAGS += -mhtm
+
 tm-syscall: tm-syscall-asm.S
-tm-syscall: CFLAGS += -mhtm -I../../../../../usr/include
+tm-syscall: CFLAGS += -I../../../../../usr/include
 tm-tmspr: CFLAGS += -pthread
 
+$(SIGNAL_CONTEXT_CHK_TESTS): tm-signal.S
+$(SIGNAL_CONTEXT_CHK_TESTS): CFLAGS += -mhtm -m64 -mvsx
+
 include ../../lib.mk
 
 clean:
diff --git a/tools/testing/selftests/powerpc/tm/tm-exec.c b/tools/testing/selftests/powerpc/tm/tm-exec.c
new file mode 100644
index 000000000000..3d27fa0ece04
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-exec.c
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * Syscalls can be performed provided the transactions are suspended.
+ * The exec() class of syscall is unique as a new process is loaded.
+ *
+ * It makes little sense for after an exec() call for the previously
+ * suspended transaction to still exist.
+ */
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <inttypes.h>
+#include <libgen.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "utils.h"
+#include "tm.h"
+
+static char *path;
+
+static int test_exec(void)
+{
+        SKIP_IF(!have_htm());
+
+        asm __volatile__(
+                "tbegin.;"
+                "blt    1f; "
+                "tsuspend.;"
+                "1: ;"
+                : : : "memory");
+
+        execl(path, "tm-exec", "--child", NULL);
+
+        /* Shouldn't get here */
+        perror("execl() failed");
+        return 1;
+}
+
+static int after_exec(void)
+{
+        asm __volatile__(
+                "tbegin.;"
+                "blt    1f;"
+                "tsuspend.;"
+                "1: ;"
+                : : : "memory");
+
+        FAIL_IF(failure_is_nesting());
+        return 0;
+}
+
+int main(int argc, char *argv[])
+{
+        path = argv[0];
+
+        if (argc > 1 && strcmp(argv[1], "--child") == 0)
+                return after_exec();
+
+        return test_harness(test_exec, "tm_exec");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-fpu.c b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-fpu.c
new file mode 100644
index 000000000000..c760debbd5ad
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-fpu.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *
+ * Test the kernel's signal frame code.
+ *
+ * The kernel sets up two sets of ucontexts if the signal was to be
+ * delivered while the thread was in a transaction.
+ * Expected behaviour is that the checkpointed state is in the user
+ * context passed to the signal handler. The speculated state can be
+ * accessed with the uc_link pointer.
+ *
+ * The rationale for this is that if TM unaware code (which linked
+ * against TM libs) installs a signal handler it will not know of the
+ * speculative nature of the 'live' registers and may infer the wrong
+ * thing.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+#include "tm.h"
+
+#define MAX_ATTEMPT 500000
+
+#define NV_FPU_REGS 18
+
+long tm_signal_self_context_load(pid_t pid, long *gprs, double *fps, vector int *vms, vector int *vss);
+
+/* Be sure there are 2x as many as there are NV FPU regs (2x18) */
+static double fps[] = {
+         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+        -1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18
+};
+
+static sig_atomic_t fail;
+
+static void signal_usr1(int signum, siginfo_t *info, void *uc)
+{
+        int i;
+        ucontext_t *ucp = uc;
+        ucontext_t *tm_ucp = ucp->uc_link;
+
+        for (i = 0; i < NV_FPU_REGS && !fail; i++) {
+                fail = (ucp->uc_mcontext.fp_regs[i + 14] != fps[i]);
+                fail |= (tm_ucp->uc_mcontext.fp_regs[i + 14] != fps[i + NV_FPU_REGS]);
+                if (fail)
+                        printf("Failed on %d FP %g or %g\n", i, ucp->uc_mcontext.fp_regs[i + 14], tm_ucp->uc_mcontext.fp_regs[i + 14]);
+        }
+}
+
+static int tm_signal_context_chk_fpu()
+{
+        struct sigaction act;
+        int i;
+        long rc;
+        pid_t pid = getpid();
+
+        SKIP_IF(!have_htm());
+
+        act.sa_sigaction = signal_usr1;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction sigusr1");
+                exit(1);
+        }
+
+        i = 0;
+        while (i < MAX_ATTEMPT && !fail) {
+                rc = tm_signal_self_context_load(pid, NULL, fps, NULL, NULL);
+                FAIL_IF(rc != pid);
+                i++;
+        }
+
+        return fail;
+}
+
+int main(void)
+{
+        return test_harness(tm_signal_context_chk_fpu, "tm_signal_context_chk_fpu");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-gpr.c b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-gpr.c
new file mode 100644
index 000000000000..df91330a08ef
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-gpr.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *
+ * Test the kernel's signal frame code.
+ *
+ * The kernel sets up two sets of ucontexts if the signal was to be
+ * delivered while the thread was in a transaction.
+ * Expected behaviour is that the checkpointed state is in the user
+ * context passed to the signal handler. The speculated state can be
+ * accessed with the uc_link pointer.
+ *
+ * The rationale for this is that if TM unaware code (which linked
+ * against TM libs) installs a signal handler it will not know of the
+ * speculative nature of the 'live' registers and may infer the wrong
+ * thing.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+#include "tm.h"
+
+#define MAX_ATTEMPT 500000
+
+#define NV_GPR_REGS 18
+
+long tm_signal_self_context_load(pid_t pid, long *gprs, double *fps, vector int *vms, vector int *vss);
+
+static sig_atomic_t fail;
+
+static long gps[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+                                         -1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15,-16,-17,-18};
+
+static void signal_usr1(int signum, siginfo_t *info, void *uc)
+{
+        int i;
+        ucontext_t *ucp = uc;
+        ucontext_t *tm_ucp = ucp->uc_link;
+
+        for (i = 0; i < NV_GPR_REGS && !fail; i++) {
+                fail = (ucp->uc_mcontext.gp_regs[i + 14] != gps[i]);
+                fail |= (tm_ucp->uc_mcontext.gp_regs[i + 14] != gps[i + NV_GPR_REGS]);
+                if (fail)
+                        printf("Failed on %d GPR %lu or %lu\n", i,
+                                        ucp->uc_mcontext.gp_regs[i + 14], tm_ucp->uc_mcontext.gp_regs[i + 14]);
+        }
+}
+
+static int tm_signal_context_chk_gpr()
+{
+        struct sigaction act;
+        int i;
+        long rc;
+        pid_t pid = getpid();
+
+        SKIP_IF(!have_htm());
+
+        act.sa_sigaction = signal_usr1;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction sigusr1");
+                exit(1);
+        }
+
+        i = 0;
+        while (i < MAX_ATTEMPT && !fail) {
+                rc = tm_signal_self_context_load(pid, gps, NULL, NULL, NULL);
+                FAIL_IF(rc != pid);
+                i++;
+        }
+
+        return fail;
+}
+
+int main(void)
+{
+        return test_harness(tm_signal_context_chk_gpr, "tm_signal_context_chk_gpr");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vmx.c b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vmx.c
new file mode 100644
index 000000000000..f0ee55fd5185
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vmx.c
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *
+ * Test the kernel's signal frame code.
+ *
+ * The kernel sets up two sets of ucontexts if the signal was to be
+ * delivered while the thread was in a transaction.
+ * Expected behaviour is that the checkpointed state is in the user
+ * context passed to the signal handler. The speculated state can be
+ * accessed with the uc_link pointer.
+ *
+ * The rationale for this is that if TM unaware code (which linked
+ * against TM libs) installs a signal handler it will not know of the
+ * speculative nature of the 'live' registers and may infer the wrong
+ * thing.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+#include "tm.h"
+
+#define MAX_ATTEMPT 500000
+
+#define NV_VMX_REGS 12
+
+long tm_signal_self_context_load(pid_t pid, long *gprs, double *fps, vector int *vms, vector int *vss);
+
+static sig_atomic_t fail;
+
+vector int vms[] = {
+        {1, 2, 3, 4 },{5, 6, 7, 8 },{9, 10,11,12},
+        {13,14,15,16},{17,18,19,20},{21,22,23,24},
+        {25,26,27,28},{29,30,31,32},{33,34,35,36},
+        {37,38,39,40},{41,42,43,44},{45,46,47,48},
+        {-1, -2, -3, -4}, {-5, -6, -7, -8}, {-9, -10,-11,-12},
+        {-13,-14,-15,-16},{-17,-18,-19,-20},{-21,-22,-23,-24},
+        {-25,-26,-27,-28},{-29,-30,-31,-32},{-33,-34,-35,-36},
+        {-37,-38,-39,-40},{-41,-42,-43,-44},{-45,-46,-47,-48}
+};
+
+static void signal_usr1(int signum, siginfo_t *info, void *uc)
+{
+        int i;
+        ucontext_t *ucp = uc;
+        ucontext_t *tm_ucp = ucp->uc_link;
+
+        for (i = 0; i < NV_VMX_REGS && !fail; i++) {
+                fail = memcmp(ucp->uc_mcontext.v_regs->vrregs[i + 20],
+                                &vms[i], sizeof(vector int));
+                fail |= memcmp(tm_ucp->uc_mcontext.v_regs->vrregs[i + 20],
+                                &vms[i + NV_VMX_REGS], sizeof (vector int));
+
+                if (fail) {
+                        int j;
+
+                        fprintf(stderr, "Failed on %d vmx 0x", i);
+                        for (j = 0; j < 4; j++)
+                                fprintf(stderr, "%04x", ucp->uc_mcontext.v_regs->vrregs[i + 20][j]);
+                        fprintf(stderr, " vs 0x");
+                        for (j = 0 ; j < 4; j++)
+                                fprintf(stderr, "%04x", tm_ucp->uc_mcontext.v_regs->vrregs[i + 20][j]);
+                        fprintf(stderr, "\n");
+                }
+        }
+}
+
+static int tm_signal_context_chk()
+{
+        struct sigaction act;
+        int i;
+        long rc;
+        pid_t pid = getpid();
+
+        SKIP_IF(!have_htm());
+
+        act.sa_sigaction = signal_usr1;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction sigusr1");
+                exit(1);
+        }
+
+        i = 0;
+        while (i < MAX_ATTEMPT && !fail) {
+                rc = tm_signal_self_context_load(pid, NULL, NULL, vms, NULL);
+                FAIL_IF(rc != pid);
+                i++;
+        }
+
+        return fail;
+}
+
+int main(void)
+{
+        return test_harness(tm_signal_context_chk, "tm_signal_context_chk_vmx");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vsx.c b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vsx.c
new file mode 100644
index 000000000000..b99c3d835957
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-signal-context-chk-vsx.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2016, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ *
+ * Test the kernel's signal frame code.
+ *
+ * The kernel sets up two sets of ucontexts if the signal was to be
+ * delivered while the thread was in a transaction.
+ * Expected behaviour is that the checkpointed state is in the user
+ * context passed to the signal handler. The speculated state can be
+ * accessed with the uc_link pointer.
+ *
+ * The rationale for this is that if TM unaware code (which linked
+ * against TM libs) installs a signal handler it will not know of the
+ * speculative nature of the 'live' registers and may infer the wrong
+ * thing.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+
+#include <altivec.h>
+
+#include "utils.h"
+#include "tm.h"
+
+#define MAX_ATTEMPT 500000
+
+#define NV_VSX_REGS 12
+
+long tm_signal_self_context_load(pid_t pid, long *gprs, double *fps, vector int *vms, vector int *vss);
+
+static sig_atomic_t fail;
+
+vector int vss[] = {
+        {1, 2, 3, 4 },{5, 6, 7, 8 },{9, 10,11,12},
+        {13,14,15,16},{17,18,19,20},{21,22,23,24},
+        {25,26,27,28},{29,30,31,32},{33,34,35,36},
+        {37,38,39,40},{41,42,43,44},{45,46,47,48},
+        {-1, -2, -3, -4 },{-5, -6, -7, -8 },{-9, -10,-11,-12},
+        {-13,-14,-15,-16},{-17,-18,-19,-20},{-21,-22,-23,-24},
+        {-25,-26,-27,-28},{-29,-30,-31,-32},{-33,-34,-35,-36},
+        {-37,-38,-39,-40},{-41,-42,-43,-44},{-45,-46,-47,-48}
+};
+
+static void signal_usr1(int signum, siginfo_t *info, void *uc)
+{
+        int i;
+        uint8_t vsc[sizeof(vector int)];
+        uint8_t vst[sizeof(vector int)];
+        ucontext_t *ucp = uc;
+        ucontext_t *tm_ucp = ucp->uc_link;
+
+        /*
+         * The other half of the VSX regs will be after v_regs.
+         *
+         * In short, vmx_reserve array holds everything. v_regs is a 16
+         * byte aligned pointer at the start of vmx_reserve (vmx_reserve
+         * may or may not be 16 aligned) where the v_regs structure exists.
+         * (half of) The VSX regsters are directly after v_regs so the
+         * easiest way to find them below.
+         */
+        long *vsx_ptr = (long *)(ucp->uc_mcontext.v_regs + 1);
+        long *tm_vsx_ptr = (long *)(tm_ucp->uc_mcontext.v_regs + 1);
+        for (i = 0; i < NV_VSX_REGS && !fail; i++) {
+                memcpy(vsc, &ucp->uc_mcontext.fp_regs[i + 20], 8);
+                memcpy(vsc + 8, &vsx_ptr[20 + i], 8);
+                fail = memcmp(vsc, &vss[i], sizeof(vector int));
+                memcpy(vst, &tm_ucp->uc_mcontext.fp_regs[i + 20], 8);
+                memcpy(vst + 8, &tm_vsx_ptr[20 + i], 8);
+                fail |= memcmp(vst, &vss[i + NV_VSX_REGS], sizeof(vector int));
+
+                if (fail) {
+                        int j;
+
+                        fprintf(stderr, "Failed on %d vsx 0x", i);
+                        for (j = 0; j < 16; j++)
+                                fprintf(stderr, "%02x", vsc[j]);
+                        fprintf(stderr, " vs 0x");
+                        for (j = 0; j < 16; j++)
+                                fprintf(stderr, "%02x", vst[j]);
+                        fprintf(stderr, "\n");
+                }
+        }
+}
+
+static int tm_signal_context_chk()
+{
+        struct sigaction act;
+        int i;
+        long rc;
+        pid_t pid = getpid();
+
+        SKIP_IF(!have_htm());
+
+        act.sa_sigaction = signal_usr1;
+        sigemptyset(&act.sa_mask);
+        act.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGUSR1, &act, NULL) < 0) {
+                perror("sigaction sigusr1");
+                exit(1);
+        }
+
+        i = 0;
+        while (i < MAX_ATTEMPT && !fail) {
+                rc = tm_signal_self_context_load(pid, NULL, NULL, NULL, vss);
+                FAIL_IF(rc != pid);
+                i++;
+        }
+
+        return fail;
+}
+
+int main(void)
+{
+        return test_harness(tm_signal_context_chk, "tm_signal_context_chk_vsx");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal.S b/tools/testing/selftests/powerpc/tm/tm-signal.S
new file mode 100644
index 000000000000..4e13e8b3a96f
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-signal.S
@@ -0,0 +1,114 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include "../basic_asm.h"
+#include "../gpr_asm.h"
+#include "../fpu_asm.h"
+#include "../vmx_asm.h"
+#include "../vsx_asm.h"
+
+/*
+ * Large caveat here being that the caller cannot expect the
+ * signal to always be sent! The hardware can (AND WILL!) abort
+ * the transaction between the tbegin and the tsuspend (however
+ * unlikely it seems or infrequently it actually happens).
+ * You have been warned.
+ */
+/* long tm_signal_self(pid_t pid, long *gprs, double *fps, vector *vms, vector *vss); */
+FUNC_START(tm_signal_self_context_load)
+        PUSH_BASIC_STACK(512)
+        /*
+         * Don't strictly need to save and restore as it depends on if
+         * we're going to use them, however this reduces messy logic
+         */
+        PUSH_VMX(STACK_FRAME_LOCAL(5,0),r8)
+        PUSH_FPU(512)
+        PUSH_NVREGS_BELOW_FPU(512)
+        std r3, STACK_FRAME_PARAM(0)(sp) /* pid */
+        std r4, STACK_FRAME_PARAM(1)(sp) /* gps */
+        std r5, STACK_FRAME_PARAM(2)(sp) /* fps */
+        std r6, STACK_FRAME_PARAM(3)(sp) /* vms */
+        std r7, STACK_FRAME_PARAM(4)(sp) /* vss */
+
+        ld r3, STACK_FRAME_PARAM(1)(sp)
+        cmpdi r3, 0
+        beq skip_gpr_lc
+        bl load_gpr
+skip_gpr_lc:
+        ld r3, STACK_FRAME_PARAM(2)(sp)
+        cmpdi   r3, 0
+        beq     skip_fpu_lc
+        bl load_fpu
+skip_fpu_lc:
+        ld r3, STACK_FRAME_PARAM(3)(sp)
+        cmpdi r3, 0
+        beq     skip_vmx_lc
+        bl load_vmx
+skip_vmx_lc:
+        ld r3, STACK_FRAME_PARAM(4)(sp)
+        cmpdi   r3, 0
+        beq     skip_vsx_lc
+        bl load_vsx
+skip_vsx_lc:
+        /*
+         * Set r3 (return value) before tbegin. Use the pid as a known
+         * 'all good' return value, zero is used to indicate a non-doomed
+         * transaction.
+         */
+        ld      r3, STACK_FRAME_PARAM(0)(sp)
+        tbegin.
+        beq     1f
+        tsuspend. /* Can't enter a syscall transactionally */
+        ld      r3, STACK_FRAME_PARAM(1)(sp)
+        cmpdi   r3, 0
+        beq skip_gpr_lt
+        /* Get the second half of the array */
+        addi    r3, r3, 8 * 18
+        bl load_gpr
+skip_gpr_lt:
+        ld r3, STACK_FRAME_PARAM(2)(sp)
+        cmpdi   r3, 0
+        beq     skip_fpu_lt
+        /* Get the second half of the array */
+        addi    r3, r3, 8 * 18
+        bl load_fpu
+skip_fpu_lt:
+        ld r3, STACK_FRAME_PARAM(3)(sp)
+        cmpdi r3, 0
+        beq     skip_vmx_lt
+        /* Get the second half of the array */
+        addi    r3, r3, 16 * 12
+        bl load_vmx
+skip_vmx_lt:
+        ld r3, STACK_FRAME_PARAM(4)(sp)
+        cmpdi   r3, 0
+        beq     skip_vsx_lt
+        /* Get the second half of the array */
+        addi    r3, r3, 16 * 12
+        bl load_vsx
+skip_vsx_lt:
+        li      r0, 37 /* sys_kill */
+        ld r3, STACK_FRAME_PARAM(0)(sp) /* pid */
+        li r4, 10 /* SIGUSR1 */
+        sc /* Taking the signal will doom the transaction */
+        tabort. 0
+        tresume. /* Be super sure we abort */
+        /*
+         * This will cause us to resume doomed transaction and cause
+         * hardware to cleanup, we'll end up at 1: anything between
+         * tresume. and 1: shouldn't ever run.
+         */
+        li r3, 0
+        1:
+        POP_VMX(STACK_FRAME_LOCAL(5,0),r4)
+        POP_FPU(512)
+        POP_NVREGS_BELOW_FPU(512)
+        POP_BASIC_STACK(512)
+        blr
+FUNC_END(tm_signal_self_context_load)
diff --git a/tools/testing/selftests/powerpc/tm/tm-syscall.c b/tools/testing/selftests/powerpc/tm/tm-syscall.c
index 60560cb20e38..454b965a2db3 100644
--- a/tools/testing/selftests/powerpc/tm/tm-syscall.c
+++ b/tools/testing/selftests/powerpc/tm/tm-syscall.c
@@ -27,21 +27,6 @@ unsigned retries = 0;
 #define TEST_DURATION 10 /* seconds */
 #define TM_RETRIES 100
 
-long failure_code(void)
-{
-        return __builtin_get_texasru() >> 24;
-}
-
-bool failure_is_persistent(void)
-{
-        return (failure_code() & TM_CAUSE_PERSISTENT) == TM_CAUSE_PERSISTENT;
-}
-
-bool failure_is_syscall(void)
-{
-        return (failure_code() & TM_CAUSE_SYSCALL) == TM_CAUSE_SYSCALL;
-}
-
 pid_t getppid_tm(bool suspend)
 {
         int i;
diff --git a/tools/testing/selftests/powerpc/tm/tm.h b/tools/testing/selftests/powerpc/tm/tm.h
index 24144b25772c..2c8da74304e7 100644
--- a/tools/testing/selftests/powerpc/tm/tm.h
+++ b/tools/testing/selftests/powerpc/tm/tm.h
@@ -6,8 +6,9 @@
 #ifndef _SELFTESTS_POWERPC_TM_TM_H
 #define _SELFTESTS_POWERPC_TM_TM_H
 
-#include <stdbool.h>
+#include <asm/tm.h>
 #include <asm/cputable.h>
+#include <stdbool.h>
 
 #include "../utils.h"
 
@@ -31,4 +32,51 @@ static inline bool have_htm_nosc(void)
 #endif
 }
 
+static inline long failure_code(void)
+{
+        return __builtin_get_texasru() >> 24;
+}
+
+static inline bool failure_is_persistent(void)
+{
+        return (failure_code() & TM_CAUSE_PERSISTENT) == TM_CAUSE_PERSISTENT;
+}
+
+static inline bool failure_is_syscall(void)
+{
+        return (failure_code() & TM_CAUSE_SYSCALL) == TM_CAUSE_SYSCALL;
+}
+
+static inline bool failure_is_nesting(void)
+{
+        return (__builtin_get_texasru() & 0x400000);
+}
+
+static inline int tcheck(void)
+{
+        long cr;
+        asm volatile ("tcheck 0" : "=r"(cr) : : "cr0");
+        return (cr >> 28) & 4;
+}
+
+static inline bool tcheck_doomed(void)
+{
+        return tcheck() & 8;
+}
+
+static inline bool tcheck_active(void)
+{
+        return tcheck() & 4;
+}
+
+static inline bool tcheck_suspended(void)
+{
+        return tcheck() & 2;
+}
+
+static inline bool tcheck_transactional(void)
+{
+        return tcheck() & 6;
+}
+
 #endif /* _SELFTESTS_POWERPC_TM_TM_H */
diff --git a/tools/testing/selftests/powerpc/utils.h b/tools/testing/selftests/powerpc/utils.h
index a985cfaa535e..53405e8a52ab 100644
--- a/tools/testing/selftests/powerpc/utils.h
+++ b/tools/testing/selftests/powerpc/utils.h
@@ -22,15 +22,27 @@ typedef uint32_t u32;
 typedef uint16_t u16;
 typedef uint8_t u8;
 
-
+void test_harness_set_timeout(uint64_t time);
 int test_harness(int (test_function)(void), char *name);
 extern void *get_auxv_entry(int type);
 int pick_online_cpu(void);
 
+static inline bool have_hwcap(unsigned long ftr)
+{
+        return ((unsigned long)get_auxv_entry(AT_HWCAP) & ftr) == ftr;
+}
+
+#ifdef AT_HWCAP2
 static inline bool have_hwcap2(unsigned long ftr2)
 {
         return ((unsigned long)get_auxv_entry(AT_HWCAP2) & ftr2) == ftr2;
 }
+#else
+static inline bool have_hwcap2(unsigned long ftr2)
+{
+        return false;
+}
+#endif
 
 /* Yes, this is evil */
 #define FAIL_IF(x)                                              \
diff --git a/tools/testing/selftests/powerpc/vmx_asm.h b/tools/testing/selftests/powerpc/vmx_asm.h
new file mode 100644
index 000000000000..2eaaeca9cf1d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/vmx_asm.h
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include "basic_asm.h"
+
+/* POS MUST BE 16 ALIGNED! */
+#define PUSH_VMX(pos,reg) \
+        li      reg,pos; \
+        stvx    v20,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v21,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v22,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v23,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v24,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v25,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v26,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v27,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v28,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v29,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v30,reg,%r1; \
+        addi    reg,reg,16; \
+        stvx    v31,reg,%r1;
+
+/* POS MUST BE 16 ALIGNED! */
+#define POP_VMX(pos,reg) \
+        li      reg,pos; \
+        lvx     v20,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v21,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v22,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v23,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v24,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v25,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v26,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v27,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v28,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v29,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v30,reg,%r1; \
+        addi    reg,reg,16; \
+        lvx     v31,reg,%r1;
+
+/*
+ * Careful this will 'clobber' vmx (by design)
+ * Don't call this from C
+ */
+FUNC_START(load_vmx)
+        li      r5,0
+        lvx     v20,r5,r3
+        addi    r5,r5,16
+        lvx     v21,r5,r3
+        addi    r5,r5,16
+        lvx     v22,r5,r3
+        addi    r5,r5,16
+        lvx     v23,r5,r3
+        addi    r5,r5,16
+        lvx     v24,r5,r3
+        addi    r5,r5,16
+        lvx     v25,r5,r3
+        addi    r5,r5,16
+        lvx     v26,r5,r3
+        addi    r5,r5,16
+        lvx     v27,r5,r3
+        addi    r5,r5,16
+        lvx     v28,r5,r3
+        addi    r5,r5,16
+        lvx     v29,r5,r3
+        addi    r5,r5,16
+        lvx     v30,r5,r3
+        addi    r5,r5,16
+        lvx     v31,r5,r3
+        blr
+FUNC_END(load_vmx)
diff --git a/tools/testing/selftests/powerpc/vsx_asm.h b/tools/testing/selftests/powerpc/vsx_asm.h
new file mode 100644
index 000000000000..d828bfb6ef2d
--- /dev/null
+++ b/tools/testing/selftests/powerpc/vsx_asm.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2015, Cyril Bur, IBM Corp.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include "basic_asm.h"
+
+/*
+ * Careful this will 'clobber' vsx (by design), VSX are always
+ * volatile though so unlike vmx this isn't so much of an issue
+ * Still should avoid calling from C
+ */
+FUNC_START(load_vsx)
+        li      r5,0
+        lxvx    vs20,r5,r3
+        addi    r5,r5,16
+        lxvx    vs21,r5,r3
+        addi    r5,r5,16
+        lxvx    vs22,r5,r3
+        addi    r5,r5,16
+        lxvx    vs23,r5,r3
+        addi    r5,r5,16
+        lxvx    vs24,r5,r3
+        addi    r5,r5,16
+        lxvx    vs25,r5,r3
+        addi    r5,r5,16
+        lxvx    vs26,r5,r3
+        addi    r5,r5,16
+        lxvx    vs27,r5,r3
+        addi    r5,r5,16
+        lxvx    vs28,r5,r3
+        addi    r5,r5,16
+        lxvx    vs29,r5,r3
+        addi    r5,r5,16
+        lxvx    vs30,r5,r3
+        addi    r5,r5,16
+        lxvx    vs31,r5,r3
+        blr
+FUNC_END(load_vsx)
+
+FUNC_START(store_vsx)
+        li      r5,0
+        stxvx   vs20,r5,r3
+        addi    r5,r5,16
+        stxvx   vs21,r5,r3
+        addi    r5,r5,16
+        stxvx   vs22,r5,r3
+        addi    r5,r5,16
+        stxvx   vs23,r5,r3
+        addi    r5,r5,16
+        stxvx   vs24,r5,r3
+        addi    r5,r5,16
+        stxvx   vs25,r5,r3
+        addi    r5,r5,16
+        stxvx   vs26,r5,r3
+        addi    r5,r5,16
+        stxvx   vs27,r5,r3
+        addi    r5,r5,16
+        stxvx   vs28,r5,r3
+        addi    r5,r5,16
+        stxvx   vs29,r5,r3
+        addi    r5,r5,16
+        stxvx   vs30,r5,r3
+        addi    r5,r5,16
+        stxvx   vs31,r5,r3
+        blr
+FUNC_END(store_vsx)
diff --git a/tools/testing/selftests/prctl/.gitignore b/tools/testing/selftests/prctl/.gitignore
new file mode 100644
index 000000000000..0b5c27447bf6
--- /dev/null
+++ b/tools/testing/selftests/prctl/.gitignore
@@ -0,0 +1,3 @@
+disable-tsc-ctxt-sw-stress-test
+disable-tsc-on-off-stress-test
+disable-tsc-test
diff --git a/tools/testing/selftests/prctl/Makefile b/tools/testing/selftests/prctl/Makefile
new file mode 100644
index 000000000000..35aa1c8f2df2
--- /dev/null
+++ b/tools/testing/selftests/prctl/Makefile
@@ -0,0 +1,15 @@
+ifndef CROSS_COMPILE
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/x86/ -e s/x86_64/x86/)
+
+ifeq ($(ARCH),x86)
+TEST_PROGS := disable-tsc-ctxt-sw-stress-test disable-tsc-on-off-stress-test \
+                disable-tsc-test
+all: $(TEST_PROGS)
+
+include ../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
+endif
+endif
diff --git a/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c b/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c
new file mode 100644
index 000000000000..f7499d1c0415
--- /dev/null
+++ b/tools/testing/selftests/prctl/disable-tsc-ctxt-sw-stress-test.c
@@ -0,0 +1,97 @@
+/*
+ * Tests for prctl(PR_GET_TSC, ...) / prctl(PR_SET_TSC, ...)
+ *
+ * Tests if the control register is updated correctly
+ * at context switches
+ *
+ * Warning: this test will cause a very high load for a few seconds
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <inttypes.h>
+#include <wait.h>
+
+
+#include <sys/prctl.h>
+#include <linux/prctl.h>
+
+/* Get/set the process' ability to use the timestamp counter instruction */
+#ifndef PR_GET_TSC
+#define PR_GET_TSC 25
+#define PR_SET_TSC 26
+# define PR_TSC_ENABLE          1   /* allow the use of the timestamp counter */
+# define PR_TSC_SIGSEGV         2   /* throw a SIGSEGV instead of reading the TSC */
+#endif
+
+static uint64_t rdtsc(void)
+{
+uint32_t lo, hi;
+/* We cannot use "=A", since this would use %rax on x86_64 */
+__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+return (uint64_t)hi << 32 | lo;
+}
+
+static void sigsegv_expect(int sig)
+{
+        /* */
+}
+
+static void segvtask(void)
+{
+        if (prctl(PR_SET_TSC, PR_TSC_SIGSEGV) < 0)
+        {
+                perror("prctl");
+                exit(0);
+        }
+        signal(SIGSEGV, sigsegv_expect);
+        alarm(10);
+        rdtsc();
+        fprintf(stderr, "FATAL ERROR, rdtsc() succeeded while disabled\n");
+        exit(0);
+}
+
+
+static void sigsegv_fail(int sig)
+{
+        fprintf(stderr, "FATAL ERROR, rdtsc() failed while enabled\n");
+        exit(0);
+}
+
+static void rdtsctask(void)
+{
+        if (prctl(PR_SET_TSC, PR_TSC_ENABLE) < 0)
+        {
+                perror("prctl");
+                exit(0);
+        }
+        signal(SIGSEGV, sigsegv_fail);
+        alarm(10);
+        for(;;) rdtsc();
+}
+
+
+int main(void)
+{
+        int n_tasks = 100, i;
+
+        fprintf(stderr, "[No further output means we're allright]\n");
+
+        for (i=0; i<n_tasks; i++)
+                if (fork() == 0)
+                {
+                        if (i & 1)
+                                segvtask();
+                        else
+                                rdtsctask();
+                }
+
+        for (i=0; i<n_tasks; i++)
+                wait(NULL);
+
+        exit(0);
+}
+
diff --git a/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c b/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c
new file mode 100644
index 000000000000..a06f027e9d16
--- /dev/null
+++ b/tools/testing/selftests/prctl/disable-tsc-on-off-stress-test.c
@@ -0,0 +1,96 @@
+/*
+ * Tests for prctl(PR_GET_TSC, ...) / prctl(PR_SET_TSC, ...)
+ *
+ * Tests if the control register is updated correctly
+ * when set with prctl()
+ *
+ * Warning: this test will cause a very high load for a few seconds
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <inttypes.h>
+#include <wait.h>
+
+
+#include <sys/prctl.h>
+#include <linux/prctl.h>
+
+/* Get/set the process' ability to use the timestamp counter instruction */
+#ifndef PR_GET_TSC
+#define PR_GET_TSC 25
+#define PR_SET_TSC 26
+# define PR_TSC_ENABLE          1   /* allow the use of the timestamp counter */
+# define PR_TSC_SIGSEGV         2   /* throw a SIGSEGV instead of reading the TSC */
+#endif
+
+/* snippet from wikipedia :-) */
+
+static uint64_t rdtsc(void)
+{
+uint32_t lo, hi;
+/* We cannot use "=A", since this would use %rax on x86_64 */
+__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+return (uint64_t)hi << 32 | lo;
+}
+
+int should_segv = 0;
+
+static void sigsegv_cb(int sig)
+{
+        if (!should_segv)
+        {
+                fprintf(stderr, "FATAL ERROR, rdtsc() failed while enabled\n");
+                exit(0);
+        }
+        if (prctl(PR_SET_TSC, PR_TSC_ENABLE) < 0)
+        {
+                perror("prctl");
+                exit(0);
+        }
+        should_segv = 0;
+
+        rdtsc();
+}
+
+static void task(void)
+{
+        signal(SIGSEGV, sigsegv_cb);
+        alarm(10);
+        for(;;)
+        {
+                rdtsc();
+                if (should_segv)
+                {
+                        fprintf(stderr, "FATAL ERROR, rdtsc() succeeded while disabled\n");
+                        exit(0);
+                }
+                if (prctl(PR_SET_TSC, PR_TSC_SIGSEGV) < 0)
+                {
+                        perror("prctl");
+                        exit(0);
+                }
+                should_segv = 1;
+        }
+}
+
+
+int main(void)
+{
+        int n_tasks = 100, i;
+
+        fprintf(stderr, "[No further output means we're allright]\n");
+
+        for (i=0; i<n_tasks; i++)
+                if (fork() == 0)
+                        task();
+
+        for (i=0; i<n_tasks; i++)
+                wait(NULL);
+
+        exit(0);
+}
+
diff --git a/tools/testing/selftests/prctl/disable-tsc-test.c b/tools/testing/selftests/prctl/disable-tsc-test.c
new file mode 100644
index 000000000000..8d494f7bebdb
--- /dev/null
+++ b/tools/testing/selftests/prctl/disable-tsc-test.c
@@ -0,0 +1,95 @@
+/*
+ * Tests for prctl(PR_GET_TSC, ...) / prctl(PR_SET_TSC, ...)
+ *
+ * Basic test to test behaviour of PR_GET_TSC and PR_SET_TSC
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <inttypes.h>
+
+
+#include <sys/prctl.h>
+#include <linux/prctl.h>
+
+/* Get/set the process' ability to use the timestamp counter instruction */
+#ifndef PR_GET_TSC
+#define PR_GET_TSC 25
+#define PR_SET_TSC 26
+# define PR_TSC_ENABLE          1   /* allow the use of the timestamp counter */
+# define PR_TSC_SIGSEGV         2   /* throw a SIGSEGV instead of reading the TSC */
+#endif
+
+const char *tsc_names[] =
+{
+        [0] = "[not set]",
+        [PR_TSC_ENABLE] = "PR_TSC_ENABLE",
+        [PR_TSC_SIGSEGV] = "PR_TSC_SIGSEGV",
+};
+
+static uint64_t rdtsc(void)
+{
+uint32_t lo, hi;
+/* We cannot use "=A", since this would use %rax on x86_64 */
+__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+return (uint64_t)hi << 32 | lo;
+}
+
+static void sigsegv_cb(int sig)
+{
+        int tsc_val = 0;
+
+        printf("[ SIG_SEGV ]\n");
+        printf("prctl(PR_GET_TSC, &tsc_val); ");
+        fflush(stdout);
+
+        if ( prctl(PR_GET_TSC, &tsc_val) == -1)
+                perror("prctl");
+
+        printf("tsc_val == %s\n", tsc_names[tsc_val]);
+        printf("prctl(PR_SET_TSC, PR_TSC_ENABLE)\n");
+        fflush(stdout);
+        if ( prctl(PR_SET_TSC, PR_TSC_ENABLE) == -1)
+                perror("prctl");
+
+        printf("rdtsc() == ");
+}
+
+int main(void)
+{
+        int tsc_val = 0;
+
+        signal(SIGSEGV, sigsegv_cb);
+
+        printf("rdtsc() == %llu\n", (unsigned long long)rdtsc());
+        printf("prctl(PR_GET_TSC, &tsc_val); ");
+        fflush(stdout);
+
+        if ( prctl(PR_GET_TSC, &tsc_val) == -1)
+                perror("prctl");
+
+        printf("tsc_val == %s\n", tsc_names[tsc_val]);
+        printf("rdtsc() == %llu\n", (unsigned long long)rdtsc());
+        printf("prctl(PR_SET_TSC, PR_TSC_ENABLE)\n");
+        fflush(stdout);
+
+        if ( prctl(PR_SET_TSC, PR_TSC_ENABLE) == -1)
+                perror("prctl");
+
+        printf("rdtsc() == %llu\n", (unsigned long long)rdtsc());
+        printf("prctl(PR_SET_TSC, PR_TSC_SIGSEGV)\n");
+        fflush(stdout);
+
+        if ( prctl(PR_SET_TSC, PR_TSC_SIGSEGV) == -1)
+                perror("prctl");
+
+        printf("rdtsc() == ");
+        fflush(stdout);
+        printf("%llu\n", (unsigned long long)rdtsc());
+        fflush(stdout);
+
+        exit(EXIT_SUCCESS);
+}
+
diff --git a/tools/testing/selftests/ptp/.gitignore b/tools/testing/selftests/ptp/.gitignore
new file mode 100644
index 000000000000..f562e49d6917
--- /dev/null
+++ b/tools/testing/selftests/ptp/.gitignore
@@ -0,0 +1 @@
+testptp
diff --git a/tools/testing/selftests/ptp/Makefile b/tools/testing/selftests/ptp/Makefile
new file mode 100644
index 000000000000..83dd42b2129e
--- /dev/null
+++ b/tools/testing/selftests/ptp/Makefile
@@ -0,0 +1,8 @@
+TEST_PROGS := testptp
+LDLIBS += -lrt
+all: $(TEST_PROGS)
+
+include ../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
diff --git a/tools/testing/selftests/ptp/testptp.c b/tools/testing/selftests/ptp/testptp.c
new file mode 100644
index 000000000000..5d2eae16f7ee
--- /dev/null
+++ b/tools/testing/selftests/ptp/testptp.c
@@ -0,0 +1,523 @@
+/*
+ * PTP 1588 clock support - User space test program
+ *
+ * Copyright (C) 2010 OMICRON electronics GmbH
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  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 General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#define _GNU_SOURCE
+#define __SANE_USERSPACE_TYPES__        /* For PPC64, to get LL64 types */
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <math.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/timex.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <linux/ptp_clock.h>
+
+#define DEVICE "/dev/ptp0"
+
+#ifndef ADJ_SETOFFSET
+#define ADJ_SETOFFSET 0x0100
+#endif
+
+#ifndef CLOCK_INVALID
+#define CLOCK_INVALID -1
+#endif
+
+/* clock_adjtime is not available in GLIBC < 2.14 */
+#if !__GLIBC_PREREQ(2, 14)
+#include <sys/syscall.h>
+static int clock_adjtime(clockid_t id, struct timex *tx)
+{
+        return syscall(__NR_clock_adjtime, id, tx);
+}
+#endif
+
+static clockid_t get_clockid(int fd)
+{
+#define CLOCKFD 3
+#define FD_TO_CLOCKID(fd)       ((~(clockid_t) (fd) << 3) | CLOCKFD)
+
+        return FD_TO_CLOCKID(fd);
+}
+
+static void handle_alarm(int s)
+{
+        printf("received signal %d\n", s);
+}
+
+static int install_handler(int signum, void (*handler)(int))
+{
+        struct sigaction action;
+        sigset_t mask;
+
+        /* Unblock the signal. */
+        sigemptyset(&mask);
+        sigaddset(&mask, signum);
+        sigprocmask(SIG_UNBLOCK, &mask, NULL);
+
+        /* Install the signal handler. */
+        action.sa_handler = handler;
+        action.sa_flags = 0;
+        sigemptyset(&action.sa_mask);
+        sigaction(signum, &action, NULL);
+
+        return 0;
+}
+
+static long ppb_to_scaled_ppm(int ppb)
+{
+        /*
+         * The 'freq' field in the 'struct timex' is in parts per
+         * million, but with a 16 bit binary fractional field.
+         * Instead of calculating either one of
+         *
+         *    scaled_ppm = (ppb / 1000) << 16  [1]
+         *    scaled_ppm = (ppb << 16) / 1000  [2]
+         *
+         * we simply use double precision math, in order to avoid the
+         * truncation in [1] and the possible overflow in [2].
+         */
+        return (long) (ppb * 65.536);
+}
+
+static int64_t pctns(struct ptp_clock_time *t)
+{
+        return t->sec * 1000000000LL + t->nsec;
+}
+
+static void usage(char *progname)
+{
+        fprintf(stderr,
+                "usage: %s [options]\n"
+                " -a val     request a one-shot alarm after 'val' seconds\n"
+                " -A val     request a periodic alarm every 'val' seconds\n"
+                " -c         query the ptp clock's capabilities\n"
+                " -d name    device to open\n"
+                " -e val     read 'val' external time stamp events\n"
+                " -f val     adjust the ptp clock frequency by 'val' ppb\n"
+                " -g         get the ptp clock time\n"
+                " -h         prints this message\n"
+                " -i val     index for event/trigger\n"
+                " -k val     measure the time offset between system and phc clock\n"
+                "            for 'val' times (Maximum 25)\n"
+                " -l         list the current pin configuration\n"
+                " -L pin,val configure pin index 'pin' with function 'val'\n"
+                "            the channel index is taken from the '-i' option\n"
+                "            'val' specifies the auxiliary function:\n"
+                "            0 - none\n"
+                "            1 - external time stamp\n"
+                "            2 - periodic output\n"
+                " -p val     enable output with a period of 'val' nanoseconds\n"
+                " -P val     enable or disable (val=1|0) the system clock PPS\n"
+                " -s         set the ptp clock time from the system time\n"
+                " -S         set the system time from the ptp clock time\n"
+                " -t val     shift the ptp clock time by 'val' seconds\n"
+                " -T val     set the ptp clock time to 'val' seconds\n",
+                progname);
+}
+
+int main(int argc, char *argv[])
+{
+        struct ptp_clock_caps caps;
+        struct ptp_extts_event event;
+        struct ptp_extts_request extts_request;
+        struct ptp_perout_request perout_request;
+        struct ptp_pin_desc desc;
+        struct timespec ts;
+        struct timex tx;
+
+        static timer_t timerid;
+        struct itimerspec timeout;
+        struct sigevent sigevent;
+
+        struct ptp_clock_time *pct;
+        struct ptp_sys_offset *sysoff;
+
+
+        char *progname;
+        unsigned int i;
+        int c, cnt, fd;
+
+        char *device = DEVICE;
+        clockid_t clkid;
+        int adjfreq = 0x7fffffff;
+        int adjtime = 0;
+        int capabilities = 0;
+        int extts = 0;
+        int gettime = 0;
+        int index = 0;
+        int list_pins = 0;
+        int oneshot = 0;
+        int pct_offset = 0;
+        int n_samples = 0;
+        int periodic = 0;
+        int perout = -1;
+        int pin_index = -1, pin_func;
+        int pps = -1;
+        int seconds = 0;
+        int settime = 0;
+
+        int64_t t1, t2, tp;
+        int64_t interval, offset;
+
+        progname = strrchr(argv[0], '/');
+        progname = progname ? 1+progname : argv[0];
+        while (EOF != (c = getopt(argc, argv, "a:A:cd:e:f:ghi:k:lL:p:P:sSt:T:v"))) {
+                switch (c) {
+                case 'a':
+                        oneshot = atoi(optarg);
+                        break;
+                case 'A':
+                        periodic = atoi(optarg);
+                        break;
+                case 'c':
+                        capabilities = 1;
+                        break;
+                case 'd':
+                        device = optarg;
+                        break;
+                case 'e':
+                        extts = atoi(optarg);
+                        break;
+                case 'f':
+                        adjfreq = atoi(optarg);
+                        break;
+                case 'g':
+                        gettime = 1;
+                        break;
+                case 'i':
+                        index = atoi(optarg);
+                        break;
+                case 'k':
+                        pct_offset = 1;
+                        n_samples = atoi(optarg);
+                        break;
+                case 'l':
+                        list_pins = 1;
+                        break;
+                case 'L':
+                        cnt = sscanf(optarg, "%d,%d", &pin_index, &pin_func);
+                        if (cnt != 2) {
+                                usage(progname);
+                                return -1;
+                        }
+                        break;
+                case 'p':
+                        perout = atoi(optarg);
+                        break;
+                case 'P':
+                        pps = atoi(optarg);
+                        break;
+                case 's':
+                        settime = 1;
+                        break;
+                case 'S':
+                        settime = 2;
+                        break;
+                case 't':
+                        adjtime = atoi(optarg);
+                        break;
+                case 'T':
+                        settime = 3;
+                        seconds = atoi(optarg);
+                        break;
+                case 'h':
+                        usage(progname);
+                        return 0;
+                case '?':
+                default:
+                        usage(progname);
+                        return -1;
+                }
+        }
+
+        fd = open(device, O_RDWR);
+        if (fd < 0) {
+                fprintf(stderr, "opening %s: %s\n", device, strerror(errno));
+                return -1;
+        }
+
+        clkid = get_clockid(fd);
+        if (CLOCK_INVALID == clkid) {
+                fprintf(stderr, "failed to read clock id\n");
+                return -1;
+        }
+
+        if (capabilities) {
+                if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) {
+                        perror("PTP_CLOCK_GETCAPS");
+                } else {
+                        printf("capabilities:\n"
+                               "  %d maximum frequency adjustment (ppb)\n"
+                               "  %d programmable alarms\n"
+                               "  %d external time stamp channels\n"
+                               "  %d programmable periodic signals\n"
+                               "  %d pulse per second\n"
+                               "  %d programmable pins\n"
+                               "  %d cross timestamping\n",
+                               caps.max_adj,
+                               caps.n_alarm,
+                               caps.n_ext_ts,
+                               caps.n_per_out,
+                               caps.pps,
+                               caps.n_pins,
+                               caps.cross_timestamping);
+                }
+        }
+
+        if (0x7fffffff != adjfreq) {
+                memset(&tx, 0, sizeof(tx));
+                tx.modes = ADJ_FREQUENCY;
+                tx.freq = ppb_to_scaled_ppm(adjfreq);
+                if (clock_adjtime(clkid, &tx)) {
+                        perror("clock_adjtime");
+                } else {
+                        puts("frequency adjustment okay");
+                }
+        }
+
+        if (adjtime) {
+                memset(&tx, 0, sizeof(tx));
+                tx.modes = ADJ_SETOFFSET;
+                tx.time.tv_sec = adjtime;
+                tx.time.tv_usec = 0;
+                if (clock_adjtime(clkid, &tx) < 0) {
+                        perror("clock_adjtime");
+                } else {
+                        puts("time shift okay");
+                }
+        }
+
+        if (gettime) {
+                if (clock_gettime(clkid, &ts)) {
+                        perror("clock_gettime");
+                } else {
+                        printf("clock time: %ld.%09ld or %s",
+                               ts.tv_sec, ts.tv_nsec, ctime(&ts.tv_sec));
+                }
+        }
+
+        if (settime == 1) {
+                clock_gettime(CLOCK_REALTIME, &ts);
+                if (clock_settime(clkid, &ts)) {
+                        perror("clock_settime");
+                } else {
+                        puts("set time okay");
+                }
+        }
+
+        if (settime == 2) {
+                clock_gettime(clkid, &ts);
+                if (clock_settime(CLOCK_REALTIME, &ts)) {
+                        perror("clock_settime");
+                } else {
+                        puts("set time okay");
+                }
+        }
+
+        if (settime == 3) {
+                ts.tv_sec = seconds;
+                ts.tv_nsec = 0;
+                if (clock_settime(clkid, &ts)) {
+                        perror("clock_settime");
+                } else {
+                        puts("set time okay");
+                }
+        }
+
+        if (extts) {
+                memset(&extts_request, 0, sizeof(extts_request));
+                extts_request.index = index;
+                extts_request.flags = PTP_ENABLE_FEATURE;
+                if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
+                        perror("PTP_EXTTS_REQUEST");
+                        extts = 0;
+                } else {
+                        puts("external time stamp request okay");
+                }
+                for (; extts; extts--) {
+                        cnt = read(fd, &event, sizeof(event));
+                        if (cnt != sizeof(event)) {
+                                perror("read");
+                                break;
+                        }
+                        printf("event index %u at %lld.%09u\n", event.index,
+                               event.t.sec, event.t.nsec);
+                        fflush(stdout);
+                }
+                /* Disable the feature again. */
+                extts_request.flags = 0;
+                if (ioctl(fd, PTP_EXTTS_REQUEST, &extts_request)) {
+                        perror("PTP_EXTTS_REQUEST");
+                }
+        }
+
+        if (list_pins) {
+                int n_pins = 0;
+                if (ioctl(fd, PTP_CLOCK_GETCAPS, &caps)) {
+                        perror("PTP_CLOCK_GETCAPS");
+                } else {
+                        n_pins = caps.n_pins;
+                }
+                for (i = 0; i < n_pins; i++) {
+                        desc.index = i;
+                        if (ioctl(fd, PTP_PIN_GETFUNC, &desc)) {
+                                perror("PTP_PIN_GETFUNC");
+                                break;
+                        }
+                        printf("name %s index %u func %u chan %u\n",
+                               desc.name, desc.index, desc.func, desc.chan);
+                }
+        }
+
+        if (oneshot) {
+                install_handler(SIGALRM, handle_alarm);
+                /* Create a timer. */
+                sigevent.sigev_notify = SIGEV_SIGNAL;
+                sigevent.sigev_signo = SIGALRM;
+                if (timer_create(clkid, &sigevent, &timerid)) {
+                        perror("timer_create");
+                        return -1;
+                }
+                /* Start the timer. */
+                memset(&timeout, 0, sizeof(timeout));
+                timeout.it_value.tv_sec = oneshot;
+                if (timer_settime(timerid, 0, &timeout, NULL)) {
+                        perror("timer_settime");
+                        return -1;
+                }
+                pause();
+                timer_delete(timerid);
+        }
+
+        if (periodic) {
+                install_handler(SIGALRM, handle_alarm);
+                /* Create a timer. */
+                sigevent.sigev_notify = SIGEV_SIGNAL;
+                sigevent.sigev_signo = SIGALRM;
+                if (timer_create(clkid, &sigevent, &timerid)) {
+                        perror("timer_create");
+                        return -1;
+                }
+                /* Start the timer. */
+                memset(&timeout, 0, sizeof(timeout));
+                timeout.it_interval.tv_sec = periodic;
+                timeout.it_value.tv_sec = periodic;
+                if (timer_settime(timerid, 0, &timeout, NULL)) {
+                        perror("timer_settime");
+                        return -1;
+                }
+                while (1) {
+                        pause();
+                }
+                timer_delete(timerid);
+        }
+
+        if (perout >= 0) {
+                if (clock_gettime(clkid, &ts)) {
+                        perror("clock_gettime");
+                        return -1;
+                }
+                memset(&perout_request, 0, sizeof(perout_request));
+                perout_request.index = index;
+                perout_request.start.sec = ts.tv_sec + 2;
+                perout_request.start.nsec = 0;
+                perout_request.period.sec = 0;
+                perout_request.period.nsec = perout;
+                if (ioctl(fd, PTP_PEROUT_REQUEST, &perout_request)) {
+                        perror("PTP_PEROUT_REQUEST");
+                } else {
+                        puts("periodic output request okay");
+                }
+        }
+
+        if (pin_index >= 0) {
+                memset(&desc, 0, sizeof(desc));
+                desc.index = pin_index;
+                desc.func = pin_func;
+                desc.chan = index;
+                if (ioctl(fd, PTP_PIN_SETFUNC, &desc)) {
+                        perror("PTP_PIN_SETFUNC");
+                } else {
+                        puts("set pin function okay");
+                }
+        }
+
+        if (pps != -1) {
+                int enable = pps ? 1 : 0;
+                if (ioctl(fd, PTP_ENABLE_PPS, enable)) {
+                        perror("PTP_ENABLE_PPS");
+                } else {
+                        puts("pps for system time request okay");
+                }
+        }
+
+        if (pct_offset) {
+                if (n_samples <= 0 || n_samples > 25) {
+                        puts("n_samples should be between 1 and 25");
+                        usage(progname);
+                        return -1;
+                }
+
+                sysoff = calloc(1, sizeof(*sysoff));
+                if (!sysoff) {
+                        perror("calloc");
+                        return -1;
+                }
+                sysoff->n_samples = n_samples;
+
+                if (ioctl(fd, PTP_SYS_OFFSET, sysoff))
+                        perror("PTP_SYS_OFFSET");
+                else
+                        puts("system and phc clock time offset request okay");
+
+                pct = &sysoff->ts[0];
+                for (i = 0; i < sysoff->n_samples; i++) {
+                        t1 = pctns(pct+2*i);
+                        tp = pctns(pct+2*i+1);
+                        t2 = pctns(pct+2*i+2);
+                        interval = t2 - t1;
+                        offset = (t2 + t1) / 2 - tp;
+
+                        printf("system time: %lld.%u\n",
+                                (pct+2*i)->sec, (pct+2*i)->nsec);
+                        printf("phc    time: %lld.%u\n",
+                                (pct+2*i+1)->sec, (pct+2*i+1)->nsec);
+                        printf("system time: %lld.%u\n",
+                                (pct+2*i+2)->sec, (pct+2*i+2)->nsec);
+                        printf("system/phc clock time offset is %" PRId64 " ns\n"
+                               "system     clock time delay  is %" PRId64 " ns\n",
+                                offset, interval);
+                }
+
+                free(sysoff);
+        }
+
+        close(fd);
+        return 0;
+}
diff --git a/tools/testing/selftests/ptp/testptp.mk b/tools/testing/selftests/ptp/testptp.mk
new file mode 100644
index 000000000000..4ef2d9755421
--- /dev/null
+++ b/tools/testing/selftests/ptp/testptp.mk
@@ -0,0 +1,33 @@
+# PTP 1588 clock support - User space test program
+#
+# Copyright (C) 2010 OMICRON electronics GmbH
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+CC        = $(CROSS_COMPILE)gcc
+INC       = -I$(KBUILD_OUTPUT)/usr/include
+CFLAGS    = -Wall $(INC)
+LDLIBS    = -lrt
+PROGS     = testptp
+
+all: $(PROGS)
+
+testptp: testptp.o
+
+clean:
+        rm -f testptp.o
+
+distclean: clean
+        rm -f $(PROGS)
diff --git a/tools/testing/selftests/rcutorture/bin/functions.sh b/tools/testing/selftests/rcutorture/bin/functions.sh
index b325470c01b3..1426a9b97494 100644
--- a/tools/testing/selftests/rcutorture/bin/functions.sh
+++ b/tools/testing/selftests/rcutorture/bin/functions.sh
@@ -99,8 +99,9 @@ configfrag_hotplug_cpu () {
 # identify_boot_image qemu-cmd
 #
 # Returns the relative path to the kernel build image.  This will be
-# arch/<arch>/boot/bzImage unless overridden with the TORTURE_BOOT_IMAGE
-# environment variable.
+# arch/<arch>/boot/bzImage or vmlinux if bzImage is not a target for the
+# architecture, unless overridden with the TORTURE_BOOT_IMAGE environment
+# variable.
 identify_boot_image () {
         if test -n "$TORTURE_BOOT_IMAGE"
         then
@@ -110,11 +111,8 @@ identify_boot_image () {
                 qemu-system-x86_64|qemu-system-i386)
                         echo arch/x86/boot/bzImage
                         ;;
-                qemu-system-ppc64)
-                        echo arch/powerpc/boot/bzImage
-                        ;;
                 *)
-                        echo ""
+                        echo vmlinux
                         ;;
                 esac
         fi
@@ -175,7 +173,7 @@ identify_qemu_args () {
         qemu-system-x86_64|qemu-system-i386)
                 ;;
         qemu-system-ppc64)
-                echo -enable-kvm -M pseries -cpu POWER7 -nodefaults
+                echo -enable-kvm -M pseries -nodefaults
                 echo -device spapr-vscsi
                 if test -n "$TORTURE_QEMU_INTERACTIVE" -a -n "$TORTURE_QEMU_MAC"
                 then
diff --git a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
index 4109f306d855..ea6e373edc27 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm-test-1-run.sh
@@ -8,9 +8,9 @@
 #
 # Usage: kvm-test-1-run.sh config builddir resdir seconds qemu-args boot_args
 #
-# qemu-args defaults to "-enable-kvm -soundhw pcspk -nographic", along with
-#                       arguments specifying the number of CPUs and other
-#                       options generated from the underlying CPU architecture.
+# qemu-args defaults to "-enable-kvm -nographic", along with arguments
+#                       specifying the number of CPUs and other options
+#                       generated from the underlying CPU architecture.
 # boot_args defaults to value returned by the per_version_boot_params
 #                       shell function.
 #
@@ -96,7 +96,8 @@ if test "$base_resdir" != "$resdir" -a -f $base_resdir/bzImage -a -f $base_resdi
 then
         # Rerunning previous test, so use that test's kernel.
         QEMU="`identify_qemu $base_resdir/vmlinux`"
-        KERNEL=$base_resdir/bzImage
+        BOOT_IMAGE="`identify_boot_image $QEMU`"
+        KERNEL=$base_resdir/${BOOT_IMAGE##*/} # use the last component of ${BOOT_IMAGE}
         ln -s $base_resdir/Make*.out $resdir  # for kvm-recheck.sh
         ln -s $base_resdir/.config $resdir  # for kvm-recheck.sh
 elif kvm-build.sh $config_template $builddir $T
@@ -110,7 +111,7 @@ then
         if test -n "$BOOT_IMAGE"
         then
                 cp $builddir/$BOOT_IMAGE $resdir
-                KERNEL=$resdir/bzImage
+                KERNEL=$resdir/${BOOT_IMAGE##*/}
         else
                 echo No identifiable boot image, not running KVM, see $resdir.
                 echo Do the torture scripts know about your architecture?
@@ -147,7 +148,7 @@ then
 fi
 
 # Generate -smp qemu argument.
-qemu_args="-enable-kvm -soundhw pcspk -nographic $qemu_args"
+qemu_args="-enable-kvm -nographic $qemu_args"
 cpu_count=`configNR_CPUS.sh $config_template`
 cpu_count=`configfrag_boot_cpus "$boot_args" "$config_template" "$cpu_count"`
 vcpus=`identify_qemu_vcpus`
@@ -229,6 +230,7 @@ fi
 if test $commandcompleted -eq 0 -a -n "$qemu_pid"
 then
         echo Grace period for qemu job at pid $qemu_pid
+        oldline="`tail $resdir/console.log`"
         while :
         do
                 kruntime=`awk 'BEGIN { print systime() - '"$kstarttime"' }' < /dev/null`
@@ -238,13 +240,29 @@ then
                 else
                         break
                 fi
-                if test $kruntime -ge $((seconds + $TORTURE_SHUTDOWN_GRACE))
+                must_continue=no
+                newline="`tail $resdir/console.log`"
+                if test "$newline" != "$oldline" && echo $newline | grep -q ' [0-9]\+us : '
+                then
+                        must_continue=yes
+                fi
+                last_ts="`tail $resdir/console.log | grep '^\[ *[0-9]\+\.[0-9]\+]' | tail -1 | sed -e 's/^\[ *//' -e 's/\..*$//'`"
+                if test -z "last_ts"
+                then
+                        last_ts=0
+                fi
+                if test "$newline" != "$oldline" -a "$last_ts" -lt $((seconds + $TORTURE_SHUTDOWN_GRACE))
+                then
+                        must_continue=yes
+                fi
+                if test $must_continue = no -a $kruntime -ge $((seconds + $TORTURE_SHUTDOWN_GRACE))
                 then
                         echo "!!! PID $qemu_pid hung at $kruntime vs. $seconds seconds" >> $resdir/Warnings 2>&1
                         kill -KILL $qemu_pid
                         break
                 fi
-                sleep 1
+                oldline=$newline
+                sleep 10
         done
 elif test -z "$qemu_pid"
 then
diff --git a/tools/testing/selftests/rcutorture/bin/kvm.sh b/tools/testing/selftests/rcutorture/bin/kvm.sh
index 0d598145873e..0aed965f0062 100755
--- a/tools/testing/selftests/rcutorture/bin/kvm.sh
+++ b/tools/testing/selftests/rcutorture/bin/kvm.sh
@@ -48,7 +48,7 @@ resdir=""
 configs=""
 cpus=0
 ds=`date +%Y.%m.%d-%H:%M:%S`
-jitter=0
+jitter="-1"
 
 . functions.sh
 
diff --git a/tools/testing/selftests/rcutorture/bin/parse-console.sh b/tools/testing/selftests/rcutorture/bin/parse-console.sh
index 5eb49b7f864c..08aa7d50ae0e 100755
--- a/tools/testing/selftests/rcutorture/bin/parse-console.sh
+++ b/tools/testing/selftests/rcutorture/bin/parse-console.sh
@@ -33,7 +33,7 @@ if grep -Pq '\x00' < $file
 then
         print_warning Console output contains nul bytes, old qemu still running?
 fi
-egrep 'Badness|WARNING:|Warn|BUG|===========|Call Trace:|Oops:|detected stalls on CPUs/tasks:|self-detected stall on CPU|Stall ended before state dump start|\?\?\? Writer stall state' < $file | grep -v 'ODEBUG: ' | grep -v 'Warning: unable to open an initial console' > $1.diags
+egrep 'Badness|WARNING:|Warn|BUG|===========|Call Trace:|Oops:|detected stalls on CPUs/tasks:|self-detected stall on CPU|Stall ended before state dump start|\?\?\? Writer stall state|rcu_.*kthread starved for' < $file | grep -v 'ODEBUG: ' | grep -v 'Warning: unable to open an initial console' > $1.diags
 if test -s $1.diags
 then
         print_warning Assertion failure in $file $title
@@ -69,6 +69,11 @@ then
         then
                 summary="$summary  Stalls: $n_stalls"
         fi
+        n_starves=`grep -c 'rcu_.*kthread starved for' $1`
+        if test "$n_starves" -ne 0
+        then
+                summary="$summary  Starves: $n_starves"
+        fi
         print_warning Summary: $summary
 else
         rm $1.diags
diff --git a/tools/testing/selftests/rcutorture/doc/initrd.txt b/tools/testing/selftests/rcutorture/doc/initrd.txt
index 4170e714f044..833f826d6ec2 100644
--- a/tools/testing/selftests/rcutorture/doc/initrd.txt
+++ b/tools/testing/selftests/rcutorture/doc/initrd.txt
@@ -13,6 +13,22 @@ cd initrd
 cpio -id < /tmp/initrd.img.zcat
 ------------------------------------------------------------------------
 
+Another way to create an initramfs image is using "dracut"[1], which is
+available on many distros, however the initramfs dracut generates is a cpio
+archive with another cpio archive in it, so an extra step is needed to create
+the initrd directory hierarchy.
+
+Here are the commands to create a initrd directory for rcutorture using
+dracut:
+
+------------------------------------------------------------------------
+dracut --no-hostonly --no-hostonly-cmdline --module "base bash shutdown" /tmp/initramfs.img
+cd tools/testing/selftests/rcutorture
+mkdir initrd
+cd initrd
+/usr/lib/dracut/skipcpio /tmp/initramfs.img | zcat | cpio -id < /tmp/initramfs.img
+------------------------------------------------------------------------
+
 Interestingly enough, if you are running rcutorture, you don't really
 need userspace in many cases.  Running without userspace has the
 advantage of allowing you to test your kernel independently of the
@@ -89,3 +105,9 @@ while :
 do
         sleep 10
 done
+------------------------------------------------------------------------
+
+References:
+[1]: https://dracut.wiki.kernel.org/index.php/Main_Page
+[2]: http://blog.elastocloud.org/2015/06/rapid-linux-kernel-devtest-with-qemu.html
+[3]: https://www.centos.org/forums/viewtopic.php?t=51621
diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c
index 2e58549b2f02..03f1fa495d74 100644
--- a/tools/testing/selftests/seccomp/seccomp_bpf.c
+++ b/tools/testing/selftests/seccomp/seccomp_bpf.c
@@ -1021,8 +1021,8 @@ void tracer_stop(int sig)
 typedef void tracer_func_t(struct __test_metadata *_metadata,
                            pid_t tracee, int status, void *args);
 
-void tracer(struct __test_metadata *_metadata, int fd, pid_t tracee,
-            tracer_func_t tracer_func, void *args)
+void start_tracer(struct __test_metadata *_metadata, int fd, pid_t tracee,
+            tracer_func_t tracer_func, void *args, bool ptrace_syscall)
 {
         int ret = -1;
         struct sigaction action = {
@@ -1042,12 +1042,16 @@ void tracer(struct __test_metadata *_metadata, int fd, pid_t tracee,
         /* Wait for attach stop */
         wait(NULL);
 
-        ret = ptrace(PTRACE_SETOPTIONS, tracee, NULL, PTRACE_O_TRACESECCOMP);
+        ret = ptrace(PTRACE_SETOPTIONS, tracee, NULL, ptrace_syscall ?
+                                                      PTRACE_O_TRACESYSGOOD :
+                                                      PTRACE_O_TRACESECCOMP);
         ASSERT_EQ(0, ret) {
                 TH_LOG("Failed to set PTRACE_O_TRACESECCOMP");
                 kill(tracee, SIGKILL);
         }
-        ptrace(PTRACE_CONT, tracee, NULL, 0);
+        ret = ptrace(ptrace_syscall ? PTRACE_SYSCALL : PTRACE_CONT,
+                     tracee, NULL, 0);
+        ASSERT_EQ(0, ret);
 
         /* Unblock the tracee */
         ASSERT_EQ(1, write(fd, "A", 1));
@@ -1063,12 +1067,13 @@ void tracer(struct __test_metadata *_metadata, int fd, pid_t tracee,
                         /* Child is dead. Time to go. */
                         return;
 
-                /* Make sure this is a seccomp event. */
-                ASSERT_EQ(true, IS_SECCOMP_EVENT(status));
+                /* Check if this is a seccomp event. */
+                ASSERT_EQ(!ptrace_syscall, IS_SECCOMP_EVENT(status));
 
                 tracer_func(_metadata, tracee, status, args);
 
-                ret = ptrace(PTRACE_CONT, tracee, NULL, NULL);
+                ret = ptrace(ptrace_syscall ? PTRACE_SYSCALL : PTRACE_CONT,
+                             tracee, NULL, 0);
                 ASSERT_EQ(0, ret);
         }
         /* Directly report the status of our test harness results. */
@@ -1079,7 +1084,7 @@ void tracer(struct __test_metadata *_metadata, int fd, pid_t tracee,
 void cont_handler(int num)
 { }
 pid_t setup_trace_fixture(struct __test_metadata *_metadata,
-                          tracer_func_t func, void *args)
+                          tracer_func_t func, void *args, bool ptrace_syscall)
 {
         char sync;
         int pipefd[2];
@@ -1095,7 +1100,8 @@ pid_t setup_trace_fixture(struct __test_metadata *_metadata,
         signal(SIGALRM, cont_handler);
         if (tracer_pid == 0) {
                 close(pipefd[0]);
-                tracer(_metadata, pipefd[1], tracee, func, args);
+                start_tracer(_metadata, pipefd[1], tracee, func, args,
+                             ptrace_syscall);
                 syscall(__NR_exit, 0);
         }
         close(pipefd[1]);
@@ -1177,7 +1183,7 @@ FIXTURE_SETUP(TRACE_poke)
 
         /* Launch tracer. */
         self->tracer = setup_trace_fixture(_metadata, tracer_poke,
-                                           &self->tracer_args);
+                                           &self->tracer_args, false);
 }
 
 FIXTURE_TEARDOWN(TRACE_poke)
@@ -1399,6 +1405,29 @@ void tracer_syscall(struct __test_metadata *_metadata, pid_t tracee,
 
 }
 
+void tracer_ptrace(struct __test_metadata *_metadata, pid_t tracee,
+                   int status, void *args)
+{
+        int ret, nr;
+        unsigned long msg;
+        static bool entry;
+
+        /* Make sure we got an empty message. */
+        ret = ptrace(PTRACE_GETEVENTMSG, tracee, NULL, &msg);
+        EXPECT_EQ(0, ret);
+        EXPECT_EQ(0, msg);
+
+        /* The only way to tell PTRACE_SYSCALL entry/exit is by counting. */
+        entry = !entry;
+        if (!entry)
+                return;
+
+        nr = get_syscall(_metadata, tracee);
+
+        if (nr == __NR_getpid)
+                change_syscall(_metadata, tracee, __NR_getppid);
+}
+
 FIXTURE_DATA(TRACE_syscall) {
         struct sock_fprog prog;
         pid_t tracer, mytid, mypid, parent;
@@ -1440,7 +1469,8 @@ FIXTURE_SETUP(TRACE_syscall)
         ASSERT_NE(self->parent, self->mypid);
 
         /* Launch tracer. */
-        self->tracer = setup_trace_fixture(_metadata, tracer_syscall, NULL);
+        self->tracer = setup_trace_fixture(_metadata, tracer_syscall, NULL,
+                                           false);
 }
 
 FIXTURE_TEARDOWN(TRACE_syscall)
@@ -1500,6 +1530,130 @@ TEST_F(TRACE_syscall, syscall_dropped)
         EXPECT_NE(self->mytid, syscall(__NR_gettid));
 }
 
+TEST_F(TRACE_syscall, skip_after_RET_TRACE)
+{
+        struct sock_filter filter[] = {
+                BPF_STMT(BPF_LD|BPF_W|BPF_ABS,
+                        offsetof(struct seccomp_data, nr)),
+                BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __NR_getppid, 0, 1),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ERRNO | EPERM),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)ARRAY_SIZE(filter),
+                .filter = filter,
+        };
+        long ret;
+
+        ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install fixture filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install "errno on getppid" filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Tracer will redirect getpid to getppid, and we should see EPERM. */
+        EXPECT_EQ(-1, syscall(__NR_getpid));
+        EXPECT_EQ(EPERM, errno);
+}
+
+TEST_F_SIGNAL(TRACE_syscall, kill_after_RET_TRACE, SIGSYS)
+{
+        struct sock_filter filter[] = {
+                BPF_STMT(BPF_LD|BPF_W|BPF_ABS,
+                        offsetof(struct seccomp_data, nr)),
+                BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __NR_getppid, 0, 1),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_KILL),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)ARRAY_SIZE(filter),
+                .filter = filter,
+        };
+        long ret;
+
+        ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install fixture filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install "death on getppid" filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Tracer will redirect getpid to getppid, and we should die. */
+        EXPECT_NE(self->mypid, syscall(__NR_getpid));
+}
+
+TEST_F(TRACE_syscall, skip_after_ptrace)
+{
+        struct sock_filter filter[] = {
+                BPF_STMT(BPF_LD|BPF_W|BPF_ABS,
+                        offsetof(struct seccomp_data, nr)),
+                BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __NR_getppid, 0, 1),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ERRNO | EPERM),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)ARRAY_SIZE(filter),
+                .filter = filter,
+        };
+        long ret;
+
+        /* Swap SECCOMP_RET_TRACE tracer for PTRACE_SYSCALL tracer. */
+        teardown_trace_fixture(_metadata, self->tracer);
+        self->tracer = setup_trace_fixture(_metadata, tracer_ptrace, NULL,
+                                           true);
+
+        ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install "errno on getppid" filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Tracer will redirect getpid to getppid, and we should see EPERM. */
+        EXPECT_EQ(-1, syscall(__NR_getpid));
+        EXPECT_EQ(EPERM, errno);
+}
+
+TEST_F_SIGNAL(TRACE_syscall, kill_after_ptrace, SIGSYS)
+{
+        struct sock_filter filter[] = {
+                BPF_STMT(BPF_LD|BPF_W|BPF_ABS,
+                        offsetof(struct seccomp_data, nr)),
+                BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __NR_getppid, 0, 1),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_KILL),
+                BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW),
+        };
+        struct sock_fprog prog = {
+                .len = (unsigned short)ARRAY_SIZE(filter),
+                .filter = filter,
+        };
+        long ret;
+
+        /* Swap SECCOMP_RET_TRACE tracer for PTRACE_SYSCALL tracer. */
+        teardown_trace_fixture(_metadata, self->tracer);
+        self->tracer = setup_trace_fixture(_metadata, tracer_ptrace, NULL,
+                                           true);
+
+        ret = prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Install "death on getppid" filter. */
+        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog, 0, 0);
+        ASSERT_EQ(0, ret);
+
+        /* Tracer will redirect getpid to getppid, and we should die. */
+        EXPECT_NE(self->mypid, syscall(__NR_getpid));
+}
+
 #ifndef __NR_seccomp
 # if defined(__i386__)
 #  define __NR_seccomp 354
diff --git a/tools/testing/selftests/timers/Makefile b/tools/testing/selftests/timers/Makefile
index 4a1be1b75a7f..1d5556869137 100644
--- a/tools/testing/selftests/timers/Makefile
+++ b/tools/testing/selftests/timers/Makefile
@@ -10,7 +10,7 @@ TEST_PROGS = posix_timers nanosleep nsleep-lat set-timer-lat mqueue-lat \
 
 TEST_PROGS_EXTENDED = alarmtimer-suspend valid-adjtimex adjtick change_skew \
                       skew_consistency clocksource-switch leap-a-day \
-                      leapcrash set-tai set-2038
+                      leapcrash set-tai set-2038 set-tz
 
 bins = $(TEST_PROGS) $(TEST_PROGS_EXTENDED)
 
@@ -30,6 +30,7 @@ run_destructive_tests: run_tests
         ./clocksource-switch
         ./leap-a-day -s -i 10
         ./leapcrash
+        ./set-tz
         ./set-tai
         ./set-2038
 
diff --git a/tools/testing/selftests/timers/posix_timers.c b/tools/testing/selftests/timers/posix_timers.c
index 5a246a02dff3..15cf56d32155 100644
--- a/tools/testing/selftests/timers/posix_timers.c
+++ b/tools/testing/selftests/timers/posix_timers.c
@@ -122,7 +122,7 @@ static int check_itimer(int which)
         else if (which == ITIMER_REAL)
                 idle_loop();
 
-        gettimeofday(&end, NULL);
+        err = gettimeofday(&end, NULL);
         if (err < 0) {
                 perror("Can't call gettimeofday()\n");
                 return -1;
@@ -175,7 +175,7 @@ static int check_timer_create(int which)
 
         user_loop();
 
-        gettimeofday(&end, NULL);
+        err = gettimeofday(&end, NULL);
         if (err < 0) {
                 perror("Can't call gettimeofday()\n");
                 return -1;
diff --git a/tools/testing/selftests/timers/rtctest.c b/tools/testing/selftests/timers/rtctest.c
index 624bce51b27d..4230d3052e5d 100644
--- a/tools/testing/selftests/timers/rtctest.c
+++ b/tools/testing/selftests/timers/rtctest.c
@@ -144,11 +144,12 @@ test_READ:
 
         retval = ioctl(fd, RTC_ALM_SET, &rtc_tm);
         if (retval == -1) {
-                if (errno == ENOTTY) {
+                if (errno == EINVAL) {
                         fprintf(stderr,
                                 "\n...Alarm IRQs not supported.\n");
                         goto test_PIE;
                 }
+
                 perror("RTC_ALM_SET ioctl");
                 exit(errno);
         }
@@ -166,6 +167,12 @@ test_READ:
         /* Enable alarm interrupts */
         retval = ioctl(fd, RTC_AIE_ON, 0);
         if (retval == -1) {
+                if (errno == EINVAL) {
+                        fprintf(stderr,
+                                "\n...Alarm IRQs not supported.\n");
+                        goto test_PIE;
+                }
+
                 perror("RTC_AIE_ON ioctl");
                 exit(errno);
         }
@@ -193,7 +200,7 @@ test_PIE:
         retval = ioctl(fd, RTC_IRQP_READ, &tmp);
         if (retval == -1) {
                 /* not all RTCs support periodic IRQs */
-                if (errno == ENOTTY) {
+                if (errno == EINVAL) {
                         fprintf(stderr, "\nNo periodic IRQ support\n");
                         goto done;
                 }
@@ -211,7 +218,7 @@ test_PIE:
                 retval = ioctl(fd, RTC_IRQP_SET, tmp);
                 if (retval == -1) {
                         /* not all RTCs can change their periodic IRQ rate */
-                        if (errno == ENOTTY) {
+                        if (errno == EINVAL) {
                                 fprintf(stderr,
                                         "\n...Periodic IRQ rate is fixed\n");
                                 goto done;
diff --git a/tools/testing/selftests/timers/set-tz.c b/tools/testing/selftests/timers/set-tz.c
new file mode 100644
index 000000000000..f4184928b16b
--- /dev/null
+++ b/tools/testing/selftests/timers/set-tz.c
@@ -0,0 +1,119 @@
+/* Set tz value
+ *              by: John Stultz <john.stultz@linaro.org>
+ *              (C) Copyright Linaro 2016
+ *              Licensed under the GPLv2
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   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 General Public License for more details.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <sys/time.h>
+#include <sys/timex.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#ifdef KTEST
+#include "../kselftest.h"
+#else
+static inline int ksft_exit_pass(void)
+{
+        exit(0);
+}
+static inline int ksft_exit_fail(void)
+{
+        exit(1);
+}
+#endif
+
+int set_tz(int min, int dst)
+{
+        struct timezone tz;
+
+        tz.tz_minuteswest = min;
+        tz.tz_dsttime = dst;
+
+        return settimeofday(0, &tz);
+}
+
+int get_tz_min(void)
+{
+        struct timezone tz;
+        struct timeval tv;
+
+        memset(&tz, 0, sizeof(tz));
+        gettimeofday(&tv, &tz);
+        return tz.tz_minuteswest;
+}
+
+int get_tz_dst(void)
+{
+        struct timezone tz;
+        struct timeval tv;
+
+        memset(&tz, 0, sizeof(tz));
+        gettimeofday(&tv, &tz);
+        return tz.tz_dsttime;
+}
+
+int main(int argc, char **argv)
+{
+        int i, ret;
+        int min, dst;
+
+        min = get_tz_min();
+        dst = get_tz_dst();
+        printf("tz_minuteswest started at %i, dst at %i\n", min, dst);
+
+        printf("Checking tz_minuteswest can be properly set: ");
+        for (i = -15*60; i < 15*60; i += 30) {
+                ret = set_tz(i, dst);
+                ret = get_tz_min();
+                if (ret != i) {
+                        printf("[FAILED] expected: %i got %i\n", i, ret);
+                        goto err;
+                }
+        }
+        printf("[OK]\n");
+
+        printf("Checking invalid tz_minuteswest values are caught: ");
+
+        if (!set_tz(-15*60-1, dst)) {
+                printf("[FAILED] %i didn't return failure!\n", -15*60-1);
+                goto err;
+        }
+
+        if (!set_tz(15*60+1, dst)) {
+                printf("[FAILED] %i didn't return failure!\n", 15*60+1);
+                goto err;
+        }
+
+        if (!set_tz(-24*60, dst)) {
+                printf("[FAILED] %i didn't return failure!\n", -24*60);
+                goto err;
+        }
+
+        if (!set_tz(24*60, dst)) {
+                printf("[FAILED] %i didn't return failure!\n", 24*60);
+                goto err;
+        }
+
+        printf("[OK]\n");
+
+        set_tz(min, dst);
+        return ksft_exit_pass();
+
+err:
+        set_tz(min, dst);
+        return ksft_exit_fail();
+}
diff --git a/tools/testing/selftests/vDSO/.gitignore b/tools/testing/selftests/vDSO/.gitignore
new file mode 100644
index 000000000000..133bf9ee986c
--- /dev/null
+++ b/tools/testing/selftests/vDSO/.gitignore
@@ -0,0 +1,2 @@
+vdso_test
+vdso_standalone_test_x86
diff --git a/tools/testing/selftests/vDSO/Makefile b/tools/testing/selftests/vDSO/Makefile
new file mode 100644
index 000000000000..706b68b1c372
--- /dev/null
+++ b/tools/testing/selftests/vDSO/Makefile
@@ -0,0 +1,20 @@
+ifndef CROSS_COMPILE
+CFLAGS := -std=gnu99
+CFLAGS_vdso_standalone_test_x86 := -nostdlib -fno-asynchronous-unwind-tables -fno-stack-protector
+ifeq ($(CONFIG_X86_32),y)
+LDLIBS += -lgcc_s
+endif
+
+TEST_PROGS := vdso_test vdso_standalone_test_x86
+
+all: $(TEST_PROGS)
+vdso_test: parse_vdso.c vdso_test.c
+vdso_standalone_test_x86: vdso_standalone_test_x86.c parse_vdso.c
+        $(CC) $(CFLAGS) $(CFLAGS_vdso_standalone_test_x86) \
+                vdso_standalone_test_x86.c parse_vdso.c \
+                -o vdso_standalone_test_x86
+
+include ../lib.mk
+clean:
+        rm -fr $(TEST_PROGS)
+endif
diff --git a/tools/testing/selftests/vDSO/parse_vdso.c b/tools/testing/selftests/vDSO/parse_vdso.c
new file mode 100644
index 000000000000..1dbb4b87268f
--- /dev/null
+++ b/tools/testing/selftests/vDSO/parse_vdso.c
@@ -0,0 +1,269 @@
+/*
+ * parse_vdso.c: Linux reference vDSO parser
+ * Written by Andrew Lutomirski, 2011-2014.
+ *
+ * This code is meant to be linked in to various programs that run on Linux.
+ * As such, it is available with as few restrictions as possible.  This file
+ * is licensed under the Creative Commons Zero License, version 1.0,
+ * available at http://creativecommons.org/publicdomain/zero/1.0/legalcode
+ *
+ * The vDSO is a regular ELF DSO that the kernel maps into user space when
+ * it starts a program.  It works equally well in statically and dynamically
+ * linked binaries.
+ *
+ * This code is tested on x86.  In principle it should work on any
+ * architecture that has a vDSO.
+ */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+#include <elf.h>
+
+/*
+ * To use this vDSO parser, first call one of the vdso_init_* functions.
+ * If you've already parsed auxv, then pass the value of AT_SYSINFO_EHDR
+ * to vdso_init_from_sysinfo_ehdr.  Otherwise pass auxv to vdso_init_from_auxv.
+ * Then call vdso_sym for each symbol you want.  For example, to look up
+ * gettimeofday on x86_64, use:
+ *
+ *     <some pointer> = vdso_sym("LINUX_2.6", "gettimeofday");
+ * or
+ *     <some pointer> = vdso_sym("LINUX_2.6", "__vdso_gettimeofday");
+ *
+ * vdso_sym will return 0 if the symbol doesn't exist or if the init function
+ * failed or was not called.  vdso_sym is a little slow, so its return value
+ * should be cached.
+ *
+ * vdso_sym is threadsafe; the init functions are not.
+ *
+ * These are the prototypes:
+ */
+extern void vdso_init_from_auxv(void *auxv);
+extern void vdso_init_from_sysinfo_ehdr(uintptr_t base);
+extern void *vdso_sym(const char *version, const char *name);
+
+
+/* And here's the code. */
+#ifndef ELF_BITS
+# if ULONG_MAX > 0xffffffffUL
+#  define ELF_BITS 64
+# else
+#  define ELF_BITS 32
+# endif
+#endif
+
+#define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x
+#define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x)
+#define ELF(x) ELF_BITS_XFORM(ELF_BITS, x)
+
+static struct vdso_info
+{
+        bool valid;
+
+        /* Load information */
+        uintptr_t load_addr;
+        uintptr_t load_offset;  /* load_addr - recorded vaddr */
+
+        /* Symbol table */
+        ELF(Sym) *symtab;
+        const char *symstrings;
+        ELF(Word) *bucket, *chain;
+        ELF(Word) nbucket, nchain;
+
+        /* Version table */
+        ELF(Versym) *versym;
+        ELF(Verdef) *verdef;
+} vdso_info;
+
+/* Straight from the ELF specification. */
+static unsigned long elf_hash(const unsigned char *name)
+{
+        unsigned long h = 0, g;
+        while (*name)
+        {
+                h = (h << 4) + *name++;
+                if (g = h & 0xf0000000)
+                        h ^= g >> 24;
+                h &= ~g;
+        }
+        return h;
+}
+
+void vdso_init_from_sysinfo_ehdr(uintptr_t base)
+{
+        size_t i;
+        bool found_vaddr = false;
+
+        vdso_info.valid = false;
+
+        vdso_info.load_addr = base;
+
+        ELF(Ehdr) *hdr = (ELF(Ehdr)*)base;
+        if (hdr->e_ident[EI_CLASS] !=
+            (ELF_BITS == 32 ? ELFCLASS32 : ELFCLASS64)) {
+                return;  /* Wrong ELF class -- check ELF_BITS */
+        }
+
+        ELF(Phdr) *pt = (ELF(Phdr)*)(vdso_info.load_addr + hdr->e_phoff);
+        ELF(Dyn) *dyn = 0;
+
+        /*
+         * We need two things from the segment table: the load offset
+         * and the dynamic table.
+         */
+        for (i = 0; i < hdr->e_phnum; i++)
+        {
+                if (pt[i].p_type == PT_LOAD && !found_vaddr) {
+                        found_vaddr = true;
+                        vdso_info.load_offset = base
+                                + (uintptr_t)pt[i].p_offset
+                                - (uintptr_t)pt[i].p_vaddr;
+                } else if (pt[i].p_type == PT_DYNAMIC) {
+                        dyn = (ELF(Dyn)*)(base + pt[i].p_offset);
+                }
+        }
+
+        if (!found_vaddr || !dyn)
+                return;  /* Failed */
+
+        /*
+         * Fish out the useful bits of the dynamic table.
+         */
+        ELF(Word) *hash = 0;
+        vdso_info.symstrings = 0;
+        vdso_info.symtab = 0;
+        vdso_info.versym = 0;
+        vdso_info.verdef = 0;
+        for (i = 0; dyn[i].d_tag != DT_NULL; i++) {
+                switch (dyn[i].d_tag) {
+                case DT_STRTAB:
+                        vdso_info.symstrings = (const char *)
+                                ((uintptr_t)dyn[i].d_un.d_ptr
+                                 + vdso_info.load_offset);
+                        break;
+                case DT_SYMTAB:
+                        vdso_info.symtab = (ELF(Sym) *)
+                                ((uintptr_t)dyn[i].d_un.d_ptr
+                                 + vdso_info.load_offset);
+                        break;
+                case DT_HASH:
+                        hash = (ELF(Word) *)
+                                ((uintptr_t)dyn[i].d_un.d_ptr
+                                 + vdso_info.load_offset);
+                        break;
+                case DT_VERSYM:
+                        vdso_info.versym = (ELF(Versym) *)
+                                ((uintptr_t)dyn[i].d_un.d_ptr
+                                 + vdso_info.load_offset);
+                        break;
+                case DT_VERDEF:
+                        vdso_info.verdef = (ELF(Verdef) *)
+                                ((uintptr_t)dyn[i].d_un.d_ptr
+                                 + vdso_info.load_offset);
+                        break;
+                }
+        }
+        if (!vdso_info.symstrings || !vdso_info.symtab || !hash)
+                return;  /* Failed */
+
+        if (!vdso_info.verdef)
+                vdso_info.versym = 0;
+
+        /* Parse the hash table header. */
+        vdso_info.nbucket = hash[0];
+        vdso_info.nchain = hash[1];
+        vdso_info.bucket = &hash[2];
+        vdso_info.chain = &hash[vdso_info.nbucket + 2];
+
+        /* That's all we need. */
+        vdso_info.valid = true;
+}
+
+static bool vdso_match_version(ELF(Versym) ver,
+                               const char *name, ELF(Word) hash)
+{
+        /*
+         * This is a helper function to check if the version indexed by
+         * ver matches name (which hashes to hash).
+         *
+         * The version definition table is a mess, and I don't know how
+         * to do this in better than linear time without allocating memory
+         * to build an index.  I also don't know why the table has
+         * variable size entries in the first place.
+         *
+         * For added fun, I can't find a comprehensible specification of how
+         * to parse all the weird flags in the table.
+         *
+         * So I just parse the whole table every time.
+         */
+
+        /* First step: find the version definition */
+        ver &= 0x7fff;  /* Apparently bit 15 means "hidden" */
+        ELF(Verdef) *def = vdso_info.verdef;
+        while(true) {
+                if ((def->vd_flags & VER_FLG_BASE) == 0
+                    && (def->vd_ndx & 0x7fff) == ver)
+                        break;
+
+                if (def->vd_next == 0)
+                        return false;  /* No definition. */
+
+                def = (ELF(Verdef) *)((char *)def + def->vd_next);
+        }
+
+        /* Now figure out whether it matches. */
+        ELF(Verdaux) *aux = (ELF(Verdaux)*)((char *)def + def->vd_aux);
+        return def->vd_hash == hash
+                && !strcmp(name, vdso_info.symstrings + aux->vda_name);
+}
+
+void *vdso_sym(const char *version, const char *name)
+{
+        unsigned long ver_hash;
+        if (!vdso_info.valid)
+                return 0;
+
+        ver_hash = elf_hash(version);
+        ELF(Word) chain = vdso_info.bucket[elf_hash(name) % vdso_info.nbucket];
+
+        for (; chain != STN_UNDEF; chain = vdso_info.chain[chain]) {
+                ELF(Sym) *sym = &vdso_info.symtab[chain];
+
+                /* Check for a defined global or weak function w/ right name. */
+                if (ELF64_ST_TYPE(sym->st_info) != STT_FUNC)
+                        continue;
+                if (ELF64_ST_BIND(sym->st_info) != STB_GLOBAL &&
+                    ELF64_ST_BIND(sym->st_info) != STB_WEAK)
+                        continue;
+                if (sym->st_shndx == SHN_UNDEF)
+                        continue;
+                if (strcmp(name, vdso_info.symstrings + sym->st_name))
+                        continue;
+
+                /* Check symbol version. */
+                if (vdso_info.versym
+                    && !vdso_match_version(vdso_info.versym[chain],
+                                           version, ver_hash))
+                        continue;
+
+                return (void *)(vdso_info.load_offset + sym->st_value);
+        }
+
+        return 0;
+}
+
+void vdso_init_from_auxv(void *auxv)
+{
+        ELF(auxv_t) *elf_auxv = auxv;
+        for (int i = 0; elf_auxv[i].a_type != AT_NULL; i++)
+        {
+                if (elf_auxv[i].a_type == AT_SYSINFO_EHDR) {
+                        vdso_init_from_sysinfo_ehdr(elf_auxv[i].a_un.a_val);
+                        return;
+                }
+        }
+
+        vdso_info.valid = false;
+}
diff --git a/tools/testing/selftests/vDSO/vdso_standalone_test_x86.c b/tools/testing/selftests/vDSO/vdso_standalone_test_x86.c
new file mode 100644
index 000000000000..93b0ebf8cc38
--- /dev/null
+++ b/tools/testing/selftests/vDSO/vdso_standalone_test_x86.c
@@ -0,0 +1,128 @@
+/*
+ * vdso_test.c: Sample code to test parse_vdso.c on x86
+ * Copyright (c) 2011-2014 Andy Lutomirski
+ * Subject to the GNU General Public License, version 2
+ *
+ * You can amuse yourself by compiling with:
+ * gcc -std=gnu99 -nostdlib
+ *     -Os -fno-asynchronous-unwind-tables -flto -lgcc_s
+ *      vdso_standalone_test_x86.c parse_vdso.c
+ * to generate a small binary.  On x86_64, you can omit -lgcc_s
+ * if you want the binary to be completely standalone.
+ */
+
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <stdint.h>
+
+extern void *vdso_sym(const char *version, const char *name);
+extern void vdso_init_from_sysinfo_ehdr(uintptr_t base);
+extern void vdso_init_from_auxv(void *auxv);
+
+/* We need a libc functions... */
+int strcmp(const char *a, const char *b)
+{
+        /* This implementation is buggy: it never returns -1. */
+        while (*a || *b) {
+                if (*a != *b)
+                        return 1;
+                if (*a == 0 || *b == 0)
+                        return 1;
+                a++;
+                b++;
+        }
+
+        return 0;
+}
+
+/* ...and two syscalls.  This is x86-specific. */
+static inline long x86_syscall3(long nr, long a0, long a1, long a2)
+{
+        long ret;
+#ifdef __x86_64__
+        asm volatile ("syscall" : "=a" (ret) : "a" (nr),
+                      "D" (a0), "S" (a1), "d" (a2) :
+                      "cc", "memory", "rcx",
+                      "r8", "r9", "r10", "r11" );
+#else
+        asm volatile ("int $0x80" : "=a" (ret) : "a" (nr),
+                      "b" (a0), "c" (a1), "d" (a2) :
+                      "cc", "memory" );
+#endif
+        return ret;
+}
+
+static inline long linux_write(int fd, const void *data, size_t len)
+{
+        return x86_syscall3(__NR_write, fd, (long)data, (long)len);
+}
+
+static inline void linux_exit(int code)
+{
+        x86_syscall3(__NR_exit, code, 0, 0);
+}
+
+void to_base10(char *lastdig, time_t n)
+{
+        while (n) {
+                *lastdig = (n % 10) + '0';
+                n /= 10;
+                lastdig--;
+        }
+}
+
+__attribute__((externally_visible)) void c_main(void **stack)
+{
+        /* Parse the stack */
+        long argc = (long)*stack;
+        stack += argc + 2;
+
+        /* Now we're pointing at the environment.  Skip it. */
+        while(*stack)
+                stack++;
+        stack++;
+
+        /* Now we're pointing at auxv.  Initialize the vDSO parser. */
+        vdso_init_from_auxv((void *)stack);
+
+        /* Find gettimeofday. */
+        typedef long (*gtod_t)(struct timeval *tv, struct timezone *tz);
+        gtod_t gtod = (gtod_t)vdso_sym("LINUX_2.6", "__vdso_gettimeofday");
+
+        if (!gtod)
+                linux_exit(1);
+
+        struct timeval tv;
+        long ret = gtod(&tv, 0);
+
+        if (ret == 0) {
+                char buf[] = "The time is                     .000000\n";
+                to_base10(buf + 31, tv.tv_sec);
+                to_base10(buf + 38, tv.tv_usec);
+                linux_write(1, buf, sizeof(buf) - 1);
+        } else {
+                linux_exit(ret);
+        }
+
+        linux_exit(0);
+}
+
+/*
+ * This is the real entry point.  It passes the initial stack into
+ * the C entry point.
+ */
+asm (
+        ".text\n"
+        ".global _start\n"
+        ".type _start,@function\n"
+        "_start:\n\t"
+#ifdef __x86_64__
+        "mov %rsp,%rdi\n\t"
+        "jmp c_main"
+#else
+        "push %esp\n\t"
+        "call c_main\n\t"
+        "int $3"
+#endif
+        );
diff --git a/tools/testing/selftests/vDSO/vdso_test.c b/tools/testing/selftests/vDSO/vdso_test.c
new file mode 100644
index 000000000000..8daeb7d7032c
--- /dev/null
+++ b/tools/testing/selftests/vDSO/vdso_test.c
@@ -0,0 +1,52 @@
+/*
+ * vdso_test.c: Sample code to test parse_vdso.c
+ * Copyright (c) 2014 Andy Lutomirski
+ * Subject to the GNU General Public License, version 2
+ *
+ * Compile with:
+ * gcc -std=gnu99 vdso_test.c parse_vdso.c
+ *
+ * Tested on x86, 32-bit and 64-bit.  It may work on other architectures, too.
+ */
+
+#include <stdint.h>
+#include <elf.h>
+#include <stdio.h>
+#include <sys/auxv.h>
+#include <sys/time.h>
+
+extern void *vdso_sym(const char *version, const char *name);
+extern void vdso_init_from_sysinfo_ehdr(uintptr_t base);
+extern void vdso_init_from_auxv(void *auxv);
+
+int main(int argc, char **argv)
+{
+        unsigned long sysinfo_ehdr = getauxval(AT_SYSINFO_EHDR);
+        if (!sysinfo_ehdr) {
+                printf("AT_SYSINFO_EHDR is not present!\n");
+                return 0;
+        }
+
+        vdso_init_from_sysinfo_ehdr(getauxval(AT_SYSINFO_EHDR));
+
+        /* Find gettimeofday. */
+        typedef long (*gtod_t)(struct timeval *tv, struct timezone *tz);
+        gtod_t gtod = (gtod_t)vdso_sym("LINUX_2.6", "__vdso_gettimeofday");
+
+        if (!gtod) {
+                printf("Could not find __vdso_gettimeofday\n");
+                return 1;
+        }
+
+        struct timeval tv;
+        long ret = gtod(&tv, 0);
+
+        if (ret == 0) {
+                printf("The time is %lld.%06lld\n",
+                       (long long)tv.tv_sec, (long long)tv.tv_usec);
+        } else {
+                printf("__vdso_gettimeofday failed\n");
+        }
+
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/.gitignore b/tools/testing/selftests/vm/.gitignore
index a937a9d26b60..142c565bb351 100644
--- a/tools/testing/selftests/vm/.gitignore
+++ b/tools/testing/selftests/vm/.gitignore
@@ -7,3 +7,4 @@ mlock2-tests
 on-fault-limit
 transhuge-stress
 userfaultfd
+mlock-intersect-test
diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile
index e4bb1de1d526..bbab7f4664ac 100644
--- a/tools/testing/selftests/vm/Makefile
+++ b/tools/testing/selftests/vm/Makefile
@@ -10,6 +10,7 @@ BINARIES += on-fault-limit
 BINARIES += thuge-gen
 BINARIES += transhuge-stress
 BINARIES += userfaultfd
+BINARIES += mlock-random-test
 
 all: $(BINARIES)
 %: %.c
@@ -17,6 +18,9 @@ all: $(BINARIES)
 userfaultfd: userfaultfd.c ../../../../usr/include/linux/kernel.h
         $(CC) $(CFLAGS) -O2 -o $@ $< -lpthread
 
+mlock-random-test: mlock-random-test.c
+        $(CC) $(CFLAGS) -o $@ $< -lcap
+
 ../../../../usr/include/linux/kernel.h:
         make -C ../../../.. headers_install
 
diff --git a/tools/testing/selftests/vm/compaction_test.c b/tools/testing/selftests/vm/compaction_test.c
index 932ff577ffc0..6d1437f895b8 100644
--- a/tools/testing/selftests/vm/compaction_test.c
+++ b/tools/testing/selftests/vm/compaction_test.c
@@ -101,7 +101,7 @@ int check_compaction(unsigned long mem_free, unsigned int hugepage_size)
 
         /* Start with the initial condition of 0 huge pages*/
         if (write(fd, "0", sizeof(char)) != sizeof(char)) {
-                perror("Failed to write to /proc/sys/vm/nr_hugepages\n");
+                perror("Failed to write 0 to /proc/sys/vm/nr_hugepages\n");
                 goto close_fd;
         }
 
@@ -110,14 +110,14 @@ int check_compaction(unsigned long mem_free, unsigned int hugepage_size)
         /* Request a large number of huge pages. The Kernel will allocate
            as much as it can */
         if (write(fd, "100000", (6*sizeof(char))) != (6*sizeof(char))) {
-                perror("Failed to write to /proc/sys/vm/nr_hugepages\n");
+                perror("Failed to write 100000 to /proc/sys/vm/nr_hugepages\n");
                 goto close_fd;
         }
 
         lseek(fd, 0, SEEK_SET);
 
         if (read(fd, nr_hugepages, sizeof(nr_hugepages)) <= 0) {
-                perror("Failed to read from /proc/sys/vm/nr_hugepages\n");
+                perror("Failed to re-read from /proc/sys/vm/nr_hugepages\n");
                 goto close_fd;
         }
 
@@ -136,9 +136,9 @@ int check_compaction(unsigned long mem_free, unsigned int hugepage_size)
         printf("No of huge pages allocated = %d\n",
                (atoi(nr_hugepages)));
 
-        if (write(fd, initial_nr_hugepages, sizeof(initial_nr_hugepages))
+        if (write(fd, initial_nr_hugepages, strlen(initial_nr_hugepages))
             != strlen(initial_nr_hugepages)) {
-                perror("Failed to write to /proc/sys/vm/nr_hugepages\n");
+                perror("Failed to write value to /proc/sys/vm/nr_hugepages\n");
                 goto close_fd;
         }
 
diff --git a/tools/testing/selftests/vm/mlock-random-test.c b/tools/testing/selftests/vm/mlock-random-test.c
new file mode 100644
index 000000000000..83de4f58d262
--- /dev/null
+++ b/tools/testing/selftests/vm/mlock-random-test.c
@@ -0,0 +1,293 @@
+/*
+ * It tests the mlock/mlock2() when they are invoked
+ * on randomly memory region.
+ */
+#include <unistd.h>
+#include <sys/resource.h>
+#include <sys/capability.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <time.h>
+#include "mlock2.h"
+
+#define CHUNK_UNIT (128 * 1024)
+#define MLOCK_RLIMIT_SIZE (CHUNK_UNIT * 2)
+#define MLOCK_WITHIN_LIMIT_SIZE CHUNK_UNIT
+#define MLOCK_OUTOF_LIMIT_SIZE (CHUNK_UNIT * 3)
+
+#define TEST_LOOP 100
+#define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))
+
+int set_cap_limits(rlim_t max)
+{
+        struct rlimit new;
+        cap_t cap = cap_init();
+
+        new.rlim_cur = max;
+        new.rlim_max = max;
+        if (setrlimit(RLIMIT_MEMLOCK, &new)) {
+                perror("setrlimit() returns error\n");
+                return -1;
+        }
+
+        /* drop capabilities including CAP_IPC_LOCK */
+        if (cap_set_proc(cap)) {
+                perror("cap_set_proc() returns error\n");
+                return -2;
+        }
+
+        return 0;
+}
+
+int get_proc_locked_vm_size(void)
+{
+        FILE *f;
+        int ret = -1;
+        char line[1024] = {0};
+        unsigned long lock_size = 0;
+
+        f = fopen("/proc/self/status", "r");
+        if (!f) {
+                perror("fopen");
+                return -1;
+        }
+
+        while (fgets(line, 1024, f)) {
+                if (strstr(line, "VmLck")) {
+                        ret = sscanf(line, "VmLck:\t%8lu kB", &lock_size);
+                        if (ret <= 0) {
+                                printf("sscanf() on VmLck error: %s: %d\n",
+                                                line, ret);
+                                fclose(f);
+                                return -1;
+                        }
+                        fclose(f);
+                        return (int)(lock_size << 10);
+                }
+        }
+
+        perror("cann't parse VmLck in /proc/self/status\n");
+        fclose(f);
+        return -1;
+}
+
+/*
+ * Get the MMUPageSize of the memory region including input
+ * address from proc file.
+ *
+ * return value: on error case, 0 will be returned.
+ * Otherwise the page size(in bytes) is returned.
+ */
+int get_proc_page_size(unsigned long addr)
+{
+        FILE *smaps;
+        char *line;
+        unsigned long mmupage_size = 0;
+        size_t size;
+
+        smaps = seek_to_smaps_entry(addr);
+        if (!smaps) {
+                printf("Unable to parse /proc/self/smaps\n");
+                return 0;
+        }
+
+        while (getline(&line, &size, smaps) > 0) {
+                if (!strstr(line, "MMUPageSize")) {
+                        free(line);
+                        line = NULL;
+                        size = 0;
+                        continue;
+                }
+
+                /* found the MMUPageSize of this section */
+                if (sscanf(line, "MMUPageSize:    %8lu kB",
+                                        &mmupage_size) < 1) {
+                        printf("Unable to parse smaps entry for Size:%s\n",
+                                        line);
+                        break;
+                }
+
+        }
+        free(line);
+        if (smaps)
+                fclose(smaps);
+        return mmupage_size << 10;
+}
+
+/*
+ * Test mlock/mlock2() on provided memory chunk.
+ * It expects the mlock/mlock2() to be successful (within rlimit)
+ *
+ * With allocated memory chunk [p, p + alloc_size), this
+ * test will choose start/len randomly to perform mlock/mlock2
+ * [start, start +  len] memory range. The range is within range
+ * of the allocated chunk.
+ *
+ * The memory region size alloc_size is within the rlimit.
+ * So we always expect a success of mlock/mlock2.
+ *
+ * VmLck is assumed to be 0 before this test.
+ *
+ *    return value: 0 - success
+ *    else: failure
+ */
+int test_mlock_within_limit(char *p, int alloc_size)
+{
+        int i;
+        int ret = 0;
+        int locked_vm_size = 0;
+        struct rlimit cur;
+        int page_size = 0;
+
+        getrlimit(RLIMIT_MEMLOCK, &cur);
+        if (cur.rlim_cur < alloc_size) {
+                printf("alloc_size[%d] < %u rlimit,lead to mlock failure\n",
+                                alloc_size, (unsigned int)cur.rlim_cur);
+                return -1;
+        }
+
+        srand(time(NULL));
+        for (i = 0; i < TEST_LOOP; i++) {
+                /*
+                 * - choose mlock/mlock2 randomly
+                 * - choose lock_size randomly but lock_size < alloc_size
+                 * - choose start_offset randomly but p+start_offset+lock_size
+                 *   < p+alloc_size
+                 */
+                int is_mlock = !!(rand() % 2);
+                int lock_size = rand() % alloc_size;
+                int start_offset = rand() % (alloc_size - lock_size);
+
+                if (is_mlock)
+                        ret = mlock(p + start_offset, lock_size);
+                else
+                        ret = mlock2_(p + start_offset, lock_size,
+                                       MLOCK_ONFAULT);
+
+                if (ret) {
+                        printf("%s() failure at |%p(%d)| mlock:|%p(%d)|\n",
+                                        is_mlock ? "mlock" : "mlock2",
+                                        p, alloc_size,
+                                        p + start_offset, lock_size);
+                        return ret;
+                }
+        }
+
+        /*
+         * Check VmLck left by the tests.
+         */
+        locked_vm_size = get_proc_locked_vm_size();
+        page_size = get_proc_page_size((unsigned long)p);
+        if (page_size == 0) {
+                printf("cannot get proc MMUPageSize\n");
+                return -1;
+        }
+
+        if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size) {
+                printf("test_mlock_within_limit() left VmLck:%d on %d chunk\n",
+                                locked_vm_size, alloc_size);
+                return -1;
+        }
+
+        return 0;
+}
+
+
+/*
+ * We expect the mlock/mlock2() to be fail (outof limitation)
+ *
+ * With allocated memory chunk [p, p + alloc_size), this
+ * test will randomly choose start/len and perform mlock/mlock2
+ * on [start, start+len] range.
+ *
+ * The memory region size alloc_size is above the rlimit.
+ * And the len to be locked is higher than rlimit.
+ * So we always expect a failure of mlock/mlock2.
+ * No locked page number should be increased as a side effect.
+ *
+ *    return value: 0 - success
+ *    else: failure
+ */
+int test_mlock_outof_limit(char *p, int alloc_size)
+{
+        int i;
+        int ret = 0;
+        int locked_vm_size = 0, old_locked_vm_size = 0;
+        struct rlimit cur;
+
+        getrlimit(RLIMIT_MEMLOCK, &cur);
+        if (cur.rlim_cur >= alloc_size) {
+                printf("alloc_size[%d] >%u rlimit, violates test condition\n",
+                                alloc_size, (unsigned int)cur.rlim_cur);
+                return -1;
+        }
+
+        old_locked_vm_size = get_proc_locked_vm_size();
+        srand(time(NULL));
+        for (i = 0; i < TEST_LOOP; i++) {
+                int is_mlock = !!(rand() % 2);
+                int lock_size = (rand() % (alloc_size - cur.rlim_cur))
+                        + cur.rlim_cur;
+                int start_offset = rand() % (alloc_size - lock_size);
+
+                if (is_mlock)
+                        ret = mlock(p + start_offset, lock_size);
+                else
+                        ret = mlock2_(p + start_offset, lock_size,
+                                        MLOCK_ONFAULT);
+                if (ret == 0) {
+                        printf("%s() succeeds? on %p(%d) mlock%p(%d)\n",
+                                        is_mlock ? "mlock" : "mlock2",
+                                        p, alloc_size,
+                                        p + start_offset, lock_size);
+                        return -1;
+                }
+        }
+
+        locked_vm_size = get_proc_locked_vm_size();
+        if (locked_vm_size != old_locked_vm_size) {
+                printf("tests leads to new mlocked page: old[%d], new[%d]\n",
+                                old_locked_vm_size,
+                                locked_vm_size);
+                return -1;
+        }
+
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        char *p = NULL;
+        int ret = 0;
+
+        if (set_cap_limits(MLOCK_RLIMIT_SIZE))
+                return -1;
+
+        p = malloc(MLOCK_WITHIN_LIMIT_SIZE);
+        if (p == NULL) {
+                perror("malloc() failure\n");
+                return -1;
+        }
+        ret = test_mlock_within_limit(p, MLOCK_WITHIN_LIMIT_SIZE);
+        if (ret)
+                return ret;
+        munlock(p, MLOCK_WITHIN_LIMIT_SIZE);
+        free(p);
+
+
+        p = malloc(MLOCK_OUTOF_LIMIT_SIZE);
+        if (p == NULL) {
+                perror("malloc() failure\n");
+                return -1;
+        }
+        ret = test_mlock_outof_limit(p, MLOCK_OUTOF_LIMIT_SIZE);
+        if (ret)
+                return ret;
+        munlock(p, MLOCK_OUTOF_LIMIT_SIZE);
+        free(p);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/vm/mlock2-tests.c b/tools/testing/selftests/vm/mlock2-tests.c
index 02ca5e0177c5..ff0cda2b19c9 100644
--- a/tools/testing/selftests/vm/mlock2-tests.c
+++ b/tools/testing/selftests/vm/mlock2-tests.c
@@ -1,33 +1,12 @@
 #define _GNU_SOURCE
 #include <sys/mman.h>
 #include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 #include <sys/time.h>
 #include <sys/resource.h>
-#include <syscall.h>
-#include <errno.h>
 #include <stdbool.h>
-
-#ifndef MLOCK_ONFAULT
-#define MLOCK_ONFAULT 1
-#endif
-
-#ifndef MCL_ONFAULT
-#define MCL_ONFAULT (MCL_FUTURE << 1)
-#endif
-
-static int mlock2_(void *start, size_t len, int flags)
-{
-#ifdef __NR_mlock2
-        return syscall(__NR_mlock2, start, len, flags);
-#else
-        errno = ENOSYS;
-        return -1;
-#endif
-}
+#include "mlock2.h"
 
 struct vm_boundaries {
         unsigned long start;
@@ -138,46 +117,6 @@ static uint64_t get_kpageflags(unsigned long pfn)
         return flags;
 }
 
-static FILE *seek_to_smaps_entry(unsigned long addr)
-{
-        FILE *file;
-        char *line = NULL;
-        size_t size = 0;
-        unsigned long start, end;
-        char perms[5];
-        unsigned long offset;
-        char dev[32];
-        unsigned long inode;
-        char path[BUFSIZ];
-
-        file = fopen("/proc/self/smaps", "r");
-        if (!file) {
-                perror("fopen smaps");
-                _exit(1);
-        }
-
-        while (getline(&line, &size, file) > 0) {
-                if (sscanf(line, "%lx-%lx %s %lx %s %lu %s\n",
-                           &start, &end, perms, &offset, dev, &inode, path) < 6)
-                        goto next;
-
-                if (start <= addr && addr < end)
-                        goto out;
-
-next:
-                free(line);
-                line = NULL;
-                size = 0;
-        }
-
-        fclose(file);
-        file = NULL;
-
-out:
-        free(line);
-        return file;
-}
-
 #define VMFLAGS "VmFlags:"
 
 static bool is_vmflag_set(unsigned long addr, const char *vmflag)
diff --git a/tools/testing/selftests/vm/mlock2.h b/tools/testing/selftests/vm/mlock2.h
new file mode 100644
index 000000000000..7ee062929d3e
--- /dev/null
+++ b/tools/testing/selftests/vm/mlock2.h
@@ -0,0 +1,62 @@
+#include <syscall.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifndef MLOCK_ONFAULT
+#define MLOCK_ONFAULT 1
+#endif
+
+#ifndef MCL_ONFAULT
+#define MCL_ONFAULT (MCL_FUTURE << 1)
+#endif
+
+static int mlock2_(void *start, size_t len, int flags)
+{
+#ifdef __NR_mlock2
+        return syscall(__NR_mlock2, start, len, flags);
+#else
+        errno = ENOSYS;
+        return -1;
+#endif
+}
+
+static FILE *seek_to_smaps_entry(unsigned long addr)
+{
+        FILE *file;
+        char *line = NULL;
+        size_t size = 0;
+        unsigned long start, end;
+        char perms[5];
+        unsigned long offset;
+        char dev[32];
+        unsigned long inode;
+        char path[BUFSIZ];
+
+        file = fopen("/proc/self/smaps", "r");
+        if (!file) {
+                perror("fopen smaps");
+                _exit(1);
+        }
+
+        while (getline(&line, &size, file) > 0) {
+                if (sscanf(line, "%lx-%lx %s %lx %s %lu %s\n",
+                           &start, &end, perms, &offset, dev, &inode, path) < 6)
+                        goto next;
+
+                if (start <= addr && addr < end)
+                        goto out;
+
+next:
+                free(line);
+                line = NULL;
+                size = 0;
+        }
+
+        fclose(file);
+        file = NULL;
+
+out:
+        free(line);
+        return file;
+}
diff --git a/tools/testing/selftests/vm/on-fault-limit.c b/tools/testing/selftests/vm/on-fault-limit.c
index 245acccce42d..0ae458f32fdb 100644
--- a/tools/testing/selftests/vm/on-fault-limit.c
+++ b/tools/testing/selftests/vm/on-fault-limit.c
@@ -20,7 +20,7 @@ static int test_limit(void)
                 return ret;
         }
 
-        if (mlockall(MCL_CURRENT | MCL_ONFAULT | MCL_FUTURE)) {
+        if (mlockall(MCL_ONFAULT | MCL_FUTURE)) {
                 perror("mlockall");
                 return ret;
         }
diff --git a/tools/testing/selftests/watchdog/.gitignore b/tools/testing/selftests/watchdog/.gitignore
new file mode 100644
index 000000000000..5aac51575c7e
--- /dev/null
+++ b/tools/testing/selftests/watchdog/.gitignore
@@ -0,0 +1 @@
+watchdog-test
diff --git a/tools/testing/selftests/watchdog/Makefile b/tools/testing/selftests/watchdog/Makefile
new file mode 100644
index 000000000000..f863c664e3d1
--- /dev/null
+++ b/tools/testing/selftests/watchdog/Makefile
@@ -0,0 +1,8 @@
+TEST_PROGS := watchdog-test
+
+all: $(TEST_PROGS)
+
+include ../lib.mk
+
+clean:
+        rm -fr $(TEST_PROGS)
diff --git a/tools/testing/selftests/watchdog/watchdog-test.c b/tools/testing/selftests/watchdog/watchdog-test.c
new file mode 100644
index 000000000000..6983d05097e2
--- /dev/null
+++ b/tools/testing/selftests/watchdog/watchdog-test.c
@@ -0,0 +1,105 @@
+/*
+ * Watchdog Driver Test Program
+ */
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+
+int fd;
+const char v = 'V';
+
+/*
+ * This function simply sends an IOCTL to the driver, which in turn ticks
+ * the PC Watchdog card to reset its internal timer so it doesn't trigger
+ * a computer reset.
+ */
+static void keep_alive(void)
+{
+    int dummy;
+
+    printf(".");
+    ioctl(fd, WDIOC_KEEPALIVE, &dummy);
+}
+
+/*
+ * The main program.  Run the program with "-d" to disable the card,
+ * or "-e" to enable the card.
+ */
+
+static void term(int sig)
+{
+    int ret = write(fd, &v, 1);
+
+    close(fd);
+    if (ret < 0)
+        printf("\nStopping watchdog ticks failed (%d)...\n", errno);
+    else
+        printf("\nStopping watchdog ticks...\n");
+    exit(0);
+}
+
+int main(int argc, char *argv[])
+{
+    int flags;
+    unsigned int ping_rate = 1;
+    int ret;
+
+    setbuf(stdout, NULL);
+
+    fd = open("/dev/watchdog", O_WRONLY);
+
+    if (fd == -1) {
+        printf("Watchdog device not enabled.\n");
+        exit(-1);
+    }
+
+    if (argc > 1) {
+        if (!strncasecmp(argv[1], "-d", 2)) {
+            flags = WDIOS_DISABLECARD;
+            ioctl(fd, WDIOC_SETOPTIONS, &flags);
+            printf("Watchdog card disabled.\n");
+            goto end;
+        } else if (!strncasecmp(argv[1], "-e", 2)) {
+            flags = WDIOS_ENABLECARD;
+            ioctl(fd, WDIOC_SETOPTIONS, &flags);
+            printf("Watchdog card enabled.\n");
+            goto end;
+        } else if (!strncasecmp(argv[1], "-t", 2) && argv[2]) {
+            flags = atoi(argv[2]);
+            ioctl(fd, WDIOC_SETTIMEOUT, &flags);
+            printf("Watchdog timeout set to %u seconds.\n", flags);
+            goto end;
+        } else if (!strncasecmp(argv[1], "-p", 2) && argv[2]) {
+            ping_rate = strtoul(argv[2], NULL, 0);
+            printf("Watchdog ping rate set to %u seconds.\n", ping_rate);
+        } else {
+            printf("-d to disable, -e to enable, -t <n> to set " \
+                "the timeout,\n-p <n> to set the ping rate, and \n");
+            printf("run by itself to tick the card.\n");
+            goto end;
+        }
+    }
+
+    printf("Watchdog Ticking Away!\n");
+
+    signal(SIGINT, term);
+
+    while(1) {
+        keep_alive();
+        sleep(ping_rate);
+    }
+end:
+    ret = write(fd, &v, 1);
+    if (ret < 0)
+        printf("Stopping watchdog ticks failed (%d)...\n", errno);
+    close(fd);
+    return 0;
+}
diff --git a/tools/testing/selftests/x86/Makefile b/tools/testing/selftests/x86/Makefile
index c73425de3cfe..a89f80a5b711 100644
--- a/tools/testing/selftests/x86/Makefile
+++ b/tools/testing/selftests/x86/Makefile
@@ -4,8 +4,9 @@ include ../lib.mk
 
 .PHONY: all all_32 all_64 warn_32bit_failure clean
 
-TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt ptrace_syscall \
-                        check_initial_reg_state sigreturn ldt_gdt iopl
+TARGETS_C_BOTHBITS := single_step_syscall sysret_ss_attrs syscall_nt ptrace_syscall test_mremap_vdso \
+                        check_initial_reg_state sigreturn ldt_gdt iopl \
+                        protection_keys
 TARGETS_C_32BIT_ONLY := entry_from_vm86 syscall_arg_fault test_syscall_vdso unwind_vdso \
                         test_FCMOV test_FCOMI test_FISTTP \
                         vdso_restorer
diff --git a/tools/testing/selftests/x86/mpx-debug.h b/tools/testing/selftests/x86/mpx-debug.h
new file mode 100644
index 000000000000..9230981f2e12
--- /dev/null
+++ b/tools/testing/selftests/x86/mpx-debug.h
@@ -0,0 +1,14 @@
+#ifndef _MPX_DEBUG_H
+#define _MPX_DEBUG_H
+
+#ifndef DEBUG_LEVEL
+#define DEBUG_LEVEL 0
+#endif
+#define dprintf_level(level, args...) do { if(level <= DEBUG_LEVEL) printf(args); } while(0)
+#define dprintf1(args...) dprintf_level(1, args)
+#define dprintf2(args...) dprintf_level(2, args)
+#define dprintf3(args...) dprintf_level(3, args)
+#define dprintf4(args...) dprintf_level(4, args)
+#define dprintf5(args...) dprintf_level(5, args)
+
+#endif /* _MPX_DEBUG_H */
diff --git a/tools/testing/selftests/x86/mpx-dig.c b/tools/testing/selftests/x86/mpx-dig.c
new file mode 100644
index 000000000000..ce85356d7e2e
--- /dev/null
+++ b/tools/testing/selftests/x86/mpx-dig.c
@@ -0,0 +1,498 @@
+/*
+ * Written by Dave Hansen <dave.hansen@intel.com>
+ */
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <string.h>
+#include <fcntl.h>
+#include "mpx-debug.h"
+#include "mpx-mm.h"
+#include "mpx-hw.h"
+
+unsigned long bounds_dir_global;
+
+#define mpx_dig_abort() __mpx_dig_abort(__FILE__, __func__, __LINE__)
+static void inline __mpx_dig_abort(const char *file, const char *func, int line)
+{
+        fprintf(stderr, "MPX dig abort @ %s::%d in %s()\n", file, line, func);
+        printf("MPX dig abort @ %s::%d in %s()\n", file, line, func);
+        abort();
+}
+
+/*
+ * run like this (BDIR finds the probably bounds directory):
+ *
+ *      BDIR="$(cat /proc/$pid/smaps | grep -B1 2097152 \
+ *              | head -1 | awk -F- '{print $1}')";
+ *      ./mpx-dig $pid 0x$BDIR
+ *
+ * NOTE:
+ *      assumes that the only 2097152-kb VMA is the bounds dir
+ */
+
+long nr_incore(void *ptr, unsigned long size_bytes)
+{
+        int i;
+        long ret = 0;
+        long vec_len = size_bytes / PAGE_SIZE;
+        unsigned char *vec = malloc(vec_len);
+        int incore_ret;
+
+        if (!vec)
+                mpx_dig_abort();
+
+        incore_ret = mincore(ptr, size_bytes, vec);
+        if (incore_ret) {
+                printf("mincore ret: %d\n", incore_ret);
+                perror("mincore");
+                mpx_dig_abort();
+        }
+        for (i = 0; i < vec_len; i++)
+                ret += vec[i];
+        free(vec);
+        return ret;
+}
+
+int open_proc(int pid, char *file)
+{
+        static char buf[100];
+        int fd;
+
+        snprintf(&buf[0], sizeof(buf), "/proc/%d/%s", pid, file);
+        fd = open(&buf[0], O_RDONLY);
+        if (fd < 0)
+                perror(buf);
+
+        return fd;
+}
+
+struct vaddr_range {
+        unsigned long start;
+        unsigned long end;
+};
+struct vaddr_range *ranges;
+int nr_ranges_allocated;
+int nr_ranges_populated;
+int last_range = -1;
+
+int __pid_load_vaddrs(int pid)
+{
+        int ret = 0;
+        int proc_maps_fd = open_proc(pid, "maps");
+        char linebuf[10000];
+        unsigned long start;
+        unsigned long end;
+        char rest[1000];
+        FILE *f = fdopen(proc_maps_fd, "r");
+
+        if (!f)
+                mpx_dig_abort();
+        nr_ranges_populated = 0;
+        while (!feof(f)) {
+                char *readret = fgets(linebuf, sizeof(linebuf), f);
+                int parsed;
+
+                if (readret == NULL) {
+                        if (feof(f))
+                                break;
+                        mpx_dig_abort();
+                }
+
+                parsed = sscanf(linebuf, "%lx-%lx%s", &start, &end, rest);
+                if (parsed != 3)
+                        mpx_dig_abort();
+
+                dprintf4("result[%d]: %lx-%lx<->%s\n", parsed, start, end, rest);
+                if (nr_ranges_populated >= nr_ranges_allocated) {
+                        ret = -E2BIG;
+                        break;
+                }
+                ranges[nr_ranges_populated].start = start;
+                ranges[nr_ranges_populated].end = end;
+                nr_ranges_populated++;
+        }
+        last_range = -1;
+        fclose(f);
+        close(proc_maps_fd);
+        return ret;
+}
+
+int pid_load_vaddrs(int pid)
+{
+        int ret;
+
+        dprintf2("%s(%d)\n", __func__, pid);
+        if (!ranges) {
+                nr_ranges_allocated = 4;
+                ranges = malloc(nr_ranges_allocated * sizeof(ranges[0]));
+                dprintf2("%s(%d) allocated %d ranges @ %p\n", __func__, pid,
+                         nr_ranges_allocated, ranges);
+                assert(ranges != NULL);
+        }
+        do {
+                ret = __pid_load_vaddrs(pid);
+                if (!ret)
+                        break;
+                if (ret == -E2BIG) {
+                        dprintf2("%s(%d) need to realloc\n", __func__, pid);
+                        nr_ranges_allocated *= 2;
+                        ranges = realloc(ranges,
+                                        nr_ranges_allocated * sizeof(ranges[0]));
+                        dprintf2("%s(%d) allocated %d ranges @ %p\n", __func__,
+                                        pid, nr_ranges_allocated, ranges);
+                        assert(ranges != NULL);
+                        dprintf1("reallocating to hold %d ranges\n", nr_ranges_allocated);
+                }
+        } while (1);
+
+        dprintf2("%s(%d) done\n", __func__, pid);
+
+        return ret;
+}
+
+static inline int vaddr_in_range(unsigned long vaddr, struct vaddr_range *r)
+{
+        if (vaddr < r->start)
+                return 0;
+        if (vaddr >= r->end)
+                return 0;
+        return 1;
+}
+
+static inline int vaddr_mapped_by_range(unsigned long vaddr)
+{
+        int i;
+
+        if (last_range > 0 && vaddr_in_range(vaddr, &ranges[last_range]))
+                return 1;
+
+        for (i = 0; i < nr_ranges_populated; i++) {
+                struct vaddr_range *r = &ranges[i];
+
+                if (vaddr_in_range(vaddr, r))
+                        continue;
+                last_range = i;
+                return 1;
+        }
+        return 0;
+}
+
+const int bt_entry_size_bytes = sizeof(unsigned long) * 4;
+
+void *read_bounds_table_into_buf(unsigned long table_vaddr)
+{
+#ifdef MPX_DIG_STANDALONE
+        static char bt_buf[MPX_BOUNDS_TABLE_SIZE_BYTES];
+        off_t seek_ret = lseek(fd, table_vaddr, SEEK_SET);
+        if (seek_ret != table_vaddr)
+                mpx_dig_abort();
+
+        int read_ret = read(fd, &bt_buf, sizeof(bt_buf));
+        if (read_ret != sizeof(bt_buf))
+                mpx_dig_abort();
+        return &bt_buf;
+#else
+        return (void *)table_vaddr;
+#endif
+}
+
+int dump_table(unsigned long table_vaddr, unsigned long base_controlled_vaddr,
+                unsigned long bde_vaddr)
+{
+        unsigned long offset_inside_bt;
+        int nr_entries = 0;
+        int do_abort = 0;
+        char *bt_buf;
+
+        dprintf3("%s() base_controlled_vaddr: 0x%012lx bde_vaddr: 0x%012lx\n",
+                        __func__, base_controlled_vaddr, bde_vaddr);
+
+        bt_buf = read_bounds_table_into_buf(table_vaddr);
+
+        dprintf4("%s() read done\n", __func__);
+
+        for (offset_inside_bt = 0;
+             offset_inside_bt < MPX_BOUNDS_TABLE_SIZE_BYTES;
+             offset_inside_bt += bt_entry_size_bytes) {
+                unsigned long bt_entry_index;
+                unsigned long bt_entry_controls;
+                unsigned long this_bt_entry_for_vaddr;
+                unsigned long *bt_entry_buf;
+                int i;
+
+                dprintf4("%s() offset_inside_bt: 0x%lx of 0x%llx\n", __func__,
+                        offset_inside_bt, MPX_BOUNDS_TABLE_SIZE_BYTES);
+                bt_entry_buf = (void *)&bt_buf[offset_inside_bt];
+                if (!bt_buf) {
+                        printf("null bt_buf\n");
+                        mpx_dig_abort();
+                }
+                if (!bt_entry_buf) {
+                        printf("null bt_entry_buf\n");
+                        mpx_dig_abort();
+                }
+                dprintf4("%s() reading *bt_entry_buf @ %p\n", __func__,
+                                bt_entry_buf);
+                if (!bt_entry_buf[0] &&
+                    !bt_entry_buf[1] &&
+                    !bt_entry_buf[2] &&
+                    !bt_entry_buf[3])
+                        continue;
+
+                nr_entries++;
+
+                bt_entry_index = offset_inside_bt/bt_entry_size_bytes;
+                bt_entry_controls = sizeof(void *);
+                this_bt_entry_for_vaddr =
+                        base_controlled_vaddr + bt_entry_index*bt_entry_controls;
+                /*
+                 * We sign extend vaddr bits 48->63 which effectively
+                 * creates a hole in the virtual address space.
+                 * This calculation corrects for the hole.
+                 */
+                if (this_bt_entry_for_vaddr > 0x00007fffffffffffUL)
+                        this_bt_entry_for_vaddr |= 0xffff800000000000;
+
+                if (!vaddr_mapped_by_range(this_bt_entry_for_vaddr)) {
+                        printf("bt_entry_buf: %p\n", bt_entry_buf);
+                        printf("there is a bte for %lx but no mapping\n",
+                                        this_bt_entry_for_vaddr);
+                        printf("          bde   vaddr: %016lx\n", bde_vaddr);
+                        printf("base_controlled_vaddr: %016lx\n", base_controlled_vaddr);
+                        printf("          table_vaddr: %016lx\n", table_vaddr);
+                        printf("          entry vaddr: %016lx @ offset %lx\n",
+                                table_vaddr + offset_inside_bt, offset_inside_bt);
+                        do_abort = 1;
+                        mpx_dig_abort();
+                }
+                if (DEBUG_LEVEL < 4)
+                        continue;
+
+                printf("table entry[%lx]: ", offset_inside_bt);
+                for (i = 0; i < bt_entry_size_bytes; i += sizeof(unsigned long))
+                        printf("0x%016lx ", bt_entry_buf[i]);
+                printf("\n");
+        }
+        if (do_abort)
+                mpx_dig_abort();
+        dprintf4("%s() done\n",  __func__);
+        return nr_entries;
+}
+
+int search_bd_buf(char *buf, int len_bytes, unsigned long bd_offset_bytes,
+                int *nr_populated_bdes)
+{
+        unsigned long i;
+        int total_entries = 0;
+
+        dprintf3("%s(%p, %x, %lx, ...) buf end: %p\n", __func__, buf,
+                        len_bytes, bd_offset_bytes, buf + len_bytes);
+
+        for (i = 0; i < len_bytes; i += sizeof(unsigned long)) {
+                unsigned long bd_index = (bd_offset_bytes + i) / sizeof(unsigned long);
+                unsigned long *bounds_dir_entry_ptr = (unsigned long *)&buf[i];
+                unsigned long bounds_dir_entry;
+                unsigned long bd_for_vaddr;
+                unsigned long bt_start;
+                unsigned long bt_tail;
+                int nr_entries;
+
+                dprintf4("%s() loop i: %ld bounds_dir_entry_ptr: %p\n", __func__, i,
+                                bounds_dir_entry_ptr);
+
+                bounds_dir_entry = *bounds_dir_entry_ptr;
+                if (!bounds_dir_entry) {
+                        dprintf4("no bounds dir at index 0x%lx / 0x%lx "
+                                 "start at offset:%lx %lx\n", bd_index, bd_index,
+                                        bd_offset_bytes, i);
+                        continue;
+                }
+                dprintf3("found bounds_dir_entry: 0x%lx @ "
+                         "index 0x%lx buf ptr: %p\n", bounds_dir_entry, i,
+                                        &buf[i]);
+                /* mask off the enable bit: */
+                bounds_dir_entry &= ~0x1;
+                (*nr_populated_bdes)++;
+                dprintf4("nr_populated_bdes: %p\n", nr_populated_bdes);
+                dprintf4("*nr_populated_bdes: %d\n", *nr_populated_bdes);
+
+                bt_start = bounds_dir_entry;
+                bt_tail = bounds_dir_entry + MPX_BOUNDS_TABLE_SIZE_BYTES - 1;
+                if (!vaddr_mapped_by_range(bt_start)) {
+                        printf("bounds directory 0x%lx points to nowhere\n",
+                                        bounds_dir_entry);
+                        mpx_dig_abort();
+                }
+                if (!vaddr_mapped_by_range(bt_tail)) {
+                        printf("bounds directory end 0x%lx points to nowhere\n",
+                                        bt_tail);
+                        mpx_dig_abort();
+                }
+                /*
+                 * Each bounds directory entry controls 1MB of virtual address
+                 * space.  This variable is the virtual address in the process
+                 * of the beginning of the area controlled by this bounds_dir.
+                 */
+                bd_for_vaddr = bd_index * (1UL<<20);
+
+                nr_entries = dump_table(bounds_dir_entry, bd_for_vaddr,
+                                bounds_dir_global+bd_offset_bytes+i);
+                total_entries += nr_entries;
+                dprintf5("dir entry[%4ld @ %p]: 0x%lx %6d entries "
+                         "total this buf: %7d bd_for_vaddrs: 0x%lx -> 0x%lx\n",
+                                bd_index, buf+i,
+                                bounds_dir_entry, nr_entries, total_entries,
+                                bd_for_vaddr, bd_for_vaddr + (1UL<<20));
+        }
+        dprintf3("%s(%p, %x, %lx, ...) done\n", __func__, buf, len_bytes,
+                        bd_offset_bytes);
+        return total_entries;
+}
+
+int proc_pid_mem_fd = -1;
+
+void *fill_bounds_dir_buf_other(long byte_offset_inside_bounds_dir,
+                           long buffer_size_bytes, void *buffer)
+{
+        unsigned long seekto = bounds_dir_global + byte_offset_inside_bounds_dir;
+        int read_ret;
+        off_t seek_ret = lseek(proc_pid_mem_fd, seekto, SEEK_SET);
+
+        if (seek_ret != seekto)
+                mpx_dig_abort();
+
+        read_ret = read(proc_pid_mem_fd, buffer, buffer_size_bytes);
+        /* there shouldn't practically be short reads of /proc/$pid/mem */
+        if (read_ret != buffer_size_bytes)
+                mpx_dig_abort();
+
+        return buffer;
+}
+void *fill_bounds_dir_buf_self(long byte_offset_inside_bounds_dir,
+                           long buffer_size_bytes, void *buffer)
+
+{
+        unsigned char vec[buffer_size_bytes / PAGE_SIZE];
+        char *dig_bounds_dir_ptr =
+                (void *)(bounds_dir_global + byte_offset_inside_bounds_dir);
+        /*
+         * use mincore() to quickly find the areas of the bounds directory
+         * that have memory and thus will be worth scanning.
+         */
+        int incore_ret;
+
+        int incore = 0;
+        int i;
+
+        dprintf4("%s() dig_bounds_dir_ptr: %p\n", __func__, dig_bounds_dir_ptr);
+
+        incore_ret = mincore(dig_bounds_dir_ptr, buffer_size_bytes, &vec[0]);
+        if (incore_ret) {
+                printf("mincore ret: %d\n", incore_ret);
+                perror("mincore");
+                mpx_dig_abort();
+        }
+        for (i = 0; i < sizeof(vec); i++)
+                incore += vec[i];
+        dprintf4("%s() total incore: %d\n", __func__, incore);
+        if (!incore)
+                return NULL;
+        dprintf3("%s() total incore: %d\n", __func__, incore);
+        return dig_bounds_dir_ptr;
+}
+
+int inspect_pid(int pid)
+{
+        static int dig_nr;
+        long offset_inside_bounds_dir;
+        char bounds_dir_buf[sizeof(unsigned long) * (1UL << 15)];
+        char *dig_bounds_dir_ptr;
+        int total_entries = 0;
+        int nr_populated_bdes = 0;
+        int inspect_self;
+
+        if (getpid() == pid) {
+                dprintf4("inspecting self\n");
+                inspect_self = 1;
+        } else {
+                dprintf4("inspecting pid %d\n", pid);
+                mpx_dig_abort();
+        }
+
+        for (offset_inside_bounds_dir = 0;
+             offset_inside_bounds_dir < MPX_BOUNDS_TABLE_SIZE_BYTES;
+             offset_inside_bounds_dir += sizeof(bounds_dir_buf)) {
+                static int bufs_skipped;
+                int this_entries;
+
+                if (inspect_self) {
+                        dig_bounds_dir_ptr =
+                                fill_bounds_dir_buf_self(offset_inside_bounds_dir,
+                                                         sizeof(bounds_dir_buf),
+                                                         &bounds_dir_buf[0]);
+                } else {
+                        dig_bounds_dir_ptr =
+                                fill_bounds_dir_buf_other(offset_inside_bounds_dir,
+                                                          sizeof(bounds_dir_buf),
+                                                          &bounds_dir_buf[0]);
+                }
+                if (!dig_bounds_dir_ptr) {
+                        bufs_skipped++;
+                        continue;
+                }
+                this_entries = search_bd_buf(dig_bounds_dir_ptr,
+                                        sizeof(bounds_dir_buf),
+                                        offset_inside_bounds_dir,
+                                        &nr_populated_bdes);
+                total_entries += this_entries;
+        }
+        printf("mpx dig (%3d) complete, SUCCESS (%8d / %4d)\n", ++dig_nr,
+                        total_entries, nr_populated_bdes);
+        return total_entries + nr_populated_bdes;
+}
+
+#ifdef MPX_DIG_REMOTE
+int main(int argc, char **argv)
+{
+        int err;
+        char *c;
+        unsigned long bounds_dir_entry;
+        int pid;
+
+        printf("mpx-dig starting...\n");
+        err = sscanf(argv[1], "%d", &pid);
+        printf("parsing: '%s', err: %d\n", argv[1], err);
+        if (err != 1)
+                mpx_dig_abort();
+
+        err = sscanf(argv[2], "%lx", &bounds_dir_global);
+        printf("parsing: '%s': %d\n", argv[2], err);
+        if (err != 1)
+                mpx_dig_abort();
+
+        proc_pid_mem_fd = open_proc(pid, "mem");
+        if (proc_pid_mem_fd < 0)
+                mpx_dig_abort();
+
+        inspect_pid(pid);
+        return 0;
+}
+#endif
+
+long inspect_me(struct mpx_bounds_dir *bounds_dir)
+{
+        int pid = getpid();
+
+        pid_load_vaddrs(pid);
+        bounds_dir_global = (unsigned long)bounds_dir;
+        dprintf4("enter %s() bounds dir: %p\n", __func__, bounds_dir);
+        return inspect_pid(pid);
+}
diff --git a/tools/testing/selftests/x86/mpx-hw.h b/tools/testing/selftests/x86/mpx-hw.h
new file mode 100644
index 000000000000..093c190178a9
--- /dev/null
+++ b/tools/testing/selftests/x86/mpx-hw.h
@@ -0,0 +1,123 @@
+#ifndef _MPX_HW_H
+#define _MPX_HW_H
+
+#include <assert.h>
+
+/* Describe the MPX Hardware Layout in here */
+
+#define NR_MPX_BOUNDS_REGISTERS 4
+
+#ifdef __i386__
+
+#define MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES       16 /* 4 * 32-bits */
+#define MPX_BOUNDS_TABLE_SIZE_BYTES             (1ULL << 14) /* 16k */
+#define MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES         4
+#define MPX_BOUNDS_DIR_SIZE_BYTES               (1ULL << 22) /* 4MB */
+
+#define MPX_BOUNDS_TABLE_BOTTOM_BIT             2
+#define MPX_BOUNDS_TABLE_TOP_BIT                11
+#define MPX_BOUNDS_DIR_BOTTOM_BIT               12
+#define MPX_BOUNDS_DIR_TOP_BIT                  31
+
+#else
+
+/*
+ * Linear Address of "pointer" (LAp)
+ *   0 ->  2: ignored
+ *   3 -> 19: index in to bounds table
+ *  20 -> 47: index in to bounds directory
+ *  48 -> 63: ignored
+ */
+
+#define MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES       32
+#define MPX_BOUNDS_TABLE_SIZE_BYTES             (1ULL << 22) /* 4MB */
+#define MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES         8
+#define MPX_BOUNDS_DIR_SIZE_BYTES               (1ULL << 31) /* 2GB */
+
+#define MPX_BOUNDS_TABLE_BOTTOM_BIT             3
+#define MPX_BOUNDS_TABLE_TOP_BIT                19
+#define MPX_BOUNDS_DIR_BOTTOM_BIT               20
+#define MPX_BOUNDS_DIR_TOP_BIT                  47
+
+#endif
+
+#define MPX_BOUNDS_DIR_NR_ENTRIES       \
+        (MPX_BOUNDS_DIR_SIZE_BYTES/MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES)
+#define MPX_BOUNDS_TABLE_NR_ENTRIES     \
+        (MPX_BOUNDS_TABLE_SIZE_BYTES/MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES)
+
+#define MPX_BOUNDS_TABLE_ENTRY_VALID_BIT        0x1
+
+struct mpx_bd_entry {
+        union {
+                char x[MPX_BOUNDS_DIR_ENTRY_SIZE_BYTES];
+                void *contents[1];
+        };
+} __attribute__((packed));
+
+struct mpx_bt_entry {
+        union {
+                char x[MPX_BOUNDS_TABLE_ENTRY_SIZE_BYTES];
+                unsigned long contents[1];
+        };
+} __attribute__((packed));
+
+struct mpx_bounds_dir {
+        struct mpx_bd_entry entries[MPX_BOUNDS_DIR_NR_ENTRIES];
+} __attribute__((packed));
+
+struct mpx_bounds_table {
+        struct mpx_bt_entry entries[MPX_BOUNDS_TABLE_NR_ENTRIES];
+} __attribute__((packed));
+
+static inline unsigned long GET_BITS(unsigned long val, int bottombit, int topbit)
+{
+        int total_nr_bits = topbit - bottombit;
+        unsigned long mask = (1UL << total_nr_bits)-1;
+        return (val >> bottombit) & mask;
+}
+
+static inline unsigned long __vaddr_bounds_table_index(void *vaddr)
+{
+        return GET_BITS((unsigned long)vaddr, MPX_BOUNDS_TABLE_BOTTOM_BIT,
+                                              MPX_BOUNDS_TABLE_TOP_BIT);
+}
+
+static inline unsigned long __vaddr_bounds_directory_index(void *vaddr)
+{
+        return GET_BITS((unsigned long)vaddr, MPX_BOUNDS_DIR_BOTTOM_BIT,
+                                              MPX_BOUNDS_DIR_TOP_BIT);
+}
+
+static inline struct mpx_bd_entry *mpx_vaddr_to_bd_entry(void *vaddr,
+                struct mpx_bounds_dir *bounds_dir)
+{
+        unsigned long index = __vaddr_bounds_directory_index(vaddr);
+        return &bounds_dir->entries[index];
+}
+
+static inline int bd_entry_valid(struct mpx_bd_entry *bounds_dir_entry)
+{
+        unsigned long __bd_entry = (unsigned long)bounds_dir_entry->contents;
+        return (__bd_entry & MPX_BOUNDS_TABLE_ENTRY_VALID_BIT);
+}
+
+static inline struct mpx_bounds_table *
+__bd_entry_to_bounds_table(struct mpx_bd_entry *bounds_dir_entry)
+{
+        unsigned long __bd_entry = (unsigned long)bounds_dir_entry->contents;
+        assert(__bd_entry & MPX_BOUNDS_TABLE_ENTRY_VALID_BIT);
+        __bd_entry &= ~MPX_BOUNDS_TABLE_ENTRY_VALID_BIT;
+        return (struct mpx_bounds_table *)__bd_entry;
+}
+
+static inline struct mpx_bt_entry *
+mpx_vaddr_to_bt_entry(void *vaddr, struct mpx_bounds_dir *bounds_dir)
+{
+        struct mpx_bd_entry *bde = mpx_vaddr_to_bd_entry(vaddr, bounds_dir);
+        struct mpx_bounds_table *bt = __bd_entry_to_bounds_table(bde);
+        unsigned long index = __vaddr_bounds_table_index(vaddr);
+        return &bt->entries[index];
+}
+
+#endif /* _MPX_HW_H */
diff --git a/tools/testing/selftests/x86/mpx-mini-test.c b/tools/testing/selftests/x86/mpx-mini-test.c
new file mode 100644
index 000000000000..616ee9673339
--- /dev/null
+++ b/tools/testing/selftests/x86/mpx-mini-test.c
@@ -0,0 +1,1585 @@
+/*
+ * mpx-mini-test.c: routines to test Intel MPX (Memory Protection eXtentions)
+ *
+ * Written by:
+ * "Ren, Qiaowei" <qiaowei.ren@intel.com>
+ * "Wei, Gang" <gang.wei@intel.com>
+ * "Hansen, Dave" <dave.hansen@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2.
+ */
+
+/*
+ * 2014-12-05: Dave Hansen: fixed all of the compiler warnings, and made sure
+ *             it works on 32-bit.
+ */
+
+int inspect_every_this_many_mallocs = 100;
+int zap_all_every_this_many_mallocs = 1000;
+
+#define _GNU_SOURCE
+#define _LARGEFILE64_SOURCE
+
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <signal.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ucontext.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "mpx-hw.h"
+#include "mpx-debug.h"
+#include "mpx-mm.h"
+
+#ifndef __always_inline
+#define __always_inline inline __attribute__((always_inline)
+#endif
+
+#ifndef TEST_DURATION_SECS
+#define TEST_DURATION_SECS 3
+#endif
+
+void write_int_to(char *prefix, char *file, int int_to_write)
+{
+        char buf[100];
+        int fd = open(file, O_RDWR);
+        int len;
+        int ret;
+
+        assert(fd >= 0);
+        len = snprintf(buf, sizeof(buf), "%s%d", prefix, int_to_write);
+        assert(len >= 0);
+        assert(len < sizeof(buf));
+        ret = write(fd, buf, len);
+        assert(ret == len);
+        ret = close(fd);
+        assert(!ret);
+}
+
+void write_pid_to(char *prefix, char *file)
+{
+        write_int_to(prefix, file, getpid());
+}
+
+void trace_me(void)
+{
+/* tracing events dir */
+#define TED "/sys/kernel/debug/tracing/events/"
+/*
+        write_pid_to("common_pid=", TED "signal/filter");
+        write_pid_to("common_pid=", TED "exceptions/filter");
+        write_int_to("", TED "signal/enable", 1);
+        write_int_to("", TED "exceptions/enable", 1);
+*/
+        write_pid_to("", "/sys/kernel/debug/tracing/set_ftrace_pid");
+        write_int_to("", "/sys/kernel/debug/tracing/trace", 0);
+}
+
+#define test_failed() __test_failed(__FILE__, __LINE__)
+static void __test_failed(char *f, int l)
+{
+        fprintf(stderr, "abort @ %s::%d\n", f, l);
+        abort();
+}
+
+/* Error Printf */
+#define eprintf(args...)        fprintf(stderr, args)
+
+#ifdef __i386__
+
+/* i386 directory size is 4MB */
+#define REG_IP_IDX      REG_EIP
+#define REX_PREFIX
+
+#define XSAVE_OFFSET_IN_FPMEM   sizeof(struct _libc_fpstate)
+
+/*
+ * __cpuid() is from the Linux Kernel:
+ */
+static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
+                unsigned int *ecx, unsigned int *edx)
+{
+        /* ecx is often an input as well as an output. */
+        asm volatile(
+                "push %%ebx;"
+                "cpuid;"
+                "mov %%ebx, %1;"
+                "pop %%ebx"
+                : "=a" (*eax),
+                  "=g" (*ebx),
+                  "=c" (*ecx),
+                  "=d" (*edx)
+                : "0" (*eax), "2" (*ecx));
+}
+
+#else /* __i386__ */
+
+#define REG_IP_IDX      REG_RIP
+#define REX_PREFIX "0x48, "
+
+#define XSAVE_OFFSET_IN_FPMEM   0
+
+/*
+ * __cpuid() is from the Linux Kernel:
+ */
+static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
+                unsigned int *ecx, unsigned int *edx)
+{
+        /* ecx is often an input as well as an output. */
+        asm volatile(
+                "cpuid;"
+                : "=a" (*eax),
+                  "=b" (*ebx),
+                  "=c" (*ecx),
+                  "=d" (*edx)
+                : "0" (*eax), "2" (*ecx));
+}
+
+#endif /* !__i386__ */
+
+struct xsave_hdr_struct {
+        uint64_t xstate_bv;
+        uint64_t reserved1[2];
+        uint64_t reserved2[5];
+} __attribute__((packed));
+
+struct bndregs_struct {
+        uint64_t bndregs[8];
+} __attribute__((packed));
+
+struct bndcsr_struct {
+        uint64_t cfg_reg_u;
+        uint64_t status_reg;
+} __attribute__((packed));
+
+struct xsave_struct {
+        uint8_t fpu_sse[512];
+        struct xsave_hdr_struct xsave_hdr;
+        uint8_t ymm[256];
+        uint8_t lwp[128];
+        struct bndregs_struct bndregs;
+        struct bndcsr_struct bndcsr;
+} __attribute__((packed));
+
+uint8_t __attribute__((__aligned__(64))) buffer[4096];
+struct xsave_struct *xsave_buf = (struct xsave_struct *)buffer;
+
+uint8_t __attribute__((__aligned__(64))) test_buffer[4096];
+struct xsave_struct *xsave_test_buf = (struct xsave_struct *)test_buffer;
+
+uint64_t num_bnd_chk;
+
+static __always_inline void xrstor_state(struct xsave_struct *fx, uint64_t mask)
+{
+        uint32_t lmask = mask;
+        uint32_t hmask = mask >> 32;
+
+        asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x2f\n\t"
+                     : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
+                     :   "memory");
+}
+
+static __always_inline void xsave_state_1(void *_fx, uint64_t mask)
+{
+        uint32_t lmask = mask;
+        uint32_t hmask = mask >> 32;
+        unsigned char *fx = _fx;
+
+        asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x27\n\t"
+                     : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
+                     :   "memory");
+}
+
+static inline uint64_t xgetbv(uint32_t index)
+{
+        uint32_t eax, edx;
+
+        asm volatile(".byte 0x0f,0x01,0xd0" /* xgetbv */
+                     : "=a" (eax), "=d" (edx)
+                     : "c" (index));
+        return eax + ((uint64_t)edx << 32);
+}
+
+static uint64_t read_mpx_status_sig(ucontext_t *uctxt)
+{
+        memset(buffer, 0, sizeof(buffer));
+        memcpy(buffer,
+                (uint8_t *)uctxt->uc_mcontext.fpregs + XSAVE_OFFSET_IN_FPMEM,
+                sizeof(struct xsave_struct));
+
+        return xsave_buf->bndcsr.status_reg;
+}
+
+#include <pthread.h>
+
+static uint8_t *get_next_inst_ip(uint8_t *addr)
+{
+        uint8_t *ip = addr;
+        uint8_t sib;
+        uint8_t rm;
+        uint8_t mod;
+        uint8_t base;
+        uint8_t modrm;
+
+        /* determine the prefix. */
+        switch(*ip) {
+        case 0xf2:
+        case 0xf3:
+        case 0x66:
+                ip++;
+                break;
+        }
+
+        /* look for rex prefix */
+        if ((*ip & 0x40) == 0x40)
+                ip++;
+
+        /* Make sure we have a MPX instruction. */
+        if (*ip++ != 0x0f)
+                return addr;
+
+        /* Skip the op code byte. */
+        ip++;
+
+        /* Get the modrm byte. */
+        modrm = *ip++;
+
+        /* Break it down into parts. */
+        rm = modrm & 7;
+        mod = (modrm >> 6);
+
+        /* Init the parts of the address mode. */
+        base = 8;
+
+        /* Is it a mem mode? */
+        if (mod != 3) {
+                /* look for scaled indexed addressing */
+                if (rm == 4) {
+                        /* SIB addressing */
+                        sib = *ip++;
+                        base = sib & 7;
+                        switch (mod) {
+                        case 0:
+                                if (base == 5)
+                                        ip += 4;
+                                break;
+
+                        case 1:
+                                ip++;
+                                break;
+
+                        case 2:
+                                ip += 4;
+                                break;
+                        }
+
+                } else {
+                        /* MODRM addressing */
+                        switch (mod) {
+                        case 0:
+                                /* DISP32 addressing, no base */
+                                if (rm == 5)
+                                        ip += 4;
+                                break;
+
+                        case 1:
+                                ip++;
+                                break;
+
+                        case 2:
+                                ip += 4;
+                                break;
+                        }
+                }
+        }
+        return ip;
+}
+
+#ifdef si_lower
+static inline void *__si_bounds_lower(siginfo_t *si)
+{
+        return si->si_lower;
+}
+
+static inline void *__si_bounds_upper(siginfo_t *si)
+{
+        return si->si_upper;
+}
+#else
+static inline void **__si_bounds_hack(siginfo_t *si)
+{
+        void *sigfault = &si->_sifields._sigfault;
+        void *end_sigfault = sigfault + sizeof(si->_sifields._sigfault);
+        void **__si_lower = end_sigfault;
+
+        return __si_lower;
+}
+
+static inline void *__si_bounds_lower(siginfo_t *si)
+{
+        return *__si_bounds_hack(si);
+}
+
+static inline void *__si_bounds_upper(siginfo_t *si)
+{
+        return (*__si_bounds_hack(si)) + sizeof(void *);
+}
+#endif
+
+static int br_count;
+static int expected_bnd_index = -1;
+uint64_t shadow_plb[NR_MPX_BOUNDS_REGISTERS][2]; /* shadow MPX bound registers */
+unsigned long shadow_map[NR_MPX_BOUNDS_REGISTERS];
+
+/*
+ * The kernel is supposed to provide some information about the bounds
+ * exception in the siginfo.  It should match what we have in the bounds
+ * registers that we are checking against.  Just check against the shadow copy
+ * since it is easily available, and we also check that *it* matches the real
+ * registers.
+ */
+void check_siginfo_vs_shadow(siginfo_t* si)
+{
+        int siginfo_ok = 1;
+        void *shadow_lower = (void *)(unsigned long)shadow_plb[expected_bnd_index][0];
+        void *shadow_upper = (void *)(unsigned long)shadow_plb[expected_bnd_index][1];
+
+        if ((expected_bnd_index < 0) ||
+            (expected_bnd_index >= NR_MPX_BOUNDS_REGISTERS)) {
+                fprintf(stderr, "ERROR: invalid expected_bnd_index: %d\n",
+                        expected_bnd_index);
+                exit(6);
+        }
+        if (__si_bounds_lower(si) != shadow_lower)
+                siginfo_ok = 0;
+        if (__si_bounds_upper(si) != shadow_upper)
+                siginfo_ok = 0;
+
+        if (!siginfo_ok) {
+                fprintf(stderr, "ERROR: siginfo bounds do not match "
+                        "shadow bounds for register %d\n", expected_bnd_index);
+                exit(7);
+        }
+}
+
+void handler(int signum, siginfo_t *si, void *vucontext)
+{
+        int i;
+        ucontext_t *uctxt = vucontext;
+        int trapno;
+        unsigned long ip;
+
+        dprintf1("entered signal handler\n");
+
+        trapno = uctxt->uc_mcontext.gregs[REG_TRAPNO];
+        ip = uctxt->uc_mcontext.gregs[REG_IP_IDX];
+
+        if (trapno == 5) {
+                typeof(si->si_addr) *si_addr_ptr = &si->si_addr;
+                uint64_t status = read_mpx_status_sig(uctxt);
+                uint64_t br_reason =  status & 0x3;
+
+                br_count++;
+                dprintf1("#BR 0x%jx (total seen: %d)\n", status, br_count);
+
+#define __SI_FAULT      (3 << 16)
+#define SEGV_BNDERR     (__SI_FAULT|3)  /* failed address bound checks */
+
+                dprintf2("Saw a #BR! status 0x%jx at %016lx br_reason: %jx\n",
+                                status, ip, br_reason);
+                dprintf2("si_signo: %d\n", si->si_signo);
+                dprintf2("  signum: %d\n", signum);
+                dprintf2("info->si_code == SEGV_BNDERR: %d\n",
+                                (si->si_code == SEGV_BNDERR));
+                dprintf2("info->si_code: %d\n", si->si_code);
+                dprintf2("info->si_lower: %p\n", __si_bounds_lower(si));
+                dprintf2("info->si_upper: %p\n", __si_bounds_upper(si));
+
+                check_siginfo_vs_shadow(si);
+
+                for (i = 0; i < 8; i++)
+                        dprintf3("[%d]: %p\n", i, si_addr_ptr[i]);
+                switch (br_reason) {
+                case 0: /* traditional BR */
+                        fprintf(stderr,
+                                "Undefined status with bound exception:%jx\n",
+                                 status);
+                        exit(5);
+                case 1: /* #BR MPX bounds exception */
+                        /* these are normal and we expect to see them */
+                        dprintf1("bounds exception (normal): status 0x%jx at %p si_addr: %p\n",
+                                status, (void *)ip, si->si_addr);
+                        num_bnd_chk++;
+                        uctxt->uc_mcontext.gregs[REG_IP_IDX] =
+                                (greg_t)get_next_inst_ip((uint8_t *)ip);
+                        break;
+                case 2:
+                        fprintf(stderr, "#BR status == 2, missing bounds table,"
+                                        "kernel should have handled!!\n");
+                        exit(4);
+                        break;
+                default:
+                        fprintf(stderr, "bound check error: status 0x%jx at %p\n",
+                                status, (void *)ip);
+                        num_bnd_chk++;
+                        uctxt->uc_mcontext.gregs[REG_IP_IDX] =
+                                (greg_t)get_next_inst_ip((uint8_t *)ip);
+                        fprintf(stderr, "bound check error: si_addr %p\n", si->si_addr);
+                        exit(3);
+                }
+        } else if (trapno == 14) {
+                eprintf("ERROR: In signal handler, page fault, trapno = %d, ip = %016lx\n",
+                        trapno, ip);
+                eprintf("si_addr %p\n", si->si_addr);
+                eprintf("REG_ERR: %lx\n", (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
+                test_failed();
+        } else {
+                eprintf("unexpected trap %d! at 0x%lx\n", trapno, ip);
+                eprintf("si_addr %p\n", si->si_addr);
+                eprintf("REG_ERR: %lx\n", (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
+                test_failed();
+        }
+}
+
+static inline void cpuid_count(unsigned int op, int count,
+                               unsigned int *eax, unsigned int *ebx,
+                               unsigned int *ecx, unsigned int *edx)
+{
+        *eax = op;
+        *ecx = count;
+        __cpuid(eax, ebx, ecx, edx);
+}
+
+#define XSTATE_CPUID        0x0000000d
+
+/*
+ * List of XSAVE features Linux knows about:
+ */
+enum xfeature_bit {
+        XSTATE_BIT_FP,
+        XSTATE_BIT_SSE,
+        XSTATE_BIT_YMM,
+        XSTATE_BIT_BNDREGS,
+        XSTATE_BIT_BNDCSR,
+        XSTATE_BIT_OPMASK,
+        XSTATE_BIT_ZMM_Hi256,
+        XSTATE_BIT_Hi16_ZMM,
+
+        XFEATURES_NR_MAX,
+};
+
+#define XSTATE_FP              (1 << XSTATE_BIT_FP)
+#define XSTATE_SSE            (1 << XSTATE_BIT_SSE)
+#define XSTATE_YMM            (1 << XSTATE_BIT_YMM)
+#define XSTATE_BNDREGS    (1 << XSTATE_BIT_BNDREGS)
+#define XSTATE_BNDCSR      (1 << XSTATE_BIT_BNDCSR)
+#define XSTATE_OPMASK      (1 << XSTATE_BIT_OPMASK)
+#define XSTATE_ZMM_Hi256        (1 << XSTATE_BIT_ZMM_Hi256)
+#define XSTATE_Hi16_ZMM  (1 << XSTATE_BIT_Hi16_ZMM)
+
+#define MPX_XSTATES             (XSTATE_BNDREGS | XSTATE_BNDCSR) /* 0x18 */
+
+bool one_bit(unsigned int x, int bit)
+{
+        return !!(x & (1<<bit));
+}
+
+void print_state_component(int state_bit_nr, char *name)
+{
+        unsigned int eax, ebx, ecx, edx;
+        unsigned int state_component_size;
+        unsigned int state_component_supervisor;
+        unsigned int state_component_user;
+        unsigned int state_component_aligned;
+
+        /* See SDM Section 13.2 */
+        cpuid_count(XSTATE_CPUID, state_bit_nr, &eax, &ebx, &ecx, &edx);
+        assert(eax || ebx || ecx);
+        state_component_size = eax;
+        state_component_supervisor = ((!ebx) && one_bit(ecx, 0));
+        state_component_user = !one_bit(ecx, 0);
+        state_component_aligned = one_bit(ecx, 1);
+        printf("%8s: size: %d user: %d supervisor: %d aligned: %d\n",
+                name,
+                state_component_size,       state_component_user,
+                state_component_supervisor, state_component_aligned);
+
+}
+
+/* Intel-defined CPU features, CPUID level 0x00000001 (ecx) */
+#define XSAVE_FEATURE_BIT       (26)  /* XSAVE/XRSTOR/XSETBV/XGETBV */
+#define OSXSAVE_FEATURE_BIT     (27) /* XSAVE enabled in the OS */
+
+bool check_mpx_support(void)
+{
+        unsigned int eax, ebx, ecx, edx;
+
+        cpuid_count(1, 0, &eax, &ebx, &ecx, &edx);
+
+        /* We can't do much without XSAVE, so just make these assert()'s */
+        if (!one_bit(ecx, XSAVE_FEATURE_BIT)) {
+                fprintf(stderr, "processor lacks XSAVE, can not run MPX tests\n");
+                exit(0);
+        }
+
+        if (!one_bit(ecx, OSXSAVE_FEATURE_BIT)) {
+                fprintf(stderr, "processor lacks OSXSAVE, can not run MPX tests\n");
+                exit(0);
+        }
+
+        /* CPUs not supporting the XSTATE CPUID leaf do not support MPX */
+        /* Is this redundant with the feature bit checks? */
+        cpuid_count(0, 0, &eax, &ebx, &ecx, &edx);
+        if (eax < XSTATE_CPUID) {
+                fprintf(stderr, "processor lacks XSTATE CPUID leaf,"
+                                " can not run MPX tests\n");
+                exit(0);
+        }
+
+        printf("XSAVE is supported by HW & OS\n");
+
+        cpuid_count(XSTATE_CPUID, 0, &eax, &ebx, &ecx, &edx);
+
+        printf("XSAVE processor supported state mask: 0x%x\n", eax);
+        printf("XSAVE OS supported state mask: 0x%jx\n", xgetbv(0));
+
+        /* Make sure that the MPX states are enabled in in XCR0 */
+        if ((eax & MPX_XSTATES) != MPX_XSTATES) {
+                fprintf(stderr, "processor lacks MPX XSTATE(s), can not run MPX tests\n");
+                exit(0);
+        }
+
+        /* Make sure the MPX states are supported by XSAVE* */
+        if ((xgetbv(0) & MPX_XSTATES) != MPX_XSTATES) {
+                fprintf(stderr, "MPX XSTATE(s) no enabled in XCR0, "
+                                "can not run MPX tests\n");
+                exit(0);
+        }
+
+        print_state_component(XSTATE_BIT_BNDREGS, "BNDREGS");
+        print_state_component(XSTATE_BIT_BNDCSR,  "BNDCSR");
+
+        return true;
+}
+
+void enable_mpx(void *l1base)
+{
+        /* enable point lookup */
+        memset(buffer, 0, sizeof(buffer));
+        xrstor_state(xsave_buf, 0x18);
+
+        xsave_buf->xsave_hdr.xstate_bv = 0x10;
+        xsave_buf->bndcsr.cfg_reg_u = (unsigned long)l1base | 1;
+        xsave_buf->bndcsr.status_reg = 0;
+
+        dprintf2("bf xrstor\n");
+        dprintf2("xsave cndcsr: status %jx, configu %jx\n",
+               xsave_buf->bndcsr.status_reg, xsave_buf->bndcsr.cfg_reg_u);
+        xrstor_state(xsave_buf, 0x18);
+        dprintf2("after xrstor\n");
+
+        xsave_state_1(xsave_buf, 0x18);
+
+        dprintf1("xsave bndcsr: status %jx, configu %jx\n",
+               xsave_buf->bndcsr.status_reg, xsave_buf->bndcsr.cfg_reg_u);
+}
+
+#include <sys/prctl.h>
+
+struct mpx_bounds_dir *bounds_dir_ptr;
+
+unsigned long __bd_incore(const char *func, int line)
+{
+        unsigned long ret = nr_incore(bounds_dir_ptr, MPX_BOUNDS_DIR_SIZE_BYTES);
+        return ret;
+}
+#define bd_incore() __bd_incore(__func__, __LINE__)
+
+void check_clear(void *ptr, unsigned long sz)
+{
+        unsigned long *i;
+
+        for (i = ptr; (void *)i < ptr + sz; i++) {
+                if (*i) {
+                        dprintf1("%p is NOT clear at %p\n", ptr, i);
+                        assert(0);
+                }
+        }
+        dprintf1("%p is clear for %lx\n", ptr, sz);
+}
+
+void check_clear_bd(void)
+{
+        check_clear(bounds_dir_ptr, 2UL << 30);
+}
+
+#define USE_MALLOC_FOR_BOUNDS_DIR 1
+bool process_specific_init(void)
+{
+        unsigned long size;
+        unsigned long *dir;
+        /* Guarantee we have the space to align it, add padding: */
+        unsigned long pad = getpagesize();
+
+        size = 2UL << 30; /* 2GB */
+        if (sizeof(unsigned long) == 4)
+                size = 4UL << 20; /* 4MB */
+        dprintf1("trying to allocate %ld MB bounds directory\n", (size >> 20));
+
+        if (USE_MALLOC_FOR_BOUNDS_DIR) {
+                unsigned long _dir;
+
+                dir = malloc(size + pad);
+                assert(dir);
+                _dir = (unsigned long)dir;
+                _dir += 0xfffUL;
+                _dir &= ~0xfffUL;
+                dir = (void *)_dir;
+        } else {
+                /*
+                 * This makes debugging easier because the address
+                 * calculations are simpler:
+                 */
+                dir = mmap((void *)0x200000000000, size + pad,
+                                PROT_READ|PROT_WRITE,
+                                MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+                if (dir == (void *)-1) {
+                        perror("unable to allocate bounds directory");
+                        abort();
+                }
+                check_clear(dir, size);
+        }
+        bounds_dir_ptr = (void *)dir;
+        madvise(bounds_dir_ptr, size, MADV_NOHUGEPAGE);
+        bd_incore();
+        dprintf1("bounds directory: 0x%p -> 0x%p\n", bounds_dir_ptr,
+                        (char *)bounds_dir_ptr + size);
+        check_clear(dir, size);
+        enable_mpx(dir);
+        check_clear(dir, size);
+        if (prctl(43, 0, 0, 0, 0)) {
+                printf("no MPX support\n");
+                abort();
+                return false;
+        }
+        return true;
+}
+
+bool process_specific_finish(void)
+{
+        if (prctl(44)) {
+                printf("no MPX support\n");
+                return false;
+        }
+        return true;
+}
+
+void setup_handler()
+{
+        int r, rs;
+        struct sigaction newact;
+        struct sigaction oldact;
+
+        /* #BR is mapped to sigsegv */
+        int signum  = SIGSEGV;
+
+        newact.sa_handler = 0;   /* void(*)(int)*/
+        newact.sa_sigaction = handler; /* void (*)(int, siginfo_t*, void *) */
+
+        /*sigset_t - signals to block while in the handler */
+        /* get the old signal mask. */
+        rs = sigprocmask(SIG_SETMASK, 0, &newact.sa_mask);
+        assert(rs == 0);
+
+        /* call sa_sigaction, not sa_handler*/
+        newact.sa_flags = SA_SIGINFO;
+
+        newact.sa_restorer = 0;  /* void(*)(), obsolete */
+        r = sigaction(signum, &newact, &oldact);
+        assert(r == 0);
+}
+
+void mpx_prepare(void)
+{
+        dprintf2("%s()\n", __func__);
+        setup_handler();
+        process_specific_init();
+}
+
+void mpx_cleanup(void)
+{
+        printf("%s(): %jd BRs. bye...\n", __func__, num_bnd_chk);
+        process_specific_finish();
+}
+
+/*-------------- the following is test case ---------------*/
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+uint64_t num_lower_brs;
+uint64_t num_upper_brs;
+
+#define MPX_CONFIG_OFFSET 1024
+#define MPX_BOUNDS_OFFSET 960
+#define MPX_HEADER_OFFSET 512
+#define MAX_ADDR_TESTED (1<<28)
+#define TEST_ROUNDS 100
+
+/*
+      0F 1A /r BNDLDX-Load
+      0F 1B /r BNDSTX-Store Extended Bounds Using Address Translation
+   66 0F 1A /r BNDMOV bnd1, bnd2/m128
+   66 0F 1B /r BNDMOV bnd1/m128, bnd2
+   F2 0F 1A /r BNDCU bnd, r/m64
+   F2 0F 1B /r BNDCN bnd, r/m64
+   F3 0F 1A /r BNDCL bnd, r/m64
+   F3 0F 1B /r BNDMK bnd, m64
+*/
+
+static __always_inline void xsave_state(void *_fx, uint64_t mask)
+{
+        uint32_t lmask = mask;
+        uint32_t hmask = mask >> 32;
+        unsigned char *fx = _fx;
+
+        asm volatile(".byte " REX_PREFIX "0x0f,0xae,0x27\n\t"
+                     : : "D" (fx), "m" (*fx), "a" (lmask), "d" (hmask)
+                     :   "memory");
+}
+
+static __always_inline void mpx_clear_bnd0(void)
+{
+        long size = 0;
+        void *ptr = NULL;
+        /* F3 0F 1B /r BNDMK bnd, m64                   */
+        /* f3 0f 1b 04 11    bndmk  (%rcx,%rdx,1),%bnd0 */
+        asm volatile(".byte 0xf3,0x0f,0x1b,0x04,0x11\n\t"
+                     : : "c" (ptr), "d" (size-1)
+                     :   "memory");
+}
+
+static __always_inline void mpx_make_bound_helper(unsigned long ptr,
+                unsigned long size)
+{
+        /* F3 0F 1B /r          BNDMK bnd, m64                  */
+        /* f3 0f 1b 04 11       bndmk  (%rcx,%rdx,1),%bnd0      */
+        asm volatile(".byte 0xf3,0x0f,0x1b,0x04,0x11\n\t"
+                     : : "c" (ptr), "d" (size-1)
+                     :   "memory");
+}
+
+static __always_inline void mpx_check_lowerbound_helper(unsigned long ptr)
+{
+        /* F3 0F 1A /r  NDCL bnd, r/m64                 */
+        /* f3 0f 1a 01  bndcl  (%rcx),%bnd0             */
+        asm volatile(".byte 0xf3,0x0f,0x1a,0x01\n\t"
+                     : : "c" (ptr)
+                     :   "memory");
+}
+
+static __always_inline void mpx_check_upperbound_helper(unsigned long ptr)
+{
+        /* F2 0F 1A /r  BNDCU bnd, r/m64        */
+        /* f2 0f 1a 01  bndcu  (%rcx),%bnd0     */
+        asm volatile(".byte 0xf2,0x0f,0x1a,0x01\n\t"
+                     : : "c" (ptr)
+                     :   "memory");
+}
+
+static __always_inline void mpx_movbndreg_helper()
+{
+        /* 66 0F 1B /r  BNDMOV bnd1/m128, bnd2  */
+        /* 66 0f 1b c2  bndmov %bnd0,%bnd2      */
+
+        asm volatile(".byte 0x66,0x0f,0x1b,0xc2\n\t");
+}
+
+static __always_inline void mpx_movbnd2mem_helper(uint8_t *mem)
+{
+        /* 66 0F 1B /r  BNDMOV bnd1/m128, bnd2  */
+        /* 66 0f 1b 01  bndmov %bnd0,(%rcx)     */
+        asm volatile(".byte 0x66,0x0f,0x1b,0x01\n\t"
+                     : : "c" (mem)
+                     :   "memory");
+}
+
+static __always_inline void mpx_movbnd_from_mem_helper(uint8_t *mem)
+{
+        /* 66 0F 1A /r  BNDMOV bnd1, bnd2/m128  */
+        /* 66 0f 1a 01  bndmov (%rcx),%bnd0     */
+        asm volatile(".byte 0x66,0x0f,0x1a,0x01\n\t"
+                     : : "c" (mem)
+                     :   "memory");
+}
+
+static __always_inline void mpx_store_dsc_helper(unsigned long ptr_addr,
+                unsigned long ptr_val)
+{
+        /* 0F 1B /r     BNDSTX-Store Extended Bounds Using Address Translation  */
+        /* 0f 1b 04 11  bndstx %bnd0,(%rcx,%rdx,1)                              */
+        asm volatile(".byte 0x0f,0x1b,0x04,0x11\n\t"
+                     : : "c" (ptr_addr), "d" (ptr_val)
+                     :   "memory");
+}
+
+static __always_inline void mpx_load_dsc_helper(unsigned long ptr_addr,
+                unsigned long ptr_val)
+{
+        /* 0F 1A /r     BNDLDX-Load                     */
+        /*/ 0f 1a 04 11 bndldx (%rcx,%rdx,1),%bnd0      */
+        asm volatile(".byte 0x0f,0x1a,0x04,0x11\n\t"
+                     : : "c" (ptr_addr), "d" (ptr_val)
+                     :   "memory");
+}
+
+void __print_context(void *__print_xsave_buffer, int line)
+{
+        uint64_t *bounds = (uint64_t *)(__print_xsave_buffer + MPX_BOUNDS_OFFSET);
+        uint64_t *cfg    = (uint64_t *)(__print_xsave_buffer + MPX_CONFIG_OFFSET);
+
+        int i;
+        eprintf("%s()::%d\n", "print_context", line);
+        for (i = 0; i < 4; i++) {
+                eprintf("bound[%d]: 0x%016lx 0x%016lx(0x%016lx)\n", i,
+                       (unsigned long)bounds[i*2],
+                       ~(unsigned long)bounds[i*2+1],
+                        (unsigned long)bounds[i*2+1]);
+        }
+
+        eprintf("cpcfg: %jx  cpstatus: %jx\n", cfg[0], cfg[1]);
+}
+#define print_context(x) __print_context(x, __LINE__)
+#ifdef DEBUG
+#define dprint_context(x) print_context(x)
+#else
+#define dprint_context(x) do{}while(0)
+#endif
+
+void init()
+{
+        int i;
+
+        srand((unsigned int)time(NULL));
+
+        for (i = 0; i < 4; i++) {
+                shadow_plb[i][0] = 0;
+                shadow_plb[i][1] = ~(unsigned long)0;
+        }
+}
+
+long int __mpx_random(int line)
+{
+#ifdef NOT_SO_RANDOM
+        static long fake = 722122311;
+        fake += 563792075;
+        return fakse;
+#else
+        return random();
+#endif
+}
+#define mpx_random() __mpx_random(__LINE__)
+
+uint8_t *get_random_addr()
+{
+        uint8_t*addr = (uint8_t *)(unsigned long)(rand() % MAX_ADDR_TESTED);
+        return (addr - (unsigned long)addr % sizeof(uint8_t *));
+}
+
+static inline bool compare_context(void *__xsave_buffer)
+{
+        uint64_t *bounds = (uint64_t *)(__xsave_buffer + MPX_BOUNDS_OFFSET);
+
+        int i;
+        for (i = 0; i < 4; i++) {
+                dprintf3("shadow[%d]{%016lx/%016lx}\nbounds[%d]{%016lx/%016lx}\n",
+                       i, (unsigned long)shadow_plb[i][0], (unsigned long)shadow_plb[i][1],
+                       i, (unsigned long)bounds[i*2],     ~(unsigned long)bounds[i*2+1]);
+                if ((shadow_plb[i][0] != bounds[i*2]) ||
+                    (shadow_plb[i][1] != ~(unsigned long)bounds[i*2+1])) {
+                        eprintf("ERROR comparing shadow to real bound register %d\n", i);
+                        eprintf("shadow{0x%016lx/0x%016lx}\nbounds{0x%016lx/0x%016lx}\n",
+                               (unsigned long)shadow_plb[i][0], (unsigned long)shadow_plb[i][1],
+                               (unsigned long)bounds[i*2], (unsigned long)bounds[i*2+1]);
+                        return false;
+                }
+        }
+
+        return true;
+}
+
+void mkbnd_shadow(uint8_t *ptr, int index, long offset)
+{
+        uint64_t *lower = (uint64_t *)&(shadow_plb[index][0]);
+        uint64_t *upper = (uint64_t *)&(shadow_plb[index][1]);
+        *lower = (unsigned long)ptr;
+        *upper = (unsigned long)ptr + offset - 1;
+}
+
+void check_lowerbound_shadow(uint8_t *ptr, int index)
+{
+        uint64_t *lower = (uint64_t *)&(shadow_plb[index][0]);
+        if (*lower > (uint64_t)(unsigned long)ptr)
+                num_lower_brs++;
+        else
+                dprintf1("LowerBoundChk passed:%p\n", ptr);
+}
+
+void check_upperbound_shadow(uint8_t *ptr, int index)
+{
+        uint64_t upper = *(uint64_t *)&(shadow_plb[index][1]);
+        if (upper < (uint64_t)(unsigned long)ptr)
+                num_upper_brs++;
+        else
+                dprintf1("UpperBoundChk passed:%p\n", ptr);
+}
+
+__always_inline void movbndreg_shadow(int src, int dest)
+{
+        shadow_plb[dest][0] = shadow_plb[src][0];
+        shadow_plb[dest][1] = shadow_plb[src][1];
+}
+
+__always_inline void movbnd2mem_shadow(int src, unsigned long *dest)
+{
+        unsigned long *lower = (unsigned long *)&(shadow_plb[src][0]);
+        unsigned long *upper = (unsigned long *)&(shadow_plb[src][1]);
+        *dest = *lower;
+        *(dest+1) = *upper;
+}
+
+__always_inline void movbnd_from_mem_shadow(unsigned long *src, int dest)
+{
+        unsigned long *lower = (unsigned long *)&(shadow_plb[dest][0]);
+        unsigned long *upper = (unsigned long *)&(shadow_plb[dest][1]);
+        *lower = *src;
+        *upper = *(src+1);
+}
+
+__always_inline void stdsc_shadow(int index, uint8_t *ptr, uint8_t *ptr_val)
+{
+        shadow_map[0] = (unsigned long)shadow_plb[index][0];
+        shadow_map[1] = (unsigned long)shadow_plb[index][1];
+        shadow_map[2] = (unsigned long)ptr_val;
+        dprintf3("%s(%d, %p, %p) set shadow map[2]: %p\n", __func__,
+                        index, ptr, ptr_val, ptr_val);
+        /*ptr ignored */
+}
+
+void lddsc_shadow(int index, uint8_t *ptr, uint8_t *ptr_val)
+{
+        uint64_t lower = shadow_map[0];
+        uint64_t upper = shadow_map[1];
+        uint8_t *value = (uint8_t *)shadow_map[2];
+
+        if (value != ptr_val) {
+                dprintf2("%s(%d, %p, %p) init shadow bounds[%d] "
+                         "because %p != %p\n", __func__, index, ptr,
+                         ptr_val, index, value, ptr_val);
+                shadow_plb[index][0] = 0;
+                shadow_plb[index][1] = ~(unsigned long)0;
+        } else {
+                shadow_plb[index][0] = lower;
+                shadow_plb[index][1] = upper;
+        }
+        /* ptr ignored */
+}
+
+static __always_inline void mpx_test_helper0(uint8_t *buf, uint8_t *ptr)
+{
+        mpx_make_bound_helper((unsigned long)ptr, 0x1800);
+}
+
+static __always_inline void mpx_test_helper0_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        mkbnd_shadow(ptr, 0, 0x1800);
+}
+
+static __always_inline void mpx_test_helper1(uint8_t *buf, uint8_t *ptr)
+{
+        /* these are hard-coded to check bnd0 */
+        expected_bnd_index = 0;
+        mpx_check_lowerbound_helper((unsigned long)(ptr-1));
+        mpx_check_upperbound_helper((unsigned long)(ptr+0x1800));
+        /* reset this since we do not expect any more bounds exceptions */
+        expected_bnd_index = -1;
+}
+
+static __always_inline void mpx_test_helper1_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        check_lowerbound_shadow(ptr-1, 0);
+        check_upperbound_shadow(ptr+0x1800, 0);
+}
+
+static __always_inline void mpx_test_helper2(uint8_t *buf, uint8_t *ptr)
+{
+        mpx_make_bound_helper((unsigned long)ptr, 0x1800);
+        mpx_movbndreg_helper();
+        mpx_movbnd2mem_helper(buf);
+        mpx_make_bound_helper((unsigned long)(ptr+0x12), 0x1800);
+}
+
+static __always_inline void mpx_test_helper2_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        mkbnd_shadow(ptr, 0, 0x1800);
+        movbndreg_shadow(0, 2);
+        movbnd2mem_shadow(0, (unsigned long *)buf);
+        mkbnd_shadow(ptr+0x12, 0, 0x1800);
+}
+
+static __always_inline void mpx_test_helper3(uint8_t *buf, uint8_t *ptr)
+{
+        mpx_movbnd_from_mem_helper(buf);
+}
+
+static __always_inline void mpx_test_helper3_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        movbnd_from_mem_shadow((unsigned long *)buf, 0);
+}
+
+static __always_inline void mpx_test_helper4(uint8_t *buf, uint8_t *ptr)
+{
+        mpx_store_dsc_helper((unsigned long)buf, (unsigned long)ptr);
+        mpx_make_bound_helper((unsigned long)(ptr+0x12), 0x1800);
+}
+
+static __always_inline void mpx_test_helper4_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        stdsc_shadow(0, buf, ptr);
+        mkbnd_shadow(ptr+0x12, 0, 0x1800);
+}
+
+static __always_inline void mpx_test_helper5(uint8_t *buf, uint8_t *ptr)
+{
+        mpx_load_dsc_helper((unsigned long)buf, (unsigned long)ptr);
+}
+
+static __always_inline void mpx_test_helper5_shadow(uint8_t *buf, uint8_t *ptr)
+{
+        lddsc_shadow(0, buf, ptr);
+}
+
+#define NR_MPX_TEST_FUNCTIONS 6
+
+/*
+ * For compatibility reasons, MPX will clear the bounds registers
+ * when you make function calls (among other things).  We have to
+ * preserve the registers in between calls to the "helpers" since
+ * they build on each other.
+ *
+ * Be very careful not to make any function calls inside the
+ * helpers, or anywhere else beween the xrstor and xsave.
+ */
+#define run_helper(helper_nr, buf, buf_shadow, ptr)     do {    \
+        xrstor_state(xsave_test_buf, flags);                    \
+        mpx_test_helper##helper_nr(buf, ptr);                   \
+        xsave_state(xsave_test_buf, flags);                     \
+        mpx_test_helper##helper_nr##_shadow(buf_shadow, ptr);   \
+} while (0)
+
+static void run_helpers(int nr, uint8_t *buf, uint8_t *buf_shadow, uint8_t *ptr)
+{
+        uint64_t flags = 0x18;
+
+        dprint_context(xsave_test_buf);
+        switch (nr) {
+        case 0:
+                run_helper(0, buf, buf_shadow, ptr);
+                break;
+        case 1:
+                run_helper(1, buf, buf_shadow, ptr);
+                break;
+        case 2:
+                run_helper(2, buf, buf_shadow, ptr);
+                break;
+        case 3:
+                run_helper(3, buf, buf_shadow, ptr);
+                break;
+        case 4:
+                run_helper(4, buf, buf_shadow, ptr);
+                break;
+        case 5:
+                run_helper(5, buf, buf_shadow, ptr);
+                break;
+        default:
+                test_failed();
+                break;
+        }
+        dprint_context(xsave_test_buf);
+}
+
+unsigned long buf_shadow[1024]; /* used to check load / store descriptors */
+extern long inspect_me(struct mpx_bounds_dir *bounds_dir);
+
+long cover_buf_with_bt_entries(void *buf, long buf_len)
+{
+        int i;
+        long nr_to_fill;
+        int ratio = 1000;
+        unsigned long buf_len_in_ptrs;
+
+        /* Fill about 1/100 of the space with bt entries */
+        nr_to_fill = buf_len / (sizeof(unsigned long) * ratio);
+
+        if (!nr_to_fill)
+                dprintf3("%s() nr_to_fill: %ld\n", __func__, nr_to_fill);
+
+        /* Align the buffer to pointer size */
+        while (((unsigned long)buf) % sizeof(void *)) {
+                buf++;
+                buf_len--;
+        }
+        /* We are storing pointers, so make */
+        buf_len_in_ptrs = buf_len / sizeof(void *);
+
+        for (i = 0; i < nr_to_fill; i++) {
+                long index = (mpx_random() % buf_len_in_ptrs);
+                void *ptr = buf + index * sizeof(unsigned long);
+                unsigned long ptr_addr = (unsigned long)ptr;
+
+                /* ptr and size can be anything */
+                mpx_make_bound_helper((unsigned long)ptr, 8);
+
+                /*
+                 * take bnd0 and put it in to bounds tables "buf + index" is an
+                 * address inside the buffer where we are pretending that we
+                 * are going to put a pointer We do not, though because we will
+                 * never load entries from the table, so it doesn't matter.
+                 */
+                mpx_store_dsc_helper(ptr_addr, (unsigned long)ptr);
+                dprintf4("storing bound table entry for %lx (buf start @ %p)\n",
+                                ptr_addr, buf);
+        }
+        return nr_to_fill;
+}
+
+unsigned long align_down(unsigned long alignme, unsigned long align_to)
+{
+        return alignme & ~(align_to-1);
+}
+
+unsigned long align_up(unsigned long alignme, unsigned long align_to)
+{
+        return (alignme + align_to - 1) & ~(align_to-1);
+}
+
+/*
+ * Using 1MB alignment guarantees that each no allocation
+ * will overlap with another's bounds tables.
+ *
+ * We have to cook our own allocator here.  malloc() can
+ * mix other allocation with ours which means that even
+ * if we free all of our allocations, there might still
+ * be bounds tables for the *areas* since there is other
+ * valid memory there.
+ *
+ * We also can't use malloc() because a free() of an area
+ * might not free it back to the kernel.  We want it
+ * completely unmapped an malloc() does not guarantee
+ * that.
+ */
+#ifdef __i386__
+long alignment = 4096;
+long sz_alignment = 4096;
+#else
+long alignment = 1 * MB;
+long sz_alignment = 1 * MB;
+#endif
+void *mpx_mini_alloc(unsigned long sz)
+{
+        unsigned long long tries = 0;
+        static void *last;
+        void *ptr;
+        void *try_at;
+
+        sz = align_up(sz, sz_alignment);
+
+        try_at = last + alignment;
+        while (1) {
+                ptr = mmap(try_at, sz, PROT_READ|PROT_WRITE,
+                                MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+                if (ptr == (void *)-1)
+                        return NULL;
+                if (ptr == try_at)
+                        break;
+
+                munmap(ptr, sz);
+                try_at += alignment;
+#ifdef __i386__
+                /*
+                 * This isn't quite correct for 32-bit binaries
+                 * on 64-bit kernels since they can use the
+                 * entire 32-bit address space, but it's close
+                 * enough.
+                 */
+                if (try_at > (void *)0xC0000000)
+#else
+                if (try_at > (void *)0x0000800000000000)
+#endif
+                        try_at = (void *)0x0;
+                if (!(++tries % 10000))
+                        dprintf1("stuck in %s(), tries: %lld\n", __func__, tries);
+                continue;
+        }
+        last = ptr;
+        dprintf3("mpx_mini_alloc(0x%lx) returning: %p\n", sz, ptr);
+        return ptr;
+}
+void mpx_mini_free(void *ptr, long sz)
+{
+        dprintf2("%s() ptr: %p\n", __func__, ptr);
+        if ((unsigned long)ptr > 0x100000000000) {
+                dprintf1("uh oh !!!!!!!!!!!!!!! pointer too high: %p\n", ptr);
+                test_failed();
+        }
+        sz = align_up(sz, sz_alignment);
+        dprintf3("%s() ptr: %p before munmap\n", __func__, ptr);
+        munmap(ptr, sz);
+        dprintf3("%s() ptr: %p DONE\n", __func__, ptr);
+}
+
+#define NR_MALLOCS 100
+struct one_malloc {
+        char *ptr;
+        int nr_filled_btes;
+        unsigned long size;
+};
+struct one_malloc mallocs[NR_MALLOCS];
+
+void free_one_malloc(int index)
+{
+        unsigned long free_ptr;
+        unsigned long mask;
+
+        if (!mallocs[index].ptr)
+                return;
+
+        mpx_mini_free(mallocs[index].ptr, mallocs[index].size);
+        dprintf4("freed[%d]:  %p\n", index, mallocs[index].ptr);
+
+        free_ptr = (unsigned long)mallocs[index].ptr;
+        mask = alignment-1;
+        dprintf4("lowerbits: %lx / %lx mask: %lx\n", free_ptr,
+                        (free_ptr & mask), mask);
+        assert((free_ptr & mask) == 0);
+
+        mallocs[index].ptr = NULL;
+}
+
+#ifdef __i386__
+#define MPX_BOUNDS_TABLE_COVERS 4096
+#else
+#define MPX_BOUNDS_TABLE_COVERS (1 * MB)
+#endif
+void zap_everything(void)
+{
+        long after_zap;
+        long before_zap;
+        int i;
+
+        before_zap = inspect_me(bounds_dir_ptr);
+        dprintf1("zapping everything start: %ld\n", before_zap);
+        for (i = 0; i < NR_MALLOCS; i++)
+                free_one_malloc(i);
+
+        after_zap = inspect_me(bounds_dir_ptr);
+        dprintf1("zapping everything done: %ld\n", after_zap);
+        /*
+         * We only guarantee to empty the thing out if our allocations are
+         * exactly aligned on the boundaries of a boudns table.
+         */
+        if ((alignment >= MPX_BOUNDS_TABLE_COVERS) &&
+            (sz_alignment >= MPX_BOUNDS_TABLE_COVERS)) {
+                if (after_zap != 0)
+                        test_failed();
+
+                assert(after_zap == 0);
+        }
+}
+
+void do_one_malloc(void)
+{
+        static int malloc_counter;
+        long sz;
+        int rand_index = (mpx_random() % NR_MALLOCS);
+        void *ptr = mallocs[rand_index].ptr;
+
+        dprintf3("%s() enter\n", __func__);
+
+        if (ptr) {
+                dprintf3("freeing one malloc at index: %d\n", rand_index);
+                free_one_malloc(rand_index);
+                if (mpx_random() % (NR_MALLOCS*3) == 3) {
+                        int i;
+                        dprintf3("zapping some more\n");
+                        for (i = rand_index; i < NR_MALLOCS; i++)
+                                free_one_malloc(i);
+                }
+                if ((mpx_random() % zap_all_every_this_many_mallocs) == 4)
+                        zap_everything();
+        }
+
+        /* 1->~1M */
+        sz = (1 + mpx_random() % 1000) * 1000;
+        ptr = mpx_mini_alloc(sz);
+        if (!ptr) {
+                /*
+                 * If we are failing allocations, just assume we
+                 * are out of memory and zap everything.
+                 */
+                dprintf3("zapping everything because out of memory\n");
+                zap_everything();
+                goto out;
+        }
+
+        dprintf3("malloc: %p size: 0x%lx\n", ptr, sz);
+        mallocs[rand_index].nr_filled_btes = cover_buf_with_bt_entries(ptr, sz);
+        mallocs[rand_index].ptr = ptr;
+        mallocs[rand_index].size = sz;
+out:
+        if ((++malloc_counter) % inspect_every_this_many_mallocs == 0)
+                inspect_me(bounds_dir_ptr);
+}
+
+void run_timed_test(void (*test_func)(void))
+{
+        int done = 0;
+        long iteration = 0;
+        static time_t last_print;
+        time_t now;
+        time_t start;
+
+        time(&start);
+        while (!done) {
+                time(&now);
+                if ((now - start) > TEST_DURATION_SECS)
+                        done = 1;
+
+                test_func();
+                iteration++;
+
+                if ((now - last_print > 1) || done) {
+                        printf("iteration %ld complete, OK so far\n", iteration);
+                        last_print = now;
+                }
+        }
+}
+
+void check_bounds_table_frees(void)
+{
+        printf("executing unmaptest\n");
+        inspect_me(bounds_dir_ptr);
+        run_timed_test(&do_one_malloc);
+        printf("done with malloc() fun\n");
+}
+
+void insn_test_failed(int test_nr, int test_round, void *buf,
+                void *buf_shadow, void *ptr)
+{
+        print_context(xsave_test_buf);
+        eprintf("ERROR: test %d round %d failed\n", test_nr, test_round);
+        while (test_nr == 5) {
+                struct mpx_bt_entry *bte;
+                struct mpx_bounds_dir *bd = (void *)bounds_dir_ptr;
+                struct mpx_bd_entry *bde = mpx_vaddr_to_bd_entry(buf, bd);
+
+                printf("  bd: %p\n", bd);
+                printf("&bde: %p\n", bde);
+                printf("*bde: %lx\n", *(unsigned long *)bde);
+                if (!bd_entry_valid(bde))
+                        break;
+
+                bte = mpx_vaddr_to_bt_entry(buf, bd);
+                printf(" te: %p\n", bte);
+                printf("bte[0]: %lx\n", bte->contents[0]);
+                printf("bte[1]: %lx\n", bte->contents[1]);
+                printf("bte[2]: %lx\n", bte->contents[2]);
+                printf("bte[3]: %lx\n", bte->contents[3]);
+                break;
+        }
+        test_failed();
+}
+
+void check_mpx_insns_and_tables(void)
+{
+        int successes = 0;
+        int failures  = 0;
+        int buf_size = (1024*1024);
+        unsigned long *buf = malloc(buf_size);
+        const int total_nr_tests = NR_MPX_TEST_FUNCTIONS * TEST_ROUNDS;
+        int i, j;
+
+        memset(buf, 0, buf_size);
+        memset(buf_shadow, 0, sizeof(buf_shadow));
+
+        for (i = 0; i < TEST_ROUNDS; i++) {
+                uint8_t *ptr = get_random_addr() + 8;
+
+                for (j = 0; j < NR_MPX_TEST_FUNCTIONS; j++) {
+                        if (0 && j != 5) {
+                                successes++;
+                                continue;
+                        }
+                        dprintf2("starting test %d round %d\n", j, i);
+                        dprint_context(xsave_test_buf);
+                        /*
+                         * test5 loads an address from the bounds tables.
+                         * The load will only complete if 'ptr' matches
+                         * the load and the store, so with random addrs,
+                         * the odds of this are very small.  Make it
+                         * higher by only moving 'ptr' 1/10 times.
+                         */
+                        if (random() % 10 <= 0)
+                                ptr = get_random_addr() + 8;
+                        dprintf3("random ptr{%p}\n", ptr);
+                        dprint_context(xsave_test_buf);
+                        run_helpers(j, (void *)buf, (void *)buf_shadow, ptr);
+                        dprint_context(xsave_test_buf);
+                        if (!compare_context(xsave_test_buf)) {
+                                insn_test_failed(j, i, buf, buf_shadow, ptr);
+                                failures++;
+                                goto exit;
+                        }
+                        successes++;
+                        dprint_context(xsave_test_buf);
+                        dprintf2("finished test %d round %d\n", j, i);
+                        dprintf3("\n");
+                        dprint_context(xsave_test_buf);
+                }
+        }
+
+exit:
+        dprintf2("\nabout to free:\n");
+        free(buf);
+        dprintf1("successes: %d\n", successes);
+        dprintf1(" failures: %d\n", failures);
+        dprintf1("    tests: %d\n", total_nr_tests);
+        dprintf1(" expected: %jd #BRs\n", num_upper_brs + num_lower_brs);
+        dprintf1("      saw: %d #BRs\n", br_count);
+        if (failures) {
+                eprintf("ERROR: non-zero number of failures\n");
+                exit(20);
+        }
+        if (successes != total_nr_tests) {
+                eprintf("ERROR: succeded fewer than number of tries (%d != %d)\n",
+                                successes, total_nr_tests);
+                exit(21);
+        }
+        if (num_upper_brs + num_lower_brs != br_count) {
+                eprintf("ERROR: unexpected number of #BRs: %jd %jd %d\n",
+                                num_upper_brs, num_lower_brs, br_count);
+                eprintf("successes: %d\n", successes);
+                eprintf(" failures: %d\n", failures);
+                eprintf("    tests: %d\n", total_nr_tests);
+                eprintf(" expected: %jd #BRs\n", num_upper_brs + num_lower_brs);
+                eprintf("      saw: %d #BRs\n", br_count);
+                exit(22);
+        }
+}
+
+/*
+ * This is supposed to SIGSEGV nicely once the kernel
+ * can no longer allocate vaddr space.
+ */
+void exhaust_vaddr_space(void)
+{
+        unsigned long ptr;
+        /* Try to make sure there is no room for a bounds table anywhere */
+        unsigned long skip = MPX_BOUNDS_TABLE_SIZE_BYTES - PAGE_SIZE;
+#ifdef __i386__
+        unsigned long max_vaddr = 0xf7788000UL;
+#else
+        unsigned long max_vaddr = 0x800000000000UL;
+#endif
+
+        dprintf1("%s() start\n", __func__);
+        /* do not start at 0, we aren't allowed to map there */
+        for (ptr = PAGE_SIZE; ptr < max_vaddr; ptr += skip) {
+                void *ptr_ret;
+                int ret = madvise((void *)ptr, PAGE_SIZE, MADV_NORMAL);
+
+                if (!ret) {
+                        dprintf1("madvise() %lx ret: %d\n", ptr, ret);
+                        continue;
+                }
+                ptr_ret = mmap((void *)ptr, PAGE_SIZE, PROT_READ|PROT_WRITE,
+                                MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+                if (ptr_ret != (void *)ptr) {
+                        perror("mmap");
+                        dprintf1("mmap(%lx) ret: %p\n", ptr, ptr_ret);
+                        break;
+                }
+                if (!(ptr & 0xffffff))
+                        dprintf1("mmap(%lx) ret: %p\n", ptr, ptr_ret);
+        }
+        for (ptr = PAGE_SIZE; ptr < max_vaddr; ptr += skip) {
+                dprintf2("covering 0x%lx with bounds table entries\n", ptr);
+                cover_buf_with_bt_entries((void *)ptr, PAGE_SIZE);
+        }
+        dprintf1("%s() end\n", __func__);
+        printf("done with vaddr space fun\n");
+}
+
+void mpx_table_test(void)
+{
+        printf("starting mpx bounds table test\n");
+        run_timed_test(check_mpx_insns_and_tables);
+        printf("done with mpx bounds table test\n");
+}
+
+int main(int argc, char **argv)
+{
+        int unmaptest = 0;
+        int vaddrexhaust = 0;
+        int tabletest = 0;
+        int i;
+
+        check_mpx_support();
+        mpx_prepare();
+        srandom(11179);
+
+        bd_incore();
+        init();
+        bd_incore();
+
+        trace_me();
+
+        xsave_state((void *)xsave_test_buf, 0x1f);
+        if (!compare_context(xsave_test_buf))
+                printf("Init failed\n");
+
+        for (i = 1; i < argc; i++) {
+                if (!strcmp(argv[i], "unmaptest"))
+                        unmaptest = 1;
+                if (!strcmp(argv[i], "vaddrexhaust"))
+                        vaddrexhaust = 1;
+                if (!strcmp(argv[i], "tabletest"))
+                        tabletest = 1;
+        }
+        if (!(unmaptest || vaddrexhaust || tabletest)) {
+                unmaptest = 1;
+                /* vaddrexhaust = 1; */
+                tabletest = 1;
+        }
+        if (unmaptest)
+                check_bounds_table_frees();
+        if (tabletest)
+                mpx_table_test();
+        if (vaddrexhaust)
+                exhaust_vaddr_space();
+        printf("%s completed successfully\n", argv[0]);
+        exit(0);
+}
+
+#include "mpx-dig.c"
diff --git a/tools/testing/selftests/x86/mpx-mm.h b/tools/testing/selftests/x86/mpx-mm.h
new file mode 100644
index 000000000000..af706a5398f7
--- /dev/null
+++ b/tools/testing/selftests/x86/mpx-mm.h
@@ -0,0 +1,9 @@
+#ifndef _MPX_MM_H
+#define _MPX_MM_H
+
+#define PAGE_SIZE 4096
+#define MB (1UL<<20)
+
+extern long nr_incore(void *ptr, unsigned long size_bytes);
+
+#endif /* _MPX_MM_H */
diff --git a/tools/testing/selftests/x86/pkey-helpers.h b/tools/testing/selftests/x86/pkey-helpers.h
new file mode 100644
index 000000000000..b20293956eec
--- /dev/null
+++ b/tools/testing/selftests/x86/pkey-helpers.h
@@ -0,0 +1,219 @@
+#ifndef _PKEYS_HELPER_H
+#define _PKEYS_HELPER_H
+#define _GNU_SOURCE
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <signal.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ucontext.h>
+#include <sys/mman.h>
+
+#define NR_PKEYS 16
+#define PKRU_BITS_PER_PKEY 2
+
+#ifndef DEBUG_LEVEL
+#define DEBUG_LEVEL 0
+#endif
+#define DPRINT_IN_SIGNAL_BUF_SIZE 4096
+extern int dprint_in_signal;
+extern char dprint_in_signal_buffer[DPRINT_IN_SIGNAL_BUF_SIZE];
+static inline void sigsafe_printf(const char *format, ...)
+{
+        va_list ap;
+
+        va_start(ap, format);
+        if (!dprint_in_signal) {
+                vprintf(format, ap);
+        } else {
+                int len = vsnprintf(dprint_in_signal_buffer,
+                                    DPRINT_IN_SIGNAL_BUF_SIZE,
+                                    format, ap);
+                /*
+                 * len is amount that would have been printed,
+                 * but actual write is truncated at BUF_SIZE.
+                 */
+                if (len > DPRINT_IN_SIGNAL_BUF_SIZE)
+                        len = DPRINT_IN_SIGNAL_BUF_SIZE;
+                write(1, dprint_in_signal_buffer, len);
+        }
+        va_end(ap);
+}
+#define dprintf_level(level, args...) do {      \
+        if (level <= DEBUG_LEVEL)               \
+                sigsafe_printf(args);           \
+        fflush(NULL);                           \
+} while (0)
+#define dprintf0(args...) dprintf_level(0, args)
+#define dprintf1(args...) dprintf_level(1, args)
+#define dprintf2(args...) dprintf_level(2, args)
+#define dprintf3(args...) dprintf_level(3, args)
+#define dprintf4(args...) dprintf_level(4, args)
+
+extern unsigned int shadow_pkru;
+static inline unsigned int __rdpkru(void)
+{
+        unsigned int eax, edx;
+        unsigned int ecx = 0;
+        unsigned int pkru;
+
+        asm volatile(".byte 0x0f,0x01,0xee\n\t"
+                     : "=a" (eax), "=d" (edx)
+                     : "c" (ecx));
+        pkru = eax;
+        return pkru;
+}
+
+static inline unsigned int _rdpkru(int line)
+{
+        unsigned int pkru = __rdpkru();
+
+        dprintf4("rdpkru(line=%d) pkru: %x shadow: %x\n",
+                        line, pkru, shadow_pkru);
+        assert(pkru == shadow_pkru);
+
+        return pkru;
+}
+
+#define rdpkru() _rdpkru(__LINE__)
+
+static inline void __wrpkru(unsigned int pkru)
+{
+        unsigned int eax = pkru;
+        unsigned int ecx = 0;
+        unsigned int edx = 0;
+
+        dprintf4("%s() changing %08x to %08x\n", __func__, __rdpkru(), pkru);
+        asm volatile(".byte 0x0f,0x01,0xef\n\t"
+                     : : "a" (eax), "c" (ecx), "d" (edx));
+        assert(pkru == __rdpkru());
+}
+
+static inline void wrpkru(unsigned int pkru)
+{
+        dprintf4("%s() changing %08x to %08x\n", __func__, __rdpkru(), pkru);
+        /* will do the shadow check for us: */
+        rdpkru();
+        __wrpkru(pkru);
+        shadow_pkru = pkru;
+        dprintf4("%s(%08x) pkru: %08x\n", __func__, pkru, __rdpkru());
+}
+
+/*
+ * These are technically racy. since something could
+ * change PKRU between the read and the write.
+ */
+static inline void __pkey_access_allow(int pkey, int do_allow)
+{
+        unsigned int pkru = rdpkru();
+        int bit = pkey * 2;
+
+        if (do_allow)
+                pkru &= (1<<bit);
+        else
+                pkru |= (1<<bit);
+
+        dprintf4("pkru now: %08x\n", rdpkru());
+        wrpkru(pkru);
+}
+
+static inline void __pkey_write_allow(int pkey, int do_allow_write)
+{
+        long pkru = rdpkru();
+        int bit = pkey * 2 + 1;
+
+        if (do_allow_write)
+                pkru &= (1<<bit);
+        else
+                pkru |= (1<<bit);
+
+        wrpkru(pkru);
+        dprintf4("pkru now: %08x\n", rdpkru());
+}
+
+#define PROT_PKEY0     0x10            /* protection key value (bit 0) */
+#define PROT_PKEY1     0x20            /* protection key value (bit 1) */
+#define PROT_PKEY2     0x40            /* protection key value (bit 2) */
+#define PROT_PKEY3     0x80            /* protection key value (bit 3) */
+
+#define PAGE_SIZE 4096
+#define MB      (1<<20)
+
+static inline void __cpuid(unsigned int *eax, unsigned int *ebx,
+                unsigned int *ecx, unsigned int *edx)
+{
+        /* ecx is often an input as well as an output. */
+        asm volatile(
+                "cpuid;"
+                : "=a" (*eax),
+                  "=b" (*ebx),
+                  "=c" (*ecx),
+                  "=d" (*edx)
+                : "0" (*eax), "2" (*ecx));
+}
+
+/* Intel-defined CPU features, CPUID level 0x00000007:0 (ecx) */
+#define X86_FEATURE_PKU        (1<<3) /* Protection Keys for Userspace */
+#define X86_FEATURE_OSPKE      (1<<4) /* OS Protection Keys Enable */
+
+static inline int cpu_has_pku(void)
+{
+        unsigned int eax;
+        unsigned int ebx;
+        unsigned int ecx;
+        unsigned int edx;
+
+        eax = 0x7;
+        ecx = 0x0;
+        __cpuid(&eax, &ebx, &ecx, &edx);
+
+        if (!(ecx & X86_FEATURE_PKU)) {
+                dprintf2("cpu does not have PKU\n");
+                return 0;
+        }
+        if (!(ecx & X86_FEATURE_OSPKE)) {
+                dprintf2("cpu does not have OSPKE\n");
+                return 0;
+        }
+        return 1;
+}
+
+#define XSTATE_PKRU_BIT (9)
+#define XSTATE_PKRU     0x200
+
+int pkru_xstate_offset(void)
+{
+        unsigned int eax;
+        unsigned int ebx;
+        unsigned int ecx;
+        unsigned int edx;
+        int xstate_offset;
+        int xstate_size;
+        unsigned long XSTATE_CPUID = 0xd;
+        int leaf;
+
+        /* assume that XSTATE_PKRU is set in XCR0 */
+        leaf = XSTATE_PKRU_BIT;
+        {
+                eax = XSTATE_CPUID;
+                ecx = leaf;
+                __cpuid(&eax, &ebx, &ecx, &edx);
+
+                if (leaf == XSTATE_PKRU_BIT) {
+                        xstate_offset = ebx;
+                        xstate_size = eax;
+                }
+        }
+
+        if (xstate_size == 0) {
+                printf("could not find size/offset of PKRU in xsave state\n");
+                return 0;
+        }
+
+        return xstate_offset;
+}
+
+#endif /* _PKEYS_HELPER_H */
diff --git a/tools/testing/selftests/x86/protection_keys.c b/tools/testing/selftests/x86/protection_keys.c
new file mode 100644
index 000000000000..bdd58c78902e
--- /dev/null
+++ b/tools/testing/selftests/x86/protection_keys.c
@@ -0,0 +1,1410 @@
+/*
+ * Tests x86 Memory Protection Keys (see Documentation/x86/protection-keys.txt)
+ *
+ * There are examples in here of:
+ *  * how to set protection keys on memory
+ *  * how to set/clear bits in PKRU (the rights register)
+ *  * how to handle SEGV_PKRU signals and extract pkey-relevant
+ *    information from the siginfo
+ *
+ * Things to add:
+ *      make sure KSM and KSM COW breaking works
+ *      prefault pages in at malloc, or not
+ *      protect MPX bounds tables with protection keys?
+ *      make sure VMA splitting/merging is working correctly
+ *      OOMs can destroy mm->mmap (see exit_mmap()), so make sure it is immune to pkeys
+ *      look for pkey "leaks" where it is still set on a VMA but "freed" back to the kernel
+ *      do a plain mprotect() to a mprotect_pkey() area and make sure the pkey sticks
+ *
+ * Compile like this:
+ *      gcc      -o protection_keys    -O2 -g -std=gnu99 -pthread -Wall protection_keys.c -lrt -ldl -lm
+ *      gcc -m32 -o protection_keys_32 -O2 -g -std=gnu99 -pthread -Wall protection_keys.c -lrt -ldl -lm
+ */
+#define _GNU_SOURCE
+#include <errno.h>
+#include <linux/futex.h>
+#include <sys/time.h>
+#include <sys/syscall.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <signal.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <ucontext.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/ptrace.h>
+#include <setjmp.h>
+
+#include "pkey-helpers.h"
+
+int iteration_nr = 1;
+int test_nr;
+
+unsigned int shadow_pkru;
+
+#define HPAGE_SIZE      (1UL<<21)
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
+#define ALIGN_UP(x, align_to)   (((x) + ((align_to)-1)) & ~((align_to)-1))
+#define ALIGN_DOWN(x, align_to) ((x) & ~((align_to)-1))
+#define ALIGN_PTR_UP(p, ptr_align_to)   ((typeof(p))ALIGN_UP((unsigned long)(p),        ptr_align_to))
+#define ALIGN_PTR_DOWN(p, ptr_align_to) ((typeof(p))ALIGN_DOWN((unsigned long)(p),      ptr_align_to))
+#define __stringify_1(x...)     #x
+#define __stringify(x...)       __stringify_1(x)
+
+#define PTR_ERR_ENOTSUP ((void *)-ENOTSUP)
+
+int dprint_in_signal;
+char dprint_in_signal_buffer[DPRINT_IN_SIGNAL_BUF_SIZE];
+
+extern void abort_hooks(void);
+#define pkey_assert(condition) do {             \
+        if (!(condition)) {                     \
+                dprintf0("assert() at %s::%d test_nr: %d iteration: %d\n", \
+                                __FILE__, __LINE__,     \
+                                test_nr, iteration_nr); \
+                dprintf0("errno at assert: %d", errno); \
+                abort_hooks();                  \
+                assert(condition);              \
+        }                                       \
+} while (0)
+#define raw_assert(cond) assert(cond)
+
+void cat_into_file(char *str, char *file)
+{
+        int fd = open(file, O_RDWR);
+        int ret;
+
+        dprintf2("%s(): writing '%s' to '%s'\n", __func__, str, file);
+        /*
+         * these need to be raw because they are called under
+         * pkey_assert()
+         */
+        raw_assert(fd >= 0);
+        ret = write(fd, str, strlen(str));
+        if (ret != strlen(str)) {
+                perror("write to file failed");
+                fprintf(stderr, "filename: '%s' str: '%s'\n", file, str);
+                raw_assert(0);
+        }
+        close(fd);
+}
+
+#if CONTROL_TRACING > 0
+static int warned_tracing;
+int tracing_root_ok(void)
+{
+        if (geteuid() != 0) {
+                if (!warned_tracing)
+                        fprintf(stderr, "WARNING: not run as root, "
+                                        "can not do tracing control\n");
+                warned_tracing = 1;
+                return 0;
+        }
+        return 1;
+}
+#endif
+
+void tracing_on(void)
+{
+#if CONTROL_TRACING > 0
+#define TRACEDIR "/sys/kernel/debug/tracing"
+        char pidstr[32];
+
+        if (!tracing_root_ok())
+                return;
+
+        sprintf(pidstr, "%d", getpid());
+        cat_into_file("0", TRACEDIR "/tracing_on");
+        cat_into_file("\n", TRACEDIR "/trace");
+        if (1) {
+                cat_into_file("function_graph", TRACEDIR "/current_tracer");
+                cat_into_file("1", TRACEDIR "/options/funcgraph-proc");
+        } else {
+                cat_into_file("nop", TRACEDIR "/current_tracer");
+        }
+        cat_into_file(pidstr, TRACEDIR "/set_ftrace_pid");
+        cat_into_file("1", TRACEDIR "/tracing_on");
+        dprintf1("enabled tracing\n");
+#endif
+}
+
+void tracing_off(void)
+{
+#if CONTROL_TRACING > 0
+        if (!tracing_root_ok())
+                return;
+        cat_into_file("0", "/sys/kernel/debug/tracing/tracing_on");
+#endif
+}
+
+void abort_hooks(void)
+{
+        fprintf(stderr, "running %s()...\n", __func__);
+        tracing_off();
+#ifdef SLEEP_ON_ABORT
+        sleep(SLEEP_ON_ABORT);
+#endif
+}
+
+static inline void __page_o_noops(void)
+{
+        /* 8-bytes of instruction * 512 bytes = 1 page */
+        asm(".rept 512 ; nopl 0x7eeeeeee(%eax) ; .endr");
+}
+
+/*
+ * This attempts to have roughly a page of instructions followed by a few
+ * instructions that do a write, and another page of instructions.  That
+ * way, we are pretty sure that the write is in the second page of
+ * instructions and has at least a page of padding behind it.
+ *
+ * *That* lets us be sure to madvise() away the write instruction, which
+ * will then fault, which makes sure that the fault code handles
+ * execute-only memory properly.
+ */
+__attribute__((__aligned__(PAGE_SIZE)))
+void lots_o_noops_around_write(int *write_to_me)
+{
+        dprintf3("running %s()\n", __func__);
+        __page_o_noops();
+        /* Assume this happens in the second page of instructions: */
+        *write_to_me = __LINE__;
+        /* pad out by another page: */
+        __page_o_noops();
+        dprintf3("%s() done\n", __func__);
+}
+
+/* Define some kernel-like types */
+#define  u8 uint8_t
+#define u16 uint16_t
+#define u32 uint32_t
+#define u64 uint64_t
+
+#ifdef __i386__
+#define SYS_mprotect_key 380
+#define SYS_pkey_alloc   381
+#define SYS_pkey_free    382
+#define REG_IP_IDX REG_EIP
+#define si_pkey_offset 0x18
+#else
+#define SYS_mprotect_key 329
+#define SYS_pkey_alloc   330
+#define SYS_pkey_free    331
+#define REG_IP_IDX REG_RIP
+#define si_pkey_offset 0x20
+#endif
+
+void dump_mem(void *dumpme, int len_bytes)
+{
+        char *c = (void *)dumpme;
+        int i;
+
+        for (i = 0; i < len_bytes; i += sizeof(u64)) {
+                u64 *ptr = (u64 *)(c + i);
+                dprintf1("dump[%03d][@%p]: %016jx\n", i, ptr, *ptr);
+        }
+}
+
+#define __SI_FAULT      (3 << 16)
+#define SEGV_BNDERR     (__SI_FAULT|3)  /* failed address bound checks */
+#define SEGV_PKUERR     (__SI_FAULT|4)
+
+static char *si_code_str(int si_code)
+{
+        if (si_code & SEGV_MAPERR)
+                return "SEGV_MAPERR";
+        if (si_code & SEGV_ACCERR)
+                return "SEGV_ACCERR";
+        if (si_code & SEGV_BNDERR)
+                return "SEGV_BNDERR";
+        if (si_code & SEGV_PKUERR)
+                return "SEGV_PKUERR";
+        return "UNKNOWN";
+}
+
+int pkru_faults;
+int last_si_pkey = -1;
+void signal_handler(int signum, siginfo_t *si, void *vucontext)
+{
+        ucontext_t *uctxt = vucontext;
+        int trapno;
+        unsigned long ip;
+        char *fpregs;
+        u32 *pkru_ptr;
+        u64 si_pkey;
+        u32 *si_pkey_ptr;
+        int pkru_offset;
+        fpregset_t fpregset;
+
+        dprint_in_signal = 1;
+        dprintf1(">>>>===============SIGSEGV============================\n");
+        dprintf1("%s()::%d, pkru: 0x%x shadow: %x\n", __func__, __LINE__,
+                        __rdpkru(), shadow_pkru);
+
+        trapno = uctxt->uc_mcontext.gregs[REG_TRAPNO];
+        ip = uctxt->uc_mcontext.gregs[REG_IP_IDX];
+        fpregset = uctxt->uc_mcontext.fpregs;
+        fpregs = (void *)fpregset;
+
+        dprintf2("%s() trapno: %d ip: 0x%lx info->si_code: %s/%d\n", __func__,
+                        trapno, ip, si_code_str(si->si_code), si->si_code);
+#ifdef __i386__
+        /*
+         * 32-bit has some extra padding so that userspace can tell whether
+         * the XSTATE header is present in addition to the "legacy" FPU
+         * state.  We just assume that it is here.
+         */
+        fpregs += 0x70;
+#endif
+        pkru_offset = pkru_xstate_offset();
+        pkru_ptr = (void *)(&fpregs[pkru_offset]);
+
+        dprintf1("siginfo: %p\n", si);
+        dprintf1(" fpregs: %p\n", fpregs);
+        /*
+         * If we got a PKRU fault, we *HAVE* to have at least one bit set in
+         * here.
+         */
+        dprintf1("pkru_xstate_offset: %d\n", pkru_xstate_offset());
+        if (DEBUG_LEVEL > 4)
+                dump_mem(pkru_ptr - 128, 256);
+        pkey_assert(*pkru_ptr);
+
+        si_pkey_ptr = (u32 *)(((u8 *)si) + si_pkey_offset);
+        dprintf1("si_pkey_ptr: %p\n", si_pkey_ptr);
+        dump_mem(si_pkey_ptr - 8, 24);
+        si_pkey = *si_pkey_ptr;
+        pkey_assert(si_pkey < NR_PKEYS);
+        last_si_pkey = si_pkey;
+
+        if ((si->si_code == SEGV_MAPERR) ||
+            (si->si_code == SEGV_ACCERR) ||
+            (si->si_code == SEGV_BNDERR)) {
+                printf("non-PK si_code, exiting...\n");
+                exit(4);
+        }
+
+        dprintf1("signal pkru from xsave: %08x\n", *pkru_ptr);
+        /* need __rdpkru() version so we do not do shadow_pkru checking */
+        dprintf1("signal pkru from  pkru: %08x\n", __rdpkru());
+        dprintf1("si_pkey from siginfo: %jx\n", si_pkey);
+        *(u64 *)pkru_ptr = 0x00000000;
+        dprintf1("WARNING: set PRKU=0 to allow faulting instruction to continue\n");
+        pkru_faults++;
+        dprintf1("<<<<==================================================\n");
+        return;
+        if (trapno == 14) {
+                fprintf(stderr,
+                        "ERROR: In signal handler, page fault, trapno = %d, ip = %016lx\n",
+                        trapno, ip);
+                fprintf(stderr, "si_addr %p\n", si->si_addr);
+                fprintf(stderr, "REG_ERR: %lx\n",
+                                (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
+                exit(1);
+        } else {
+                fprintf(stderr, "unexpected trap %d! at 0x%lx\n", trapno, ip);
+                fprintf(stderr, "si_addr %p\n", si->si_addr);
+                fprintf(stderr, "REG_ERR: %lx\n",
+                                (unsigned long)uctxt->uc_mcontext.gregs[REG_ERR]);
+                exit(2);
+        }
+        dprint_in_signal = 0;
+}
+
+int wait_all_children(void)
+{
+        int status;
+        return waitpid(-1, &status, 0);
+}
+
+void sig_chld(int x)
+{
+        dprint_in_signal = 1;
+        dprintf2("[%d] SIGCHLD: %d\n", getpid(), x);
+        dprint_in_signal = 0;
+}
+
+void setup_sigsegv_handler(void)
+{
+        int r, rs;
+        struct sigaction newact;
+        struct sigaction oldact;
+
+        /* #PF is mapped to sigsegv */
+        int signum  = SIGSEGV;
+
+        newact.sa_handler = 0;
+        newact.sa_sigaction = signal_handler;
+
+        /*sigset_t - signals to block while in the handler */
+        /* get the old signal mask. */
+        rs = sigprocmask(SIG_SETMASK, 0, &newact.sa_mask);
+        pkey_assert(rs == 0);
+
+        /* call sa_sigaction, not sa_handler*/
+        newact.sa_flags = SA_SIGINFO;
+
+        newact.sa_restorer = 0;  /* void(*)(), obsolete */
+        r = sigaction(signum, &newact, &oldact);
+        r = sigaction(SIGALRM, &newact, &oldact);
+        pkey_assert(r == 0);
+}
+
+void setup_handlers(void)
+{
+        signal(SIGCHLD, &sig_chld);
+        setup_sigsegv_handler();
+}
+
+pid_t fork_lazy_child(void)
+{
+        pid_t forkret;
+
+        forkret = fork();
+        pkey_assert(forkret >= 0);
+        dprintf3("[%d] fork() ret: %d\n", getpid(), forkret);
+
+        if (!forkret) {
+                /* in the child */
+                while (1) {
+                        dprintf1("child sleeping...\n");
+                        sleep(30);
+                }
+        }
+        return forkret;
+}
+
+void davecmp(void *_a, void *_b, int len)
+{
+        int i;
+        unsigned long *a = _a;
+        unsigned long *b = _b;
+
+        for (i = 0; i < len / sizeof(*a); i++) {
+                if (a[i] == b[i])
+                        continue;
+
+                dprintf3("[%3d]: a: %016lx b: %016lx\n", i, a[i], b[i]);
+        }
+}
+
+void dumpit(char *f)
+{
+        int fd = open(f, O_RDONLY);
+        char buf[100];
+        int nr_read;
+
+        dprintf2("maps fd: %d\n", fd);
+        do {
+                nr_read = read(fd, &buf[0], sizeof(buf));
+                write(1, buf, nr_read);
+        } while (nr_read > 0);
+        close(fd);
+}
+
+#define PKEY_DISABLE_ACCESS    0x1
+#define PKEY_DISABLE_WRITE     0x2
+
+u32 pkey_get(int pkey, unsigned long flags)
+{
+        u32 mask = (PKEY_DISABLE_ACCESS|PKEY_DISABLE_WRITE);
+        u32 pkru = __rdpkru();
+        u32 shifted_pkru;
+        u32 masked_pkru;
+
+        dprintf1("%s(pkey=%d, flags=%lx) = %x / %d\n",
+                        __func__, pkey, flags, 0, 0);
+        dprintf2("%s() raw pkru: %x\n", __func__, pkru);
+
+        shifted_pkru = (pkru >> (pkey * PKRU_BITS_PER_PKEY));
+        dprintf2("%s() shifted_pkru: %x\n", __func__, shifted_pkru);
+        masked_pkru = shifted_pkru & mask;
+        dprintf2("%s() masked  pkru: %x\n", __func__, masked_pkru);
+        /*
+         * shift down the relevant bits to the lowest two, then
+         * mask off all the other high bits.
+         */
+        return masked_pkru;
+}
+
+int pkey_set(int pkey, unsigned long rights, unsigned long flags)
+{
+        u32 mask = (PKEY_DISABLE_ACCESS|PKEY_DISABLE_WRITE);
+        u32 old_pkru = __rdpkru();
+        u32 new_pkru;
+
+        /* make sure that 'rights' only contains the bits we expect: */
+        assert(!(rights & ~mask));
+
+        /* copy old pkru */
+        new_pkru = old_pkru;
+        /* mask out bits from pkey in old value: */
+        new_pkru &= ~(mask << (pkey * PKRU_BITS_PER_PKEY));
+        /* OR in new bits for pkey: */
+        new_pkru |= (rights << (pkey * PKRU_BITS_PER_PKEY));
+
+        __wrpkru(new_pkru);
+
+        dprintf3("%s(pkey=%d, rights=%lx, flags=%lx) = %x pkru now: %x old_pkru: %x\n",
+                        __func__, pkey, rights, flags, 0, __rdpkru(), old_pkru);
+        return 0;
+}
+
+void pkey_disable_set(int pkey, int flags)
+{
+        unsigned long syscall_flags = 0;
+        int ret;
+        int pkey_rights;
+        u32 orig_pkru;
+
+        dprintf1("START->%s(%d, 0x%x)\n", __func__,
+                pkey, flags);
+        pkey_assert(flags & (PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE));
+
+        pkey_rights = pkey_get(pkey, syscall_flags);
+
+        dprintf1("%s(%d) pkey_get(%d): %x\n", __func__,
+                        pkey, pkey, pkey_rights);
+        pkey_assert(pkey_rights >= 0);
+
+        pkey_rights |= flags;
+
+        ret = pkey_set(pkey, pkey_rights, syscall_flags);
+        assert(!ret);
+        /*pkru and flags have the same format */
+        shadow_pkru |= flags << (pkey * 2);
+        dprintf1("%s(%d) shadow: 0x%x\n", __func__, pkey, shadow_pkru);
+
+        pkey_assert(ret >= 0);
+
+        pkey_rights = pkey_get(pkey, syscall_flags);
+        dprintf1("%s(%d) pkey_get(%d): %x\n", __func__,
+                        pkey, pkey, pkey_rights);
+
+        dprintf1("%s(%d) pkru: 0x%x\n", __func__, pkey, rdpkru());
+        if (flags)
+                pkey_assert(rdpkru() > orig_pkru);
+        dprintf1("END<---%s(%d, 0x%x)\n", __func__,
+                pkey, flags);
+}
+
+void pkey_disable_clear(int pkey, int flags)
+{
+        unsigned long syscall_flags = 0;
+        int ret;
+        int pkey_rights = pkey_get(pkey, syscall_flags);
+        u32 orig_pkru = rdpkru();
+
+        pkey_assert(flags & (PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE));
+
+        dprintf1("%s(%d) pkey_get(%d): %x\n", __func__,
+                        pkey, pkey, pkey_rights);
+        pkey_assert(pkey_rights >= 0);
+
+        pkey_rights |= flags;
+
+        ret = pkey_set(pkey, pkey_rights, 0);
+        /* pkru and flags have the same format */
+        shadow_pkru &= ~(flags << (pkey * 2));
+        pkey_assert(ret >= 0);
+
+        pkey_rights = pkey_get(pkey, syscall_flags);
+        dprintf1("%s(%d) pkey_get(%d): %x\n", __func__,
+                        pkey, pkey, pkey_rights);
+
+        dprintf1("%s(%d) pkru: 0x%x\n", __func__, pkey, rdpkru());
+        if (flags)
+                assert(rdpkru() > orig_pkru);
+}
+
+void pkey_write_allow(int pkey)
+{
+        pkey_disable_clear(pkey, PKEY_DISABLE_WRITE);
+}
+void pkey_write_deny(int pkey)
+{
+        pkey_disable_set(pkey, PKEY_DISABLE_WRITE);
+}
+void pkey_access_allow(int pkey)
+{
+        pkey_disable_clear(pkey, PKEY_DISABLE_ACCESS);
+}
+void pkey_access_deny(int pkey)
+{
+        pkey_disable_set(pkey, PKEY_DISABLE_ACCESS);
+}
+
+int sys_mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
+                unsigned long pkey)
+{
+        int sret;
+
+        dprintf2("%s(0x%p, %zx, prot=%lx, pkey=%lx)\n", __func__,
+                        ptr, size, orig_prot, pkey);
+
+        errno = 0;
+        sret = syscall(SYS_mprotect_key, ptr, size, orig_prot, pkey);
+        if (errno) {
+                dprintf2("SYS_mprotect_key sret: %d\n", sret);
+                dprintf2("SYS_mprotect_key prot: 0x%lx\n", orig_prot);
+                dprintf2("SYS_mprotect_key failed, errno: %d\n", errno);
+                if (DEBUG_LEVEL >= 2)
+                        perror("SYS_mprotect_pkey");
+        }
+        return sret;
+}
+
+int sys_pkey_alloc(unsigned long flags, unsigned long init_val)
+{
+        int ret = syscall(SYS_pkey_alloc, flags, init_val);
+        dprintf1("%s(flags=%lx, init_val=%lx) syscall ret: %d errno: %d\n",
+                        __func__, flags, init_val, ret, errno);
+        return ret;
+}
+
+int alloc_pkey(void)
+{
+        int ret;
+        unsigned long init_val = 0x0;
+
+        dprintf1("alloc_pkey()::%d, pkru: 0x%x shadow: %x\n",
+                        __LINE__, __rdpkru(), shadow_pkru);
+        ret = sys_pkey_alloc(0, init_val);
+        /*
+         * pkey_alloc() sets PKRU, so we need to reflect it in
+         * shadow_pkru:
+         */
+        dprintf4("alloc_pkey()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n",
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        if (ret) {
+                /* clear both the bits: */
+                shadow_pkru &= ~(0x3      << (ret * 2));
+                dprintf4("alloc_pkey()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n",
+                                __LINE__, ret, __rdpkru(), shadow_pkru);
+                /*
+                 * move the new state in from init_val
+                 * (remember, we cheated and init_val == pkru format)
+                 */
+                shadow_pkru |=  (init_val << (ret * 2));
+        }
+        dprintf4("alloc_pkey()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n",
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        dprintf1("alloc_pkey()::%d errno: %d\n", __LINE__, errno);
+        /* for shadow checking: */
+        rdpkru();
+        dprintf4("alloc_pkey()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n",
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        return ret;
+}
+
+int sys_pkey_free(unsigned long pkey)
+{
+        int ret = syscall(SYS_pkey_free, pkey);
+        dprintf1("%s(pkey=%ld) syscall ret: %d\n", __func__, pkey, ret);
+        return ret;
+}
+
+/*
+ * I had a bug where pkey bits could be set by mprotect() but
+ * not cleared.  This ensures we get lots of random bit sets
+ * and clears on the vma and pte pkey bits.
+ */
+int alloc_random_pkey(void)
+{
+        int max_nr_pkey_allocs;
+        int ret;
+        int i;
+        int alloced_pkeys[NR_PKEYS];
+        int nr_alloced = 0;
+        int random_index;
+        memset(alloced_pkeys, 0, sizeof(alloced_pkeys));
+
+        /* allocate every possible key and make a note of which ones we got */
+        max_nr_pkey_allocs = NR_PKEYS;
+        max_nr_pkey_allocs = 1;
+        for (i = 0; i < max_nr_pkey_allocs; i++) {
+                int new_pkey = alloc_pkey();
+                if (new_pkey < 0)
+                        break;
+                alloced_pkeys[nr_alloced++] = new_pkey;
+        }
+
+        pkey_assert(nr_alloced > 0);
+        /* select a random one out of the allocated ones */
+        random_index = rand() % nr_alloced;
+        ret = alloced_pkeys[random_index];
+        /* now zero it out so we don't free it next */
+        alloced_pkeys[random_index] = 0;
+
+        /* go through the allocated ones that we did not want and free them */
+        for (i = 0; i < nr_alloced; i++) {
+                int free_ret;
+                if (!alloced_pkeys[i])
+                        continue;
+                free_ret = sys_pkey_free(alloced_pkeys[i]);
+                pkey_assert(!free_ret);
+        }
+        dprintf1("%s()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n", __func__,
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        return ret;
+}
+
+int mprotect_pkey(void *ptr, size_t size, unsigned long orig_prot,
+                unsigned long pkey)
+{
+        int nr_iterations = random() % 100;
+        int ret;
+
+        while (0) {
+                int rpkey = alloc_random_pkey();
+                ret = sys_mprotect_pkey(ptr, size, orig_prot, pkey);
+                dprintf1("sys_mprotect_pkey(%p, %zx, prot=0x%lx, pkey=%ld) ret: %d\n",
+                                ptr, size, orig_prot, pkey, ret);
+                if (nr_iterations-- < 0)
+                        break;
+
+                dprintf1("%s()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n", __func__,
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+                sys_pkey_free(rpkey);
+                dprintf1("%s()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n", __func__,
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        }
+        pkey_assert(pkey < NR_PKEYS);
+
+        ret = sys_mprotect_pkey(ptr, size, orig_prot, pkey);
+        dprintf1("mprotect_pkey(%p, %zx, prot=0x%lx, pkey=%ld) ret: %d\n",
+                        ptr, size, orig_prot, pkey, ret);
+        pkey_assert(!ret);
+        dprintf1("%s()::%d, ret: %d pkru: 0x%x shadow: 0x%x\n", __func__,
+                        __LINE__, ret, __rdpkru(), shadow_pkru);
+        return ret;
+}
+
+struct pkey_malloc_record {
+        void *ptr;
+        long size;
+};
+struct pkey_malloc_record *pkey_malloc_records;
+long nr_pkey_malloc_records;
+void record_pkey_malloc(void *ptr, long size)
+{
+        long i;
+        struct pkey_malloc_record *rec = NULL;
+
+        for (i = 0; i < nr_pkey_malloc_records; i++) {
+                rec = &pkey_malloc_records[i];
+                /* find a free record */
+                if (rec)
+                        break;
+        }
+        if (!rec) {
+                /* every record is full */
+                size_t old_nr_records = nr_pkey_malloc_records;
+                size_t new_nr_records = (nr_pkey_malloc_records * 2 + 1);
+                size_t new_size = new_nr_records * sizeof(struct pkey_malloc_record);
+                dprintf2("new_nr_records: %zd\n", new_nr_records);
+                dprintf2("new_size: %zd\n", new_size);
+                pkey_malloc_records = realloc(pkey_malloc_records, new_size);
+                pkey_assert(pkey_malloc_records != NULL);
+                rec = &pkey_malloc_records[nr_pkey_malloc_records];
+                /*
+                 * realloc() does not initialize memory, so zero it from
+                 * the first new record all the way to the end.
+                 */
+                for (i = 0; i < new_nr_records - old_nr_records; i++)
+                        memset(rec + i, 0, sizeof(*rec));
+        }
+        dprintf3("filling malloc record[%d/%p]: {%p, %ld}\n",
+                (int)(rec - pkey_malloc_records), rec, ptr, size);
+        rec->ptr = ptr;
+        rec->size = size;
+        nr_pkey_malloc_records++;
+}
+
+void free_pkey_malloc(void *ptr)
+{
+        long i;
+        int ret;
+        dprintf3("%s(%p)\n", __func__, ptr);
+        for (i = 0; i < nr_pkey_malloc_records; i++) {
+                struct pkey_malloc_record *rec = &pkey_malloc_records[i];
+                dprintf4("looking for ptr %p at record[%ld/%p]: {%p, %ld}\n",
+                                ptr, i, rec, rec->ptr, rec->size);
+                if ((ptr <  rec->ptr) ||
+                    (ptr >= rec->ptr + rec->size))
+                        continue;
+
+                dprintf3("found ptr %p at record[%ld/%p]: {%p, %ld}\n",
+                                ptr, i, rec, rec->ptr, rec->size);
+                nr_pkey_malloc_records--;
+                ret = munmap(rec->ptr, rec->size);
+                dprintf3("munmap ret: %d\n", ret);
+                pkey_assert(!ret);
+                dprintf3("clearing rec->ptr, rec: %p\n", rec);
+                rec->ptr = NULL;
+                dprintf3("done clearing rec->ptr, rec: %p\n", rec);
+                return;
+        }
+        pkey_assert(false);
+}
+
+
+void *malloc_pkey_with_mprotect(long size, int prot, u16 pkey)
+{
+        void *ptr;
+        int ret;
+
+        rdpkru();
+        dprintf1("doing %s(size=%ld, prot=0x%x, pkey=%d)\n", __func__,
+                        size, prot, pkey);
+        pkey_assert(pkey < NR_PKEYS);
+        ptr = mmap(NULL, size, prot, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+        pkey_assert(ptr != (void *)-1);
+        ret = mprotect_pkey((void *)ptr, PAGE_SIZE, prot, pkey);
+        pkey_assert(!ret);
+        record_pkey_malloc(ptr, size);
+        rdpkru();
+
+        dprintf1("%s() for pkey %d @ %p\n", __func__, pkey, ptr);
+        return ptr;
+}
+
+void *malloc_pkey_anon_huge(long size, int prot, u16 pkey)
+{
+        int ret;
+        void *ptr;
+
+        dprintf1("doing %s(size=%ld, prot=0x%x, pkey=%d)\n", __func__,
+                        size, prot, pkey);
+        /*
+         * Guarantee we can fit at least one huge page in the resulting
+         * allocation by allocating space for 2:
+         */
+        size = ALIGN_UP(size, HPAGE_SIZE * 2);
+        ptr = mmap(NULL, size, PROT_NONE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+        pkey_assert(ptr != (void *)-1);
+        record_pkey_malloc(ptr, size);
+        mprotect_pkey(ptr, size, prot, pkey);
+
+        dprintf1("unaligned ptr: %p\n", ptr);
+        ptr = ALIGN_PTR_UP(ptr, HPAGE_SIZE);
+        dprintf1("  aligned ptr: %p\n", ptr);
+        ret = madvise(ptr, HPAGE_SIZE, MADV_HUGEPAGE);
+        dprintf1("MADV_HUGEPAGE ret: %d\n", ret);
+        ret = madvise(ptr, HPAGE_SIZE, MADV_WILLNEED);
+        dprintf1("MADV_WILLNEED ret: %d\n", ret);
+        memset(ptr, 0, HPAGE_SIZE);
+
+        dprintf1("mmap()'d thp for pkey %d @ %p\n", pkey, ptr);
+        return ptr;
+}
+
+int hugetlb_setup_ok;
+#define GET_NR_HUGE_PAGES 10
+void setup_hugetlbfs(void)
+{
+        int err;
+        int fd;
+        int validated_nr_pages;
+        int i;
+        char buf[] = "123";
+
+        if (geteuid() != 0) {
+                fprintf(stderr, "WARNING: not run as root, can not do hugetlb test\n");
+                return;
+        }
+
+        cat_into_file(__stringify(GET_NR_HUGE_PAGES), "/proc/sys/vm/nr_hugepages");
+
+        /*
+         * Now go make sure that we got the pages and that they
+         * are 2M pages.  Someone might have made 1G the default.
+         */
+        fd = open("/sys/kernel/mm/hugepages/hugepages-2048kB/nr_hugepages", O_RDONLY);
+        if (fd < 0) {
+                perror("opening sysfs 2M hugetlb config");
+                return;
+        }
+
+        /* -1 to guarantee leaving the trailing \0 */
+        err = read(fd, buf, sizeof(buf)-1);
+        close(fd);
+        if (err <= 0) {
+                perror("reading sysfs 2M hugetlb config");
+                return;
+        }
+
+        if (atoi(buf) != GET_NR_HUGE_PAGES) {
+                fprintf(stderr, "could not confirm 2M pages, got: '%s' expected %d\n",
+                        buf, GET_NR_HUGE_PAGES);
+                return;
+        }
+
+        hugetlb_setup_ok = 1;
+}
+
+void *malloc_pkey_hugetlb(long size, int prot, u16 pkey)
+{
+        void *ptr;
+        int flags = MAP_ANONYMOUS|MAP_PRIVATE|MAP_HUGETLB;
+
+        if (!hugetlb_setup_ok)
+                return PTR_ERR_ENOTSUP;
+
+        dprintf1("doing %s(%ld, %x, %x)\n", __func__, size, prot, pkey);
+        size = ALIGN_UP(size, HPAGE_SIZE * 2);
+        pkey_assert(pkey < NR_PKEYS);
+        ptr = mmap(NULL, size, PROT_NONE, flags, -1, 0);
+        pkey_assert(ptr != (void *)-1);
+        mprotect_pkey(ptr, size, prot, pkey);
+
+        record_pkey_malloc(ptr, size);
+
+        dprintf1("mmap()'d hugetlbfs for pkey %d @ %p\n", pkey, ptr);
+        return ptr;
+}
+
+void *malloc_pkey_mmap_dax(long size, int prot, u16 pkey)
+{
+        void *ptr;
+        int fd;
+
+        dprintf1("doing %s(size=%ld, prot=0x%x, pkey=%d)\n", __func__,
+                        size, prot, pkey);
+        pkey_assert(pkey < NR_PKEYS);
+        fd = open("/dax/foo", O_RDWR);
+        pkey_assert(fd >= 0);
+
+        ptr = mmap(0, size, prot, MAP_SHARED, fd, 0);
+        pkey_assert(ptr != (void *)-1);
+
+        mprotect_pkey(ptr, size, prot, pkey);
+
+        record_pkey_malloc(ptr, size);
+
+        dprintf1("mmap()'d for pkey %d @ %p\n", pkey, ptr);
+        close(fd);
+        return ptr;
+}
+
+void *(*pkey_malloc[])(long size, int prot, u16 pkey) = {
+
+        malloc_pkey_with_mprotect,
+        malloc_pkey_anon_huge,
+        malloc_pkey_hugetlb
+/* can not do direct with the pkey_mprotect() API:
+        malloc_pkey_mmap_direct,
+        malloc_pkey_mmap_dax,
+*/
+};
+
+void *malloc_pkey(long size, int prot, u16 pkey)
+{
+        void *ret;
+        static int malloc_type;
+        int nr_malloc_types = ARRAY_SIZE(pkey_malloc);
+
+        pkey_assert(pkey < NR_PKEYS);
+
+        while (1) {
+                pkey_assert(malloc_type < nr_malloc_types);
+
+                ret = pkey_malloc[malloc_type](size, prot, pkey);
+                pkey_assert(ret != (void *)-1);
+
+                malloc_type++;
+                if (malloc_type >= nr_malloc_types)
+                        malloc_type = (random()%nr_malloc_types);
+
+                /* try again if the malloc_type we tried is unsupported */
+                if (ret == PTR_ERR_ENOTSUP)
+                        continue;
+
+                break;
+        }
+
+        dprintf3("%s(%ld, prot=%x, pkey=%x) returning: %p\n", __func__,
+                        size, prot, pkey, ret);
+        return ret;
+}
+
+int last_pkru_faults;
+void expected_pk_fault(int pkey)
+{
+        dprintf2("%s(): last_pkru_faults: %d pkru_faults: %d\n",
+                        __func__, last_pkru_faults, pkru_faults);
+        dprintf2("%s(%d): last_si_pkey: %d\n", __func__, pkey, last_si_pkey);
+        pkey_assert(last_pkru_faults + 1 == pkru_faults);
+        pkey_assert(last_si_pkey == pkey);
+        /*
+         * The signal handler shold have cleared out PKRU to let the
+         * test program continue.  We now have to restore it.
+         */
+        if (__rdpkru() != 0)
+                pkey_assert(0);
+
+        __wrpkru(shadow_pkru);
+        dprintf1("%s() set PKRU=%x to restore state after signal nuked it\n",
+                        __func__, shadow_pkru);
+        last_pkru_faults = pkru_faults;
+        last_si_pkey = -1;
+}
+
+void do_not_expect_pk_fault(void)
+{
+        pkey_assert(last_pkru_faults == pkru_faults);
+}
+
+int test_fds[10] = { -1 };
+int nr_test_fds;
+void __save_test_fd(int fd)
+{
+        pkey_assert(fd >= 0);
+        pkey_assert(nr_test_fds < ARRAY_SIZE(test_fds));
+        test_fds[nr_test_fds] = fd;
+        nr_test_fds++;
+}
+
+int get_test_read_fd(void)
+{
+        int test_fd = open("/etc/passwd", O_RDONLY);
+        __save_test_fd(test_fd);
+        return test_fd;
+}
+
+void close_test_fds(void)
+{
+        int i;
+
+        for (i = 0; i < nr_test_fds; i++) {
+                if (test_fds[i] < 0)
+                        continue;
+                close(test_fds[i]);
+                test_fds[i] = -1;
+        }
+        nr_test_fds = 0;
+}
+
+#define barrier() __asm__ __volatile__("": : :"memory")
+__attribute__((noinline)) int read_ptr(int *ptr)
+{
+        /*
+         * Keep GCC from optimizing this away somehow
+         */
+        barrier();
+        return *ptr;
+}
+
+void test_read_of_write_disabled_region(int *ptr, u16 pkey)
+{
+        int ptr_contents;
+
+        dprintf1("disabling write access to PKEY[1], doing read\n");
+        pkey_write_deny(pkey);
+        ptr_contents = read_ptr(ptr);
+        dprintf1("*ptr: %d\n", ptr_contents);
+        dprintf1("\n");
+}
+void test_read_of_access_disabled_region(int *ptr, u16 pkey)
+{
+        int ptr_contents;
+
+        dprintf1("disabling access to PKEY[%02d], doing read @ %p\n", pkey, ptr);
+        rdpkru();
+        pkey_access_deny(pkey);
+        ptr_contents = read_ptr(ptr);
+        dprintf1("*ptr: %d\n", ptr_contents);
+        expected_pk_fault(pkey);
+}
+void test_write_of_write_disabled_region(int *ptr, u16 pkey)
+{
+        dprintf1("disabling write access to PKEY[%02d], doing write\n", pkey);
+        pkey_write_deny(pkey);
+        *ptr = __LINE__;
+        expected_pk_fault(pkey);
+}
+void test_write_of_access_disabled_region(int *ptr, u16 pkey)
+{
+        dprintf1("disabling access to PKEY[%02d], doing write\n", pkey);
+        pkey_access_deny(pkey);
+        *ptr = __LINE__;
+        expected_pk_fault(pkey);
+}
+void test_kernel_write_of_access_disabled_region(int *ptr, u16 pkey)
+{
+        int ret;
+        int test_fd = get_test_read_fd();
+
+        dprintf1("disabling access to PKEY[%02d], "
+                 "having kernel read() to buffer\n", pkey);
+        pkey_access_deny(pkey);
+        ret = read(test_fd, ptr, 1);
+        dprintf1("read ret: %d\n", ret);
+        pkey_assert(ret);
+}
+void test_kernel_write_of_write_disabled_region(int *ptr, u16 pkey)
+{
+        int ret;
+        int test_fd = get_test_read_fd();
+
+        pkey_write_deny(pkey);
+        ret = read(test_fd, ptr, 100);
+        dprintf1("read ret: %d\n", ret);
+        if (ret < 0 && (DEBUG_LEVEL > 0))
+                perror("verbose read result (OK for this to be bad)");
+        pkey_assert(ret);
+}
+
+void test_kernel_gup_of_access_disabled_region(int *ptr, u16 pkey)
+{
+        int pipe_ret, vmsplice_ret;
+        struct iovec iov;
+        int pipe_fds[2];
+
+        pipe_ret = pipe(pipe_fds);
+
+        pkey_assert(pipe_ret == 0);
+        dprintf1("disabling access to PKEY[%02d], "
+                 "having kernel vmsplice from buffer\n", pkey);
+        pkey_access_deny(pkey);
+        iov.iov_base = ptr;
+        iov.iov_len = PAGE_SIZE;
+        vmsplice_ret = vmsplice(pipe_fds[1], &iov, 1, SPLICE_F_GIFT);
+        dprintf1("vmsplice() ret: %d\n", vmsplice_ret);
+        pkey_assert(vmsplice_ret == -1);
+
+        close(pipe_fds[0]);
+        close(pipe_fds[1]);
+}
+
+void test_kernel_gup_write_to_write_disabled_region(int *ptr, u16 pkey)
+{
+        int ignored = 0xdada;
+        int futex_ret;
+        int some_int = __LINE__;
+
+        dprintf1("disabling write to PKEY[%02d], "
+                 "doing futex gunk in buffer\n", pkey);
+        *ptr = some_int;
+        pkey_write_deny(pkey);
+        futex_ret = syscall(SYS_futex, ptr, FUTEX_WAIT, some_int-1, NULL,
+                        &ignored, ignored);
+        if (DEBUG_LEVEL > 0)
+                perror("futex");
+        dprintf1("futex() ret: %d\n", futex_ret);
+}
+
+/* Assumes that all pkeys other than 'pkey' are unallocated */
+void test_pkey_syscalls_on_non_allocated_pkey(int *ptr, u16 pkey)
+{
+        int err;
+        int i;
+
+        /* Note: 0 is the default pkey, so don't mess with it */
+        for (i = 1; i < NR_PKEYS; i++) {
+                if (pkey == i)
+                        continue;
+
+                dprintf1("trying get/set/free to non-allocated pkey: %2d\n", i);
+                err = sys_pkey_free(i);
+                pkey_assert(err);
+
+                /* not enforced when pkey_get() is not a syscall
+                err = pkey_get(i, 0);
+                pkey_assert(err < 0);
+                */
+
+                err = sys_pkey_free(i);
+                pkey_assert(err);
+
+                err = sys_mprotect_pkey(ptr, PAGE_SIZE, PROT_READ, i);
+                pkey_assert(err);
+        }
+}
+
+/* Assumes that all pkeys other than 'pkey' are unallocated */
+void test_pkey_syscalls_bad_args(int *ptr, u16 pkey)
+{
+        int err;
+        int bad_flag = (PKEY_DISABLE_ACCESS | PKEY_DISABLE_WRITE) + 1;
+        int bad_pkey = NR_PKEYS+99;
+
+        /* not enforced when pkey_get() is not a syscall
+        err = pkey_get(bad_pkey, bad_flag);
+        pkey_assert(err < 0);
+        */
+
+        /* pass a known-invalid pkey in: */
+        err = sys_mprotect_pkey(ptr, PAGE_SIZE, PROT_READ, bad_pkey);
+        pkey_assert(err);
+}
+
+/* Assumes that all pkeys other than 'pkey' are unallocated */
+void test_pkey_alloc_exhaust(int *ptr, u16 pkey)
+{
+        unsigned long flags;
+        unsigned long init_val;
+        int err;
+        int allocated_pkeys[NR_PKEYS] = {0};
+        int nr_allocated_pkeys = 0;
+        int i;
+
+        for (i = 0; i < NR_PKEYS*2; i++) {
+                int new_pkey;
+                dprintf1("%s() alloc loop: %d\n", __func__, i);
+                new_pkey = alloc_pkey();
+                dprintf4("%s()::%d, err: %d pkru: 0x%x shadow: 0x%x\n", __func__,
+                                __LINE__, err, __rdpkru(), shadow_pkru);
+                rdpkru(); /* for shadow checking */
+                dprintf2("%s() errno: %d ENOSPC: %d\n", __func__, errno, ENOSPC);
+                if ((new_pkey == -1) && (errno == ENOSPC)) {
+                        dprintf2("%s() failed to allocate pkey after %d tries\n",
+                                __func__, nr_allocated_pkeys);
+                        break;
+                }
+                pkey_assert(nr_allocated_pkeys < NR_PKEYS);
+                allocated_pkeys[nr_allocated_pkeys++] = new_pkey;
+        }
+
+        dprintf3("%s()::%d\n", __func__, __LINE__);
+
+        /*
+         * ensure it did not reach the end of the loop without
+         * failure:
+         */
+        pkey_assert(i < NR_PKEYS*2);
+
+        /*
+         * There are 16 pkeys supported in hardware.  One is taken
+         * up for the default (0) and another can be taken up by
+         * an execute-only mapping.  Ensure that we can allocate
+         * at least 14 (16-2).
+         */
+        pkey_assert(i >= NR_PKEYS-2);
+
+        for (i = 0; i < nr_allocated_pkeys; i++) {
+                err = sys_pkey_free(allocated_pkeys[i]);
+                pkey_assert(!err);
+                rdpkru(); /* for shadow checking */
+        }
+}
+
+void test_ptrace_of_child(int *ptr, u16 pkey)
+{
+        __attribute__((__unused__)) int peek_result;
+        pid_t child_pid;
+        void *ignored = 0;
+        long ret;
+        int status;
+        /*
+         * This is the "control" for our little expermient.  Make sure
+         * we can always access it when ptracing.
+         */
+        int *plain_ptr_unaligned = malloc(HPAGE_SIZE);
+        int *plain_ptr = ALIGN_PTR_UP(plain_ptr_unaligned, PAGE_SIZE);
+
+        /*
+         * Fork a child which is an exact copy of this process, of course.
+         * That means we can do all of our tests via ptrace() and then plain
+         * memory access and ensure they work differently.
+         */
+        child_pid = fork_lazy_child();
+        dprintf1("[%d] child pid: %d\n", getpid(), child_pid);
+
+        ret = ptrace(PTRACE_ATTACH, child_pid, ignored, ignored);
+        if (ret)
+                perror("attach");
+        dprintf1("[%d] attach ret: %ld %d\n", getpid(), ret, __LINE__);
+        pkey_assert(ret != -1);
+        ret = waitpid(child_pid, &status, WUNTRACED);
+        if ((ret != child_pid) || !(WIFSTOPPED(status))) {
+                fprintf(stderr, "weird waitpid result %ld stat %x\n",
+                                ret, status);
+                pkey_assert(0);
+        }
+        dprintf2("waitpid ret: %ld\n", ret);
+        dprintf2("waitpid status: %d\n", status);
+
+        pkey_access_deny(pkey);
+        pkey_write_deny(pkey);
+
+        /* Write access, untested for now:
+        ret = ptrace(PTRACE_POKEDATA, child_pid, peek_at, data);
+        pkey_assert(ret != -1);
+        dprintf1("poke at %p: %ld\n", peek_at, ret);
+        */
+
+        /*
+         * Try to access the pkey-protected "ptr" via ptrace:
+         */
+        ret = ptrace(PTRACE_PEEKDATA, child_pid, ptr, ignored);
+        /* expect it to work, without an error: */
+        pkey_assert(ret != -1);
+        /* Now access from the current task, and expect an exception: */
+        peek_result = read_ptr(ptr);
+        expected_pk_fault(pkey);
+
+        /*
+         * Try to access the NON-pkey-protected "plain_ptr" via ptrace:
+         */
+        ret = ptrace(PTRACE_PEEKDATA, child_pid, plain_ptr, ignored);
+        /* expect it to work, without an error: */
+        pkey_assert(ret != -1);
+        /* Now access from the current task, and expect NO exception: */
+        peek_result = read_ptr(plain_ptr);
+        do_not_expect_pk_fault();
+
+        ret = ptrace(PTRACE_DETACH, child_pid, ignored, 0);
+        pkey_assert(ret != -1);
+
+        ret = kill(child_pid, SIGKILL);
+        pkey_assert(ret != -1);
+
+        wait(&status);
+
+        free(plain_ptr_unaligned);
+}
+
+void test_executing_on_unreadable_memory(int *ptr, u16 pkey)
+{
+        void *p1;
+        int scratch;
+        int ptr_contents;
+        int ret;
+
+        p1 = ALIGN_PTR_UP(&lots_o_noops_around_write, PAGE_SIZE);
+        dprintf3("&lots_o_noops: %p\n", &lots_o_noops_around_write);
+        /* lots_o_noops_around_write should be page-aligned already */
+        assert(p1 == &lots_o_noops_around_write);
+
+        /* Point 'p1' at the *second* page of the function: */
+        p1 += PAGE_SIZE;
+
+        madvise(p1, PAGE_SIZE, MADV_DONTNEED);
+        lots_o_noops_around_write(&scratch);
+        ptr_contents = read_ptr(p1);
+        dprintf2("ptr (%p) contents@%d: %x\n", p1, __LINE__, ptr_contents);
+
+        ret = mprotect_pkey(p1, PAGE_SIZE, PROT_EXEC, (u64)pkey);
+        pkey_assert(!ret);
+        pkey_access_deny(pkey);
+
+        dprintf2("pkru: %x\n", rdpkru());
+
+        /*
+         * Make sure this is an *instruction* fault
+         */
+        madvise(p1, PAGE_SIZE, MADV_DONTNEED);
+        lots_o_noops_around_write(&scratch);
+        do_not_expect_pk_fault();
+        ptr_contents = read_ptr(p1);
+        dprintf2("ptr (%p) contents@%d: %x\n", p1, __LINE__, ptr_contents);
+        expected_pk_fault(pkey);
+}
+
+void test_mprotect_pkey_on_unsupported_cpu(int *ptr, u16 pkey)
+{
+        int size = PAGE_SIZE;
+        int sret;
+
+        if (cpu_has_pku()) {
+                dprintf1("SKIP: %s: no CPU support\n", __func__);
+                return;
+        }
+
+        sret = syscall(SYS_mprotect_key, ptr, size, PROT_READ, pkey);
+        pkey_assert(sret < 0);
+}
+
+void (*pkey_tests[])(int *ptr, u16 pkey) = {
+        test_read_of_write_disabled_region,
+        test_read_of_access_disabled_region,
+        test_write_of_write_disabled_region,
+        test_write_of_access_disabled_region,
+        test_kernel_write_of_access_disabled_region,
+        test_kernel_write_of_write_disabled_region,
+        test_kernel_gup_of_access_disabled_region,
+        test_kernel_gup_write_to_write_disabled_region,
+        test_executing_on_unreadable_memory,
+        test_ptrace_of_child,
+        test_pkey_syscalls_on_non_allocated_pkey,
+        test_pkey_syscalls_bad_args,
+        test_pkey_alloc_exhaust,
+};
+
+void run_tests_once(void)
+{
+        int *ptr;
+        int prot = PROT_READ|PROT_WRITE;
+
+        for (test_nr = 0; test_nr < ARRAY_SIZE(pkey_tests); test_nr++) {
+                int pkey;
+                int orig_pkru_faults = pkru_faults;
+
+                dprintf1("======================\n");
+                dprintf1("test %d preparing...\n", test_nr);
+
+                tracing_on();
+                pkey = alloc_random_pkey();
+                dprintf1("test %d starting with pkey: %d\n", test_nr, pkey);
+                ptr = malloc_pkey(PAGE_SIZE, prot, pkey);
+                dprintf1("test %d starting...\n", test_nr);
+                pkey_tests[test_nr](ptr, pkey);
+                dprintf1("freeing test memory: %p\n", ptr);
+                free_pkey_malloc(ptr);
+                sys_pkey_free(pkey);
+
+                dprintf1("pkru_faults: %d\n", pkru_faults);
+                dprintf1("orig_pkru_faults: %d\n", orig_pkru_faults);
+
+                tracing_off();
+                close_test_fds();
+
+                printf("test %2d PASSED (itertation %d)\n", test_nr, iteration_nr);
+                dprintf1("======================\n\n");
+        }
+        iteration_nr++;
+}
+
+void pkey_setup_shadow(void)
+{
+        shadow_pkru = __rdpkru();
+}
+
+int main(void)
+{
+        int nr_iterations = 22;
+
+        setup_handlers();
+
+        printf("has pku: %d\n", cpu_has_pku());
+
+        if (!cpu_has_pku()) {
+                int size = PAGE_SIZE;
+                int *ptr;
+
+                printf("running PKEY tests for unsupported CPU/OS\n");
+
+                ptr  = mmap(NULL, size, PROT_NONE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+                assert(ptr != (void *)-1);
+                test_mprotect_pkey_on_unsupported_cpu(ptr, 1);
+                exit(0);
+        }
+
+        pkey_setup_shadow();
+        printf("startup pkru: %x\n", rdpkru());
+        setup_hugetlbfs();
+
+        while (nr_iterations-- > 0)
+                run_tests_once();
+
+        printf("done (all tests OK)\n");
+        return 0;
+}
diff --git a/tools/testing/selftests/x86/ptrace_syscall.c b/tools/testing/selftests/x86/ptrace_syscall.c
index 421456784bc6..b037ce9cf116 100644
--- a/tools/testing/selftests/x86/ptrace_syscall.c
+++ b/tools/testing/selftests/x86/ptrace_syscall.c
@@ -147,7 +147,7 @@ static void test_sys32_regs(void (*do_syscall)(struct syscall_args32 *))
         if (args.nr != getpid() ||
             args.arg0 != 10 || args.arg1 != 11 || args.arg2 != 12 ||
             args.arg3 != 13 || args.arg4 != 14 || args.arg5 != 15) {
-                printf("[FAIL]\tgetpid() failed to preseve regs\n");
+                printf("[FAIL]\tgetpid() failed to preserve regs\n");
                 nerrs++;
         } else {
                 printf("[OK]\tgetpid() preserves regs\n");
@@ -162,7 +162,7 @@ static void test_sys32_regs(void (*do_syscall)(struct syscall_args32 *))
         if (args.nr != 0 ||
             args.arg0 != getpid() || args.arg1 != SIGUSR1 || args.arg2 != 12 ||
             args.arg3 != 13 || args.arg4 != 14 || args.arg5 != 15) {
-                printf("[FAIL]\tkill(getpid(), SIGUSR1) failed to preseve regs\n");
+                printf("[FAIL]\tkill(getpid(), SIGUSR1) failed to preserve regs\n");
                 nerrs++;
         } else {
                 printf("[OK]\tkill(getpid(), SIGUSR1) preserves regs\n");
diff --git a/tools/testing/selftests/x86/sigreturn.c b/tools/testing/selftests/x86/sigreturn.c
index 8a577e7070c6..246145b84a12 100644
--- a/tools/testing/selftests/x86/sigreturn.c
+++ b/tools/testing/selftests/x86/sigreturn.c
@@ -106,7 +106,7 @@ asm (".pushsection .text\n\t"
      ".type int3, @function\n\t"
      ".align 4096\n\t"
      "int3:\n\t"
-     "mov %ss,%eax\n\t"
+     "mov %ss,%ecx\n\t"
      "int3\n\t"
      ".size int3, . - int3\n\t"
      ".align 4096, 0xcc\n\t"
@@ -306,7 +306,7 @@ static volatile sig_atomic_t sig_corrupt_final_ss;
 #ifdef __x86_64__
 # define REG_IP REG_RIP
 # define REG_SP REG_RSP
-# define REG_AX REG_RAX
+# define REG_CX REG_RCX
 
 struct selectors {
         unsigned short cs, gs, fs, ss;
@@ -326,7 +326,7 @@ static unsigned short *csptr(ucontext_t *ctx)
 #else
 # define REG_IP REG_EIP
 # define REG_SP REG_ESP
-# define REG_AX REG_EAX
+# define REG_CX REG_ECX
 
 static greg_t *ssptr(ucontext_t *ctx)
 {
@@ -457,10 +457,10 @@ static void sigusr1(int sig, siginfo_t *info, void *ctx_void)
         ctx->uc_mcontext.gregs[REG_IP] =
                 sig_cs == code16_sel ? 0 : (unsigned long)&int3;
         ctx->uc_mcontext.gregs[REG_SP] = (unsigned long)0x8badf00d5aadc0deULL;
-        ctx->uc_mcontext.gregs[REG_AX] = 0;
+        ctx->uc_mcontext.gregs[REG_CX] = 0;
 
         memcpy(&requested_regs, &ctx->uc_mcontext.gregs, sizeof(gregset_t));
-        requested_regs[REG_AX] = *ssptr(ctx);   /* The asm code does this. */
+        requested_regs[REG_CX] = *ssptr(ctx);   /* The asm code does this. */
 
         return;
 }
@@ -482,7 +482,7 @@ static void sigtrap(int sig, siginfo_t *info, void *ctx_void)
         unsigned short ss;
         asm ("mov %%ss,%0" : "=r" (ss));
 
-        greg_t asm_ss = ctx->uc_mcontext.gregs[REG_AX];
+        greg_t asm_ss = ctx->uc_mcontext.gregs[REG_CX];
         if (asm_ss != sig_ss && sig == SIGTRAP) {
                 /* Sanity check failure. */
                 printf("[FAIL]\tSIGTRAP: ss = %hx, frame ss = %hx, ax = %llx\n",
@@ -654,8 +654,8 @@ static int test_valid_sigreturn(int cs_bits, bool use_16bit_ss, int force_ss)
 #endif
 
                 /* Sanity check on the kernel */
-                if (i == REG_AX && requested_regs[i] != resulting_regs[i]) {
-                        printf("[FAIL]\tAX (saved SP) mismatch: requested 0x%llx; got 0x%llx\n",
+                if (i == REG_CX && requested_regs[i] != resulting_regs[i]) {
+                        printf("[FAIL]\tCX (saved SP) mismatch: requested 0x%llx; got 0x%llx\n",
                                (unsigned long long)requested_regs[i],
                                (unsigned long long)resulting_regs[i]);
                         nerrs++;
diff --git a/tools/testing/selftests/x86/test_mremap_vdso.c b/tools/testing/selftests/x86/test_mremap_vdso.c
new file mode 100644
index 000000000000..bf0d687c7db7
--- /dev/null
+++ b/tools/testing/selftests/x86/test_mremap_vdso.c
@@ -0,0 +1,111 @@
+/*
+ * 32-bit test to check vDSO mremap.
+ *
+ * Copyright (c) 2016 Dmitry Safonov
+ * Suggested-by: Andrew Lutomirski
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+/*
+ * Can be built statically:
+ * gcc -Os -Wall -static -m32 test_mremap_vdso.c
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <sys/mman.h>
+#include <sys/auxv.h>
+#include <sys/syscall.h>
+#include <sys/wait.h>
+
+#define PAGE_SIZE       4096
+
+static int try_to_remap(void *vdso_addr, unsigned long size)
+{
+        void *dest_addr, *new_addr;
+
+        /* Searching for memory location where to remap */
+        dest_addr = mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
+        if (dest_addr == MAP_FAILED) {
+                printf("[WARN]\tmmap failed (%d): %m\n", errno);
+                return 0;
+        }
+
+        printf("[NOTE]\tMoving vDSO: [%p, %#lx] -> [%p, %#lx]\n",
+                vdso_addr, (unsigned long)vdso_addr + size,
+                dest_addr, (unsigned long)dest_addr + size);
+        fflush(stdout);
+
+        new_addr = mremap(vdso_addr, size, size,
+                        MREMAP_FIXED|MREMAP_MAYMOVE, dest_addr);
+        if ((unsigned long)new_addr == (unsigned long)-1) {
+                munmap(dest_addr, size);
+                if (errno == EINVAL) {
+                        printf("[NOTE]\tvDSO partial move failed, will try with bigger size\n");
+                        return -1; /* Retry with larger */
+                }
+                printf("[FAIL]\tmremap failed (%d): %m\n", errno);
+                return 1;
+        }
+
+        return 0;
+
+}
+
+int main(int argc, char **argv, char **envp)
+{
+        pid_t child;
+
+        child = fork();
+        if (child == -1) {
+                printf("[WARN]\tfailed to fork (%d): %m\n", errno);
+                return 1;
+        }
+
+        if (child == 0) {
+                unsigned long vdso_size = PAGE_SIZE;
+                unsigned long auxval;
+                int ret = -1;
+
+                auxval = getauxval(AT_SYSINFO_EHDR);
+                printf("\tAT_SYSINFO_EHDR is %#lx\n", auxval);
+                if (!auxval || auxval == -ENOENT) {
+                        printf("[WARN]\tgetauxval failed\n");
+                        return 0;
+                }
+
+                /* Simpler than parsing ELF header */
+                while (ret < 0) {
+                        ret = try_to_remap((void *)auxval, vdso_size);
+                        vdso_size += PAGE_SIZE;
+                }
+
+                /* Glibc is likely to explode now - exit with raw syscall */
+                asm volatile ("int $0x80" : : "a" (__NR_exit), "b" (!!ret));
+        } else {
+                int status;
+
+                if (waitpid(child, &status, 0) != child ||
+                        !WIFEXITED(status)) {
+                        printf("[FAIL]\tmremap() of the vDSO does not work on this kernel!\n");
+                        return 1;
+                } else if (WEXITSTATUS(status) != 0) {
+                        printf("[FAIL]\tChild failed with %d\n",
+                                        WEXITSTATUS(status));
+                        return 1;
+                }
+                printf("[OK]\n");
+        }
+
+        return 0;
+}
diff --git a/tools/testing/selftests/zram/README b/tools/testing/selftests/zram/README
index eb17917c8a3a..7972cc512408 100644
--- a/tools/testing/selftests/zram/README
+++ b/tools/testing/selftests/zram/README
@@ -13,7 +13,7 @@ Statistics for individual zram devices are exported through sysfs nodes at
 
 Kconfig required:
 CONFIG_ZRAM=y
-CONFIG_ZRAM_LZ4_COMPRESS=y
+CONFIG_CRYPTO_LZ4=y
 CONFIG_ZPOOL=y
 CONFIG_ZSMALLOC=y
 
diff --git a/tools/virtio/linux/dma-mapping.h b/tools/virtio/linux/dma-mapping.h
index 4f93af89ae16..18601f6689b9 100644
--- a/tools/virtio/linux/dma-mapping.h
+++ b/tools/virtio/linux/dma-mapping.h
@@ -14,4 +14,20 @@ enum dma_data_direction {
         DMA_NONE = 3,
 };
 
+#define dma_alloc_coherent(d, s, hp, f) ({ \
+        void *__dma_alloc_coherent_p = kmalloc((s), (f)); \
+        *(hp) = (unsigned long)__dma_alloc_coherent_p; \
+        __dma_alloc_coherent_p; \
+})
+
+#define dma_free_coherent(d, s, p, h) kfree(p)
+
+#define dma_map_page(d, p, o, s, dir) (page_to_phys(p) + (o))
+
+#define dma_map_single(d, p, s, dir) (virt_to_phys(p))
+#define dma_mapping_error(...) (0)
+
+#define dma_unmap_single(...) do { } while (0)
+#define dma_unmap_page(...) do { } while (0)
+
 #endif
diff --git a/tools/virtio/linux/kernel.h b/tools/virtio/linux/kernel.h
index 033849948215..d9554fc3f340 100644
--- a/tools/virtio/linux/kernel.h
+++ b/tools/virtio/linux/kernel.h
@@ -20,7 +20,9 @@
 
 #define PAGE_SIZE getpagesize()
 #define PAGE_MASK (~(PAGE_SIZE-1))
+#define PAGE_ALIGN(x) ((x + PAGE_SIZE - 1) & PAGE_MASK)
 
+typedef unsigned long long phys_addr_t;
 typedef unsigned long long dma_addr_t;
 typedef size_t __kernel_size_t;
 typedef unsigned int __wsum;
@@ -57,6 +59,11 @@ static inline void *kzalloc(size_t s, gfp_t gfp)
         return p;
 }
 
+static inline void *alloc_pages_exact(size_t s, gfp_t gfp)
+{
+        return kmalloc(s, gfp);
+}
+
 static inline void kfree(void *p)
 {
         if (p >= __kfree_ignore_start && p < __kfree_ignore_end)
@@ -64,6 +71,11 @@ static inline void kfree(void *p)
         free(p);
 }
 
+static inline void free_pages_exact(void *p, size_t s)
+{
+        kfree(p);
+}
+
 static inline void *krealloc(void *p, size_t s, gfp_t gfp)
 {
         return realloc(p, s);
@@ -105,6 +117,8 @@ static inline void free_page(unsigned long addr)
 #define dev_err(dev, format, ...) fprintf (stderr, format, ## __VA_ARGS__)
 #define dev_warn(dev, format, ...) fprintf (stderr, format, ## __VA_ARGS__)
 
+#define WARN_ON_ONCE(cond) ((cond) && fprintf (stderr, "WARNING\n"))
+
 #define min(x, y) ({                            \
         typeof(x) _min1 = (x);                  \
         typeof(y) _min2 = (y);                  \
diff --git a/tools/virtio/linux/slab.h b/tools/virtio/linux/slab.h
index 81baeac8ae40..7e1c1197d439 100644
--- a/tools/virtio/linux/slab.h
+++ b/tools/virtio/linux/slab.h
@@ -1,2 +1,6 @@
 #ifndef LINUX_SLAB_H
+#define GFP_KERNEL 0
+#define GFP_ATOMIC 0
+#define __GFP_NOWARN 0
+#define __GFP_ZERO 0
 #endif
diff --git a/tools/virtio/linux/virtio.h b/tools/virtio/linux/virtio.h
index ee125e714053..9377c8b4ac16 100644
--- a/tools/virtio/linux/virtio.h
+++ b/tools/virtio/linux/virtio.h
@@ -3,8 +3,12 @@
 #include <linux/scatterlist.h>
 #include <linux/kernel.h>
 
+struct device {
+        void *parent;
+};
+
 struct virtio_device {
-        void *dev;
+        struct device dev;
         u64 features;
 };
 
diff --git a/tools/virtio/linux/virtio_config.h b/tools/virtio/linux/virtio_config.h
index 57a6964a1e35..9ba11815e0a1 100644
--- a/tools/virtio/linux/virtio_config.h
+++ b/tools/virtio/linux/virtio_config.h
@@ -40,6 +40,19 @@ static inline void __virtio_clear_bit(struct virtio_device *vdev,
 #define virtio_has_feature(dev, feature) \
         (__virtio_test_bit((dev), feature))
 
+/**
+ * virtio_has_iommu_quirk - determine whether this device has the iommu quirk
+ * @vdev: the device
+ */
+static inline bool virtio_has_iommu_quirk(const struct virtio_device *vdev)
+{
+        /*
+         * Note the reverse polarity of the quirk feature (compared to most
+         * other features), this is for compatibility with legacy systems.
+         */
+        return !virtio_has_feature(vdev, VIRTIO_F_IOMMU_PLATFORM);
+}
+
 static inline bool virtio_is_little_endian(struct virtio_device *vdev)
 {
         return virtio_has_feature(vdev, VIRTIO_F_VERSION_1) ||
diff --git a/tools/virtio/ringtest/Makefile b/tools/virtio/ringtest/Makefile
index 6ba745529833..877a8a4721b6 100644
--- a/tools/virtio/ringtest/Makefile
+++ b/tools/virtio/ringtest/Makefile
@@ -1,6 +1,6 @@
 all:
 
-all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder
+all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder ptr_ring noring
 
 CFLAGS += -Wall
 CFLAGS += -pthread -O2 -ggdb
@@ -8,6 +8,7 @@ LDFLAGS += -pthread -O2 -ggdb
 
 main.o: main.c main.h
 ring.o: ring.c main.h
+ptr_ring.o: ptr_ring.c main.h ../../../include/linux/ptr_ring.h
 virtio_ring_0_9.o: virtio_ring_0_9.c main.h
 virtio_ring_poll.o: virtio_ring_poll.c virtio_ring_0_9.c main.h
 virtio_ring_inorder.o: virtio_ring_inorder.c virtio_ring_0_9.c main.h
@@ -15,11 +16,15 @@ ring: ring.o main.o
 virtio_ring_0_9: virtio_ring_0_9.o main.o
 virtio_ring_poll: virtio_ring_poll.o main.o
 virtio_ring_inorder: virtio_ring_inorder.o main.o
+ptr_ring: ptr_ring.o main.o
+noring: noring.o main.o
 clean:
         -rm main.o
         -rm ring.o ring
         -rm virtio_ring_0_9.o virtio_ring_0_9
         -rm virtio_ring_poll.o virtio_ring_poll
         -rm virtio_ring_inorder.o virtio_ring_inorder
+        -rm ptr_ring.o ptr_ring
+        -rm noring.o noring
 
 .PHONY: all clean
diff --git a/tools/virtio/ringtest/README b/tools/virtio/ringtest/README
index 34e94c46104f..d83707a336c9 100644
--- a/tools/virtio/ringtest/README
+++ b/tools/virtio/ringtest/README
@@ -1,2 +1,6 @@
 Partial implementation of various ring layouts, useful to tune virtio design.
 Uses shared memory heavily.
+
+Typical use:
+
+# sh run-on-all.sh perf stat -r 10 --log-fd 1 -- ./ring
diff --git a/tools/virtio/ringtest/noring.c b/tools/virtio/ringtest/noring.c
new file mode 100644
index 000000000000..eda2f4824130
--- /dev/null
+++ b/tools/virtio/ringtest/noring.c
@@ -0,0 +1,69 @@
+#define _GNU_SOURCE
+#include "main.h"
+#include <assert.h>
+
+/* stub implementation: useful for measuring overhead */
+void alloc_ring(void)
+{
+}
+
+/* guest side */
+int add_inbuf(unsigned len, void *buf, void *datap)
+{
+        return 0;
+}
+
+/*
+ * skb_array API provides no way for producer to find out whether a given
+ * buffer was consumed.  Our tests merely require that a successful get_buf
+ * implies that add_inbuf succeed in the past, and that add_inbuf will succeed,
+ * fake it accordingly.
+ */
+void *get_buf(unsigned *lenp, void **bufp)
+{
+        return "Buffer";
+}
+
+void poll_used(void)
+{
+}
+
+void disable_call()
+{
+        assert(0);
+}
+
+bool enable_call()
+{
+        assert(0);
+}
+
+void kick_available(void)
+{
+        assert(0);
+}
+
+/* host side */
+void disable_kick()
+{
+        assert(0);
+}
+
+bool enable_kick()
+{
+        assert(0);
+}
+
+void poll_avail(void)
+{
+}
+
+bool use_buf(unsigned *lenp, void **bufp)
+{
+        return true;
+}
+
+void call_used(void)
+{
+        assert(0);
+}
diff --git a/tools/virtio/ringtest/ptr_ring.c b/tools/virtio/ringtest/ptr_ring.c
new file mode 100644
index 000000000000..bd2ad1d3b7a9
--- /dev/null
+++ b/tools/virtio/ringtest/ptr_ring.c
@@ -0,0 +1,198 @@
+#define _GNU_SOURCE
+#include "main.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <pthread.h>
+#include <malloc.h>
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+
+#define SMP_CACHE_BYTES 64
+#define cache_line_size() SMP_CACHE_BYTES
+#define ____cacheline_aligned_in_smp __attribute__ ((aligned (SMP_CACHE_BYTES)))
+#define unlikely(x)    (__builtin_expect(!!(x), 0))
+#define likely(x)    (__builtin_expect(!!(x), 1))
+#define ALIGN(x, a) (((x) + (a) - 1) / (a) * (a))
+typedef pthread_spinlock_t  spinlock_t;
+
+typedef int gfp_t;
+static void *kmalloc(unsigned size, gfp_t gfp)
+{
+        return memalign(64, size);
+}
+
+static void *kzalloc(unsigned size, gfp_t gfp)
+{
+        void *p = memalign(64, size);
+        if (!p)
+                return p;
+        memset(p, 0, size);
+
+        return p;
+}
+
+static void kfree(void *p)
+{
+        if (p)
+                free(p);
+}
+
+static void spin_lock_init(spinlock_t *lock)
+{
+        int r = pthread_spin_init(lock, 0);
+        assert(!r);
+}
+
+static void spin_lock(spinlock_t *lock)
+{
+        int ret = pthread_spin_lock(lock);
+        assert(!ret);
+}
+
+static void spin_unlock(spinlock_t *lock)
+{
+        int ret = pthread_spin_unlock(lock);
+        assert(!ret);
+}
+
+static void spin_lock_bh(spinlock_t *lock)
+{
+        spin_lock(lock);
+}
+
+static void spin_unlock_bh(spinlock_t *lock)
+{
+        spin_unlock(lock);
+}
+
+static void spin_lock_irq(spinlock_t *lock)
+{
+        spin_lock(lock);
+}
+
+static void spin_unlock_irq(spinlock_t *lock)
+{
+        spin_unlock(lock);
+}
+
+static void spin_lock_irqsave(spinlock_t *lock, unsigned long f)
+{
+        spin_lock(lock);
+}
+
+static void spin_unlock_irqrestore(spinlock_t *lock, unsigned long f)
+{
+        spin_unlock(lock);
+}
+
+#include "../../../include/linux/ptr_ring.h"
+
+static unsigned long long headcnt, tailcnt;
+static struct ptr_ring array ____cacheline_aligned_in_smp;
+
+/* implemented by ring */
+void alloc_ring(void)
+{
+        int ret = ptr_ring_init(&array, ring_size, 0);
+        assert(!ret);
+}
+
+/* guest side */
+int add_inbuf(unsigned len, void *buf, void *datap)
+{
+        int ret;
+
+        ret = __ptr_ring_produce(&array, buf);
+        if (ret >= 0) {
+                ret = 0;
+                headcnt++;
+        }
+
+        return ret;
+}
+
+/*
+ * ptr_ring API provides no way for producer to find out whether a given
+ * buffer was consumed.  Our tests merely require that a successful get_buf
+ * implies that add_inbuf succeed in the past, and that add_inbuf will succeed,
+ * fake it accordingly.
+ */
+void *get_buf(unsigned *lenp, void **bufp)
+{
+        void *datap;
+
+        if (tailcnt == headcnt || __ptr_ring_full(&array))
+                datap = NULL;
+        else {
+                datap = "Buffer\n";
+                ++tailcnt;
+        }
+
+        return datap;
+}
+
+void poll_used(void)
+{
+        void *b;
+
+        do {
+                if (tailcnt == headcnt || __ptr_ring_full(&array)) {
+                        b = NULL;
+                        barrier();
+                } else {
+                        b = "Buffer\n";
+                }
+        } while (!b);
+}
+
+void disable_call()
+{
+        assert(0);
+}
+
+bool enable_call()
+{
+        assert(0);
+}
+
+void kick_available(void)
+{
+        assert(0);
+}
+
+/* host side */
+void disable_kick()
+{
+        assert(0);
+}
+
+bool enable_kick()
+{
+        assert(0);
+}
+
+void poll_avail(void)
+{
+        void *b;
+
+        do {
+                barrier();
+                b = __ptr_ring_peek(&array);
+        } while (!b);
+}
+
+bool use_buf(unsigned *lenp, void **bufp)
+{
+        void *ptr;
+
+        ptr = __ptr_ring_consume(&array);
+
+        return ptr;
+}
+
+void call_used(void)
+{
+        assert(0);
+}
diff --git a/tools/virtio/ringtest/run-on-all.sh b/tools/virtio/ringtest/run-on-all.sh
index 52b0f71ffa8d..2e69ca812b4c 100755
--- a/tools/virtio/ringtest/run-on-all.sh
+++ b/tools/virtio/ringtest/run-on-all.sh
@@ -3,10 +3,10 @@
 #use last CPU for host. Why not the first?
 #many devices tend to use cpu0 by default so
 #it tends to be busier
-HOST_AFFINITY=$(cd /dev/cpu; ls|grep -v '[a-z]'|sort -n|tail -1)
+HOST_AFFINITY=$(lscpu -p=cpu | tail -1)
 
 #run command on all cpus
-for cpu in $(cd /dev/cpu; ls|grep -v '[a-z]'|sort -n);
+for cpu in $(seq 0 $HOST_AFFINITY)
 do
         #Don't run guest and host on same CPU
         #It actually works ok if using signalling
diff --git a/tools/vm/page_owner_sort.c b/tools/vm/page_owner_sort.c
index 77147b42d598..f1c055f3c243 100644
--- a/tools/vm/page_owner_sort.c
+++ b/tools/vm/page_owner_sort.c
@@ -79,12 +79,12 @@ static void add_list(char *buf, int len)
         }
 }
 
-#define BUF_SIZE        1024
+#define BUF_SIZE        (128 * 1024)
 
 int main(int argc, char **argv)
 {
         FILE *fin, *fout;
-        char buf[BUF_SIZE];
+        char *buf;
         int ret, i, count;
         struct block_list *list2;
         struct stat st;
@@ -107,6 +107,11 @@ int main(int argc, char **argv)
         max_size = st.st_size / 100; /* hack ... */
 
         list = malloc(max_size * sizeof(*list));
+        buf = malloc(BUF_SIZE);
+        if (!list || !buf) {
+                printf("Out of memory\n");
+                exit(1);
+        }
 
         for ( ; ; ) {
                 ret = read_block(buf, BUF_SIZE, fin);
diff --git a/tools/vm/slabinfo.c b/tools/vm/slabinfo.c
index 1889163f2f05..b9d34b37c017 100644
--- a/tools/vm/slabinfo.c
+++ b/tools/vm/slabinfo.c
@@ -492,7 +492,7 @@ static void slab_stats(struct slabinfo *s)
                         s->deactivate_to_head + s->deactivate_to_tail + s->deactivate_bypass;
 
         if (total) {
-                printf("\nSlab Deactivation             Ocurrences  %%\n");
+                printf("\nSlab Deactivation             Occurrences %%\n");
                 printf("-------------------------------------------------\n");
                 printf("Slab full                     %7lu  %3lu%%\n",
                         s->deactivate_full, (s->deactivate_full * 100) / total);
@@ -510,10 +510,11 @@ static void slab_stats(struct slabinfo *s)
                         s->alloc_node_mismatch, (s->alloc_node_mismatch * 100) / total);
         }
 
-        if (s->cmpxchg_double_fail || s->cmpxchg_double_cpu_fail)
+        if (s->cmpxchg_double_fail || s->cmpxchg_double_cpu_fail) {
                 printf("\nCmpxchg_double Looping\n------------------------\n");
                 printf("Locked Cmpxchg Double redos   %lu\nUnlocked Cmpxchg Double redos %lu\n",
                         s->cmpxchg_double_fail, s->cmpxchg_double_cpu_fail);
+        }
 }
 
 static void report(struct slabinfo *s)