99 files changed, 5138 insertions, 1762 deletions

diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
new file mode 100644
index 000000000000..11224eddcdc2
--- /dev/null
+++ b/tools/hv/hv_kvp_daemon.c
@@ -0,0 +1,500 @@
+/*
+ * An implementation of key value pair (KVP) functionality for Linux.
+ *
+ *
+ * Copyright (C) 2010, Novell, Inc.
+ * Author : K. Y. Srinivasan <ksrinivasan@novell.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, GOOD TITLE or
+ * NON INFRINGEMENT.  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 <sys/types.h>
+#include <sys/socket.h>
+#include <sys/poll.h>
+#include <sys/utsname.h>
+#include <linux/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <linux/connector.h>
+#include <linux/netlink.h>
+#include <ifaddrs.h>
+#include <netdb.h>
+#include <syslog.h>
+
+/*
+ * KYS: TODO. Need to register these in the kernel.
+ *
+ * The following definitions are shared with the in-kernel component; do not
+ * change any of this without making the corresponding changes in
+ * the KVP kernel component.
+ */
+#define CN_KVP_IDX              0x9     /* MSFT KVP functionality */
+#define CN_KVP_VAL              0x1 /* This supports queries from the kernel */
+#define CN_KVP_USER_VAL         0x2 /* This supports queries from the user  */
+
+/*
+ * KVP protocol: The user mode component first registers with the
+ * the kernel component. Subsequently, the kernel component requests, data
+ * for the specified keys. In response to this message the user mode component
+ * fills in the value corresponding to the specified key. We overload the
+ * sequence field in the cn_msg header to define our KVP message types.
+ *
+ * We use this infrastructure for also supporting queries from user mode
+ * application for state that may be maintained in the KVP kernel component.
+ *
+ * XXXKYS: Have a shared header file between the user and kernel (TODO)
+ */
+
+enum kvp_op {
+        KVP_REGISTER = 0, /* Register the user mode component*/
+        KVP_KERNEL_GET, /*Kernel is requesting the value for the specified key*/
+        KVP_KERNEL_SET, /*Kernel is providing the value for the specified key*/
+        KVP_USER_GET, /*User is requesting the value for the specified key*/
+        KVP_USER_SET /*User is providing the value for the specified key*/
+};
+
+#define HV_KVP_EXCHANGE_MAX_KEY_SIZE    512
+#define HV_KVP_EXCHANGE_MAX_VALUE_SIZE  2048
+
+struct hv_ku_msg {
+        __u32   kvp_index;
+        __u8  kvp_key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; /* Key name */
+        __u8  kvp_value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; /* Key  value */
+};
+
+enum key_index {
+        FullyQualifiedDomainName = 0,
+        IntegrationServicesVersion, /*This key is serviced in the kernel*/
+        NetworkAddressIPv4,
+        NetworkAddressIPv6,
+        OSBuildNumber,
+        OSName,
+        OSMajorVersion,
+        OSMinorVersion,
+        OSVersion,
+        ProcessorArchitecture
+};
+
+/*
+ * End of shared definitions.
+ */
+
+static char kvp_send_buffer[4096];
+static char kvp_recv_buffer[4096];
+static struct sockaddr_nl addr;
+
+static char *os_name = "";
+static char *os_major = "";
+static char *os_minor = "";
+static char *processor_arch;
+static char *os_build;
+static char *lic_version;
+static struct utsname uts_buf;
+
+void kvp_get_os_info(void)
+{
+        FILE    *file;
+        char    *p, buf[512];
+
+        uname(&uts_buf);
+        os_build = uts_buf.release;
+        processor_arch = uts_buf.machine;
+
+        /*
+         * The current windows host (win7) expects the build
+         * string to be of the form: x.y.z
+         * Strip additional information we may have.
+         */
+        p = strchr(os_build, '-');
+        if (p)
+                *p = '\0';
+
+        file = fopen("/etc/SuSE-release", "r");
+        if (file != NULL)
+                goto kvp_osinfo_found;
+        file  = fopen("/etc/redhat-release", "r");
+        if (file != NULL)
+                goto kvp_osinfo_found;
+        /*
+         * Add code for other supported platforms.
+         */
+
+        /*
+         * We don't have information about the os.
+         */
+        os_name = uts_buf.sysname;
+        return;
+
+kvp_osinfo_found:
+        /* up to three lines */
+        p = fgets(buf, sizeof(buf), file);
+        if (p) {
+                p = strchr(buf, '\n');
+                if (p)
+                        *p = '\0';
+                p = strdup(buf);
+                if (!p)
+                        goto done;
+                os_name = p;
+
+                /* second line */
+                p = fgets(buf, sizeof(buf), file);
+                if (p) {
+                        p = strchr(buf, '\n');
+                        if (p)
+                                *p = '\0';
+                        p = strdup(buf);
+                        if (!p)
+                                goto done;
+                        os_major = p;
+
+                        /* third line */
+                        p = fgets(buf, sizeof(buf), file);
+                        if (p)  {
+                                p = strchr(buf, '\n');
+                                if (p)
+                                        *p = '\0';
+                                p = strdup(buf);
+                                if (p)
+                                        os_minor = p;
+                        }
+                }
+        }
+
+done:
+        fclose(file);
+        return;
+}
+
+static int
+kvp_get_ip_address(int family, char *buffer, int length)
+{
+        struct ifaddrs *ifap;
+        struct ifaddrs *curp;
+        int ipv4_len = strlen("255.255.255.255") + 1;
+        int ipv6_len = strlen("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")+1;
+        int offset = 0;
+        const char *str;
+        char tmp[50];
+        int error = 0;
+
+        /*
+         * On entry into this function, the buffer is capable of holding the
+         * maximum key value (2048 bytes).
+         */
+
+        if (getifaddrs(&ifap)) {
+                strcpy(buffer, "getifaddrs failed\n");
+                return 1;
+        }
+
+        curp = ifap;
+        while (curp != NULL) {
+                if ((curp->ifa_addr != NULL) &&
+                   (curp->ifa_addr->sa_family == family)) {
+                        if (family == AF_INET) {
+                                struct sockaddr_in *addr =
+                                (struct sockaddr_in *) curp->ifa_addr;
+
+                                str = inet_ntop(family, &addr->sin_addr,
+                                                tmp, 50);
+                                if (str == NULL) {
+                                        strcpy(buffer, "inet_ntop failed\n");
+                                        error = 1;
+                                        goto getaddr_done;
+                                }
+                                if (offset == 0)
+                                        strcpy(buffer, tmp);
+                                else
+                                        strcat(buffer, tmp);
+                                strcat(buffer, ";");
+
+                                offset += strlen(str) + 1;
+                                if ((length - offset) < (ipv4_len + 1))
+                                        goto getaddr_done;
+
+                        } else {
+
+                        /*
+                         * We only support AF_INET and AF_INET6
+                         * and the list of addresses is separated by a ";".
+                         */
+                                struct sockaddr_in6 *addr =
+                                (struct sockaddr_in6 *) curp->ifa_addr;
+
+                                str = inet_ntop(family,
+                                        &addr->sin6_addr.s6_addr,
+                                        tmp, 50);
+                                if (str == NULL) {
+                                        strcpy(buffer, "inet_ntop failed\n");
+                                        error = 1;
+                                        goto getaddr_done;
+                                }
+                                if (offset == 0)
+                                        strcpy(buffer, tmp);
+                                else
+                                        strcat(buffer, tmp);
+                                strcat(buffer, ";");
+                                offset += strlen(str) + 1;
+                                if ((length - offset) < (ipv6_len + 1))
+                                        goto getaddr_done;
+
+                        }
+
+                }
+                curp = curp->ifa_next;
+        }
+
+getaddr_done:
+        freeifaddrs(ifap);
+        return error;
+}
+
+
+static int
+kvp_get_domain_name(char *buffer, int length)
+{
+        struct addrinfo hints, *info ;
+        int error = 0;
+
+        gethostname(buffer, length);
+        memset(&hints, 0, sizeof(hints));
+        hints.ai_family = AF_INET; /*Get only ipv4 addrinfo. */
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = AI_CANONNAME;
+
+        error = getaddrinfo(buffer, NULL, &hints, &info);
+        if (error != 0) {
+                strcpy(buffer, "getaddrinfo failed\n");
+                return error;
+        }
+        strcpy(buffer, info->ai_canonname);
+        freeaddrinfo(info);
+        return error;
+}
+
+static int
+netlink_send(int fd, struct cn_msg *msg)
+{
+        struct nlmsghdr *nlh;
+        unsigned int size;
+        struct msghdr message;
+        char buffer[64];
+        struct iovec iov[2];
+
+        size = NLMSG_SPACE(sizeof(struct cn_msg) + msg->len);
+
+        nlh = (struct nlmsghdr *)buffer;
+        nlh->nlmsg_seq = 0;
+        nlh->nlmsg_pid = getpid();
+        nlh->nlmsg_type = NLMSG_DONE;
+        nlh->nlmsg_len = NLMSG_LENGTH(size - sizeof(*nlh));
+        nlh->nlmsg_flags = 0;
+
+        iov[0].iov_base = nlh;
+        iov[0].iov_len = sizeof(*nlh);
+
+        iov[1].iov_base = msg;
+        iov[1].iov_len = size;
+
+        memset(&message, 0, sizeof(message));
+        message.msg_name = &addr;
+        message.msg_namelen = sizeof(addr);
+        message.msg_iov = iov;
+        message.msg_iovlen = 2;
+
+        return sendmsg(fd, &message, 0);
+}
+
+int main(void)
+{
+        int fd, len, sock_opt;
+        int error;
+        struct cn_msg *message;
+        struct pollfd pfd;
+        struct nlmsghdr *incoming_msg;
+        struct cn_msg   *incoming_cn_msg;
+        struct hv_ku_msg *hv_msg;
+        char    *p;
+        char    *key_value;
+        char    *key_name;
+
+        daemon(1, 0);
+        openlog("KVP", 0, LOG_USER);
+        syslog(LOG_INFO, "KVP starting; pid is:%d", getpid());
+        /*
+         * Retrieve OS release information.
+         */
+        kvp_get_os_info();
+
+        fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
+        if (fd < 0) {
+                syslog(LOG_ERR, "netlink socket creation failed; error:%d", fd);
+                exit(-1);
+        }
+        addr.nl_family = AF_NETLINK;
+        addr.nl_pad = 0;
+        addr.nl_pid = 0;
+        addr.nl_groups = CN_KVP_IDX;
+
+
+        error = bind(fd, (struct sockaddr *)&addr, sizeof(addr));
+        if (error < 0) {
+                syslog(LOG_ERR, "bind failed; error:%d", error);
+                close(fd);
+                exit(-1);
+        }
+        sock_opt = addr.nl_groups;
+        setsockopt(fd, 270, 1, &sock_opt, sizeof(sock_opt));
+        /*
+         * Register ourselves with the kernel.
+         */
+        message = (struct cn_msg *)kvp_send_buffer;
+        message->id.idx = CN_KVP_IDX;
+        message->id.val = CN_KVP_VAL;
+        message->seq = KVP_REGISTER;
+        message->ack = 0;
+        message->len = 0;
+
+        len = netlink_send(fd, message);
+        if (len < 0) {
+                syslog(LOG_ERR, "netlink_send failed; error:%d", len);
+                close(fd);
+                exit(-1);
+        }
+
+        pfd.fd = fd;
+
+        while (1) {
+                pfd.events = POLLIN;
+                pfd.revents = 0;
+                poll(&pfd, 1, -1);
+
+                len = recv(fd, kvp_recv_buffer, sizeof(kvp_recv_buffer), 0);
+
+                if (len < 0) {
+                        syslog(LOG_ERR, "recv failed; error:%d", len);
+                        close(fd);
+                        return -1;
+                }
+
+                incoming_msg = (struct nlmsghdr *)kvp_recv_buffer;
+                incoming_cn_msg = (struct cn_msg *)NLMSG_DATA(incoming_msg);
+
+                switch (incoming_cn_msg->seq) {
+                case KVP_REGISTER:
+                        /*
+                         * Driver is registering with us; stash away the version
+                         * information.
+                         */
+                        p = (char *)incoming_cn_msg->data;
+                        lic_version = malloc(strlen(p) + 1);
+                        if (lic_version) {
+                                strcpy(lic_version, p);
+                                syslog(LOG_INFO, "KVP LIC Version: %s",
+                                        lic_version);
+                        } else {
+                                syslog(LOG_ERR, "malloc failed");
+                        }
+                        continue;
+
+                case KVP_KERNEL_GET:
+                        break;
+                default:
+                        continue;
+                }
+
+                hv_msg = (struct hv_ku_msg *)incoming_cn_msg->data;
+                key_name = (char *)hv_msg->kvp_key;
+                key_value = (char *)hv_msg->kvp_value;
+
+                switch (hv_msg->kvp_index) {
+                case FullyQualifiedDomainName:
+                        kvp_get_domain_name(key_value,
+                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
+                        strcpy(key_name, "FullyQualifiedDomainName");
+                        break;
+                case IntegrationServicesVersion:
+                        strcpy(key_name, "IntegrationServicesVersion");
+                        strcpy(key_value, lic_version);
+                        break;
+                case NetworkAddressIPv4:
+                        kvp_get_ip_address(AF_INET, key_value,
+                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
+                        strcpy(key_name, "NetworkAddressIPv4");
+                        break;
+                case NetworkAddressIPv6:
+                        kvp_get_ip_address(AF_INET6, key_value,
+                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
+                        strcpy(key_name, "NetworkAddressIPv6");
+                        break;
+                case OSBuildNumber:
+                        strcpy(key_value, os_build);
+                        strcpy(key_name, "OSBuildNumber");
+                        break;
+                case OSName:
+                        strcpy(key_value, os_name);
+                        strcpy(key_name, "OSName");
+                        break;
+                case OSMajorVersion:
+                        strcpy(key_value, os_major);
+                        strcpy(key_name, "OSMajorVersion");
+                        break;
+                case OSMinorVersion:
+                        strcpy(key_value, os_minor);
+                        strcpy(key_name, "OSMinorVersion");
+                        break;
+                case OSVersion:
+                        strcpy(key_value, os_build);
+                        strcpy(key_name, "OSVersion");
+                        break;
+                case ProcessorArchitecture:
+                        strcpy(key_value, processor_arch);
+                        strcpy(key_name, "ProcessorArchitecture");
+                        break;
+                default:
+                        strcpy(key_value, "Unknown Key");
+                        /*
+                         * We use a null key name to terminate enumeration.
+                         */
+                        strcpy(key_name, "");
+                        break;
+                }
+                /*
+                 * Send the value back to the kernel. The response is
+                 * already in the receive buffer. Update the cn_msg header to
+                 * reflect the key value that has been added to the message
+                 */
+
+                incoming_cn_msg->id.idx = CN_KVP_IDX;
+                incoming_cn_msg->id.val = CN_KVP_VAL;
+                incoming_cn_msg->seq = KVP_USER_SET;
+                incoming_cn_msg->ack = 0;
+                incoming_cn_msg->len = sizeof(struct hv_ku_msg);
+
+                len = netlink_send(fd, incoming_cn_msg);
+                if (len < 0) {
+                        syslog(LOG_ERR, "net_link send failed; error:%d", len);
+                        exit(-1);
+                }
+        }
+
+}
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
index 85c5f026930d..fe6762ed56bd 100644
--- a/tools/perf/Documentation/perf-annotate.txt
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -72,6 +72,19 @@ OPTIONS
         CPUs are specified with -: 0-2. Default is to report samples on all
         CPUs.
 
+--asm-raw::
+        Show raw instruction encoding of assembly instructions.
+
+--source::
+        Interleave source code with assembly code. Enabled by default,
+        disable with --no-source.
+
+--symfs=<directory>::
+        Look for files with symbols relative to this directory.
+
+-M::
+--disassembler-style=:: Set disassembler style for objdump.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-buildid-list.txt b/tools/perf/Documentation/perf-buildid-list.txt
index 5eaac6f26d51..cc22325ffd1b 100644
--- a/tools/perf/Documentation/perf-buildid-list.txt
+++ b/tools/perf/Documentation/perf-buildid-list.txt
@@ -16,6 +16,9 @@ This command displays the buildids found in a perf.data file, so that other
 tools can be used to fetch packages with matching symbol tables for use by
 perf report.
 
+It can also be used to show the build id of the running kernel or in an ELF
+file using -i/--input.
+
 OPTIONS
 -------
 -H::
@@ -27,6 +30,9 @@ OPTIONS
 -f::
 --force::
         Don't do ownership validation.
+-k::
+--kernel::
+        Show running kernel build id.
 -v::
 --verbose::
         Be more verbose.
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 04253c07d19a..212f24d672e1 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -134,6 +134,24 @@ OPTIONS
         CPUs are specified with -: 0-2. Default is to report samples on all
         CPUs.
 
+-M::
+--disassembler-style=:: Set disassembler style for objdump.
+
+--source::
+        Interleave source code with assembly code. Enabled by default,
+        disable with --no-source.
+
+--asm-raw::
+        Show raw instruction encoding of assembly instructions.
+
+--show-total-period:: Show a column with the sum of periods.
+
+-I::
+--show-info::
+        Display extended information about the perf.data file. This adds
+        information which may be very large and thus may clutter the display.
+        It currently includes: cpu and numa topology of the host system.
+
 SEE ALSO
 --------
-linkperf:perf-stat[1]
+linkperf:perf-stat[1], linkperf:perf-annotate[1]
diff --git a/tools/perf/Documentation/perf-sched.txt b/tools/perf/Documentation/perf-sched.txt
index 46822d5fde1c..5b212b57f70b 100644
--- a/tools/perf/Documentation/perf-sched.txt
+++ b/tools/perf/Documentation/perf-sched.txt
@@ -8,7 +8,7 @@ perf-sched - Tool to trace/measure scheduler properties (latencies)
 SYNOPSIS
 --------
 [verse]
-'perf sched' {record|latency|map|replay|trace}
+'perf sched' {record|latency|map|replay|script}
 
 DESCRIPTION
 -----------
@@ -20,8 +20,8 @@ There are five variants of perf sched:
   'perf sched latency' to report the per task scheduling latencies
   and other scheduling properties of the workload.
 
-  'perf sched trace' to see a detailed trace of the workload that
-  was recorded.
+  'perf sched script' to see a detailed trace of the workload that
+   was recorded (aliased to 'perf script' for now).
 
   'perf sched replay' to simulate the workload that was recorded
   via perf sched record. (this is done by starting up mockup threads
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index db017867d9e8..dec87ecb530e 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -188,6 +188,13 @@ OPTIONS
         CPUs are specified with -: 0-2. Default is to report samples on all
         CPUs.
 
+-I::
+--show-info::
+        Display extended information about the perf.data file. This adds
+        information which may be very large and thus may clutter the display.
+        It currently includes: cpu and numa topology of the host system.
+        It can only be used with the perf script report mode.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 918cc38ee6d1..8966b9ab2014 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -94,6 +94,22 @@ an empty cgroup (monitor all the time) using, e.g., -G foo,,bar. Cgroups must ha
 corresponding events, i.e., they always refer to events defined earlier on the command
 line.
 
+-o file::
+--output file::
+Print the output into the designated file.
+
+--append::
+Append to the output file designated with the -o option. Ignored if -o is not specified.
+
+--log-fd::
+
+Log output to fd, instead of stderr.  Complementary to --output, and mutually exclusive
+with it.  --append may be used here.  Examples:
+     3>results  perf stat --log-fd 3          -- $cmd
+     3>>results perf stat --log-fd 3 --append -- $cmd
+
+
+
 EXAMPLES
 --------
 
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index f6eb1cdafb77..b1a5bbbfebef 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -106,6 +106,51 @@ Default is to monitor all CPUS.
 --zero::
         Zero history across display updates.
 
+-s::
+--sort::
+        Sort by key(s): pid, comm, dso, symbol, parent
+
+-n::
+--show-nr-samples::
+        Show a column with the number of samples.
+
+--show-total-period::
+        Show a column with the sum of periods.
+
+--dsos::
+        Only consider symbols in these dsos.
+
+--comms::
+        Only consider symbols in these comms.
+
+--symbols::
+        Only consider these symbols.
+
+-M::
+--disassembler-style=:: Set disassembler style for objdump.
+
+--source::
+        Interleave source code with assembly code. Enabled by default,
+        disable with --no-source.
+
+--asm-raw::
+        Show raw instruction encoding of assembly instructions.
+
+-G [type,min,order]::
+--call-graph::
+        Display call chains using type, min percent threshold and order.
+        type can be either:
+        - flat: single column, linear exposure of call chains.
+        - graph: use a graph tree, displaying absolute overhead rates.
+        - fractal: like graph, but displays relative rates. Each branch of
+                 the tree is considered as a new profiled object.
+
+        order can be either:
+        - callee: callee based call graph.
+        - caller: inverted caller based call graph.
+
+        Default: fractal,0.5,callee.
+
 INTERACTIVE PROMPTING KEYS
 --------------------------
 
@@ -130,9 +175,6 @@ INTERACTIVE PROMPTING KEYS
 [S]::
         Stop annotation, return to full profile display.
 
-[w]::
-        Toggle between weighted sum and individual count[E]r profile.
-
 [z]::
         Toggle event count zeroing across display updates.
 
diff --git a/tools/perf/Documentation/perfconfig.example b/tools/perf/Documentation/perfconfig.example
new file mode 100644
index 000000000000..d1448668f4d4
--- /dev/null
+++ b/tools/perf/Documentation/perfconfig.example
@@ -0,0 +1,20 @@
+[colors]
+
+        # These were the old defaults
+        top = red, lightgray
+        medium = green, lightgray
+        normal = black, lightgray
+        selected = lightgray, magenta
+        code = blue, lightgray
+
+[tui]
+
+        # Defaults if linked with libslang
+        report = on
+        annotate = on
+        top = on
+
+[buildid]
+
+        # Default, disable using /dev/null
+        dir = /root/.debug
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 56d62d3fb167..b98e3075646b 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -30,6 +30,8 @@ endif
 # Define EXTRA_CFLAGS=-m64 or EXTRA_CFLAGS=-m32 as appropriate for cross-builds.
 #
 # Define NO_DWARF if you do not want debug-info analysis feature at all.
+#
+# Define WERROR=0 to disable treating any warnings as errors.
 
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
         @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
@@ -63,6 +65,11 @@ ifeq ($(ARCH),x86_64)
         endif
 endif
 
+# Treat warnings as errors unless directed not to
+ifneq ($(WERROR),0)
+        CFLAGS_WERROR := -Werror
+endif
+
 #
 # Include saner warnings here, which can catch bugs:
 #
@@ -95,7 +102,7 @@ ifndef PERF_DEBUG
   CFLAGS_OPTIMIZE = -O6
 endif
 
-CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
+CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
 ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
@@ -181,9 +188,9 @@ strip-libs = $(filter-out -l%,$(1))
 
 $(OUTPUT)python/perf.so: $(PYRF_OBJS)
         $(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
-          --quiet build_ext \
-          --build-lib='$(OUTPUT)python' \
-          --build-temp='$(OUTPUT)python/temp'
+          --quiet build_ext; \
+        mkdir -p $(OUTPUT)python && \
+        cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
 #
 # No Perl scripts right now:
 #
@@ -459,13 +466,13 @@ else
                 LIB_OBJS += $(OUTPUT)util/ui/browsers/annotate.o
                 LIB_OBJS += $(OUTPUT)util/ui/browsers/hists.o
                 LIB_OBJS += $(OUTPUT)util/ui/browsers/map.o
-                LIB_OBJS += $(OUTPUT)util/ui/browsers/top.o
                 LIB_OBJS += $(OUTPUT)util/ui/helpline.o
                 LIB_OBJS += $(OUTPUT)util/ui/progress.o
                 LIB_OBJS += $(OUTPUT)util/ui/util.o
                 LIB_H += util/ui/browser.h
                 LIB_H += util/ui/browsers/map.h
                 LIB_H += util/ui/helpline.h
+                LIB_H += util/ui/keysyms.h
                 LIB_H += util/ui/libslang.h
                 LIB_H += util/ui/progress.h
                 LIB_H += util/ui/util.h
@@ -509,9 +516,13 @@ else
 
   PYTHON_WORD := $(call shell-wordify,$(PYTHON))
 
-  python-clean := $(PYTHON_WORD) util/setup.py clean \
-    --build-lib='$(OUTPUT)python' \
-    --build-temp='$(OUTPUT)python/temp'
+  # python extension build directories
+  PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
+  PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
+  PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
+  export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
+
+  python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 
   ifdef NO_LIBPYTHON
     $(call disable-python)
@@ -718,9 +729,6 @@ $(OUTPUT)util/ui/browser.o: util/ui/browser.c $(OUTPUT)PERF-CFLAGS
 $(OUTPUT)util/ui/browsers/annotate.o: util/ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-$(OUTPUT)util/ui/browsers/top.o: util/ui/browsers/top.c $(OUTPUT)PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
-
 $(OUTPUT)util/ui/browsers/hists.o: util/ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
@@ -868,6 +876,9 @@ install: all
         $(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
         $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
 
+install-python_ext:
+        $(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
+
 install-doc:
         $(MAKE) -C Documentation install
 
@@ -895,7 +906,7 @@ quick-install-html:
 ### Cleaning rules
 
 clean:
-        $(RM) $(OUTPUT){*.o,*/*.o,*/*/*.o,*/*/*/*.o,$(LIB_FILE),perf-archive}
+        $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS)
         $(RM) $(ALL_PROGRAMS) perf
         $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
         $(MAKE) -C Documentation/ clean
diff --git a/tools/perf/arch/arm/util/dwarf-regs.c b/tools/perf/arch/arm/util/dwarf-regs.c
index fff6450c8c99..e8d5c551c69c 100644
--- a/tools/perf/arch/arm/util/dwarf-regs.c
+++ b/tools/perf/arch/arm/util/dwarf-regs.c
@@ -8,7 +8,10 @@
  * published by the Free Software Foundation.
  */
 
+#include <stdlib.h>
+#ifndef __UCLIBC__
 #include <libio.h>
+#endif
 #include <dwarf-regs.h>
 
 struct pt_regs_dwarfnum {
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index 15130b50dfe3..744e629797be 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -2,3 +2,4 @@ ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
diff --git a/tools/perf/arch/powerpc/util/header.c b/tools/perf/arch/powerpc/util/header.c
new file mode 100644
index 000000000000..eba80c292945
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/header.c
@@ -0,0 +1,36 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../util/header.h"
+
+#define __stringify_1(x)        #x
+#define __stringify(x)          __stringify_1(x)
+
+#define mfspr(rn)       ({unsigned long rval; \
+                         asm volatile("mfspr %0," __stringify(rn) \
+                                      : "=r" (rval)); rval; })
+
+#define SPRN_PVR        0x11F   /* Processor Version Register */
+#define PVR_VER(pvr)    (((pvr) >>  16) & 0xFFFF) /* Version field */
+#define PVR_REV(pvr)    (((pvr) >>   0) & 0xFFFF) /* Revison field */
+
+int
+get_cpuid(char *buffer, size_t sz)
+{
+        unsigned long pvr;
+        int nb;
+
+        pvr = mfspr(SPRN_PVR);
+
+        nb = snprintf(buffer, sz, "%lu,%lu$", PVR_VER(pvr), PVR_REV(pvr));
+
+        /* look for end marker to ensure the entire data fit */
+        if (strchr(buffer, '$')) {
+                buffer[nb-1] = '\0';
+                return 0;
+        }
+        return -1;
+}
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
index 15130b50dfe3..744e629797be 100644
--- a/tools/perf/arch/x86/Makefile
+++ b/tools/perf/arch/x86/Makefile
@@ -2,3 +2,4 @@ ifndef NO_DWARF
 PERF_HAVE_DWARF_REGS := 1
 LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
 endif
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/header.o
diff --git a/tools/perf/arch/x86/util/header.c b/tools/perf/arch/x86/util/header.c
new file mode 100644
index 000000000000..f94006068d2b
--- /dev/null
+++ b/tools/perf/arch/x86/util/header.c
@@ -0,0 +1,59 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "../../util/header.h"
+
+static inline void
+cpuid(unsigned int op, unsigned int *a, unsigned int *b, unsigned int *c,
+      unsigned int *d)
+{
+        __asm__ __volatile__ (".byte 0x53\n\tcpuid\n\t"
+                              "movl %%ebx, %%esi\n\t.byte 0x5b"
+                        : "=a" (*a),
+                        "=S" (*b),
+                        "=c" (*c),
+                        "=d" (*d)
+                        : "a" (op));
+}
+
+int
+get_cpuid(char *buffer, size_t sz)
+{
+        unsigned int a, b, c, d, lvl;
+        int family = -1, model = -1, step = -1;
+        int nb;
+        char vendor[16];
+
+        cpuid(0, &lvl, &b, &c, &d);
+        strncpy(&vendor[0], (char *)(&b), 4);
+        strncpy(&vendor[4], (char *)(&d), 4);
+        strncpy(&vendor[8], (char *)(&c), 4);
+        vendor[12] = '\0';
+
+        if (lvl >= 1) {
+                cpuid(1, &a, &b, &c, &d);
+
+                family = (a >> 8) & 0xf;  /* bits 11 - 8 */
+                model  = (a >> 4) & 0xf;  /* Bits  7 - 4 */
+                step   = a & 0xf;
+
+                /* extended family */
+                if (family == 0xf)
+                        family += (a >> 20) & 0xff;
+
+                /* extended model */
+                if (family >= 0x6)
+                        model += ((a >> 16) & 0xf) << 4;
+        }
+        nb = snprintf(buffer, sz, "%s,%u,%u,%u$", vendor, family, model, step);
+
+        /* look for end marker to ensure the entire data fit */
+        if (strchr(buffer, '$')) {
+                buffer[nb-1] = '\0';
+                return 0;
+        }
+        return -1;
+}
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 555aefd7fe01..46b4c24f338e 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -114,10 +114,11 @@ static int hist_entry__tty_annotate(struct hist_entry *he, int evidx)
                                     print_line, full_paths, 0, 0);
 }
 
-static void hists__find_annotations(struct hists *self, int evidx)
+static void hists__find_annotations(struct hists *self, int evidx,
+                                    int nr_events)
 {
         struct rb_node *nd = rb_first(&self->entries), *next;
-        int key = KEY_RIGHT;
+        int key = K_RIGHT;
 
         while (nd) {
                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
@@ -129,7 +130,7 @@ static void hists__find_annotations(struct hists *self, int evidx)
                 notes = symbol__annotation(he->ms.sym);
                 if (notes->src == NULL) {
 find_next:
-                        if (key == KEY_LEFT)
+                        if (key == K_LEFT)
                                 nd = rb_prev(nd);
                         else
                                 nd = rb_next(nd);
@@ -137,12 +138,13 @@ find_next:
                 }
 
                 if (use_browser > 0) {
-                        key = hist_entry__tui_annotate(he, evidx);
+                        key = hist_entry__tui_annotate(he, evidx, nr_events,
+                                                       NULL, NULL, 0);
                         switch (key) {
-                        case KEY_RIGHT:
+                        case K_RIGHT:
                                 next = rb_next(nd);
                                 break;
-                        case KEY_LEFT:
+                        case K_LEFT:
                                 next = rb_prev(nd);
                                 break;
                         default:
@@ -215,7 +217,8 @@ static int __cmd_annotate(void)
                         total_nr_samples += nr_samples;
                         hists__collapse_resort(hists);
                         hists__output_resort(hists);
-                        hists__find_annotations(hists, pos->idx);
+                        hists__find_annotations(hists, pos->idx,
+                                                session->evlist->nr_entries);
                 }
         }
 
@@ -267,6 +270,14 @@ static const struct option options[] = {
         OPT_BOOLEAN('P', "full-paths", &full_paths,
                     "Don't shorten the displayed pathnames"),
         OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
+        OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
+                   "Look for files with symbols relative to this directory"),
+        OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
+                    "Interleave source code with assembly code (default)"),
+        OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
+                    "Display raw encoding of assembly instructions (default)"),
+        OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
+                   "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_END()
 };
 
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 5af32ae9031e..cb690a65bf02 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -1,7 +1,8 @@
 /*
  * builtin-buildid-list.c
  *
- * Builtin buildid-list command: list buildids in perf.data
+ * Builtin buildid-list command: list buildids in perf.data, in the running
+ * kernel and in ELF files.
  *
  * Copyright (C) 2009, Red Hat Inc.
  * Copyright (C) 2009, Arnaldo Carvalho de Melo <acme@redhat.com>
@@ -15,8 +16,11 @@
 #include "util/session.h"
 #include "util/symbol.h"
 
+#include <libelf.h>
+
 static char const *input_name = "perf.data";
 static bool force;
+static bool show_kernel;
 static bool with_hits;
 
 static const char * const buildid_list_usage[] = {
@@ -29,12 +33,13 @@ static const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('k', "kernel", &show_kernel, "Show current kernel build id"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose"),
         OPT_END()
 };
 
-static int __cmd_buildid_list(void)
+static int perf_session__list_build_ids(void)
 {
         struct perf_session *session;
 
@@ -52,6 +57,49 @@ static int __cmd_buildid_list(void)
         return 0;
 }
 
+static int sysfs__fprintf_build_id(FILE *fp)
+{
+        u8 kallsyms_build_id[BUILD_ID_SIZE];
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        if (sysfs__read_build_id("/sys/kernel/notes", kallsyms_build_id,
+                                 sizeof(kallsyms_build_id)) != 0)
+                return -1;
+
+        build_id__sprintf(kallsyms_build_id, sizeof(kallsyms_build_id),
+                          sbuild_id);
+        fprintf(fp, "%s\n", sbuild_id);
+        return 0;
+}
+
+static int filename__fprintf_build_id(const char *name, FILE *fp)
+{
+        u8 build_id[BUILD_ID_SIZE];
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        if (filename__read_build_id(name, build_id,
+                                    sizeof(build_id)) != sizeof(build_id))
+                return 0;
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        return fprintf(fp, "%s\n", sbuild_id);
+}
+
+static int __cmd_buildid_list(void)
+{
+        if (show_kernel)
+                return sysfs__fprintf_build_id(stdout);
+
+        elf_version(EV_CURRENT);
+        /*
+         * See if this is an ELF file first:
+         */
+        if (filename__fprintf_build_id(input_name, stdout))
+                return 0;
+
+        return perf_session__list_build_ids();
+}
+
 int cmd_buildid_list(int argc, const char **argv, const char *prefix __used)
 {
         argc = parse_options(argc, argv, options, buildid_list_usage, 0);
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index e8219990f8b8..b39f3a1ee7dc 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -162,7 +162,7 @@ static int __cmd_diff(void)
 
         hists__match(&session[0]->hists, &session[1]->hists);
         hists__fprintf(&session[1]->hists, &session[0]->hists,
-                       show_displacement, stdout);
+                       show_displacement, true, 0, 0, stdout);
 out_delete:
         for (i = 0; i < 2; ++i)
                 perf_session__delete(session[i]);
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 9ac05aafd9b2..899080ace267 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -942,10 +942,10 @@ static const char *record_args[] = {
         "-f",
         "-m", "1024",
         "-c", "1",
-        "-e", "lock:lock_acquire:r",
-        "-e", "lock:lock_acquired:r",
-        "-e", "lock:lock_contended:r",
-        "-e", "lock:lock_release:r",
+        "-e", "lock:lock_acquire",
+        "-e", "lock:lock_acquired",
+        "-e", "lock:lock_contended",
+        "-e", "lock:lock_release",
 };
 
 static int __cmd_record(int argc, const char **argv)
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 5f2a5c7046df..710ae3d0a489 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -134,10 +134,18 @@ static int opt_show_lines(const struct option *opt __used,
 {
         int ret = 0;
 
-        if (str)
-                ret = parse_line_range_desc(str, &params.line_range);
-        INIT_LIST_HEAD(&params.line_range.line_list);
+        if (!str)
+                return 0;
+
+        if (params.show_lines) {
+                pr_warning("Warning: more than one --line options are"
+                           " detected. Only the first one is valid.\n");
+                return 0;
+        }
+
         params.show_lines = true;
+        ret = parse_line_range_desc(str, &params.line_range);
+        INIT_LIST_HEAD(&params.line_range.line_list);
 
         return ret;
 }
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 80dc5b790e47..f82480fa7f27 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -30,8 +30,6 @@
 #include <sched.h>
 #include <sys/mman.h>
 
-#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
-
 enum write_mode_t {
         WRITE_FORCE,
         WRITE_APPEND
@@ -47,7 +45,7 @@ static int			freq				=   1000;
 static int                      output;
 static int                      pipe_output                     =      0;
 static const char               *output_name                    = NULL;
-static int                      group                           =      0;
+static bool                     group                           =  false;
 static int                      realtime_prio                   =      0;
 static bool                     nodelay                         =  false;
 static bool                     raw_samples                     =  false;
@@ -75,6 +73,7 @@ static off_t			post_processing_offset;
 
 static struct perf_session      *session;
 static const char               *cpu_list;
+static const char               *progname;
 
 static void advance_output(size_t size)
 {
@@ -139,17 +138,29 @@ static void mmap_read(struct perf_mmap *md)
 
 static volatile int done = 0;
 static volatile int signr = -1;
+static volatile int child_finished = 0;
 
 static void sig_handler(int sig)
 {
+        if (sig == SIGCHLD)
+                child_finished = 1;
+
         done = 1;
         signr = sig;
 }
 
 static void sig_atexit(void)
 {
-        if (child_pid > 0)
-                kill(child_pid, SIGTERM);
+        int status;
+
+        if (child_pid > 0) {
+                if (!child_finished)
+                        kill(child_pid, SIGTERM);
+
+                wait(&status);
+                if (WIFSIGNALED(status))
+                        psignal(WTERMSIG(status), progname);
+        }
 
         if (signr == -1 || signr == SIGUSR1)
                 return;
@@ -163,6 +174,7 @@ static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
+        attr->disabled          = 1;
         attr->inherit           = !no_inherit;
         attr->read_format       = PERF_FORMAT_TOTAL_TIME_ENABLED |
                                   PERF_FORMAT_TOTAL_TIME_RUNNING |
@@ -438,7 +450,6 @@ static void mmap_read_all(void)
 
 static int __cmd_record(int argc, const char **argv)
 {
-        int i;
         struct stat st;
         int flags;
         int err;
@@ -448,6 +459,8 @@ static int __cmd_record(int argc, const char **argv)
         char buf;
         struct machine *machine;
 
+        progname = argv[0];
+
         page_size = sysconf(_SC_PAGE_SIZE);
 
         atexit(sig_atexit);
@@ -516,6 +529,19 @@ static int __cmd_record(int argc, const char **argv)
         if (have_tracepoints(&evsel_list->entries))
                 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
 
+        perf_header__set_feat(&session->header, HEADER_HOSTNAME);
+        perf_header__set_feat(&session->header, HEADER_OSRELEASE);
+        perf_header__set_feat(&session->header, HEADER_ARCH);
+        perf_header__set_feat(&session->header, HEADER_CPUDESC);
+        perf_header__set_feat(&session->header, HEADER_NRCPUS);
+        perf_header__set_feat(&session->header, HEADER_EVENT_DESC);
+        perf_header__set_feat(&session->header, HEADER_CMDLINE);
+        perf_header__set_feat(&session->header, HEADER_VERSION);
+        perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
+        perf_header__set_feat(&session->header, HEADER_TOTAL_MEM);
+        perf_header__set_feat(&session->header, HEADER_NUMA_TOPOLOGY);
+        perf_header__set_feat(&session->header, HEADER_CPUID);
+
         /* 512 kiB: default amount of unprivileged mlocked memory */
         if (mmap_pages == UINT_MAX)
                 mmap_pages = (512 * 1024) / page_size;
@@ -674,6 +700,8 @@ static int __cmd_record(int argc, const char **argv)
                 }
         }
 
+        perf_evlist__enable(evsel_list);
+
         /*
          * Let the child rip
          */
@@ -682,7 +710,6 @@ static int __cmd_record(int argc, const char **argv)
 
         for (;;) {
                 int hits = samples;
-                int thread;
 
                 mmap_read_all();
 
@@ -693,19 +720,8 @@ static int __cmd_record(int argc, const char **argv)
                         waking++;
                 }
 
-                if (done) {
-                        for (i = 0; i < evsel_list->cpus->nr; i++) {
-                                struct perf_evsel *pos;
-
-                                list_for_each_entry(pos, &evsel_list->entries, node) {
-                                        for (thread = 0;
-                                                thread < evsel_list->threads->nr;
-                                                thread++)
-                                                ioctl(FD(pos, i, thread),
-                                                        PERF_EVENT_IOC_DISABLE);
-                                }
-                        }
-                }
+                if (done)
+                        perf_evlist__disable(evsel_list);
         }
 
         if (quiet || signr == SIGUSR1)
@@ -768,6 +784,8 @@ const struct option record_options[] = {
                     "child tasks do not inherit counters"),
         OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
         OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
+        OPT_BOOLEAN(0, "group", &group,
+                    "put the counters into a counter group"),
         OPT_BOOLEAN('g', "call-graph", &call_graph,
                     "do call-graph (stack chain/backtrace) recording"),
         OPT_INCR('v', "verbose", &verbose,
@@ -795,6 +813,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         int err = -ENOMEM;
         struct perf_evsel *pos;
 
+        perf_header__set_cmdline(argc, argv);
+
         evsel_list = perf_evlist__new(NULL, NULL);
         if (evsel_list == NULL)
                 return -ENOMEM;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index f854efda7686..4d7c8340c326 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -40,6 +40,7 @@ static char		const *input_name = "perf.data";
 static bool             force, use_tui, use_stdio;
 static bool             hide_unresolved;
 static bool             dont_use_callchains;
+static bool             show_full_info;
 
 static bool             show_threads;
 static struct perf_read_values  show_threads_values;
@@ -162,23 +163,22 @@ static int perf_session__setup_sample_type(struct perf_session *self)
 {
         if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
-                        fprintf(stderr, "selected --sort parent, but no"
-                                        " callchain data. Did you call"
-                                        " perf record without -g?\n");
+                        ui__warning("Selected --sort parent, but no "
+                                    "callchain data. Did you call "
+                                    "'perf record' without -g?\n");
                         return -EINVAL;
                 }
                 if (symbol_conf.use_callchain) {
-                        fprintf(stderr, "selected -g but no callchain data."
-                                        " Did you call perf record without"
-                                        " -g?\n");
+                        ui__warning("Selected -g but no callchain data. Did "
+                                    "you call 'perf record' without -g?\n");
                         return -1;
                 }
         } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
                    !symbol_conf.use_callchain) {
                         symbol_conf.use_callchain = true;
                         if (callchain_register_param(&callchain_param) < 0) {
-                                fprintf(stderr, "Can't register callchain"
-                                                " params\n");
+                                ui__warning("Can't register callchain "
+                                            "params.\n");
                                 return -EINVAL;
                         }
         }
@@ -230,13 +230,10 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
 
         list_for_each_entry(pos, &evlist->entries, node) {
                 struct hists *hists = &pos->hists;
-                const char *evname = NULL;
-
-                if (rb_first(&hists->entries) != rb_last(&hists->entries))
-                        evname = event_name(pos);
+                const char *evname = event_name(pos);
 
                 hists__fprintf_nr_sample_events(hists, evname, stdout);
-                hists__fprintf(hists, NULL, false, stdout);
+                hists__fprintf(hists, NULL, false, true, 0, 0, stdout);
                 fprintf(stdout, "\n\n");
         }
 
@@ -277,6 +274,9 @@ static int __cmd_report(void)
                         goto out_delete;
         }
 
+        if (use_browser <= 0)
+                perf_session__fprintf_info(session, stdout, show_full_info);
+
         if (show_threads)
                 perf_read_values_init(&show_threads_values);
 
@@ -331,9 +331,10 @@ static int __cmd_report(void)
                 goto out_delete;
         }
 
-        if (use_browser > 0)
-                perf_evlist__tui_browse_hists(session->evlist, help);
-        else
+        if (use_browser > 0) {
+                perf_evlist__tui_browse_hists(session->evlist, help,
+                                              NULL, NULL, 0);
+        } else
                 perf_evlist__tty_browse_hists(session->evlist, help);
 
 out_delete:
@@ -488,6 +489,16 @@ static const struct option options[] = {
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                     "Look for files with symbols relative to this directory"),
         OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
+        OPT_BOOLEAN('I', "show-info", &show_full_info,
+                    "Display extended information about perf.data file"),
+        OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
+                    "Interleave source code with assembly code (default)"),
+        OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
+                    "Display raw encoding of assembly instructions (default)"),
+        OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
+                   "Specify disassembler style (e.g. -M intel for intel syntax)"),
+        OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
+                    "Show a column with the sum of periods"),
         OPT_END()
 };
 
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index dcfe8873c9a1..5177964943e7 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -1637,23 +1637,29 @@ static struct perf_event_ops event_ops = {
         .ordered_samples        = true,
 };
 
-static int read_events(void)
+static void read_events(bool destroy, struct perf_session **psession)
 {
         int err = -EINVAL;
         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
                                                          0, false, &event_ops);
         if (session == NULL)
-                return -ENOMEM;
+                die("No Memory");
 
         if (perf_session__has_traces(session, "record -R")) {
                 err = perf_session__process_events(session, &event_ops);
+                if (err)
+                        die("Failed to process events, error %d", err);
+
                 nr_events      = session->hists.stats.nr_events[0];
                 nr_lost_events = session->hists.stats.total_lost;
                 nr_lost_chunks = session->hists.stats.nr_events[PERF_RECORD_LOST];
         }
 
-        perf_session__delete(session);
-        return err;
+        if (destroy)
+                perf_session__delete(session);
+
+        if (psession)
+                *psession = session;
 }
 
 static void print_bad_events(void)
@@ -1689,9 +1695,10 @@ static void print_bad_events(void)
 static void __cmd_lat(void)
 {
         struct rb_node *next;
+        struct perf_session *session;
 
         setup_pager();
-        read_events();
+        read_events(false, &session);
         sort_lat();
 
         printf("\n ---------------------------------------------------------------------------------------------------------------\n");
@@ -1717,6 +1724,7 @@ static void __cmd_lat(void)
         print_bad_events();
         printf("\n");
 
+        perf_session__delete(session);
 }
 
 static struct trace_sched_handler map_ops  = {
@@ -1731,7 +1739,7 @@ static void __cmd_map(void)
         max_cpu = sysconf(_SC_NPROCESSORS_CONF);
 
         setup_pager();
-        read_events();
+        read_events(true, NULL);
         print_bad_events();
 }
 
@@ -1744,7 +1752,7 @@ static void __cmd_replay(void)
 
         test_calibrations();
 
-        read_events();
+        read_events(true, NULL);
 
         printf("nr_run_events:        %ld\n", nr_run_events);
         printf("nr_sleep_events:      %ld\n", nr_sleep_events);
@@ -1769,7 +1777,7 @@ static void __cmd_replay(void)
 
 
 static const char * const sched_usage[] = {
-        "perf sched [<options>] {record|latency|map|replay|trace}",
+        "perf sched [<options>] {record|latency|map|replay|script}",
         NULL
 };
 
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 09024ec2ab2e..2f62a2952269 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -22,6 +22,7 @@ static u64			last_timestamp;
 static u64                      nr_unordered;
 extern const struct option      record_options[];
 static bool                     no_callchain;
+static bool                     show_full_info;
 static const char               *cpu_list;
 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 
@@ -1083,7 +1084,8 @@ static const struct option options[] = {
                      "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",
                      parse_output_fields),
         OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
-
+        OPT_BOOLEAN('I', "show-info", &show_full_info,
+                    "display extended information from perf.data file"),
         OPT_END()
 };
 
@@ -1268,6 +1270,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __used)
                         return -1;
         }
 
+        perf_session__fprintf_info(session, stdout, show_full_info);
+
         if (!no_callchain)
                 symbol_conf.use_callchain = true;
         else
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 1ad04ce29c34..7ce65f52415e 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -193,6 +193,10 @@ static int			big_num_opt			=  -1;
 static const char               *cpu_list;
 static const char               *csv_sep                        = NULL;
 static bool                     csv_output                      = false;
+static bool                     group                           = false;
+static const char               *output_name                    = NULL;
+static FILE                     *output                         = NULL;
+static int                      output_fd;
 
 static volatile int done = 0;
 
@@ -250,8 +254,13 @@ static double avg_stats(struct stats *stats)
  */
 static double stddev_stats(struct stats *stats)
 {
-        double variance = stats->M2 / (stats->n - 1);
-        double variance_mean = variance / stats->n;
+        double variance, variance_mean;
+
+        if (!stats->n)
+                return 0.0;
+
+        variance = stats->M2 / (stats->n - 1);
+        variance_mean = variance / stats->n;
 
         return sqrt(variance_mean);
 }
@@ -280,14 +289,14 @@ static int create_perf_stat_counter(struct perf_evsel *evsel)
         attr->inherit = !no_inherit;
 
         if (system_wide)
-                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, false);
+                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, group);
 
         if (target_pid == -1 && target_tid == -1) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 
-        return perf_evsel__open_per_thread(evsel, evsel_list->threads, false);
+        return perf_evsel__open_per_thread(evsel, evsel_list->threads, group);
 }
 
 /*
@@ -351,7 +360,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
                 update_stats(&ps->res_stats[i], count[i]);
 
         if (verbose) {
-                fprintf(stderr, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
+                fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
                         event_name(counter), count[0], count[1], count[2]);
         }
 
@@ -486,6 +495,8 @@ static int run_perf_stat(int argc __used, const char **argv)
         if (forks) {
                 close(go_pipe[1]);
                 wait(&status);
+                if (WIFSIGNALED(status))
+                        psignal(WTERMSIG(status), argv[0]);
         } else {
                 while(!done) sleep(1);
         }
@@ -518,9 +529,9 @@ static void print_noise_pct(double total, double avg)
                 pct = 100.0*total/avg;
 
         if (csv_output)
-                fprintf(stderr, "%s%.2f%%", csv_sep, pct);
-        else
-                fprintf(stderr, "  ( +-%6.2f%% )", pct);
+                fprintf(output, "%s%.2f%%", csv_sep, pct);
+        else if (pct)
+                fprintf(output, "  ( +-%6.2f%% )", pct);
 }
 
 static void print_noise(struct perf_evsel *evsel, double avg)
@@ -545,16 +556,17 @@ static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
                         csv_output ? 0 : -4,
                         evsel_list->cpus->map[cpu], csv_sep);
 
-        fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel));
+        fprintf(output, fmt, cpustr, msecs, csv_sep, event_name(evsel));
 
         if (evsel->cgrp)
-                fprintf(stderr, "%s%s", csv_sep, evsel->cgrp->name);
+                fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 
         if (csv_output)
                 return;
 
         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
-                fprintf(stderr, " # %8.3f CPUs utilized          ", avg / avg_stats(&walltime_nsecs_stats));
+                fprintf(output, " # %8.3f CPUs utilized          ",
+                        avg / avg_stats(&walltime_nsecs_stats));
 }
 
 static void print_stalled_cycles_frontend(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -575,9 +587,9 @@ static void print_stalled_cycles_frontend(int cpu, struct perf_evsel *evsel __us
         else if (ratio > 10.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " frontend cycles idle   ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " frontend cycles idle   ");
 }
 
 static void print_stalled_cycles_backend(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -598,9 +610,9 @@ static void print_stalled_cycles_backend(int cpu, struct perf_evsel *evsel __use
         else if (ratio > 20.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " backend  cycles idle   ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " backend  cycles idle   ");
 }
 
 static void print_branch_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -621,9 +633,9 @@ static void print_branch_misses(int cpu, struct perf_evsel *evsel __used, double
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all branches        ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all branches        ");
 }
 
 static void print_l1_dcache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -644,9 +656,9 @@ static void print_l1_dcache_misses(int cpu, struct perf_evsel *evsel __used, dou
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all L1-dcache hits  ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all L1-dcache hits  ");
 }
 
 static void print_l1_icache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -667,9 +679,9 @@ static void print_l1_icache_misses(int cpu, struct perf_evsel *evsel __used, dou
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all L1-icache hits  ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all L1-icache hits  ");
 }
 
 static void print_dtlb_cache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -690,9 +702,9 @@ static void print_dtlb_cache_misses(int cpu, struct perf_evsel *evsel __used, do
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all dTLB cache hits ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all dTLB cache hits ");
 }
 
 static void print_itlb_cache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -713,9 +725,9 @@ static void print_itlb_cache_misses(int cpu, struct perf_evsel *evsel __used, do
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all iTLB cache hits ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all iTLB cache hits ");
 }
 
 static void print_ll_cache_misses(int cpu, struct perf_evsel *evsel __used, double avg)
@@ -736,9 +748,9 @@ static void print_ll_cache_misses(int cpu, struct perf_evsel *evsel __used, doub
         else if (ratio > 5.0)
                 color = PERF_COLOR_YELLOW;
 
-        fprintf(stderr, " #  ");
-        color_fprintf(stderr, color, "%6.2f%%", ratio);
-        fprintf(stderr, " of all LL-cache hits   ");
+        fprintf(output, " #  ");
+        color_fprintf(output, color, "%6.2f%%", ratio);
+        fprintf(output, " of all LL-cache hits   ");
 }
 
 static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
@@ -761,10 +773,10 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
         else
                 cpu = 0;
 
-        fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel));
+        fprintf(output, fmt, cpustr, avg, csv_sep, event_name(evsel));
 
         if (evsel->cgrp)
-                fprintf(stderr, "%s%s", csv_sep, evsel->cgrp->name);
+                fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
 
         if (csv_output)
                 return;
@@ -775,14 +787,14 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
                 if (total)
                         ratio = avg / total;
 
-                fprintf(stderr, " #   %5.2f  insns per cycle        ", ratio);
+                fprintf(output, " #   %5.2f  insns per cycle        ", ratio);
 
                 total = avg_stats(&runtime_stalled_cycles_front_stats[cpu]);
                 total = max(total, avg_stats(&runtime_stalled_cycles_back_stats[cpu]));
 
                 if (total && avg) {
                         ratio = total / avg;
-                        fprintf(stderr, "\n                                             #   %5.2f  stalled cycles per insn", ratio);
+                        fprintf(output, "\n                                             #   %5.2f  stalled cycles per insn", ratio);
                 }
 
         } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
@@ -830,7 +842,7 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
                 if (total)
                         ratio = avg * 100 / total;
 
-                fprintf(stderr, " # %8.3f %% of all cache refs    ", ratio);
+                fprintf(output, " # %8.3f %% of all cache refs    ", ratio);
 
         } else if (perf_evsel__match(evsel, HARDWARE, HW_STALLED_CYCLES_FRONTEND)) {
                 print_stalled_cycles_frontend(cpu, evsel, avg);
@@ -842,16 +854,16 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
                 if (total)
                         ratio = 1.0 * avg / total;
 
-                fprintf(stderr, " # %8.3f GHz                    ", ratio);
+                fprintf(output, " # %8.3f GHz                    ", ratio);
         } else if (runtime_nsecs_stats[cpu].n != 0) {
                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 
                 if (total)
                         ratio = 1000.0 * avg / total;
 
-                fprintf(stderr, " # %8.3f M/sec                  ", ratio);
+                fprintf(output, " # %8.3f M/sec                  ", ratio);
         } else {
-                fprintf(stderr, "                                   ");
+                fprintf(output, "                                   ");
         }
 }
 
@@ -866,7 +878,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
         int scaled = counter->counts->scaled;
 
         if (scaled == -1) {
-                fprintf(stderr, "%*s%s%*s",
+                fprintf(output, "%*s%s%*s",
                         csv_output ? 0 : 18,
                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
                         csv_sep,
@@ -874,9 +886,9 @@ static void print_counter_aggr(struct perf_evsel *counter)
                         event_name(counter));
 
                 if (counter->cgrp)
-                        fprintf(stderr, "%s%s", csv_sep, counter->cgrp->name);
+                        fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
 
-                fputc('\n', stderr);
+                fputc('\n', output);
                 return;
         }
 
@@ -888,7 +900,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
         print_noise(counter, avg);
 
         if (csv_output) {
-                fputc('\n', stderr);
+                fputc('\n', output);
                 return;
         }
 
@@ -898,9 +910,9 @@ static void print_counter_aggr(struct perf_evsel *counter)
                 avg_enabled = avg_stats(&ps->res_stats[1]);
                 avg_running = avg_stats(&ps->res_stats[2]);
 
-                fprintf(stderr, " [%5.2f%%]", 100 * avg_running / avg_enabled);
+                fprintf(output, " [%5.2f%%]", 100 * avg_running / avg_enabled);
         }
-        fprintf(stderr, "\n");
+        fprintf(output, "\n");
 }
 
 /*
@@ -917,7 +929,7 @@ static void print_counter(struct perf_evsel *counter)
                 ena = counter->counts->cpu[cpu].ena;
                 run = counter->counts->cpu[cpu].run;
                 if (run == 0 || ena == 0) {
-                        fprintf(stderr, "CPU%*d%s%*s%s%*s",
+                        fprintf(output, "CPU%*d%s%*s%s%*s",
                                 csv_output ? 0 : -4,
                                 evsel_list->cpus->map[cpu], csv_sep,
                                 csv_output ? 0 : 18,
@@ -927,9 +939,10 @@ static void print_counter(struct perf_evsel *counter)
                                 event_name(counter));
 
                         if (counter->cgrp)
-                                fprintf(stderr, "%s%s", csv_sep, counter->cgrp->name);
+                                fprintf(output, "%s%s",
+                                        csv_sep, counter->cgrp->name);
 
-                        fputc('\n', stderr);
+                        fputc('\n', output);
                         continue;
                 }
 
@@ -942,9 +955,10 @@ static void print_counter(struct perf_evsel *counter)
                         print_noise(counter, 1.0);
 
                         if (run != ena)
-                                fprintf(stderr, "  (%.2f%%)", 100.0 * run / ena);
+                                fprintf(output, "  (%.2f%%)",
+                                        100.0 * run / ena);
                 }
-                fputc('\n', stderr);
+                fputc('\n', output);
         }
 }
 
@@ -956,21 +970,21 @@ static void print_stat(int argc, const char **argv)
         fflush(stdout);
 
         if (!csv_output) {
-                fprintf(stderr, "\n");
-                fprintf(stderr, " Performance counter stats for ");
+                fprintf(output, "\n");
+                fprintf(output, " Performance counter stats for ");
                 if(target_pid == -1 && target_tid == -1) {
-                        fprintf(stderr, "\'%s", argv[0]);
+                        fprintf(output, "\'%s", argv[0]);
                         for (i = 1; i < argc; i++)
-                                fprintf(stderr, " %s", argv[i]);
+                                fprintf(output, " %s", argv[i]);
                 } else if (target_pid != -1)
-                        fprintf(stderr, "process id \'%d", target_pid);
+                        fprintf(output, "process id \'%d", target_pid);
                 else
-                        fprintf(stderr, "thread id \'%d", target_tid);
+                        fprintf(output, "thread id \'%d", target_tid);
 
-                fprintf(stderr, "\'");
+                fprintf(output, "\'");
                 if (run_count > 1)
-                        fprintf(stderr, " (%d runs)", run_count);
-                fprintf(stderr, ":\n\n");
+                        fprintf(output, " (%d runs)", run_count);
+                fprintf(output, ":\n\n");
         }
 
         if (no_aggr) {
@@ -983,15 +997,15 @@ static void print_stat(int argc, const char **argv)
 
         if (!csv_output) {
                 if (!null_run)
-                        fprintf(stderr, "\n");
-                fprintf(stderr, " %17.9f seconds time elapsed",
+                        fprintf(output, "\n");
+                fprintf(output, " %17.9f seconds time elapsed",
                                 avg_stats(&walltime_nsecs_stats)/1e9);
                 if (run_count > 1) {
-                        fprintf(stderr, "                                        ");
+                        fprintf(output, "                                        ");
                         print_noise_pct(stddev_stats(&walltime_nsecs_stats),
                                         avg_stats(&walltime_nsecs_stats));
                 }
-                fprintf(stderr, "\n\n");
+                fprintf(output, "\n\n");
         }
 }
 
@@ -1029,6 +1043,8 @@ static int stat__set_big_num(const struct option *opt __used,
         return 0;
 }
 
+static bool append_file;
+
 static const struct option options[] = {
         OPT_CALLBACK('e', "event", &evsel_list, "event",
                      "event selector. use 'perf list' to list available events",
@@ -1043,6 +1059,8 @@ static const struct option options[] = {
                     "stat events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
+        OPT_BOOLEAN('g', "group", &group,
+                    "put the counters into a counter group"),
         OPT_BOOLEAN('c', "scale", &scale,
                     "scale/normalize counters"),
         OPT_INCR('v', "verbose", &verbose,
@@ -1067,6 +1085,11 @@ static const struct option options[] = {
         OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
                      "monitor event in cgroup name only",
                      parse_cgroups),
+        OPT_STRING('o', "output", &output_name, "file",
+                    "output file name"),
+        OPT_BOOLEAN(0, "append", &append_file, "append to the output file"),
+        OPT_INTEGER(0, "log-fd", &output_fd,
+                    "log output to fd, instead of stderr"),
         OPT_END()
 };
 
@@ -1138,6 +1161,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
 {
         struct perf_evsel *pos;
         int status = -ENOMEM;
+        const char *mode;
 
         setlocale(LC_ALL, "");
 
@@ -1148,16 +1172,46 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         argc = parse_options(argc, argv, options, stat_usage,
                 PARSE_OPT_STOP_AT_NON_OPTION);
 
-        if (csv_sep)
+        output = stderr;
+        if (output_name && strcmp(output_name, "-"))
+                output = NULL;
+
+        if (output_name && output_fd) {
+                fprintf(stderr, "cannot use both --output and --log-fd\n");
+                usage_with_options(stat_usage, options);
+        }
+        if (!output) {
+                struct timespec tm;
+                mode = append_file ? "a" : "w";
+
+                output = fopen(output_name, mode);
+                if (!output) {
+                        perror("failed to create output file");
+                        exit(-1);
+                }
+                clock_gettime(CLOCK_REALTIME, &tm);
+                fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
+        } else if (output_fd != 2) {
+                mode = append_file ? "a" : "w";
+                output = fdopen(output_fd, mode);
+                if (!output) {
+                        perror("Failed opening logfd");
+                        return -errno;
+                }
+        }
+
+        if (csv_sep) {
                 csv_output = true;
-        else
+                if (!strcmp(csv_sep, "\\t"))
+                        csv_sep = "\t";
+        } else
                 csv_sep = DEFAULT_SEPARATOR;
 
         /*
          * let the spreadsheet do the pretty-printing
          */
         if (csv_output) {
-                /* User explicitely passed -B? */
+                /* User explicitly passed -B? */
                 if (big_num_opt == 1) {
                         fprintf(stderr, "-B option not supported with -x\n");
                         usage_with_options(stat_usage, options);
@@ -1223,7 +1277,8 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         status = 0;
         for (run_idx = 0; run_idx < run_count; run_idx++) {
                 if (run_count != 1 && verbose)
-                        fprintf(stderr, "[ perf stat: executing run #%d ... ]\n", run_idx + 1);
+                        fprintf(output, "[ perf stat: executing run #%d ... ]\n",
+                                run_idx + 1);
 
                 if (sync_run)
                         sync();
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 55f4c76f2821..efe696f936e2 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -561,7 +561,7 @@ static int test__basic_mmap(void)
                 }
 
                 err = perf_event__parse_sample(event, attr.sample_type, sample_size,
-                                               false, &sample);
+                                               false, &sample, false);
                 if (err) {
                         pr_err("Can't parse sample, err = %d\n", err);
                         goto out_munmap;
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index a43433f08300..7a871714d44e 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -5,6 +5,7 @@
  * any workload, CPU or specific PID.
  *
  * Copyright (C) 2008, Red Hat Inc, Ingo Molnar <mingo@redhat.com>
+ *               2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
  *
  * Improvements and fixes by:
  *
@@ -36,6 +37,7 @@
 #include "util/parse-events.h"
 #include "util/cpumap.h"
 #include "util/xyarray.h"
+#include "util/sort.h"
 
 #include "util/debug.h"
 
@@ -65,12 +67,8 @@
 static struct perf_top top = {
         .count_filter           = 5,
         .delay_secs             = 2,
-        .display_weighted       = -1,
         .target_pid             = -1,
         .target_tid             = -1,
-        .active_symbols         = LIST_HEAD_INIT(top.active_symbols),
-        .active_symbols_lock    = PTHREAD_MUTEX_INITIALIZER,
-        .active_symbols_cond    = PTHREAD_COND_INITIALIZER,
         .freq                   = 1000, /* 1 KHz */
 };
 
@@ -78,6 +76,12 @@ static bool			system_wide			=  false;
 
 static bool                     use_tui, use_stdio;
 
+static bool                     sort_has_symbols;
+
+static bool                     dont_use_callchains;
+static char                     callchain_default_opt[]         = "fractal,0.5,callee";
+
+
 static int                      default_interval                =      0;
 
 static bool                     kptr_restrict_warned;
@@ -85,7 +89,6 @@ static bool			vmlinux_warned;
 static bool                     inherit                         =  false;
 static int                      realtime_prio                   =      0;
 static bool                     group                           =  false;
-static unsigned int             page_size;
 static unsigned int             mmap_pages                      =    128;
 
 static bool                     dump_symtab                     =  false;
@@ -93,7 +96,6 @@ static bool			dump_symtab                     =  false;
 static struct winsize           winsize;
 
 static const char               *sym_filter                     =   NULL;
-struct sym_entry                *sym_filter_entry_sched         =   NULL;
 static int                      sym_pcnt_filter                 =      5;
 
 /*
@@ -136,18 +138,18 @@ static void sig_winch_handler(int sig __used)
         update_print_entries(&winsize);
 }
 
-static int parse_source(struct sym_entry *syme)
+static int parse_source(struct hist_entry *he)
 {
         struct symbol *sym;
         struct annotation *notes;
         struct map *map;
         int err = -1;
 
-        if (!syme)
+        if (!he || !he->ms.sym)
                 return -1;
 
-        sym = sym_entry__symbol(syme);
-        map = syme->map;
+        sym = he->ms.sym;
+        map = he->ms.map;
 
         /*
          * We can't annotate with just /proc/kallsyms
@@ -175,52 +177,62 @@ static int parse_source(struct sym_entry *syme)
                 return err;
         }
 
-        err = symbol__annotate(sym, syme->map, 0);
+        err = symbol__annotate(sym, map, 0);
         if (err == 0) {
 out_assign:
-                top.sym_filter_entry = syme;
+                top.sym_filter_entry = he;
         }
 
         pthread_mutex_unlock(&notes->lock);
         return err;
 }
 
-static void __zero_source_counters(struct sym_entry *syme)
+static void __zero_source_counters(struct hist_entry *he)
 {
-        struct symbol *sym = sym_entry__symbol(syme);
+        struct symbol *sym = he->ms.sym;
         symbol__annotate_zero_histograms(sym);
 }
 
-static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip)
+static void record_precise_ip(struct hist_entry *he, int counter, u64 ip)
 {
         struct annotation *notes;
         struct symbol *sym;
 
-        if (syme != top.sym_filter_entry)
+        if (he == NULL || he->ms.sym == NULL ||
+            (he != top.sym_filter_entry && use_browser != 1))
                 return;
 
-        sym = sym_entry__symbol(syme);
+        sym = he->ms.sym;
         notes = symbol__annotation(sym);
 
         if (pthread_mutex_trylock(&notes->lock))
                 return;
 
-        ip = syme->map->map_ip(syme->map, ip);
-        symbol__inc_addr_samples(sym, syme->map, counter, ip);
+        if (notes->src == NULL &&
+            symbol__alloc_hist(sym, top.evlist->nr_entries) < 0) {
+                pthread_mutex_unlock(&notes->lock);
+                pr_err("Not enough memory for annotating '%s' symbol!\n",
+                       sym->name);
+                sleep(1);
+                return;
+        }
+
+        ip = he->ms.map->map_ip(he->ms.map, ip);
+        symbol__inc_addr_samples(sym, he->ms.map, counter, ip);
 
         pthread_mutex_unlock(&notes->lock);
 }
 
-static void show_details(struct sym_entry *syme)
+static void show_details(struct hist_entry *he)
 {
         struct annotation *notes;
         struct symbol *symbol;
         int more;
 
-        if (!syme)
+        if (!he)
                 return;
 
-        symbol = sym_entry__symbol(syme);
+        symbol = he->ms.sym;
         notes = symbol__annotation(symbol);
 
         pthread_mutex_lock(&notes->lock);
@@ -231,7 +243,7 @@ static void show_details(struct sym_entry *syme)
         printf("Showing %s for %s\n", event_name(top.sym_evsel), symbol->name);
         printf("  Events  Pcnt (>=%d%%)\n", sym_pcnt_filter);
 
-        more = symbol__annotate_printf(symbol, syme->map, top.sym_evsel->idx,
+        more = symbol__annotate_printf(symbol, he->ms.map, top.sym_evsel->idx,
                                        0, sym_pcnt_filter, top.print_entries, 4);
         if (top.zero)
                 symbol__annotate_zero_histogram(symbol, top.sym_evsel->idx);
@@ -245,21 +257,28 @@ out_unlock:
 
 static const char               CONSOLE_CLEAR[] = "";
 
-static void __list_insert_active_sym(struct sym_entry *syme)
+static struct hist_entry *
+        perf_session__add_hist_entry(struct perf_session *session,
+                                     struct addr_location *al,
+                                     struct perf_sample *sample,
+                                     struct perf_evsel *evsel)
 {
-        list_add(&syme->node, &top.active_symbols);
+        struct hist_entry *he;
+
+        he = __hists__add_entry(&evsel->hists, al, NULL, sample->period);
+        if (he == NULL)
+                return NULL;
+
+        session->hists.stats.total_period += sample->period;
+        hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
+        return he;
 }
 
-static void print_sym_table(struct perf_session *session)
+static void print_sym_table(void)
 {
         char bf[160];
         int printed = 0;
-        struct rb_node *nd;
-        struct sym_entry *syme;
-        struct rb_root tmp = RB_ROOT;
         const int win_width = winsize.ws_col - 1;
-        int sym_width, dso_width, dso_short_width;
-        float sum_ksamples = perf_top__decay_samples(&top, &tmp);
 
         puts(CONSOLE_CLEAR);
 
@@ -270,10 +289,12 @@ static void print_sym_table(struct perf_session *session)
 
         printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
 
-        if (session->hists.stats.total_lost != 0) {
+        if (top.total_lost_warned != top.session->hists.stats.total_lost) {
+                top.total_lost_warned = top.session->hists.stats.total_lost;
                 color_fprintf(stdout, PERF_COLOR_RED, "WARNING:");
                 printf(" LOST %" PRIu64 " events, Check IO/CPU overload\n",
-                       session->hists.stats.total_lost);
+                       top.total_lost_warned);
+                ++printed;
         }
 
         if (top.sym_filter_entry) {
@@ -281,58 +302,15 @@ static void print_sym_table(struct perf_session *session)
                 return;
         }
 
-        perf_top__find_widths(&top, &tmp, &dso_width, &dso_short_width,
-                              &sym_width);
-
-        if (sym_width + dso_width > winsize.ws_col - 29) {
-                dso_width = dso_short_width;
-                if (sym_width + dso_width > winsize.ws_col - 29)
-                        sym_width = winsize.ws_col - dso_width - 29;
-        }
+        hists__collapse_resort_threaded(&top.sym_evsel->hists);
+        hists__output_resort_threaded(&top.sym_evsel->hists);
+        hists__decay_entries_threaded(&top.sym_evsel->hists,
+                                      top.hide_user_symbols,
+                                      top.hide_kernel_symbols);
+        hists__output_recalc_col_len(&top.sym_evsel->hists, winsize.ws_row - 3);
         putchar('\n');
-        if (top.evlist->nr_entries == 1)
-                printf("             samples  pcnt");
-        else
-                printf("   weight    samples  pcnt");
-
-        if (verbose)
-                printf("         RIP       ");
-        printf(" %-*.*s DSO\n", sym_width, sym_width, "function");
-        printf("   %s    _______ _____",
-               top.evlist->nr_entries == 1 ? "      " : "______");
-        if (verbose)
-                printf(" ________________");
-        printf(" %-*.*s", sym_width, sym_width, graph_line);
-        printf(" %-*.*s", dso_width, dso_width, graph_line);
-        puts("\n");
-
-        for (nd = rb_first(&tmp); nd; nd = rb_next(nd)) {
-                struct symbol *sym;
-                double pcnt;
-
-                syme = rb_entry(nd, struct sym_entry, rb_node);
-                sym = sym_entry__symbol(syme);
-                if (++printed > top.print_entries ||
-                    (int)syme->snap_count < top.count_filter)
-                        continue;
-
-                pcnt = 100.0 - (100.0 * ((sum_ksamples - syme->snap_count) /
-                                         sum_ksamples));
-
-                if (top.evlist->nr_entries == 1 || !top.display_weighted)
-                        printf("%20.2f ", syme->weight);
-                else
-                        printf("%9.1f %10ld ", syme->weight, syme->snap_count);
-
-                percent_color_fprintf(stdout, "%4.1f%%", pcnt);
-                if (verbose)
-                        printf(" %016" PRIx64, sym->start);
-                printf(" %-*.*s", sym_width, sym_width, sym->name);
-                printf(" %-*.*s\n", dso_width, dso_width,
-                       dso_width >= syme->map->dso->long_name_len ?
-                                        syme->map->dso->long_name :
-                                        syme->map->dso->short_name);
-        }
+        hists__fprintf(&top.sym_evsel->hists, NULL, false, false,
+                       winsize.ws_row - 4 - printed, win_width, stdout);
 }
 
 static void prompt_integer(int *target, const char *msg)
@@ -370,10 +348,11 @@ static void prompt_percent(int *target, const char *msg)
                 *target = tmp;
 }
 
-static void prompt_symbol(struct sym_entry **target, const char *msg)
+static void prompt_symbol(struct hist_entry **target, const char *msg)
 {
         char *buf = malloc(0), *p;
-        struct sym_entry *syme = *target, *n, *found = NULL;
+        struct hist_entry *syme = *target, *n, *found = NULL;
+        struct rb_node *next;
         size_t dummy = 0;
 
         /* zero counters of active symbol */
@@ -390,17 +369,14 @@ static void prompt_symbol(struct sym_entry **target, const char *msg)
         if (p)
                 *p = 0;
 
-        pthread_mutex_lock(&top.active_symbols_lock);
-        syme = list_entry(top.active_symbols.next, struct sym_entry, node);
-        pthread_mutex_unlock(&top.active_symbols_lock);
-
-        list_for_each_entry_safe_from(syme, n, &top.active_symbols, node) {
-                struct symbol *sym = sym_entry__symbol(syme);
-
-                if (!strcmp(buf, sym->name)) {
-                        found = syme;
+        next = rb_first(&top.sym_evsel->hists.entries);
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                if (n->ms.sym && !strcmp(buf, n->ms.sym->name)) {
+                        found = n;
                         break;
                 }
+                next = rb_next(&n->rb_node);
         }
 
         if (!found) {
@@ -419,7 +395,7 @@ static void print_mapped_keys(void)
         char *name = NULL;
 
         if (top.sym_filter_entry) {
-                struct symbol *sym = sym_entry__symbol(top.sym_filter_entry);
+                struct symbol *sym = top.sym_filter_entry->ms.sym;
                 name = sym->name;
         }
 
@@ -436,9 +412,6 @@ static void print_mapped_keys(void)
         fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
         fprintf(stdout, "\t[S]     stop annotation.\n");
 
-        if (top.evlist->nr_entries > 1)
-                fprintf(stdout, "\t[w]     toggle display weighted/count[E]r. \t(%d)\n", top.display_weighted ? 1 : 0);
-
         fprintf(stdout,
                 "\t[K]     hide kernel_symbols symbols.     \t(%s)\n",
                 top.hide_kernel_symbols ? "yes" : "no");
@@ -465,7 +438,6 @@ static int key_mapped(int c)
                 case 'S':
                         return 1;
                 case 'E':
-                case 'w':
                         return top.evlist->nr_entries > 1 ? 1 : 0;
                 default:
                         break;
@@ -474,7 +446,7 @@ static int key_mapped(int c)
         return 0;
 }
 
-static void handle_keypress(struct perf_session *session, int c)
+static void handle_keypress(int c)
 {
         if (!key_mapped(c)) {
                 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
@@ -550,7 +522,7 @@ static void handle_keypress(struct perf_session *session, int c)
                 case 'Q':
                         printf("exiting.\n");
                         if (dump_symtab)
-                                perf_session__fprintf_dsos(session, stderr);
+                                perf_session__fprintf_dsos(top.session, stderr);
                         exit(0);
                 case 's':
                         prompt_symbol(&top.sym_filter_entry, "Enter details symbol");
@@ -559,7 +531,7 @@ static void handle_keypress(struct perf_session *session, int c)
                         if (!top.sym_filter_entry)
                                 break;
                         else {
-                                struct sym_entry *syme = top.sym_filter_entry;
+                                struct hist_entry *syme = top.sym_filter_entry;
 
                                 top.sym_filter_entry = NULL;
                                 __zero_source_counters(syme);
@@ -568,9 +540,6 @@ static void handle_keypress(struct perf_session *session, int c)
                 case 'U':
                         top.hide_user_symbols = !top.hide_user_symbols;
                         break;
-                case 'w':
-                        top.display_weighted = ~top.display_weighted;
-                        break;
                 case 'z':
                         top.zero = !top.zero;
                         break;
@@ -579,19 +548,31 @@ static void handle_keypress(struct perf_session *session, int c)
         }
 }
 
+static void perf_top__sort_new_samples(void *arg)
+{
+        struct perf_top *t = arg;
+        perf_top__reset_sample_counters(t);
+
+        if (t->evlist->selected != NULL)
+                t->sym_evsel = t->evlist->selected;
+
+        hists__collapse_resort_threaded(&t->sym_evsel->hists);
+        hists__output_resort_threaded(&t->sym_evsel->hists);
+        hists__decay_entries_threaded(&t->sym_evsel->hists,
+                                      top.hide_user_symbols,
+                                      top.hide_kernel_symbols);
+        hists__output_recalc_col_len(&t->sym_evsel->hists, winsize.ws_row - 3);
+}
+
 static void *display_thread_tui(void *arg __used)
 {
-        int err = 0;
-        pthread_mutex_lock(&top.active_symbols_lock);
-        while (list_empty(&top.active_symbols)) {
-                err = pthread_cond_wait(&top.active_symbols_cond,
-                                        &top.active_symbols_lock);
-                if (err)
-                        break;
-        }
-        pthread_mutex_unlock(&top.active_symbols_lock);
-        if (!err)
-                perf_top__tui_browser(&top);
+        const char *help = "For a higher level overview, try: perf top --sort comm,dso";
+
+        perf_top__sort_new_samples(&top);
+        perf_evlist__tui_browse_hists(top.evlist, help,
+                                      perf_top__sort_new_samples,
+                                      &top, top.delay_secs);
+
         exit_browser(0);
         exit(0);
         return NULL;
@@ -602,7 +583,6 @@ static void *display_thread(void *arg __used)
         struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
         struct termios tc, save;
         int delay_msecs, c;
-        struct perf_session *session = (struct perf_session *) arg;
 
         tcgetattr(0, &save);
         tc = save;
@@ -610,20 +590,35 @@ static void *display_thread(void *arg __used)
         tc.c_cc[VMIN] = 0;
         tc.c_cc[VTIME] = 0;
 
+        pthread__unblock_sigwinch();
 repeat:
         delay_msecs = top.delay_secs * 1000;
         tcsetattr(0, TCSANOW, &tc);
         /* trash return*/
         getc(stdin);
 
-        do {
-                print_sym_table(session);
-        } while (!poll(&stdin_poll, 1, delay_msecs) == 1);
-
+        while (1) {
+                print_sym_table();
+                /*
+                 * Either timeout expired or we got an EINTR due to SIGWINCH,
+                 * refresh screen in both cases.
+                 */
+                switch (poll(&stdin_poll, 1, delay_msecs)) {
+                case 0:
+                        continue;
+                case -1:
+                        if (errno == EINTR)
+                                continue;
+                        /* Fall trhu */
+                default:
+                        goto process_hotkey;
+                }
+        }
+process_hotkey:
         c = getc(stdin);
         tcsetattr(0, TCSAFLUSH, &save);
 
-        handle_keypress(session, c);
+        handle_keypress(c);
         goto repeat;
 
         return NULL;
@@ -644,9 +639,8 @@ static const char *skip_symbols[] = {
         NULL
 };
 
-static int symbol_filter(struct map *map, struct symbol *sym)
+static int symbol_filter(struct map *map __used, struct symbol *sym)
 {
-        struct sym_entry *syme;
         const char *name = sym->name;
         int i;
 
@@ -666,16 +660,6 @@ static int symbol_filter(struct map *map, struct symbol *sym)
             strstr(name, "_text_end"))
                 return 1;
 
-        syme = symbol__priv(sym);
-        syme->map = map;
-        symbol__annotate_init(map, sym);
-
-        if (!top.sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) {
-                /* schedule initial sym_filter_entry setup */
-                sym_filter_entry_sched = syme;
-                sym_filter = NULL;
-        }
-
         for (i = 0; skip_symbols[i]; i++) {
                 if (!strcmp(skip_symbols[i], name)) {
                         sym->ignore = true;
@@ -690,10 +674,11 @@ static void perf_event__process_sample(const union perf_event *event,
                                        struct perf_sample *sample,
                                        struct perf_session *session)
 {
+        struct symbol *parent = NULL;
         u64 ip = event->ip.ip;
-        struct sym_entry *syme;
         struct addr_location al;
         struct machine *machine;
+        int err;
         u8 origin = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
         ++top.samples;
@@ -782,46 +767,41 @@ static void perf_event__process_sample(const union perf_event *event,
                                 sleep(5);
                         vmlinux_warned = true;
                 }
-
-                return;
-        }
-
-        /* let's see, whether we need to install initial sym_filter_entry */
-        if (sym_filter_entry_sched) {
-                top.sym_filter_entry = sym_filter_entry_sched;
-                sym_filter_entry_sched = NULL;
-                if (parse_source(top.sym_filter_entry) < 0) {
-                        struct symbol *sym = sym_entry__symbol(top.sym_filter_entry);
-
-                        pr_err("Can't annotate %s", sym->name);
-                        if (top.sym_filter_entry->map->dso->symtab_type == SYMTAB__KALLSYMS) {
-                                pr_err(": No vmlinux file was found in the path:\n");
-                                machine__fprintf_vmlinux_path(machine, stderr);
-                        } else
-                                pr_err(".\n");
-                        exit(1);
-                }
         }
 
-        syme = symbol__priv(al.sym);
-        if (!al.sym->ignore) {
+        if (al.sym == NULL || !al.sym->ignore) {
                 struct perf_evsel *evsel;
+                struct hist_entry *he;
 
                 evsel = perf_evlist__id2evsel(top.evlist, sample->id);
                 assert(evsel != NULL);
-                syme->count[evsel->idx]++;
-                record_precise_ip(syme, evsel->idx, ip);
-                pthread_mutex_lock(&top.active_symbols_lock);
-                if (list_empty(&syme->node) || !syme->node.next) {
-                        static bool first = true;
-                        __list_insert_active_sym(syme);
-                        if (first) {
-                                pthread_cond_broadcast(&top.active_symbols_cond);
-                                first = false;
-                        }
+
+                if ((sort__has_parent || symbol_conf.use_callchain) &&
+                    sample->callchain) {
+                        err = perf_session__resolve_callchain(session, al.thread,
+                                                              sample->callchain, &parent);
+                        if (err)
+                                return;
                 }
-                pthread_mutex_unlock(&top.active_symbols_lock);
+
+                he = perf_session__add_hist_entry(session, &al, sample, evsel);
+                if (he == NULL) {
+                        pr_err("Problem incrementing symbol period, skipping event\n");
+                        return;
+                }
+
+                if (symbol_conf.use_callchain) {
+                        err = callchain_append(he->callchain, &session->callchain_cursor,
+                                               sample->period);
+                        if (err)
+                                return;
+                }
+
+                if (sort_has_symbols)
+                        record_precise_ip(he, evsel->idx, ip);
         }
+
+        return;
 }
 
 static void perf_session__mmap_read_idx(struct perf_session *self, int idx)
@@ -872,7 +852,11 @@ static void start_counters(struct perf_evlist *evlist)
                         attr->read_format |= PERF_FORMAT_ID;
                 }
 
+                if (symbol_conf.use_callchain)
+                        attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
+
                 attr->mmap = 1;
+                attr->comm = 1;
                 attr->inherit = inherit;
 try_again:
                 if (perf_evsel__open(counter, top.evlist->cpus,
@@ -927,35 +911,56 @@ out_err:
         exit(0);
 }
 
+static int setup_sample_type(void)
+{
+        if (!sort_has_symbols) {
+                if (symbol_conf.use_callchain) {
+                        ui__warning("Selected -g but \"sym\" not present in --sort/-s.");
+                        return -EINVAL;
+                }
+        } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE) {
+                if (callchain_register_param(&callchain_param) < 0) {
+                        ui__warning("Can't register callchain params.\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
 static int __cmd_top(void)
 {
         pthread_t thread;
-        int ret __used;
+        int ret;
         /*
          * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
          * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
          */
-        struct perf_session *session = perf_session__new(NULL, O_WRONLY, false, false, NULL);
-        if (session == NULL)
+        top.session = perf_session__new(NULL, O_WRONLY, false, false, NULL);
+        if (top.session == NULL)
                 return -ENOMEM;
 
+        ret = setup_sample_type();
+        if (ret)
+                goto out_delete;
+
         if (top.target_tid != -1)
                 perf_event__synthesize_thread_map(top.evlist->threads,
-                                                  perf_event__process, session);
+                                                  perf_event__process, top.session);
         else
-                perf_event__synthesize_threads(perf_event__process, session);
+                perf_event__synthesize_threads(perf_event__process, top.session);
 
         start_counters(top.evlist);
-        session->evlist = top.evlist;
-        perf_session__update_sample_type(session);
+        top.session->evlist = top.evlist;
+        perf_session__update_sample_type(top.session);
 
         /* Wait for a minimal set of events before starting the snapshot */
         poll(top.evlist->pollfd, top.evlist->nr_fds, 100);
 
-        perf_session__mmap_read(session);
+        perf_session__mmap_read(top.session);
 
         if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
-                                                             display_thread), session)) {
+                                                             display_thread), NULL)) {
                 printf("Could not create display thread.\n");
                 exit(-1);
         }
@@ -973,12 +978,96 @@ static int __cmd_top(void)
         while (1) {
                 u64 hits = top.samples;
 
-                perf_session__mmap_read(session);
+                perf_session__mmap_read(top.session);
 
                 if (hits == top.samples)
                         ret = poll(top.evlist->pollfd, top.evlist->nr_fds, 100);
         }
 
+out_delete:
+        perf_session__delete(top.session);
+        top.session = NULL;
+
+        return 0;
+}
+
+static int
+parse_callchain_opt(const struct option *opt __used, const char *arg,
+                    int unset)
+{
+        char *tok, *tok2;
+        char *endptr;
+
+        /*
+         * --no-call-graph
+         */
+        if (unset) {
+                dont_use_callchains = true;
+                return 0;
+        }
+
+        symbol_conf.use_callchain = true;
+
+        if (!arg)
+                return 0;
+
+        tok = strtok((char *)arg, ",");
+        if (!tok)
+                return -1;
+
+        /* get the output mode */
+        if (!strncmp(tok, "graph", strlen(arg)))
+                callchain_param.mode = CHAIN_GRAPH_ABS;
+
+        else if (!strncmp(tok, "flat", strlen(arg)))
+                callchain_param.mode = CHAIN_FLAT;
+
+        else if (!strncmp(tok, "fractal", strlen(arg)))
+                callchain_param.mode = CHAIN_GRAPH_REL;
+
+        else if (!strncmp(tok, "none", strlen(arg))) {
+                callchain_param.mode = CHAIN_NONE;
+                symbol_conf.use_callchain = false;
+
+                return 0;
+        }
+
+        else
+                return -1;
+
+        /* get the min percentage */
+        tok = strtok(NULL, ",");
+        if (!tok)
+                goto setup;
+
+        callchain_param.min_percent = strtod(tok, &endptr);
+        if (tok == endptr)
+                return -1;
+
+        /* get the print limit */
+        tok2 = strtok(NULL, ",");
+        if (!tok2)
+                goto setup;
+
+        if (tok2[0] != 'c') {
+                callchain_param.print_limit = strtod(tok2, &endptr);
+                tok2 = strtok(NULL, ",");
+                if (!tok2)
+                        goto setup;
+        }
+
+        /* get the call chain order */
+        if (!strcmp(tok2, "caller"))
+                callchain_param.order = ORDER_CALLER;
+        else if (!strcmp(tok2, "callee"))
+                callchain_param.order = ORDER_CALLEE;
+        else
+                return -1;
+setup:
+        if (callchain_register_param(&callchain_param) < 0) {
+                fprintf(stderr, "Can't register callchain params\n");
+                return -1;
+        }
         return 0;
 }
 
@@ -1018,7 +1107,7 @@ static const struct option options[] = {
                             "put the counters into a counter group"),
         OPT_BOOLEAN('i', "inherit", &inherit,
                     "child tasks inherit counters"),
-        OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name",
+        OPT_STRING(0, "sym-annotate", &sym_filter, "symbol name",
                     "symbol to annotate"),
         OPT_BOOLEAN('z', "zero", &top.zero,
                     "zero history across updates"),
@@ -1032,6 +1121,28 @@ static const struct option options[] = {
         OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
+        OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
+                   "sort by key(s): pid, comm, dso, symbol, parent"),
+        OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
+                    "Show a column with the number of samples"),
+        OPT_CALLBACK_DEFAULT('G', "call-graph", NULL, "output_type,min_percent, call_order",
+                     "Display callchains using output_type (graph, flat, fractal, or none), min percent threshold and callchain order. "
+                     "Default: fractal,0.5,callee", &parse_callchain_opt,
+                     callchain_default_opt),
+        OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
+                    "Show a column with the sum of periods"),
+        OPT_STRING(0, "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
+                   "only consider symbols in these dsos"),
+        OPT_STRING(0, "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
+                   "only consider symbols in these comms"),
+        OPT_STRING(0, "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
+                   "only consider these symbols"),
+        OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
+                    "Interleave source code with assembly code (default)"),
+        OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
+                    "Display raw encoding of assembly instructions (default)"),
+        OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
+                   "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_END()
 };
 
@@ -1044,18 +1155,16 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         if (top.evlist == NULL)
                 return -ENOMEM;
 
-        page_size = sysconf(_SC_PAGE_SIZE);
+        symbol_conf.exclude_other = false;
 
         argc = parse_options(argc, argv, options, top_usage, 0);
         if (argc)
                 usage_with_options(top_usage, options);
 
-        /*
-         * XXX For now start disabled, only using TUI if explicitely asked for.
-         * Change that when handle_keys equivalent gets written, live annotation
-         * done, etc.
-         */
-        use_browser = 0;
+        if (sort_order == default_sort_order)
+                sort_order = "dso,symbol";
+
+        setup_sorting(top_usage, options);
 
         if (use_stdio)
                 use_browser = 0;
@@ -1118,13 +1227,22 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 
         top.sym_evsel = list_entry(top.evlist->entries.next, struct perf_evsel, node);
 
-        symbol_conf.priv_size = (sizeof(struct sym_entry) + sizeof(struct annotation) +
-                                 (top.evlist->nr_entries + 1) * sizeof(unsigned long));
+        symbol_conf.priv_size = sizeof(struct annotation);
 
         symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
         if (symbol__init() < 0)
                 return -1;
 
+        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
+        sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
+        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
+
+        /*
+         * Avoid annotation data structures overhead when symbols aren't on the
+         * sort list.
+         */
+        sort_has_symbols = sort_sym.list.next != NULL;
+
         get_term_dimensions(&winsize);
         if (top.print_entries == 0) {
                 update_print_entries(&winsize);
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index 4702e2443a8e..b382bd551aac 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -4,7 +4,6 @@
 #include "util/util.h"
 #include "util/strbuf.h"
 
-extern const char perf_version_string[];
 extern const char perf_usage_string[];
 extern const char perf_more_info_string[];
 
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index ec635b7cc8ea..73d0cac8b67e 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -427,6 +427,24 @@ static void get_debugfs_mntpt(void)
                 debugfs_mntpt[0] = '\0';
 }
 
+static void pthread__block_sigwinch(void)
+{
+        sigset_t set;
+
+        sigemptyset(&set);
+        sigaddset(&set, SIGWINCH);
+        pthread_sigmask(SIG_BLOCK, &set, NULL);
+}
+
+void pthread__unblock_sigwinch(void)
+{
+        sigset_t set;
+
+        sigemptyset(&set);
+        sigaddset(&set, SIGWINCH);
+        pthread_sigmask(SIG_UNBLOCK, &set, NULL);
+}
+
 int main(int argc, const char **argv)
 {
         const char *cmd;
@@ -480,6 +498,12 @@ int main(int argc, const char **argv)
          * time.
          */
         setup_path();
+        /*
+         * Block SIGWINCH notifications so that the thread that wants it can
+         * unblock and get syscalls like select interrupted instead of waiting
+         * forever while the signal goes to some other non interested thread.
+         */
+        pthread__block_sigwinch();
 
         while (1) {
                 static int done_help;
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index a5fc660c1f12..914c895510f7 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -9,18 +9,21 @@ void get_term_dimensions(struct winsize *ws);
 #include "../../arch/x86/include/asm/unistd.h"
 #define rmb()           asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#define CPUINFO_PROC    "model name"
 #endif
 
 #if defined(__x86_64__)
 #include "../../arch/x86/include/asm/unistd.h"
 #define rmb()           asm volatile("lfence" ::: "memory")
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
+#define CPUINFO_PROC    "model name"
 #endif
 
 #ifdef __powerpc__
 #include "../../arch/powerpc/include/asm/unistd.h"
 #define rmb()           asm volatile ("sync" ::: "memory")
 #define cpu_relax()     asm volatile ("" ::: "memory");
+#define CPUINFO_PROC    "cpu"
 #endif
 
 #ifdef __s390__
@@ -37,30 +40,35 @@ void get_term_dimensions(struct winsize *ws);
 # define rmb()          asm volatile("" ::: "memory")
 #endif
 #define cpu_relax()     asm volatile("" ::: "memory")
+#define CPUINFO_PROC    "cpu type"
 #endif
 
 #ifdef __hppa__
 #include "../../arch/parisc/include/asm/unistd.h"
 #define rmb()           asm volatile("" ::: "memory")
 #define cpu_relax()     asm volatile("" ::: "memory");
+#define CPUINFO_PROC    "cpu"
 #endif
 
 #ifdef __sparc__
 #include "../../arch/sparc/include/asm/unistd.h"
 #define rmb()           asm volatile("":::"memory")
 #define cpu_relax()     asm volatile("":::"memory")
+#define CPUINFO_PROC    "cpu"
 #endif
 
 #ifdef __alpha__
 #include "../../arch/alpha/include/asm/unistd.h"
 #define rmb()           asm volatile("mb" ::: "memory")
 #define cpu_relax()     asm volatile("" ::: "memory")
+#define CPUINFO_PROC    "cpu model"
 #endif
 
 #ifdef __ia64__
 #include "../../arch/ia64/include/asm/unistd.h"
 #define rmb()           asm volatile ("mf" ::: "memory")
 #define cpu_relax()     asm volatile ("hint @pause" ::: "memory")
+#define CPUINFO_PROC    "model name"
 #endif
 
 #ifdef __arm__
@@ -71,6 +79,7 @@ void get_term_dimensions(struct winsize *ws);
  */
 #define rmb()           ((void(*)(void))0xffff0fa0)()
 #define cpu_relax()     asm volatile("":::"memory")
+#define CPUINFO_PROC    "Processor"
 #endif
 
 #ifdef __mips__
@@ -83,6 +92,7 @@ void get_term_dimensions(struct winsize *ws);
                                 : /* no input */                        \
                                 : "memory")
 #define cpu_relax()     asm volatile("" ::: "memory")
+#define CPUINFO_PROC    "cpu model"
 #endif
 
 #include <time.h>
@@ -171,5 +181,8 @@ struct ip_callchain {
 };
 
 extern bool perf_host, perf_guest;
+extern const char perf_version_string[];
+
+void pthread__unblock_sigwinch(void);
 
 #endif
diff --git a/tools/perf/scripts/python/bin/net_dropmonitor-record b/tools/perf/scripts/python/bin/net_dropmonitor-record
new file mode 100755
index 000000000000..423fb81dadae
--- /dev/null
+++ b/tools/perf/scripts/python/bin/net_dropmonitor-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -e skb:kfree_skb $@
diff --git a/tools/perf/scripts/python/bin/net_dropmonitor-report b/tools/perf/scripts/python/bin/net_dropmonitor-report
new file mode 100755
index 000000000000..8d698f5a06aa
--- /dev/null
+++ b/tools/perf/scripts/python/bin/net_dropmonitor-report
@@ -0,0 +1,4 @@
+#!/bin/bash
+# description: display a table of dropped frames
+
+perf script -s "$PERF_EXEC_PATH"/scripts/python/net_dropmonitor.py $@
diff --git a/tools/perf/scripts/python/net_dropmonitor.py b/tools/perf/scripts/python/net_dropmonitor.py
new file mode 100755
index 000000000000..a4ffc9500023
--- /dev/null
+++ b/tools/perf/scripts/python/net_dropmonitor.py
@@ -0,0 +1,72 @@
+# Monitor the system for dropped packets and proudce a report of drop locations and counts
+
+import os
+import sys
+
+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 Util import *
+
+drop_log = {}
+kallsyms = []
+
+def get_kallsyms_table():
+        global kallsyms
+        try:
+                f = open("/proc/kallsyms", "r")
+                linecount = 0
+                for line in f:
+                        linecount = linecount+1
+                f.seek(0)
+        except:
+                return
+
+
+        j = 0
+        for line in f:
+                loc = int(line.split()[0], 16)
+                name = line.split()[2]
+                j = j +1
+                if ((j % 100) == 0):
+                        print "\r" + str(j) + "/" + str(linecount),
+                kallsyms.append({ 'loc': loc, 'name' : name})
+
+        print "\r" + str(j) + "/" + str(linecount)
+        kallsyms.sort()
+        return
+
+def get_sym(sloc):
+        loc = int(sloc)
+        for i in kallsyms:
+                if (i['loc'] >= loc):
+                        return (i['name'], i['loc']-loc)
+        return (None, 0)
+
+def print_drop_table():
+        print "%25s %25s %25s" % ("LOCATION", "OFFSET", "COUNT")
+        for i in drop_log.keys():
+                (sym, off) = get_sym(i)
+                if sym == None:
+                        sym = i
+                print "%25s %25s %25s" % (sym, off, drop_log[i])
+
+
+def trace_begin():
+        print "Starting trace (Ctrl-C to dump results)"
+
+def trace_end():
+        print "Gathering kallsyms data"
+        get_kallsyms_table()
+        print_drop_table()
+
+# called from perf, when it finds a correspoinding event
+def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
+                        skbaddr, protocol, location):
+        slocation = str(location)
+        try:
+                drop_log[slocation] = drop_log[slocation] + 1
+        except:
+                drop_log[slocation] = 1
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index e01af2b1a469..bc8f4773d4d8 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -16,6 +16,8 @@
 #include "annotate.h"
 #include <pthread.h>
 
+const char      *disassembler_style;
+
 int symbol__annotate_init(struct map *map __used, struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
@@ -323,10 +325,15 @@ fallback:
                  dso, dso->long_name, sym, sym->name);
 
         snprintf(command, sizeof(command),
-                 "objdump --start-address=0x%016" PRIx64
-                 " --stop-address=0x%016" PRIx64 " -dS -C %s|grep -v %s|expand",
+                 "objdump %s%s --start-address=0x%016" PRIx64
+                 " --stop-address=0x%016" PRIx64
+                 " -d %s %s -C %s|grep -v %s|expand",
+                 disassembler_style ? "-M " : "",
+                 disassembler_style ? disassembler_style : "",
                  map__rip_2objdump(map, sym->start),
                  map__rip_2objdump(map, sym->end),
+                 symbol_conf.annotate_asm_raw ? "" : "--no-show-raw",
+                 symbol_conf.annotate_src ? "-S" : "",
                  symfs_filename, filename);
 
         pr_debug("Executing: %s\n", command);
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index c2c286896801..d9072523d342 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -91,13 +91,18 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
 #ifdef NO_NEWT_SUPPORT
 static inline int symbol__tui_annotate(struct symbol *sym __used,
                                        struct map *map __used,
-                                       int evidx __used, int refresh __used)
+                                       int evidx __used,
+                                       void(*timer)(void *arg) __used,
+                                       void *arg __used, int delay_secs __used)
 {
         return 0;
 }
 #else
 int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
-                         int refresh);
+                         int nr_events, void(*timer)(void *arg), void *arg,
+                         int delay_secs);
 #endif
 
+extern const char       *disassembler_style;
+
 #endif  /* __PERF_ANNOTATE_H */
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index e191eb9a667f..521c38a79190 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -200,7 +200,7 @@ static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
          * Auto-detect:
          */
         if (perf_use_color_default < 0) {
-                if (isatty(1) || pager_in_use())
+                if (isatty(fileno(fp)) || pager_in_use())
                         perf_use_color_default = 1;
                 else
                         perf_use_color_default = 0;
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index e02d78cae70f..80d9598db31a 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -341,7 +341,7 @@ const char *perf_config_dirname(const char *name, const char *value)
 
 static int perf_default_core_config(const char *var __used, const char *value __used)
 {
-        /* Add other config variables here and to Documentation/config.txt. */
+        /* Add other config variables here. */
         return 0;
 }
 
@@ -350,7 +350,7 @@ int perf_default_config(const char *var, const char *value, void *dummy __used)
         if (!prefixcmp(var, "core."))
                 return perf_default_core_config(var, value);
 
-        /* Add other config variables here and to Documentation/config.txt. */
+        /* Add other config variables here. */
         return 0;
 }
 
@@ -399,7 +399,6 @@ static int perf_config_global(void)
 int perf_config(config_fn_t fn, void *data)
 {
         int ret = 0, found = 0;
-        char *repo_config = NULL;
         const char *home = NULL;
 
         /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
@@ -414,19 +413,32 @@ int perf_config(config_fn_t fn, void *data)
         home = getenv("HOME");
         if (perf_config_global() && home) {
                 char *user_config = strdup(mkpath("%s/.perfconfig", home));
-                if (!access(user_config, R_OK)) {
-                        ret += perf_config_from_file(fn, user_config, data);
-                        found += 1;
+                struct stat st;
+
+                if (user_config == NULL) {
+                        warning("Not enough memory to process %s/.perfconfig, "
+                                "ignoring it.", home);
+                        goto out;
                 }
-                free(user_config);
-        }
 
-        repo_config = perf_pathdup("config");
-        if (!access(repo_config, R_OK)) {
-                ret += perf_config_from_file(fn, repo_config, data);
+                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);
         }
-        free(repo_config);
+out:
         if (found == 0)
                 return -1;
         return ret;
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index fddf40f30d3e..ee51e9b4dc09 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -96,6 +96,39 @@ int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
         return *lineno ?: -ENOENT;
 }
 
+static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
+
+/**
+ * cu_walk_functions_at - Walk on function DIEs at given address
+ * @cu_die: A CU DIE
+ * @addr: An address
+ * @callback: A callback which called with found DIEs
+ * @data: A user data
+ *
+ * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
+ * should be subprogram or inlined-subroutines.
+ */
+int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                    int (*callback)(Dwarf_Die *, void *), void *data)
+{
+        Dwarf_Die die_mem;
+        Dwarf_Die *sc_die;
+        int ret = -ENOENT;
+
+        /* Inlined function could be recursive. Trace it until fail */
+        for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
+             sc_die != NULL;
+             sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
+                                     &die_mem)) {
+                ret = callback(sc_die, data);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+
+}
+
 /**
  * die_compare_name - Compare diename and tname
  * @dw_die: a DIE
@@ -198,6 +231,19 @@ static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
         return 0;
 }
 
+/* Get attribute and translate it as a sdata */
+static int die_get_attr_sdata(Dwarf_Die *tp_die, unsigned int attr_name,
+                              Dwarf_Sword *result)
+{
+        Dwarf_Attribute attr;
+
+        if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
+            dwarf_formsdata(&attr, result) != 0)
+                return -ENOENT;
+
+        return 0;
+}
+
 /**
  * die_is_signed_type - Check whether a type DIE is signed or not
  * @tp_die: a DIE of a type
@@ -250,6 +296,50 @@ int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
         return 0;
 }
 
+/* Get the call file index number in CU DIE */
+static int die_get_call_fileno(Dwarf_Die *in_die)
+{
+        Dwarf_Sword idx;
+
+        if (die_get_attr_sdata(in_die, DW_AT_call_file, &idx) == 0)
+                return (int)idx;
+        else
+                return -ENOENT;
+}
+
+/* Get the declared file index number in CU DIE */
+static int die_get_decl_fileno(Dwarf_Die *pdie)
+{
+        Dwarf_Sword idx;
+
+        if (die_get_attr_sdata(pdie, DW_AT_decl_file, &idx) == 0)
+                return (int)idx;
+        else
+                return -ENOENT;
+}
+
+/**
+ * die_get_call_file - Get callsite file name of inlined function instance
+ * @in_die: a DIE of an inlined function instance
+ *
+ * Get call-site file name of @in_die. This means from which file the inline
+ * function is called.
+ */
+const char *die_get_call_file(Dwarf_Die *in_die)
+{
+        Dwarf_Die cu_die;
+        Dwarf_Files *files;
+        int idx;
+
+        idx = die_get_call_fileno(in_die);
+        if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) ||
+            dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
+                return NULL;
+
+        return dwarf_filesrc(files, idx, NULL, NULL);
+}
+
+
 /**
  * die_find_child - Generic DIE search function in DIE tree
  * @rt_die: a root DIE
@@ -374,9 +464,78 @@ Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
         return die_mem;
 }
 
+struct __instance_walk_param {
+        void    *addr;
+        int     (*callback)(Dwarf_Die *, void *);
+        void    *data;
+        int     retval;
+};
+
+static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
+{
+        struct __instance_walk_param *iwp = data;
+        Dwarf_Attribute attr_mem;
+        Dwarf_Die origin_mem;
+        Dwarf_Attribute *attr;
+        Dwarf_Die *origin;
+        int tmp;
+
+        attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
+        if (attr == NULL)
+                return DIE_FIND_CB_CONTINUE;
+
+        origin = dwarf_formref_die(attr, &origin_mem);
+        if (origin == NULL || origin->addr != iwp->addr)
+                return DIE_FIND_CB_CONTINUE;
+
+        /* Ignore redundant instances */
+        if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
+                dwarf_decl_line(origin, &tmp);
+                if (die_get_call_lineno(inst) == tmp) {
+                        tmp = die_get_decl_fileno(origin);
+                        if (die_get_call_fileno(inst) == tmp)
+                                return DIE_FIND_CB_CONTINUE;
+                }
+        }
+
+        iwp->retval = iwp->callback(inst, iwp->data);
+
+        return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
+}
+
+/**
+ * die_walk_instances - Walk on instances of given DIE
+ * @or_die: an abstract original DIE
+ * @callback: a callback function which is called with instance DIE
+ * @data: user data
+ *
+ * Walk on the instances of give @in_die. @in_die must be an inlined function
+ * declartion. This returns the return value of @callback if it returns
+ * non-zero value, or -ENOENT if there is no instance.
+ */
+int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
+                       void *data)
+{
+        Dwarf_Die cu_die;
+        Dwarf_Die die_mem;
+        struct __instance_walk_param iwp = {
+                .addr = or_die->addr,
+                .callback = callback,
+                .data = data,
+                .retval = -ENOENT,
+        };
+
+        if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
+                return -ENOENT;
+
+        die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
+
+        return iwp.retval;
+}
+
 /* Line walker internal parameters */
 struct __line_walk_param {
-        const char *fname;
+        bool recursive;
         line_walk_callback_t callback;
         void *data;
         int retval;
@@ -385,39 +544,56 @@ struct __line_walk_param {
 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
 {
         struct __line_walk_param *lw = data;
-        Dwarf_Addr addr;
+        Dwarf_Addr addr = 0;
+        const char *fname;
         int lineno;
 
         if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
+                fname = die_get_call_file(in_die);
                 lineno = die_get_call_lineno(in_die);
-                if (lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
-                        lw->retval = lw->callback(lw->fname, lineno, addr,
-                                                  lw->data);
+                if (fname && lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
+                        lw->retval = lw->callback(fname, lineno, addr, lw->data);
                         if (lw->retval != 0)
                                 return DIE_FIND_CB_END;
                 }
         }
-        return DIE_FIND_CB_SIBLING;
+        if (!lw->recursive)
+                /* Don't need to search recursively */
+                return DIE_FIND_CB_SIBLING;
+
+        if (addr) {
+                fname = dwarf_decl_file(in_die);
+                if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
+                        lw->retval = lw->callback(fname, lineno, addr, lw->data);
+                        if (lw->retval != 0)
+                                return DIE_FIND_CB_END;
+                }
+        }
+
+        /* Continue to search nested inlined function call-sites */
+        return DIE_FIND_CB_CONTINUE;
 }
 
 /* Walk on lines of blocks included in given DIE */
-static int __die_walk_funclines(Dwarf_Die *sp_die,
+static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
                                 line_walk_callback_t callback, void *data)
 {
         struct __line_walk_param lw = {
+                .recursive = recursive,
                 .callback = callback,
                 .data = data,
                 .retval = 0,
         };
         Dwarf_Die die_mem;
         Dwarf_Addr addr;
+        const char *fname;
         int lineno;
 
         /* Handle function declaration line */
-        lw.fname = dwarf_decl_file(sp_die);
-        if (lw.fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
+        fname = dwarf_decl_file(sp_die);
+        if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
             dwarf_entrypc(sp_die, &addr) == 0) {
-                lw.retval = callback(lw.fname, lineno, addr, data);
+                lw.retval = callback(fname, lineno, addr, data);
                 if (lw.retval != 0)
                         goto done;
         }
@@ -430,7 +606,7 @@ static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 {
         struct __line_walk_param *lw = data;
 
-        lw->retval = __die_walk_funclines(sp_die, lw->callback, lw->data);
+        lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
         if (lw->retval != 0)
                 return DWARF_CB_ABORT;
 
@@ -439,7 +615,7 @@ static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 
 /**
  * die_walk_lines - Walk on lines inside given DIE
- * @rt_die: a root DIE (CU or subprogram)
+ * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
  * @callback: callback routine
  * @data: user data
  *
@@ -460,12 +636,12 @@ int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
         size_t nlines, i;
 
         /* Get the CU die */
-        if (dwarf_tag(rt_die) == DW_TAG_subprogram)
+        if (dwarf_tag(rt_die) != DW_TAG_compile_unit)
                 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
         else
                 cu_die = rt_die;
         if (!cu_die) {
-                pr_debug2("Failed to get CU from subprogram\n");
+                pr_debug2("Failed to get CU from given DIE.\n");
                 return -EINVAL;
         }
 
@@ -509,7 +685,11 @@ int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
          * subroutines. We have to check functions list or given function.
          */
         if (rt_die != cu_die)
-                ret = __die_walk_funclines(rt_die, callback, data);
+                /*
+                 * Don't need walk functions recursively, because nested
+                 * inlined functions don't have lines of the specified DIE.
+                 */
+                ret = __die_walk_funclines(rt_die, false, callback, data);
         else {
                 struct __line_walk_param param = {
                         .callback = callback,
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index bc3b21167e70..6ce1717784b7 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -34,12 +34,19 @@ extern const char *cu_get_comp_dir(Dwarf_Die *cu_die);
 extern int cu_find_lineinfo(Dwarf_Die *cudie, unsigned long addr,
                             const char **fname, int *lineno);
 
+/* Walk on funcitons at given address */
+extern int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                        int (*callback)(Dwarf_Die *, void *), void *data);
+
 /* Compare diename and tname */
 extern bool die_compare_name(Dwarf_Die *dw_die, const char *tname);
 
 /* Get callsite line number of inline-function instance */
 extern int die_get_call_lineno(Dwarf_Die *in_die);
 
+/* Get callsite file name of inlined function instance */
+extern const char *die_get_call_file(Dwarf_Die *in_die);
+
 /* Get type die */
 extern Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem);
 
@@ -73,6 +80,10 @@ extern Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 extern Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
                                       Dwarf_Die *die_mem);
 
+/* Walk on the instances of given DIE */
+extern int die_walk_instances(Dwarf_Die *in_die,
+                              int (*callback)(Dwarf_Die *, void *), void *data);
+
 /* Walker on lines (Note: line number will not be sorted) */
 typedef int (* line_walk_callback_t) (const char *fname, int lineno,
                                       Dwarf_Addr addr, void *data);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 3c1b8a632101..437f8ca679a0 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -169,12 +169,17 @@ static int perf_event__synthesize_mmap_events(union perf_event *event,
                         continue;
                 pbf += n + 3;
                 if (*pbf == 'x') { /* vm_exec */
+                        char anonstr[] = "//anon\n";
                         char *execname = strchr(bf, '/');
 
                         /* Catch VDSO */
                         if (execname == NULL)
                                 execname = strstr(bf, "[vdso]");
 
+                        /* Catch anonymous mmaps */
+                        if ((execname == NULL) && !strstr(bf, "["))
+                                execname = anonstr;
+
                         if (execname == NULL)
                                 continue;
 
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 1d7f66488a88..357a85b85248 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -186,6 +186,6 @@ const char *perf_event__name(unsigned int id);
 
 int perf_event__parse_sample(const union perf_event *event, u64 type,
                              int sample_size, bool sample_id_all,
-                             struct perf_sample *sample);
+                             struct perf_sample *sample, bool swapped);
 
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index b021ea9265c3..2f6bc89027da 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -85,10 +85,45 @@ int perf_evlist__add_default(struct perf_evlist *evlist)
         struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
 
         if (evsel == NULL)
-                return -ENOMEM;
+                goto error;
+
+        /* use strdup() because free(evsel) assumes name is allocated */
+        evsel->name = strdup("cycles");
+        if (!evsel->name)
+                goto error_free;
 
         perf_evlist__add(evlist, evsel);
         return 0;
+error_free:
+        perf_evsel__delete(evsel);
+error:
+        return -ENOMEM;
+}
+
+void perf_evlist__disable(struct perf_evlist *evlist)
+{
+        int cpu, thread;
+        struct perf_evsel *pos;
+
+        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+                list_for_each_entry(pos, &evlist->entries, node) {
+                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                                ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_DISABLE);
+                }
+        }
+}
+
+void perf_evlist__enable(struct perf_evlist *evlist)
+{
+        int cpu, thread;
+        struct perf_evsel *pos;
+
+        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+                list_for_each_entry(pos, &evlist->entries, node) {
+                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                                ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_ENABLE);
+                }
+        }
 }
 
 int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
@@ -498,3 +533,9 @@ bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
         first = list_entry(evlist->entries.next, struct perf_evsel, node);
         return first->attr.sample_id_all;
 }
+
+void perf_evlist__set_selected(struct perf_evlist *evlist,
+                               struct perf_evsel *evsel)
+{
+        evlist->selected = evsel;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index b2b862374f37..6be71fc57794 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -25,6 +25,7 @@ struct perf_evlist {
         struct pollfd    *pollfd;
         struct thread_map *threads;
         struct cpu_map    *cpus;
+        struct perf_evsel *selected;
 };
 
 struct perf_evsel;
@@ -53,6 +54,12 @@ int perf_evlist__alloc_mmap(struct perf_evlist *evlist);
 int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite);
 void perf_evlist__munmap(struct perf_evlist *evlist);
 
+void perf_evlist__disable(struct perf_evlist *evlist);
+void perf_evlist__enable(struct perf_evlist *evlist);
+
+void perf_evlist__set_selected(struct perf_evlist *evlist,
+                               struct perf_evsel *evsel);
+
 static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
                                          struct cpu_map *cpus,
                                          struct thread_map *threads)
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index a03a36b7908a..b46f6e4bff3c 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -7,6 +7,8 @@
  * Released under the GPL v2. (and only v2, not any later version)
  */
 
+#include <byteswap.h>
+#include "asm/bug.h"
 #include "evsel.h"
 #include "evlist.h"
 #include "util.h"
@@ -37,6 +39,7 @@ void perf_evsel__init(struct perf_evsel *evsel,
         evsel->idx         = idx;
         evsel->attr        = *attr;
         INIT_LIST_HEAD(&evsel->node);
+        hists__init(&evsel->hists);
 }
 
 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
@@ -342,10 +345,20 @@ static bool sample_overlap(const union perf_event *event,
 
 int perf_event__parse_sample(const union perf_event *event, u64 type,
                              int sample_size, bool sample_id_all,
-                             struct perf_sample *data)
+                             struct perf_sample *data, bool swapped)
 {
         const u64 *array;
 
+        /*
+         * used for cross-endian analysis. See git commit 65014ab3
+         * for why this goofiness is needed.
+         */
+        union {
+                u64 val64;
+                u32 val32[2];
+        } u;
+
+
         data->cpu = data->pid = data->tid = -1;
         data->stream_id = data->id = data->time = -1ULL;
 
@@ -366,9 +379,16 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
         }
 
         if (type & PERF_SAMPLE_TID) {
-                u32 *p = (u32 *)array;
-                data->pid = p[0];
-                data->tid = p[1];
+                u.val64 = *array;
+                if (swapped) {
+                        /* undo swap of u64, then swap on individual u32s */
+                        u.val64 = bswap_64(u.val64);
+                        u.val32[0] = bswap_32(u.val32[0]);
+                        u.val32[1] = bswap_32(u.val32[1]);
+                }
+
+                data->pid = u.val32[0];
+                data->tid = u.val32[1];
                 array++;
         }
 
@@ -395,8 +415,15 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
         }
 
         if (type & PERF_SAMPLE_CPU) {
-                u32 *p = (u32 *)array;
-                data->cpu = *p;
+
+                u.val64 = *array;
+                if (swapped) {
+                        /* undo swap of u64, then swap on individual u32s */
+                        u.val64 = bswap_64(u.val64);
+                        u.val32[0] = bswap_32(u.val32[0]);
+                }
+
+                data->cpu = u.val32[0];
                 array++;
         }
 
@@ -423,18 +450,27 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
         }
 
         if (type & PERF_SAMPLE_RAW) {
-                u32 *p = (u32 *)array;
+                const u64 *pdata;
+
+                u.val64 = *array;
+                if (WARN_ONCE(swapped,
+                              "Endianness of raw data not corrected!\n")) {
+                        /* undo swap of u64, then swap on individual u32s */
+                        u.val64 = bswap_64(u.val64);
+                        u.val32[0] = bswap_32(u.val32[0]);
+                        u.val32[1] = bswap_32(u.val32[1]);
+                }
 
                 if (sample_overlap(event, array, sizeof(u32)))
                         return -EFAULT;
 
-                data->raw_size = *p;
-                p++;
+                data->raw_size = u.val32[0];
+                pdata = (void *) array + sizeof(u32);
 
-                if (sample_overlap(event, p, data->raw_size))
+                if (sample_overlap(event, pdata, data->raw_size))
                         return -EFAULT;
 
-                data->raw_data = p;
+                data->raw_data = (void *) pdata;
         }
 
         return 0;
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index cb2959a3fb43..76c0b2c49eb8 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
+#include <sys/utsname.h>
 
 #include "evlist.h"
 #include "evsel.h"
@@ -17,12 +18,19 @@
 #include "session.h"
 #include "symbol.h"
 #include "debug.h"
+#include "cpumap.h"
 
 static bool no_buildid_cache = false;
 
 static int event_count;
 static struct perf_trace_event_type *events;
 
+static u32 header_argc;
+static const char **header_argv;
+
+static int dsos__write_buildid_table(struct perf_header *header, int fd);
+static int perf_session__cache_build_ids(struct perf_session *session);
+
 int perf_header__push_event(u64 id, const char *name)
 {
         if (strlen(name) > MAX_EVENT_NAME)
@@ -110,6 +118,1020 @@ static int write_padded(int fd, const void *bf, size_t count,
         return err;
 }
 
+static int do_write_string(int fd, const char *str)
+{
+        u32 len, olen;
+        int ret;
+
+        olen = strlen(str) + 1;
+        len = ALIGN(olen, NAME_ALIGN);
+
+        /* write len, incl. \0 */
+        ret = do_write(fd, &len, sizeof(len));
+        if (ret < 0)
+                return ret;
+
+        return write_padded(fd, str, olen, len);
+}
+
+static char *do_read_string(int fd, struct perf_header *ph)
+{
+        ssize_t sz, ret;
+        u32 len;
+        char *buf;
+
+        sz = read(fd, &len, sizeof(len));
+        if (sz < (ssize_t)sizeof(len))
+                return NULL;
+
+        if (ph->needs_swap)
+                len = bswap_32(len);
+
+        buf = malloc(len);
+        if (!buf)
+                return NULL;
+
+        ret = read(fd, buf, len);
+        if (ret == (ssize_t)len) {
+                /*
+                 * strings are padded by zeroes
+                 * thus the actual strlen of buf
+                 * may be less than len
+                 */
+                return buf;
+        }
+
+        free(buf);
+        return NULL;
+}
+
+int
+perf_header__set_cmdline(int argc, const char **argv)
+{
+        int i;
+
+        header_argc = (u32)argc;
+
+        /* do not include NULL termination */
+        header_argv = calloc(argc, sizeof(char *));
+        if (!header_argv)
+                return -ENOMEM;
+
+        /*
+         * must copy argv contents because it gets moved
+         * around during option parsing
+         */
+        for (i = 0; i < argc ; i++)
+                header_argv[i] = argv[i];
+
+        return 0;
+}
+
+static int write_trace_info(int fd, struct perf_header *h __used,
+                            struct perf_evlist *evlist)
+{
+        return read_tracing_data(fd, &evlist->entries);
+}
+
+
+static int write_build_id(int fd, struct perf_header *h,
+                          struct perf_evlist *evlist __used)
+{
+        struct perf_session *session;
+        int err;
+
+        session = container_of(h, struct perf_session, header);
+
+        err = dsos__write_buildid_table(h, fd);
+        if (err < 0) {
+                pr_debug("failed to write buildid table\n");
+                return err;
+        }
+        if (!no_buildid_cache)
+                perf_session__cache_build_ids(session);
+
+        return 0;
+}
+
+static int write_hostname(int fd, struct perf_header *h __used,
+                          struct perf_evlist *evlist __used)
+{
+        struct utsname uts;
+        int ret;
+
+        ret = uname(&uts);
+        if (ret < 0)
+                return -1;
+
+        return do_write_string(fd, uts.nodename);
+}
+
+static int write_osrelease(int fd, struct perf_header *h __used,
+                           struct perf_evlist *evlist __used)
+{
+        struct utsname uts;
+        int ret;
+
+        ret = uname(&uts);
+        if (ret < 0)
+                return -1;
+
+        return do_write_string(fd, uts.release);
+}
+
+static int write_arch(int fd, struct perf_header *h __used,
+                      struct perf_evlist *evlist __used)
+{
+        struct utsname uts;
+        int ret;
+
+        ret = uname(&uts);
+        if (ret < 0)
+                return -1;
+
+        return do_write_string(fd, uts.machine);
+}
+
+static int write_version(int fd, struct perf_header *h __used,
+                         struct perf_evlist *evlist __used)
+{
+        return do_write_string(fd, perf_version_string);
+}
+
+static int write_cpudesc(int fd, struct perf_header *h __used,
+                       struct perf_evlist *evlist __used)
+{
+#ifndef CPUINFO_PROC
+#define CPUINFO_PROC NULL
+#endif
+        FILE *file;
+        char *buf = NULL;
+        char *s, *p;
+        const char *search = CPUINFO_PROC;
+        size_t len = 0;
+        int ret = -1;
+
+        if (!search)
+                return -1;
+
+        file = fopen("/proc/cpuinfo", "r");
+        if (!file)
+                return -1;
+
+        while (getline(&buf, &len, file) > 0) {
+                ret = strncmp(buf, search, strlen(search));
+                if (!ret)
+                        break;
+        }
+
+        if (ret)
+                goto done;
+
+        s = buf;
+
+        p = strchr(buf, ':');
+        if (p && *(p+1) == ' ' && *(p+2))
+                s = p + 2;
+        p = strchr(s, '\n');
+        if (p)
+                *p = '\0';
+
+        /* squash extra space characters (branding string) */
+        p = s;
+        while (*p) {
+                if (isspace(*p)) {
+                        char *r = p + 1;
+                        char *q = r;
+                        *p = ' ';
+                        while (*q && isspace(*q))
+                                q++;
+                        if (q != (p+1))
+                                while ((*r++ = *q++));
+                }
+                p++;
+        }
+        ret = do_write_string(fd, s);
+done:
+        free(buf);
+        fclose(file);
+        return ret;
+}
+
+static int write_nrcpus(int fd, struct perf_header *h __used,
+                        struct perf_evlist *evlist __used)
+{
+        long nr;
+        u32 nrc, nra;
+        int ret;
+
+        nr = sysconf(_SC_NPROCESSORS_CONF);
+        if (nr < 0)
+                return -1;
+
+        nrc = (u32)(nr & UINT_MAX);
+
+        nr = sysconf(_SC_NPROCESSORS_ONLN);
+        if (nr < 0)
+                return -1;
+
+        nra = (u32)(nr & UINT_MAX);
+
+        ret = do_write(fd, &nrc, sizeof(nrc));
+        if (ret < 0)
+                return ret;
+
+        return do_write(fd, &nra, sizeof(nra));
+}
+
+static int write_event_desc(int fd, struct perf_header *h __used,
+                            struct perf_evlist *evlist)
+{
+        struct perf_evsel *attr;
+        u32 nre = 0, nri, sz;
+        int ret;
+
+        list_for_each_entry(attr, &evlist->entries, node)
+                nre++;
+
+        /*
+         * write number of events
+         */
+        ret = do_write(fd, &nre, sizeof(nre));
+        if (ret < 0)
+                return ret;
+
+        /*
+         * size of perf_event_attr struct
+         */
+        sz = (u32)sizeof(attr->attr);
+        ret = do_write(fd, &sz, sizeof(sz));
+        if (ret < 0)
+                return ret;
+
+        list_for_each_entry(attr, &evlist->entries, node) {
+
+                ret = do_write(fd, &attr->attr, sz);
+                if (ret < 0)
+                        return ret;
+                /*
+                 * write number of unique id per event
+                 * there is one id per instance of an event
+                 *
+                 * copy into an nri to be independent of the
+                 * type of ids,
+                 */
+                nri = attr->ids;
+                ret = do_write(fd, &nri, sizeof(nri));
+                if (ret < 0)
+                        return ret;
+
+                /*
+                 * write event string as passed on cmdline
+                 */
+                ret = do_write_string(fd, attr->name);
+                if (ret < 0)
+                        return ret;
+                /*
+                 * write unique ids for this event
+                 */
+                ret = do_write(fd, attr->id, attr->ids * sizeof(u64));
+                if (ret < 0)
+                        return ret;
+        }
+        return 0;
+}
+
+static int write_cmdline(int fd, struct perf_header *h __used,
+                         struct perf_evlist *evlist __used)
+{
+        char buf[MAXPATHLEN];
+        char proc[32];
+        u32 i, n;
+        int ret;
+
+        /*
+         * actual atual path to perf binary
+         */
+        sprintf(proc, "/proc/%d/exe", getpid());
+        ret = readlink(proc, buf, sizeof(buf));
+        if (ret <= 0)
+                return -1;
+
+        /* readlink() does not add null termination */
+        buf[ret] = '\0';
+
+        /* account for binary path */
+        n = header_argc + 1;
+
+        ret = do_write(fd, &n, sizeof(n));
+        if (ret < 0)
+                return ret;
+
+        ret = do_write_string(fd, buf);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0 ; i < header_argc; i++) {
+                ret = do_write_string(fd, header_argv[i]);
+                if (ret < 0)
+                        return ret;
+        }
+        return 0;
+}
+
+#define CORE_SIB_FMT \
+        "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
+#define THRD_SIB_FMT \
+        "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
+
+struct cpu_topo {
+        u32 core_sib;
+        u32 thread_sib;
+        char **core_siblings;
+        char **thread_siblings;
+};
+
+static int build_cpu_topo(struct cpu_topo *tp, int cpu)
+{
+        FILE *fp;
+        char filename[MAXPATHLEN];
+        char *buf = NULL, *p;
+        size_t len = 0;
+        u32 i = 0;
+        int ret = -1;
+
+        sprintf(filename, CORE_SIB_FMT, cpu);
+        fp = fopen(filename, "r");
+        if (!fp)
+                return -1;
+
+        if (getline(&buf, &len, fp) <= 0)
+                goto done;
+
+        fclose(fp);
+
+        p = strchr(buf, '\n');
+        if (p)
+                *p = '\0';
+
+        for (i = 0; i < tp->core_sib; i++) {
+                if (!strcmp(buf, tp->core_siblings[i]))
+                        break;
+        }
+        if (i == tp->core_sib) {
+                tp->core_siblings[i] = buf;
+                tp->core_sib++;
+                buf = NULL;
+                len = 0;
+        }
+
+        sprintf(filename, THRD_SIB_FMT, cpu);
+        fp = fopen(filename, "r");
+        if (!fp)
+                goto done;
+
+        if (getline(&buf, &len, fp) <= 0)
+                goto done;
+
+        p = strchr(buf, '\n');
+        if (p)
+                *p = '\0';
+
+        for (i = 0; i < tp->thread_sib; i++) {
+                if (!strcmp(buf, tp->thread_siblings[i]))
+                        break;
+        }
+        if (i == tp->thread_sib) {
+                tp->thread_siblings[i] = buf;
+                tp->thread_sib++;
+                buf = NULL;
+        }
+        ret = 0;
+done:
+        if(fp)
+                fclose(fp);
+        free(buf);
+        return ret;
+}
+
+static void free_cpu_topo(struct cpu_topo *tp)
+{
+        u32 i;
+
+        if (!tp)
+                return;
+
+        for (i = 0 ; i < tp->core_sib; i++)
+                free(tp->core_siblings[i]);
+
+        for (i = 0 ; i < tp->thread_sib; i++)
+                free(tp->thread_siblings[i]);
+
+        free(tp);
+}
+
+static struct cpu_topo *build_cpu_topology(void)
+{
+        struct cpu_topo *tp;
+        void *addr;
+        u32 nr, i;
+        size_t sz;
+        long ncpus;
+        int ret = -1;
+
+        ncpus = sysconf(_SC_NPROCESSORS_CONF);
+        if (ncpus < 0)
+                return NULL;
+
+        nr = (u32)(ncpus & UINT_MAX);
+
+        sz = nr * sizeof(char *);
+
+        addr = calloc(1, sizeof(*tp) + 2 * sz);
+        if (!addr)
+                return NULL;
+
+        tp = addr;
+
+        addr += sizeof(*tp);
+        tp->core_siblings = addr;
+        addr += sz;
+        tp->thread_siblings = addr;
+
+        for (i = 0; i < nr; i++) {
+                ret = build_cpu_topo(tp, i);
+                if (ret < 0)
+                        break;
+        }
+        if (ret) {
+                free_cpu_topo(tp);
+                tp = NULL;
+        }
+        return tp;
+}
+
+static int write_cpu_topology(int fd, struct perf_header *h __used,
+                          struct perf_evlist *evlist __used)
+{
+        struct cpu_topo *tp;
+        u32 i;
+        int ret;
+
+        tp = build_cpu_topology();
+        if (!tp)
+                return -1;
+
+        ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
+        if (ret < 0)
+                goto done;
+
+        for (i = 0; i < tp->core_sib; i++) {
+                ret = do_write_string(fd, tp->core_siblings[i]);
+                if (ret < 0)
+                        goto done;
+        }
+        ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
+        if (ret < 0)
+                goto done;
+
+        for (i = 0; i < tp->thread_sib; i++) {
+                ret = do_write_string(fd, tp->thread_siblings[i]);
+                if (ret < 0)
+                        break;
+        }
+done:
+        free_cpu_topo(tp);
+        return ret;
+}
+
+
+
+static int write_total_mem(int fd, struct perf_header *h __used,
+                          struct perf_evlist *evlist __used)
+{
+        char *buf = NULL;
+        FILE *fp;
+        size_t len = 0;
+        int ret = -1, n;
+        uint64_t mem;
+
+        fp = fopen("/proc/meminfo", "r");
+        if (!fp)
+                return -1;
+
+        while (getline(&buf, &len, fp) > 0) {
+                ret = strncmp(buf, "MemTotal:", 9);
+                if (!ret)
+                        break;
+        }
+        if (!ret) {
+                n = sscanf(buf, "%*s %"PRIu64, &mem);
+                if (n == 1)
+                        ret = do_write(fd, &mem, sizeof(mem));
+        }
+        free(buf);
+        fclose(fp);
+        return ret;
+}
+
+static int write_topo_node(int fd, int node)
+{
+        char str[MAXPATHLEN];
+        char field[32];
+        char *buf = NULL, *p;
+        size_t len = 0;
+        FILE *fp;
+        u64 mem_total, mem_free, mem;
+        int ret = -1;
+
+        sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
+        fp = fopen(str, "r");
+        if (!fp)
+                return -1;
+
+        while (getline(&buf, &len, fp) > 0) {
+                /* skip over invalid lines */
+                if (!strchr(buf, ':'))
+                        continue;
+                if (sscanf(buf, "%*s %*d %s %"PRIu64, field, &mem) != 2)
+                        goto done;
+                if (!strcmp(field, "MemTotal:"))
+                        mem_total = mem;
+                if (!strcmp(field, "MemFree:"))
+                        mem_free = mem;
+        }
+
+        fclose(fp);
+
+        ret = do_write(fd, &mem_total, sizeof(u64));
+        if (ret)
+                goto done;
+
+        ret = do_write(fd, &mem_free, sizeof(u64));
+        if (ret)
+                goto done;
+
+        ret = -1;
+        sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
+
+        fp = fopen(str, "r");
+        if (!fp)
+                goto done;
+
+        if (getline(&buf, &len, fp) <= 0)
+                goto done;
+
+        p = strchr(buf, '\n');
+        if (p)
+                *p = '\0';
+
+        ret = do_write_string(fd, buf);
+done:
+        free(buf);
+        fclose(fp);
+        return ret;
+}
+
+static int write_numa_topology(int fd, struct perf_header *h __used,
+                          struct perf_evlist *evlist __used)
+{
+        char *buf = NULL;
+        size_t len = 0;
+        FILE *fp;
+        struct cpu_map *node_map = NULL;
+        char *c;
+        u32 nr, i, j;
+        int ret = -1;
+
+        fp = fopen("/sys/devices/system/node/online", "r");
+        if (!fp)
+                return -1;
+
+        if (getline(&buf, &len, fp) <= 0)
+                goto done;
+
+        c = strchr(buf, '\n');
+        if (c)
+                *c = '\0';
+
+        node_map = cpu_map__new(buf);
+        if (!node_map)
+                goto done;
+
+        nr = (u32)node_map->nr;
+
+        ret = do_write(fd, &nr, sizeof(nr));
+        if (ret < 0)
+                goto done;
+
+        for (i = 0; i < nr; i++) {
+                j = (u32)node_map->map[i];
+                ret = do_write(fd, &j, sizeof(j));
+                if (ret < 0)
+                        break;
+
+                ret = write_topo_node(fd, i);
+                if (ret < 0)
+                        break;
+        }
+done:
+        free(buf);
+        fclose(fp);
+        free(node_map);
+        return ret;
+}
+
+/*
+ * default get_cpuid(): nothing gets recorded
+ * actual implementation must be in arch/$(ARCH)/util/header.c
+ */
+int __attribute__((weak)) get_cpuid(char *buffer __used, size_t sz __used)
+{
+        return -1;
+}
+
+static int write_cpuid(int fd, struct perf_header *h __used,
+                       struct perf_evlist *evlist __used)
+{
+        char buffer[64];
+        int ret;
+
+        ret = get_cpuid(buffer, sizeof(buffer));
+        if (!ret)
+                goto write_it;
+
+        return -1;
+write_it:
+        return do_write_string(fd, buffer);
+}
+
+static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# hostname : %s\n", str);
+        free(str);
+}
+
+static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# os release : %s\n", str);
+        free(str);
+}
+
+static void print_arch(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# arch : %s\n", str);
+        free(str);
+}
+
+static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# cpudesc : %s\n", str);
+        free(str);
+}
+
+static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
+{
+        ssize_t ret;
+        u32 nr;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                nr = -1; /* interpreted as error */
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        fprintf(fp, "# nrcpus online : %u\n", nr);
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                nr = -1; /* interpreted as error */
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        fprintf(fp, "# nrcpus avail : %u\n", nr);
+}
+
+static void print_version(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# perf version : %s\n", str);
+        free(str);
+}
+
+static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
+{
+        ssize_t ret;
+        char *str;
+        u32 nr, i;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                return;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        fprintf(fp, "# cmdline : ");
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                fprintf(fp, "%s ", str);
+                free(str);
+        }
+        fputc('\n', fp);
+}
+
+static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
+{
+        ssize_t ret;
+        u32 nr, i;
+        char *str;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                return;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                fprintf(fp, "# sibling cores   : %s\n", str);
+                free(str);
+        }
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                return;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                fprintf(fp, "# sibling threads : %s\n", str);
+                free(str);
+        }
+}
+
+static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
+{
+        struct perf_event_attr attr;
+        uint64_t id;
+        void *buf = NULL;
+        char *str;
+        u32 nre, sz, nr, i, j, msz;
+        int ret;
+
+        /* number of events */
+        ret = read(fd, &nre, sizeof(nre));
+        if (ret != (ssize_t)sizeof(nre))
+                goto error;
+
+        if (ph->needs_swap)
+                nre = bswap_32(nre);
+
+        ret = read(fd, &sz, sizeof(sz));
+        if (ret != (ssize_t)sizeof(sz))
+                goto error;
+
+        if (ph->needs_swap)
+                sz = bswap_32(sz);
+
+        /*
+         * ensure it is at least to our ABI rev
+         */
+        if (sz < (u32)sizeof(attr))
+                goto error;
+
+        memset(&attr, 0, sizeof(attr));
+
+        /* read entire region to sync up to next field */
+        buf = malloc(sz);
+        if (!buf)
+                goto error;
+
+        msz = sizeof(attr);
+        if (sz < msz)
+                msz = sz;
+
+        for (i = 0 ; i < nre; i++) {
+
+                ret = read(fd, buf, sz);
+                if (ret != (ssize_t)sz)
+                        goto error;
+
+                if (ph->needs_swap)
+                        perf_event__attr_swap(buf);
+
+                memcpy(&attr, buf, msz);
+
+                ret = read(fd, &nr, sizeof(nr));
+                if (ret != (ssize_t)sizeof(nr))
+                        goto error;
+
+                if (ph->needs_swap)
+                        nr = bswap_32(nr);
+
+                str = do_read_string(fd, ph);
+                fprintf(fp, "# event : name = %s, ", str);
+                free(str);
+
+                fprintf(fp, "type = %d, config = 0x%"PRIx64
+                            ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
+                                attr.type,
+                                (u64)attr.config,
+                                (u64)attr.config1,
+                                (u64)attr.config2);
+
+                fprintf(fp, ", excl_usr = %d, excl_kern = %d",
+                                attr.exclude_user,
+                                attr.exclude_kernel);
+
+                if (nr)
+                        fprintf(fp, ", id = {");
+
+                for (j = 0 ; j < nr; j++) {
+                        ret = read(fd, &id, sizeof(id));
+                        if (ret != (ssize_t)sizeof(id))
+                                goto error;
+
+                        if (ph->needs_swap)
+                                id = bswap_64(id);
+
+                        if (j)
+                                fputc(',', fp);
+
+                        fprintf(fp, " %"PRIu64, id);
+                }
+                if (nr && j == nr)
+                        fprintf(fp, " }");
+                fputc('\n', fp);
+        }
+        free(buf);
+        return;
+error:
+        fprintf(fp, "# event desc: not available or unable to read\n");
+}
+
+static void print_total_mem(struct perf_header *h __used, int fd, FILE *fp)
+{
+        uint64_t mem;
+        ssize_t ret;
+
+        ret = read(fd, &mem, sizeof(mem));
+        if (ret != sizeof(mem))
+                goto error;
+
+        if (h->needs_swap)
+                mem = bswap_64(mem);
+
+        fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
+        return;
+error:
+        fprintf(fp, "# total memory : unknown\n");
+}
+
+static void print_numa_topology(struct perf_header *h __used, int fd, FILE *fp)
+{
+        ssize_t ret;
+        u32 nr, c, i;
+        char *str;
+        uint64_t mem_total, mem_free;
+
+        /* nr nodes */
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != (ssize_t)sizeof(nr))
+                goto error;
+
+        if (h->needs_swap)
+                nr = bswap_32(nr);
+
+        for (i = 0; i < nr; i++) {
+
+                /* node number */
+                ret = read(fd, &c, sizeof(c));
+                if (ret != (ssize_t)sizeof(c))
+                        goto error;
+
+                if (h->needs_swap)
+                        c = bswap_32(c);
+
+                ret = read(fd, &mem_total, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                ret = read(fd, &mem_free, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                if (h->needs_swap) {
+                        mem_total = bswap_64(mem_total);
+                        mem_free = bswap_64(mem_free);
+                }
+
+                fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
+                            " free = %"PRIu64" kB\n",
+                        c,
+                        mem_total,
+                        mem_free);
+
+                str = do_read_string(fd, h);
+                fprintf(fp, "# node%u cpu list : %s\n", c, str);
+                free(str);
+        }
+        return;
+error:
+        fprintf(fp, "# numa topology : not available\n");
+}
+
+static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
+{
+        char *str = do_read_string(fd, ph);
+        fprintf(fp, "# cpuid : %s\n", str);
+        free(str);
+}
+
+struct feature_ops {
+        int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
+        void (*print)(struct perf_header *h, int fd, FILE *fp);
+        const char *name;
+        bool full_only;
+};
+
+#define FEAT_OPA(n, w, p) \
+        [n] = { .name = #n, .write = w, .print = p }
+#define FEAT_OPF(n, w, p) \
+        [n] = { .name = #n, .write = w, .print = p, .full_only = true }
+
+static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
+        FEAT_OPA(HEADER_TRACE_INFO, write_trace_info, NULL),
+        FEAT_OPA(HEADER_BUILD_ID, write_build_id, NULL),
+        FEAT_OPA(HEADER_HOSTNAME, write_hostname, print_hostname),
+        FEAT_OPA(HEADER_OSRELEASE, write_osrelease, print_osrelease),
+        FEAT_OPA(HEADER_VERSION, write_version, print_version),
+        FEAT_OPA(HEADER_ARCH, write_arch, print_arch),
+        FEAT_OPA(HEADER_NRCPUS, write_nrcpus, print_nrcpus),
+        FEAT_OPA(HEADER_CPUDESC, write_cpudesc, print_cpudesc),
+        FEAT_OPA(HEADER_CPUID, write_cpuid, print_cpuid),
+        FEAT_OPA(HEADER_TOTAL_MEM, write_total_mem, print_total_mem),
+        FEAT_OPA(HEADER_EVENT_DESC, write_event_desc, print_event_desc),
+        FEAT_OPA(HEADER_CMDLINE, write_cmdline, print_cmdline),
+        FEAT_OPF(HEADER_CPU_TOPOLOGY, write_cpu_topology, print_cpu_topology),
+        FEAT_OPF(HEADER_NUMA_TOPOLOGY, write_numa_topology, print_numa_topology),
+};
+
+struct header_print_data {
+        FILE *fp;
+        bool full; /* extended list of headers */
+};
+
+static int perf_file_section__fprintf_info(struct perf_file_section *section,
+                                           struct perf_header *ph,
+                                           int feat, int fd, void *data)
+{
+        struct header_print_data *hd = data;
+
+        if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
+                pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
+                                "%d, continuing...\n", section->offset, feat);
+                return 0;
+        }
+        if (feat < HEADER_TRACE_INFO || feat >= HEADER_LAST_FEATURE) {
+                pr_warning("unknown feature %d\n", feat);
+                return -1;
+        }
+        if (!feat_ops[feat].print)
+                return 0;
+
+        if (!feat_ops[feat].full_only || hd->full)
+                feat_ops[feat].print(ph, fd, hd->fp);
+        else
+                fprintf(hd->fp, "# %s info available, use -I to display\n",
+                        feat_ops[feat].name);
+
+        return 0;
+}
+
+int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
+{
+        struct header_print_data hd;
+        struct perf_header *header = &session->header;
+        int fd = session->fd;
+        hd.fp = fp;
+        hd.full = full;
+
+        perf_header__process_sections(header, fd, &hd,
+                                      perf_file_section__fprintf_info);
+        return 0;
+}
+
 #define dsos__for_each_with_build_id(pos, head) \
         list_for_each_entry(pos, head, node)    \
                 if (!pos->has_build_id)         \
@@ -189,8 +1211,8 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms)
 {
         const size_t size = PATH_MAX;
-        char *realname, *filename = malloc(size),
-             *linkname = malloc(size), *targetname;
+        char *realname, *filename = zalloc(size),
+             *linkname = zalloc(size), *targetname;
         int len, err = -1;
 
         if (is_kallsyms) {
@@ -254,8 +1276,8 @@ static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
 {
         const size_t size = PATH_MAX;
-        char *filename = malloc(size),
-             *linkname = malloc(size);
+        char *filename = zalloc(size),
+             *linkname = zalloc(size);
         int err = -1;
 
         if (filename == NULL || linkname == NULL)
@@ -267,7 +1289,7 @@ int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
         if (access(linkname, F_OK))
                 goto out_free;
 
-        if (readlink(linkname, filename, size) < 0)
+        if (readlink(linkname, filename, size - 1) < 0)
                 goto out_free;
 
         if (unlink(linkname))
@@ -356,15 +1378,41 @@ static bool perf_session__read_build_ids(struct perf_session *session, bool with
         return ret;
 }
 
+static int do_write_feat(int fd, struct perf_header *h, int type,
+                         struct perf_file_section **p,
+                         struct perf_evlist *evlist)
+{
+        int err;
+        int ret = 0;
+
+        if (perf_header__has_feat(h, type)) {
+
+                (*p)->offset = lseek(fd, 0, SEEK_CUR);
+
+                err = feat_ops[type].write(fd, h, evlist);
+                if (err < 0) {
+                        pr_debug("failed to write feature %d\n", type);
+
+                        /* undo anything written */
+                        lseek(fd, (*p)->offset, SEEK_SET);
+
+                        return -1;
+                }
+                (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
+                (*p)++;
+        }
+        return ret;
+}
+
 static int perf_header__adds_write(struct perf_header *header,
                                    struct perf_evlist *evlist, int fd)
 {
         int nr_sections;
         struct perf_session *session;
-        struct perf_file_section *feat_sec;
+        struct perf_file_section *feat_sec, *p;
         int sec_size;
         u64 sec_start;
-        int idx = 0, err;
+        int err;
 
         session = container_of(header, struct perf_session, header);
 
@@ -376,7 +1424,7 @@ static int perf_header__adds_write(struct perf_header *header,
         if (!nr_sections)
                 return 0;
 
-        feat_sec = calloc(sizeof(*feat_sec), nr_sections);
+        feat_sec = p = calloc(sizeof(*feat_sec), nr_sections);
         if (feat_sec == NULL)
                 return -ENOMEM;
 
@@ -385,36 +1433,69 @@ static int perf_header__adds_write(struct perf_header *header,
         sec_start = header->data_offset + header->data_size;
         lseek(fd, sec_start + sec_size, SEEK_SET);
 
-        if (perf_header__has_feat(header, HEADER_TRACE_INFO)) {
-                struct perf_file_section *trace_sec;
-
-                trace_sec = &feat_sec[idx++];
+        err = do_write_feat(fd, header, HEADER_TRACE_INFO, &p, evlist);
+        if (err)
+                goto out_free;
 
-                /* Write trace info */
-                trace_sec->offset = lseek(fd, 0, SEEK_CUR);
-                read_tracing_data(fd, &evlist->entries);
-                trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
+        err = do_write_feat(fd, header, HEADER_BUILD_ID, &p, evlist);
+        if (err) {
+                perf_header__clear_feat(header, HEADER_BUILD_ID);
+                goto out_free;
         }
 
-        if (perf_header__has_feat(header, HEADER_BUILD_ID)) {
-                struct perf_file_section *buildid_sec;
+        err = do_write_feat(fd, header, HEADER_HOSTNAME, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_HOSTNAME);
 
-                buildid_sec = &feat_sec[idx++];
+        err = do_write_feat(fd, header, HEADER_OSRELEASE, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_OSRELEASE);
 
-                /* Write build-ids */
-                buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
-                err = dsos__write_buildid_table(header, fd);
-                if (err < 0) {
-                        pr_debug("failed to write buildid table\n");
-                        goto out_free;
-                }
-                buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
-                                          buildid_sec->offset;
-                if (!no_buildid_cache)
-                        perf_session__cache_build_ids(session);
-        }
+        err = do_write_feat(fd, header, HEADER_VERSION, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_VERSION);
+
+        err = do_write_feat(fd, header, HEADER_ARCH, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_ARCH);
+
+        err = do_write_feat(fd, header, HEADER_NRCPUS, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_NRCPUS);
+
+        err = do_write_feat(fd, header, HEADER_CPUDESC, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_CPUDESC);
+
+        err = do_write_feat(fd, header, HEADER_CPUID, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_CPUID);
+
+        err = do_write_feat(fd, header, HEADER_TOTAL_MEM, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_TOTAL_MEM);
+
+        err = do_write_feat(fd, header, HEADER_CMDLINE, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_CMDLINE);
+
+        err = do_write_feat(fd, header, HEADER_EVENT_DESC, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_EVENT_DESC);
+
+        err = do_write_feat(fd, header, HEADER_CPU_TOPOLOGY, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_CPU_TOPOLOGY);
+
+        err = do_write_feat(fd, header, HEADER_NUMA_TOPOLOGY, &p, evlist);
+        if (err)
+                perf_header__clear_feat(header, HEADER_NUMA_TOPOLOGY);
 
         lseek(fd, sec_start, SEEK_SET);
+        /*
+         * may write more than needed due to dropped feature, but
+         * this is okay, reader will skip the mising entries
+         */
         err = do_write(fd, feat_sec, sec_size);
         if (err < 0)
                 pr_debug("failed to write feature section\n");
@@ -554,9 +1635,10 @@ static int perf_header__getbuffer64(struct perf_header *header,
 }
 
 int perf_header__process_sections(struct perf_header *header, int fd,
+                                  void *data,
                                   int (*process)(struct perf_file_section *section,
-                                                 struct perf_header *ph,
-                                                 int feat, int fd))
+                                  struct perf_header *ph,
+                                  int feat, int fd, void *data))
 {
         struct perf_file_section *feat_sec;
         int nr_sections;
@@ -584,7 +1666,7 @@ int perf_header__process_sections(struct perf_header *header, int fd,
                 if (perf_header__has_feat(header, feat)) {
                         struct perf_file_section *sec = &feat_sec[idx++];
 
-                        err = process(sec, header, feat, fd);
+                        err = process(sec, header, feat, fd, data);
                         if (err < 0)
                                 break;
                 }
@@ -621,21 +1703,41 @@ int perf_file_header__read(struct perf_file_header *header,
                         bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
                 else
                         return -1;
+        } else if (ph->needs_swap) {
+                unsigned int i;
+                /*
+                 * feature bitmap is declared as an array of unsigned longs --
+                 * not good since its size can differ between the host that
+                 * generated the data file and the host analyzing the file.
+                 *
+                 * We need to handle endianness, but we don't know the size of
+                 * the unsigned long where the file was generated. Take a best
+                 * guess at determining it: try 64-bit swap first (ie., file
+                 * created on a 64-bit host), and check if the hostname feature
+                 * bit is set (this feature bit is forced on as of fbe96f2).
+                 * If the bit is not, undo the 64-bit swap and try a 32-bit
+                 * swap. If the hostname bit is still not set (e.g., older data
+                 * file), punt and fallback to the original behavior --
+                 * clearing all feature bits and setting buildid.
+                 */
+                for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i)
+                        header->adds_features[i] = bswap_64(header->adds_features[i]);
+
+                if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
+                        for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i) {
+                                header->adds_features[i] = bswap_64(header->adds_features[i]);
+                                header->adds_features[i] = bswap_32(header->adds_features[i]);
+                        }
+                }
+
+                if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
+                        bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
+                        set_bit(HEADER_BUILD_ID, header->adds_features);
+                }
         }
 
         memcpy(&ph->adds_features, &header->adds_features,
                sizeof(ph->adds_features));
-        /*
-         * FIXME: hack that assumes that if we need swap the perf.data file
-         * may be coming from an arch with a different word-size, ergo different
-         * DEFINE_BITMAP format, investigate more later, but for now its mostly
-         * safe to assume that we have a build-id section. Trace files probably
-         * have several other issues in this realm anyway...
-         */
-        if (ph->needs_swap) {
-                memset(&ph->adds_features, 0, sizeof(ph->adds_features));
-                perf_header__set_feat(ph, HEADER_BUILD_ID);
-        }
 
         ph->event_offset = header->event_types.offset;
         ph->event_size   = header->event_types.size;
@@ -726,7 +1828,16 @@ static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
                         return -1;
 
                 bev.header = old_bev.header;
-                bev.pid    = 0;
+
+                /*
+                 * As the pid is the missing value, we need to fill
+                 * it properly. The header.misc value give us nice hint.
+                 */
+                bev.pid = HOST_KERNEL_ID;
+                if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
+                    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
+                        bev.pid = DEFAULT_GUEST_KERNEL_ID;
+
                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
                 __event_process_build_id(&bev, filename, session);
 
@@ -787,7 +1898,7 @@ out:
 
 static int perf_file_section__process(struct perf_file_section *section,
                                       struct perf_header *ph,
-                                      int feat, int fd)
+                                      int feat, int fd, void *data __used)
 {
         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
@@ -804,6 +1915,21 @@ static int perf_file_section__process(struct perf_file_section *section,
                 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
                         pr_debug("Failed to read buildids, continuing...\n");
                 break;
+
+        case HEADER_HOSTNAME:
+        case HEADER_OSRELEASE:
+        case HEADER_VERSION:
+        case HEADER_ARCH:
+        case HEADER_NRCPUS:
+        case HEADER_CPUDESC:
+        case HEADER_CPUID:
+        case HEADER_TOTAL_MEM:
+        case HEADER_CMDLINE:
+        case HEADER_EVENT_DESC:
+        case HEADER_CPU_TOPOLOGY:
+        case HEADER_NUMA_TOPOLOGY:
+                break;
+
         default:
                 pr_debug("unknown feature %d, continuing...\n", feat);
         }
@@ -926,7 +2052,8 @@ int perf_session__read_header(struct perf_session *session, int fd)
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
 
-        perf_header__process_sections(header, fd, perf_file_section__process);
+        perf_header__process_sections(header, fd, NULL,
+                                      perf_file_section__process);
 
         lseek(fd, header->data_offset, SEEK_SET);
 
@@ -1091,15 +2218,29 @@ int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
                                    struct perf_session *session __unused)
 {
         union perf_event ev;
+        struct tracing_data *tdata;
         ssize_t size = 0, aligned_size = 0, padding;
         int err __used = 0;
 
+        /*
+         * We are going to store the size of the data followed
+         * by the data contents. Since the fd descriptor is a pipe,
+         * we cannot seek back to store the size of the data once
+         * we know it. Instead we:
+         *
+         * - write the tracing data to the temp file
+         * - get/write the data size to pipe
+         * - write the tracing data from the temp file
+         *   to the pipe
+         */
+        tdata = tracing_data_get(&evlist->entries, fd, true);
+        if (!tdata)
+                return -1;
+
         memset(&ev, 0, sizeof(ev));
 
         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
-        size = read_tracing_data_size(fd, &evlist->entries);
-        if (size <= 0)
-                return size;
+        size = tdata->size;
         aligned_size = ALIGN(size, sizeof(u64));
         padding = aligned_size - size;
         ev.tracing_data.header.size = sizeof(ev.tracing_data);
@@ -1107,7 +2248,12 @@ int perf_event__synthesize_tracing_data(int fd, struct perf_evlist *evlist,
 
         process(&ev, NULL, session);
 
-        err = read_tracing_data(fd, &evlist->entries);
+        /*
+         * The put function will copy all the tracing data
+         * stored in temp file to the pipe.
+         */
+        tracing_data_put(tdata);
+
         write_padded(fd, NULL, 0, padding);
 
         return aligned_size;
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 1886256768a1..3d5a742f4a2a 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -12,6 +12,20 @@
 enum {
         HEADER_TRACE_INFO = 1,
         HEADER_BUILD_ID,
+
+        HEADER_HOSTNAME,
+        HEADER_OSRELEASE,
+        HEADER_VERSION,
+        HEADER_ARCH,
+        HEADER_NRCPUS,
+        HEADER_CPUDESC,
+        HEADER_CPUID,
+        HEADER_TOTAL_MEM,
+        HEADER_CMDLINE,
+        HEADER_EVENT_DESC,
+        HEADER_CPU_TOPOLOGY,
+        HEADER_NUMA_TOPOLOGY,
+
         HEADER_LAST_FEATURE,
 };
 
@@ -68,10 +82,15 @@ void perf_header__set_feat(struct perf_header *header, int feat);
 void perf_header__clear_feat(struct perf_header *header, int feat);
 bool perf_header__has_feat(const struct perf_header *header, int feat);
 
+int perf_header__set_cmdline(int argc, const char **argv);
+
 int perf_header__process_sections(struct perf_header *header, int fd,
+                                  void *data,
                                   int (*process)(struct perf_file_section *section,
-                                                 struct perf_header *ph,
-                                                 int feat, int fd));
+                                  struct perf_header *ph,
+                                  int feat, int fd, void *data));
+
+int perf_header__fprintf_info(struct perf_session *s, FILE *fp, bool full);
 
 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms);
@@ -104,4 +123,10 @@ int perf_event__synthesize_build_id(struct dso *pos, u16 misc,
                                     struct perf_session *session);
 int perf_event__process_build_id(union perf_event *event,
                                  struct perf_session *session);
+
+/*
+ * arch specific callback
+ */
+int get_cpuid(char *buffer, size_t sz);
+
 #endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 677e1da6bb3e..f6a993963a1e 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -6,6 +6,11 @@
 #include "sort.h"
 #include <math.h>
 
+static bool hists__filter_entry_by_dso(struct hists *hists,
+                                       struct hist_entry *he);
+static bool hists__filter_entry_by_thread(struct hists *hists,
+                                          struct hist_entry *he);
+
 enum hist_filter {
         HIST_FILTER__DSO,
         HIST_FILTER__THREAD,
@@ -18,56 +23,56 @@ struct callchain_param	callchain_param = {
         .order  = ORDER_CALLEE
 };
 
-u16 hists__col_len(struct hists *self, enum hist_column col)
+u16 hists__col_len(struct hists *hists, enum hist_column col)
 {
-        return self->col_len[col];
+        return hists->col_len[col];
 }
 
-void hists__set_col_len(struct hists *self, enum hist_column col, u16 len)
+void hists__set_col_len(struct hists *hists, enum hist_column col, u16 len)
 {
-        self->col_len[col] = len;
+        hists->col_len[col] = len;
 }
 
-bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len)
+bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
 {
-        if (len > hists__col_len(self, col)) {
-                hists__set_col_len(self, col, len);
+        if (len > hists__col_len(hists, col)) {
+                hists__set_col_len(hists, col, len);
                 return true;
         }
         return false;
 }
 
-static void hists__reset_col_len(struct hists *self)
+static void hists__reset_col_len(struct hists *hists)
 {
         enum hist_column col;
 
         for (col = 0; col < HISTC_NR_COLS; ++col)
-                hists__set_col_len(self, col, 0);
+                hists__set_col_len(hists, col, 0);
 }
 
-static void hists__calc_col_len(struct hists *self, struct hist_entry *h)
+static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 {
         u16 len;
 
         if (h->ms.sym)
-                hists__new_col_len(self, HISTC_SYMBOL, h->ms.sym->namelen);
+                hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen);
         else {
                 const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
 
-                if (hists__col_len(self, HISTC_DSO) < unresolved_col_width &&
+                if (hists__col_len(hists, HISTC_DSO) < unresolved_col_width &&
                     !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
                     !symbol_conf.dso_list)
-                        hists__set_col_len(self, HISTC_DSO,
+                        hists__set_col_len(hists, HISTC_DSO,
                                            unresolved_col_width);
         }
 
         len = thread__comm_len(h->thread);
-        if (hists__new_col_len(self, HISTC_COMM, len))
-                hists__set_col_len(self, HISTC_THREAD, len + 6);
+        if (hists__new_col_len(hists, HISTC_COMM, len))
+                hists__set_col_len(hists, HISTC_THREAD, len + 6);
 
         if (h->ms.map) {
                 len = dso__name_len(h->ms.map->dso);
-                hists__new_col_len(self, HISTC_DSO, len);
+                hists__new_col_len(hists, HISTC_DSO, len);
         }
 }
 
@@ -92,6 +97,67 @@ static void hist_entry__add_cpumode_period(struct hist_entry *self,
         }
 }
 
+static void hist_entry__decay(struct hist_entry *he)
+{
+        he->period = (he->period * 7) / 8;
+        he->nr_events = (he->nr_events * 7) / 8;
+}
+
+static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
+{
+        u64 prev_period = he->period;
+
+        if (prev_period == 0)
+                return true;
+
+        hist_entry__decay(he);
+
+        if (!he->filtered)
+                hists->stats.total_period -= prev_period - he->period;
+
+        return he->period == 0;
+}
+
+static void __hists__decay_entries(struct hists *hists, bool zap_user,
+                                   bool zap_kernel, bool threaded)
+{
+        struct rb_node *next = rb_first(&hists->entries);
+        struct hist_entry *n;
+
+        while (next) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                next = rb_next(&n->rb_node);
+                /*
+                 * We may be annotating this, for instance, so keep it here in
+                 * case some it gets new samples, we'll eventually free it when
+                 * the user stops browsing and it agains gets fully decayed.
+                 */
+                if (((zap_user && n->level == '.') ||
+                     (zap_kernel && n->level != '.') ||
+                     hists__decay_entry(hists, n)) &&
+                    !n->used) {
+                        rb_erase(&n->rb_node, &hists->entries);
+
+                        if (sort__need_collapse || threaded)
+                                rb_erase(&n->rb_node_in, &hists->entries_collapsed);
+
+                        hist_entry__free(n);
+                        --hists->nr_entries;
+                }
+        }
+}
+
+void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
+{
+        return __hists__decay_entries(hists, zap_user, zap_kernel, false);
+}
+
+void hists__decay_entries_threaded(struct hists *hists,
+                                   bool zap_user, bool zap_kernel)
+{
+        return __hists__decay_entries(hists, zap_user, zap_kernel, true);
+}
+
 /*
  * histogram, sorted on item, collects periods
  */
@@ -113,11 +179,12 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
         return self;
 }
 
-static void hists__inc_nr_entries(struct hists *self, struct hist_entry *h)
+static void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
 {
         if (!h->filtered) {
-                hists__calc_col_len(self, h);
-                ++self->nr_entries;
+                hists__calc_col_len(hists, h);
+                ++hists->nr_entries;
+                hists->stats.total_period += h->period;
         }
 }
 
@@ -128,11 +195,11 @@ static u8 symbol__parent_filter(const struct symbol *parent)
         return 0;
 }
 
-struct hist_entry *__hists__add_entry(struct hists *self,
+struct hist_entry *__hists__add_entry(struct hists *hists,
                                       struct addr_location *al,
                                       struct symbol *sym_parent, u64 period)
 {
-        struct rb_node **p = &self->entries.rb_node;
+        struct rb_node **p;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         struct hist_entry entry = {
@@ -150,9 +217,13 @@ struct hist_entry *__hists__add_entry(struct hists *self,
         };
         int cmp;
 
+        pthread_mutex_lock(&hists->lock);
+
+        p = &hists->entries_in->rb_node;
+
         while (*p != NULL) {
                 parent = *p;
-                he = rb_entry(parent, struct hist_entry, rb_node);
+                he = rb_entry(parent, struct hist_entry, rb_node_in);
 
                 cmp = hist_entry__cmp(&entry, he);
 
@@ -170,12 +241,14 @@ struct hist_entry *__hists__add_entry(struct hists *self,
 
         he = hist_entry__new(&entry);
         if (!he)
-                return NULL;
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &self->entries);
-        hists__inc_nr_entries(self, he);
+                goto out_unlock;
+
+        rb_link_node(&he->rb_node_in, parent, p);
+        rb_insert_color(&he->rb_node_in, hists->entries_in);
 out:
         hist_entry__add_cpumode_period(he, al->cpumode, period);
+out_unlock:
+        pthread_mutex_unlock(&hists->lock);
         return he;
 }
 
@@ -222,7 +295,7 @@ void hist_entry__free(struct hist_entry *he)
  * collapse the histogram
  */
 
-static bool hists__collapse_insert_entry(struct hists *self,
+static bool hists__collapse_insert_entry(struct hists *hists,
                                          struct rb_root *root,
                                          struct hist_entry *he)
 {
@@ -233,15 +306,16 @@ static bool hists__collapse_insert_entry(struct hists *self,
 
         while (*p != NULL) {
                 parent = *p;
-                iter = rb_entry(parent, struct hist_entry, rb_node);
+                iter = rb_entry(parent, struct hist_entry, rb_node_in);
 
                 cmp = hist_entry__collapse(iter, he);
 
                 if (!cmp) {
                         iter->period += he->period;
+                        iter->nr_events += he->nr_events;
                         if (symbol_conf.use_callchain) {
-                                callchain_cursor_reset(&self->callchain_cursor);
-                                callchain_merge(&self->callchain_cursor, iter->callchain,
+                                callchain_cursor_reset(&hists->callchain_cursor);
+                                callchain_merge(&hists->callchain_cursor, iter->callchain,
                                                 he->callchain);
                         }
                         hist_entry__free(he);
@@ -254,35 +328,70 @@ static bool hists__collapse_insert_entry(struct hists *self,
                         p = &(*p)->rb_right;
         }
 
-        rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, root);
+        rb_link_node(&he->rb_node_in, parent, p);
+        rb_insert_color(&he->rb_node_in, root);
         return true;
 }
 
-void hists__collapse_resort(struct hists *self)
+static struct rb_root *hists__get_rotate_entries_in(struct hists *hists)
+{
+        struct rb_root *root;
+
+        pthread_mutex_lock(&hists->lock);
+
+        root = hists->entries_in;
+        if (++hists->entries_in > &hists->entries_in_array[1])
+                hists->entries_in = &hists->entries_in_array[0];
+
+        pthread_mutex_unlock(&hists->lock);
+
+        return root;
+}
+
+static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
+{
+        hists__filter_entry_by_dso(hists, he);
+        hists__filter_entry_by_thread(hists, he);
+}
+
+static void __hists__collapse_resort(struct hists *hists, bool threaded)
 {
-        struct rb_root tmp;
+        struct rb_root *root;
         struct rb_node *next;
         struct hist_entry *n;
 
-        if (!sort__need_collapse)
+        if (!sort__need_collapse && !threaded)
                 return;
 
-        tmp = RB_ROOT;
-        next = rb_first(&self->entries);
-        self->nr_entries = 0;
-        hists__reset_col_len(self);
+        root = hists__get_rotate_entries_in(hists);
+        next = rb_first(root);
+        hists->stats.total_period = 0;
 
         while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
-
-                rb_erase(&n->rb_node, &self->entries);
-                if (hists__collapse_insert_entry(self, &tmp, n))
-                        hists__inc_nr_entries(self, n);
+                n = rb_entry(next, struct hist_entry, rb_node_in);
+                next = rb_next(&n->rb_node_in);
+
+                rb_erase(&n->rb_node_in, root);
+                if (hists__collapse_insert_entry(hists, &hists->entries_collapsed, n)) {
+                        /*
+                         * If it wasn't combined with one of the entries already
+                         * collapsed, we need to apply the filters that may have
+                         * been set by, say, the hist_browser.
+                         */
+                        hists__apply_filters(hists, n);
+                        hists__inc_nr_entries(hists, n);
+                }
         }
+}
 
-        self->entries = tmp;
+void hists__collapse_resort(struct hists *hists)
+{
+        return __hists__collapse_resort(hists, false);
+}
+
+void hists__collapse_resort_threaded(struct hists *hists)
+{
+        return __hists__collapse_resort(hists, true);
 }
 
 /*
@@ -315,31 +424,43 @@ static void __hists__insert_output_entry(struct rb_root *entries,
         rb_insert_color(&he->rb_node, entries);
 }
 
-void hists__output_resort(struct hists *self)
+static void __hists__output_resort(struct hists *hists, bool threaded)
 {
-        struct rb_root tmp;
+        struct rb_root *root;
         struct rb_node *next;
         struct hist_entry *n;
         u64 min_callchain_hits;
 
-        min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100);
+        min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
+
+        if (sort__need_collapse || threaded)
+                root = &hists->entries_collapsed;
+        else
+                root = hists->entries_in;
 
-        tmp = RB_ROOT;
-        next = rb_first(&self->entries);
+        next = rb_first(root);
+        hists->entries = RB_ROOT;
 
-        self->nr_entries = 0;
-        hists__reset_col_len(self);
+        hists->nr_entries = 0;
+        hists__reset_col_len(hists);
 
         while (next) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                next = rb_next(&n->rb_node);
+                n = rb_entry(next, struct hist_entry, rb_node_in);
+                next = rb_next(&n->rb_node_in);
 
-                rb_erase(&n->rb_node, &self->entries);
-                __hists__insert_output_entry(&tmp, n, min_callchain_hits);
-                hists__inc_nr_entries(self, n);
+                __hists__insert_output_entry(&hists->entries, n, min_callchain_hits);
+                hists__inc_nr_entries(hists, n);
         }
+}
 
-        self->entries = tmp;
+void hists__output_resort(struct hists *hists)
+{
+        return __hists__output_resort(hists, false);
+}
+
+void hists__output_resort_threaded(struct hists *hists)
+{
+        return __hists__output_resort(hists, true);
 }
 
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
@@ -594,12 +715,27 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
         return ret;
 }
 
-int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
-                         struct hists *hists, struct hists *pair_hists,
-                         bool show_displacement, long displacement,
-                         bool color, u64 session_total)
+void hists__output_recalc_col_len(struct hists *hists, int max_rows)
+{
+        struct rb_node *next = rb_first(&hists->entries);
+        struct hist_entry *n;
+        int row = 0;
+
+        hists__reset_col_len(hists);
+
+        while (next && row++ < max_rows) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                if (!n->filtered)
+                        hists__calc_col_len(hists, n);
+                next = rb_next(&n->rb_node);
+        }
+}
+
+static int hist_entry__pcnt_snprintf(struct hist_entry *self, char *s,
+                                     size_t size, struct hists *pair_hists,
+                                     bool show_displacement, long displacement,
+                                     bool color, u64 session_total)
 {
-        struct sort_entry *se;
         u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
         u64 nr_events;
         const char *sep = symbol_conf.field_sep;
@@ -664,6 +800,13 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
                         ret += snprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
         }
 
+        if (symbol_conf.show_total_period) {
+                if (sep)
+                        ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
+                else
+                        ret += snprintf(s + ret, size - ret, " %12" PRIu64, period);
+        }
+
         if (pair_hists) {
                 char bf[32];
                 double old_percent = 0, new_percent = 0, diff;
@@ -698,26 +841,42 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
                 }
         }
 
+        return ret;
+}
+
+int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
+                         struct hists *hists)
+{
+        const char *sep = symbol_conf.field_sep;
+        struct sort_entry *se;
+        int ret = 0;
+
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 if (se->elide)
                         continue;
 
                 ret += snprintf(s + ret, size - ret, "%s", sep ?: "  ");
-                ret += se->se_snprintf(self, s + ret, size - ret,
+                ret += se->se_snprintf(he, s + ret, size - ret,
                                        hists__col_len(hists, se->se_width_idx));
         }
 
         return ret;
 }
 
-int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
+int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
                         struct hists *pair_hists, bool show_displacement,
                         long displacement, FILE *fp, u64 session_total)
 {
         char bf[512];
-        hist_entry__snprintf(self, bf, sizeof(bf), hists, pair_hists,
-                             show_displacement, displacement,
-                             true, session_total);
+        int ret;
+
+        if (size == 0 || size > sizeof(bf))
+                size = sizeof(bf);
+
+        ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
+                                        show_displacement, displacement,
+                                        true, session_total);
+        hist_entry__snprintf(he, bf + ret, size - ret, hists);
         return fprintf(fp, "%s\n", bf);
 }
 
@@ -738,8 +897,9 @@ static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
                                              left_margin);
 }
 
-size_t hists__fprintf(struct hists *self, struct hists *pair,
-                      bool show_displacement, FILE *fp)
+size_t hists__fprintf(struct hists *hists, struct hists *pair,
+                      bool show_displacement, bool show_header, int max_rows,
+                      int max_cols, FILE *fp)
 {
         struct sort_entry *se;
         struct rb_node *nd;
@@ -749,9 +909,13 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
         unsigned int width;
         const char *sep = symbol_conf.field_sep;
         const char *col_width = symbol_conf.col_width_list_str;
+        int nr_rows = 0;
 
         init_rem_hits();
 
+        if (!show_header)
+                goto print_entries;
+
         fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
 
         if (symbol_conf.show_nr_samples) {
@@ -761,6 +925,13 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                         fputs("  Samples  ", fp);
         }
 
+        if (symbol_conf.show_total_period) {
+                if (sep)
+                        ret += fprintf(fp, "%cPeriod", *sep);
+                else
+                        ret += fprintf(fp, "   Period    ");
+        }
+
         if (symbol_conf.show_cpu_utilization) {
                 if (sep) {
                         ret += fprintf(fp, "%csys", *sep);
@@ -803,18 +974,21 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                 width = strlen(se->se_header);
                 if (symbol_conf.col_width_list_str) {
                         if (col_width) {
-                                hists__set_col_len(self, se->se_width_idx,
+                                hists__set_col_len(hists, se->se_width_idx,
                                                    atoi(col_width));
                                 col_width = strchr(col_width, ',');
                                 if (col_width)
                                         ++col_width;
                         }
                 }
-                if (!hists__new_col_len(self, se->se_width_idx, width))
-                        width = hists__col_len(self, se->se_width_idx);
+                if (!hists__new_col_len(hists, se->se_width_idx, width))
+                        width = hists__col_len(hists, se->se_width_idx);
                 fprintf(fp, "  %*s", width, se->se_header);
         }
+
         fprintf(fp, "\n");
+        if (max_rows && ++nr_rows >= max_rows)
+                goto out;
 
         if (sep)
                 goto print_entries;
@@ -822,6 +996,8 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
         fprintf(fp, "# ........");
         if (symbol_conf.show_nr_samples)
                 fprintf(fp, " ..........");
+        if (symbol_conf.show_total_period)
+                fprintf(fp, " ............");
         if (pair) {
                 fprintf(fp, " ..........");
                 if (show_displacement)
@@ -834,17 +1010,23 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                         continue;
 
                 fprintf(fp, "  ");
-                width = hists__col_len(self, se->se_width_idx);
+                width = hists__col_len(hists, se->se_width_idx);
                 if (width == 0)
                         width = strlen(se->se_header);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
 
-        fprintf(fp, "\n#\n");
+        fprintf(fp, "\n");
+        if (max_rows && ++nr_rows >= max_rows)
+                goto out;
+
+        fprintf(fp, "#\n");
+        if (max_rows && ++nr_rows >= max_rows)
+                goto out;
 
 print_entries:
-        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 if (h->filtered)
@@ -858,19 +1040,22 @@ print_entries:
                                 displacement = 0;
                         ++position;
                 }
-                ret += hist_entry__fprintf(h, self, pair, show_displacement,
-                                           displacement, fp, self->stats.total_period);
+                ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
+                                           displacement, fp, hists->stats.total_period);
 
                 if (symbol_conf.use_callchain)
-                        ret += hist_entry__fprintf_callchain(h, self, fp,
-                                                             self->stats.total_period);
+                        ret += hist_entry__fprintf_callchain(h, hists, fp,
+                                                             hists->stats.total_period);
+                if (max_rows && ++nr_rows >= max_rows)
+                        goto out;
+
                 if (h->ms.map == NULL && verbose > 1) {
                         __map_groups__fprintf_maps(&h->thread->mg,
                                                    MAP__FUNCTION, verbose, fp);
                         fprintf(fp, "%.10s end\n", graph_dotted_line);
                 }
         }
-
+out:
         free(rem_sq_bracket);
 
         return ret;
@@ -879,7 +1064,7 @@ print_entries:
 /*
  * See hists__fprintf to match the column widths
  */
-unsigned int hists__sort_list_width(struct hists *self)
+unsigned int hists__sort_list_width(struct hists *hists)
 {
         struct sort_entry *se;
         int ret = 9; /* total % */
@@ -896,9 +1081,12 @@ unsigned int hists__sort_list_width(struct hists *self)
         if (symbol_conf.show_nr_samples)
                 ret += 11;
 
+        if (symbol_conf.show_total_period)
+                ret += 13;
+
         list_for_each_entry(se, &hist_entry__sort_list, list)
                 if (!se->elide)
-                        ret += 2 + hists__col_len(self, se->se_width_idx);
+                        ret += 2 + hists__col_len(hists, se->se_width_idx);
 
         if (verbose) /* Addr + origin */
                 ret += 3 + BITS_PER_LONG / 4;
@@ -906,63 +1094,84 @@ unsigned int hists__sort_list_width(struct hists *self)
         return ret;
 }
 
-static void hists__remove_entry_filter(struct hists *self, struct hist_entry *h,
+static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
                                        enum hist_filter filter)
 {
         h->filtered &= ~(1 << filter);
         if (h->filtered)
                 return;
 
-        ++self->nr_entries;
+        ++hists->nr_entries;
         if (h->ms.unfolded)
-                self->nr_entries += h->nr_rows;
+                hists->nr_entries += h->nr_rows;
         h->row_offset = 0;
-        self->stats.total_period += h->period;
-        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
+        hists->stats.total_period += h->period;
+        hists->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
 
-        hists__calc_col_len(self, h);
+        hists__calc_col_len(hists, h);
 }
 
-void hists__filter_by_dso(struct hists *self, const struct dso *dso)
+
+static bool hists__filter_entry_by_dso(struct hists *hists,
+                                       struct hist_entry *he)
+{
+        if (hists->dso_filter != NULL &&
+            (he->ms.map == NULL || he->ms.map->dso != hists->dso_filter)) {
+                he->filtered |= (1 << HIST_FILTER__DSO);
+                return true;
+        }
+
+        return false;
+}
+
+void hists__filter_by_dso(struct hists *hists)
 {
         struct rb_node *nd;
 
-        self->nr_entries = self->stats.total_period = 0;
-        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
-        hists__reset_col_len(self);
+        hists->nr_entries = hists->stats.total_period = 0;
+        hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        hists__reset_col_len(hists);
 
-        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 if (symbol_conf.exclude_other && !h->parent)
                         continue;
 
-                if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
-                        h->filtered |= (1 << HIST_FILTER__DSO);
+                if (hists__filter_entry_by_dso(hists, h))
                         continue;
-                }
 
-                hists__remove_entry_filter(self, h, HIST_FILTER__DSO);
+                hists__remove_entry_filter(hists, h, HIST_FILTER__DSO);
         }
 }
 
-void hists__filter_by_thread(struct hists *self, const struct thread *thread)
+static bool hists__filter_entry_by_thread(struct hists *hists,
+                                          struct hist_entry *he)
+{
+        if (hists->thread_filter != NULL &&
+            he->thread != hists->thread_filter) {
+                he->filtered |= (1 << HIST_FILTER__THREAD);
+                return true;
+        }
+
+        return false;
+}
+
+void hists__filter_by_thread(struct hists *hists)
 {
         struct rb_node *nd;
 
-        self->nr_entries = self->stats.total_period = 0;
-        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
-        hists__reset_col_len(self);
+        hists->nr_entries = hists->stats.total_period = 0;
+        hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        hists__reset_col_len(hists);
 
-        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
-                if (thread != NULL && h->thread != thread) {
-                        h->filtered |= (1 << HIST_FILTER__THREAD);
+                if (hists__filter_entry_by_thread(hists, h))
                         continue;
-                }
 
-                hists__remove_entry_filter(self, h, HIST_FILTER__THREAD);
+                hists__remove_entry_filter(hists, h, HIST_FILTER__THREAD);
         }
 }
 
@@ -976,13 +1185,13 @@ int hist_entry__annotate(struct hist_entry *he, size_t privsize)
         return symbol__annotate(he->ms.sym, he->ms.map, privsize);
 }
 
-void hists__inc_nr_events(struct hists *self, u32 type)
+void hists__inc_nr_events(struct hists *hists, u32 type)
 {
-        ++self->stats.nr_events[0];
-        ++self->stats.nr_events[type];
+        ++hists->stats.nr_events[0];
+        ++hists->stats.nr_events[type];
 }
 
-size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
+size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
 {
         int i;
         size_t ret = 0;
@@ -990,7 +1199,7 @@ size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
         for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
                 const char *name;
 
-                if (self->stats.nr_events[i] == 0)
+                if (hists->stats.nr_events[i] == 0)
                         continue;
 
                 name = perf_event__name(i);
@@ -998,8 +1207,18 @@ size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
                         continue;
 
                 ret += fprintf(fp, "%16s events: %10d\n", name,
-                               self->stats.nr_events[i]);
+                               hists->stats.nr_events[i]);
         }
 
         return ret;
 }
+
+void hists__init(struct hists *hists)
+{
+        memset(hists, 0, sizeof(*hists));
+        hists->entries_in_array[0] = hists->entries_in_array[1] = RB_ROOT;
+        hists->entries_in = &hists->entries_in_array[0];
+        hists->entries_collapsed = RB_ROOT;
+        hists->entries = RB_ROOT;
+        pthread_mutex_init(&hists->lock, NULL);
+}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 3beb97c4d822..ff93ddc91c5c 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -2,6 +2,7 @@
 #define __PERF_HIST_H
 
 #include <linux/types.h>
+#include <pthread.h>
 #include "callchain.h"
 
 extern struct callchain_param callchain_param;
@@ -42,9 +43,18 @@ enum hist_column {
         HISTC_NR_COLS, /* Last entry */
 };
 
+struct thread;
+struct dso;
+
 struct hists {
+        struct rb_root          entries_in_array[2];
+        struct rb_root          *entries_in;
         struct rb_root          entries;
+        struct rb_root          entries_collapsed;
         u64                     nr_entries;
+        const struct thread     *thread_filter;
+        const struct dso        *dso_filter;
+        pthread_mutex_t         lock;
         struct events_stats     stats;
         u64                     event_stream;
         u16                     col_len[HISTC_NR_COLS];
@@ -52,34 +62,42 @@ struct hists {
         struct callchain_cursor callchain_cursor;
 };
 
+void hists__init(struct hists *hists);
+
 struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct addr_location *al,
                                       struct symbol *parent, u64 period);
 extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
-int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
+int hist_entry__fprintf(struct hist_entry *he, size_t size, struct hists *hists,
                         struct hists *pair_hists, bool show_displacement,
-                        long displacement, FILE *fp, u64 total);
+                        long displacement, FILE *fp, u64 session_total);
 int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
-                         struct hists *hists, struct hists *pair_hists,
-                         bool show_displacement, long displacement,
-                         bool color, u64 total);
+                         struct hists *hists);
 void hist_entry__free(struct hist_entry *);
 
 void hists__output_resort(struct hists *self);
+void hists__output_resort_threaded(struct hists *hists);
 void hists__collapse_resort(struct hists *self);
+void hists__collapse_resort_threaded(struct hists *hists);
+
+void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel);
+void hists__decay_entries_threaded(struct hists *hists, bool zap_user,
+                                   bool zap_kernel);
+void hists__output_recalc_col_len(struct hists *hists, int max_rows);
 
 void hists__inc_nr_events(struct hists *self, u32 type);
 size_t hists__fprintf_nr_events(struct hists *self, FILE *fp);
 
 size_t hists__fprintf(struct hists *self, struct hists *pair,
-                      bool show_displacement, FILE *fp);
+                      bool show_displacement, bool show_header,
+                      int max_rows, int max_cols, FILE *fp);
 
 int hist_entry__inc_addr_samples(struct hist_entry *self, int evidx, u64 addr);
 int hist_entry__annotate(struct hist_entry *self, size_t privsize);
 
-void hists__filter_by_dso(struct hists *self, const struct dso *dso);
-void hists__filter_by_thread(struct hists *self, const struct thread *thread);
+void hists__filter_by_dso(struct hists *hists);
+void hists__filter_by_thread(struct hists *hists);
 
 u16 hists__col_len(struct hists *self, enum hist_column col);
 void hists__set_col_len(struct hists *self, enum hist_column col, u16 len);
@@ -90,26 +108,33 @@ struct perf_evlist;
 #ifdef NO_NEWT_SUPPORT
 static inline
 int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __used,
-                                  const char *help __used)
+                                  const char *help __used,
+                                  void(*timer)(void *arg) __used,
+                                  void *arg __used,
+                                  int refresh __used)
 {
         return 0;
 }
 
 static inline int hist_entry__tui_annotate(struct hist_entry *self __used,
-                                           int evidx __used)
+                                           int evidx __used,
+                                           int nr_events __used,
+                                           void(*timer)(void *arg) __used,
+                                           void *arg __used,
+                                           int delay_secs __used)
 {
         return 0;
 }
-#define KEY_LEFT -1
-#define KEY_RIGHT -2
+#define K_LEFT -1
+#define K_RIGHT -2
 #else
-#include <newt.h>
-int hist_entry__tui_annotate(struct hist_entry *self, int evidx);
-
-#define KEY_LEFT NEWT_KEY_LEFT
-#define KEY_RIGHT NEWT_KEY_RIGHT
+#include "ui/keysyms.h"
+int hist_entry__tui_annotate(struct hist_entry *he, int evidx, int nr_events,
+                             void(*timer)(void *arg), void *arg, int delay_secs);
 
-int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help);
+int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
+                                  void(*timer)(void *arg), void *arg,
+                                  int refresh);
 #endif
 
 unsigned int hists__sort_list_width(struct hists *self);
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index 791f9dd27ebf..547628e97f3d 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -5,7 +5,9 @@
 #define __always_inline inline
 #endif
 #define __user
+#ifndef __attribute_const__
 #define __attribute_const__
+#endif
 
 #define __used          __attribute__((__unused__))
 
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index a16ecab5229d..78284b13e808 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -18,6 +18,13 @@ static inline int is_anon_memory(const char *filename)
         return strcmp(filename, "//anon") == 0;
 }
 
+static inline int is_no_dso_memory(const char *filename)
+{
+        return !strcmp(filename, "[stack]") ||
+               !strcmp(filename, "[vdso]")  ||
+               !strcmp(filename, "[heap]");
+}
+
 void map__init(struct map *self, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso)
 {
@@ -42,9 +49,10 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
         if (self != NULL) {
                 char newfilename[PATH_MAX];
                 struct dso *dso;
-                int anon;
+                int anon, no_dso;
 
                 anon = is_anon_memory(filename);
+                no_dso = is_no_dso_memory(filename);
 
                 if (anon) {
                         snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
@@ -57,12 +65,16 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
 
                 map__init(self, type, start, start + len, pgoff, dso);
 
-                if (anon) {
-set_identity:
+                if (anon || no_dso) {
                         self->map_ip = self->unmap_ip = identity__map_ip;
-                } else if (strcmp(filename, "[vdso]") == 0) {
-                        dso__set_loaded(dso, self->type);
-                        goto set_identity;
+
+                        /*
+                         * Set memory without DSO as loaded. All map__find_*
+                         * functions still return NULL, and we avoid the
+                         * unnecessary map__load warning.
+                         */
+                        if (no_dso)
+                                dso__set_loaded(dso, self->type);
                 }
         }
         return self;
@@ -127,8 +139,8 @@ int map__load(struct map *self, symbol_filter_t filter)
 
                 if (len > sizeof(DSO__DELETED) &&
                     strcmp(name + real_len + 1, DSO__DELETED) == 0) {
-                        pr_warning("%.*s was updated, restart the long "
-                                   "running apps that use it!\n",
+                        pr_warning("%.*s was updated (is prelink enabled?). "
+                                "Restart the long running apps that use it!\n",
                                    (int)real_len, name);
                 } else {
                         pr_warning("no symbols found in %s, maybe install "
@@ -220,55 +232,55 @@ u64 map__objdump_2ip(struct map *map, u64 addr)
         return ip;
 }
 
-void map_groups__init(struct map_groups *self)
+void map_groups__init(struct map_groups *mg)
 {
         int i;
         for (i = 0; i < MAP__NR_TYPES; ++i) {
-                self->maps[i] = RB_ROOT;
-                INIT_LIST_HEAD(&self->removed_maps[i]);
+                mg->maps[i] = RB_ROOT;
+                INIT_LIST_HEAD(&mg->removed_maps[i]);
         }
-        self->machine = NULL;
+        mg->machine = NULL;
 }
 
-static void maps__delete(struct rb_root *self)
+static void maps__delete(struct rb_root *maps)
 {
-        struct rb_node *next = rb_first(self);
+        struct rb_node *next = rb_first(maps);
 
         while (next) {
                 struct map *pos = rb_entry(next, struct map, rb_node);
 
                 next = rb_next(&pos->rb_node);
-                rb_erase(&pos->rb_node, self);
+                rb_erase(&pos->rb_node, maps);
                 map__delete(pos);
         }
 }
 
-static void maps__delete_removed(struct list_head *self)
+static void maps__delete_removed(struct list_head *maps)
 {
         struct map *pos, *n;
 
-        list_for_each_entry_safe(pos, n, self, node) {
+        list_for_each_entry_safe(pos, n, maps, node) {
                 list_del(&pos->node);
                 map__delete(pos);
         }
 }
 
-void map_groups__exit(struct map_groups *self)
+void map_groups__exit(struct map_groups *mg)
 {
         int i;
 
         for (i = 0; i < MAP__NR_TYPES; ++i) {
-                maps__delete(&self->maps[i]);
-                maps__delete_removed(&self->removed_maps[i]);
+                maps__delete(&mg->maps[i]);
+                maps__delete_removed(&mg->removed_maps[i]);
         }
 }
 
-void map_groups__flush(struct map_groups *self)
+void map_groups__flush(struct map_groups *mg)
 {
         int type;
 
         for (type = 0; type < MAP__NR_TYPES; type++) {
-                struct rb_root *root = &self->maps[type];
+                struct rb_root *root = &mg->maps[type];
                 struct rb_node *next = rb_first(root);
 
                 while (next) {
@@ -280,17 +292,17 @@ void map_groups__flush(struct map_groups *self)
                          * instance in some hist_entry instances, so
                          * just move them to a separate list.
                          */
-                        list_add_tail(&pos->node, &self->removed_maps[pos->type]);
+                        list_add_tail(&pos->node, &mg->removed_maps[pos->type]);
                 }
         }
 }
 
-struct symbol *map_groups__find_symbol(struct map_groups *self,
+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 *map = map_groups__find(self, type, addr);
+        struct map *map = map_groups__find(mg, type, addr);
 
         if (map != NULL) {
                 if (mapp != NULL)
@@ -301,7 +313,7 @@ struct symbol *map_groups__find_symbol(struct map_groups *self,
         return NULL;
 }
 
-struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
                                                enum map_type type,
                                                const char *name,
                                                struct map **mapp,
@@ -309,7 +321,7 @@ struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
 {
         struct rb_node *nd;
 
-        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
                 struct map *pos = rb_entry(nd, struct map, rb_node);
                 struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
 
@@ -323,13 +335,13 @@ struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
         return NULL;
 }
 
-size_t __map_groups__fprintf_maps(struct map_groups *self,
+size_t __map_groups__fprintf_maps(struct map_groups *mg,
                                   enum map_type type, int verbose, FILE *fp)
 {
         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
         struct rb_node *nd;
 
-        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&mg->maps[type]); nd; nd = rb_next(nd)) {
                 struct map *pos = rb_entry(nd, struct map, rb_node);
                 printed += fprintf(fp, "Map:");
                 printed += map__fprintf(pos, fp);
@@ -342,22 +354,22 @@ size_t __map_groups__fprintf_maps(struct map_groups *self,
         return printed;
 }
 
-size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp)
+size_t map_groups__fprintf_maps(struct map_groups *mg, int verbose, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_maps(self, i, verbose, fp);
+                printed += __map_groups__fprintf_maps(mg, i, verbose, fp);
         return printed;
 }
 
-static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *mg,
                                                  enum map_type type,
                                                  int verbose, FILE *fp)
 {
         struct map *pos;
         size_t printed = 0;
 
-        list_for_each_entry(pos, &self->removed_maps[type], node) {
+        list_for_each_entry(pos, &mg->removed_maps[type], node) {
                 printed += fprintf(fp, "Map:");
                 printed += map__fprintf(pos, fp);
                 if (verbose > 1) {
@@ -368,26 +380,26 @@ static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
         return printed;
 }
 
-static size_t map_groups__fprintf_removed_maps(struct map_groups *self,
+static size_t map_groups__fprintf_removed_maps(struct map_groups *mg,
                                                int verbose, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_removed_maps(self, i, verbose, fp);
+                printed += __map_groups__fprintf_removed_maps(mg, i, verbose, fp);
         return printed;
 }
 
-size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp)
+size_t map_groups__fprintf(struct map_groups *mg, int verbose, FILE *fp)
 {
-        size_t printed = map_groups__fprintf_maps(self, verbose, fp);
+        size_t printed = map_groups__fprintf_maps(mg, verbose, fp);
         printed += fprintf(fp, "Removed maps:\n");
-        return printed + map_groups__fprintf_removed_maps(self, verbose, fp);
+        return printed + map_groups__fprintf_removed_maps(mg, verbose, fp);
 }
 
-int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
                                    int verbose, FILE *fp)
 {
-        struct rb_root *root = &self->maps[map->type];
+        struct rb_root *root = &mg->maps[map->type];
         struct rb_node *next = rb_first(root);
         int err = 0;
 
@@ -418,7 +430,7 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
                         }
 
                         before->end = map->start - 1;
-                        map_groups__insert(self, before);
+                        map_groups__insert(mg, before);
                         if (verbose >= 2)
                                 map__fprintf(before, fp);
                 }
@@ -432,7 +444,7 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
                         }
 
                         after->start = map->end + 1;
-                        map_groups__insert(self, after);
+                        map_groups__insert(mg, after);
                         if (verbose >= 2)
                                 map__fprintf(after, fp);
                 }
@@ -441,7 +453,7 @@ move_map:
                  * If we have references, just move them to a separate list.
                  */
                 if (pos->referenced)
-                        list_add_tail(&pos->node, &self->removed_maps[map->type]);
+                        list_add_tail(&pos->node, &mg->removed_maps[map->type]);
                 else
                         map__delete(pos);
 
@@ -455,7 +467,7 @@ move_map:
 /*
  * XXX This should not really _copy_ te maps, but refcount them.
  */
-int map_groups__clone(struct map_groups *self,
+int map_groups__clone(struct map_groups *mg,
                       struct map_groups *parent, enum map_type type)
 {
         struct rb_node *nd;
@@ -464,7 +476,7 @@ int map_groups__clone(struct map_groups *self,
                 struct map *new = map__clone(map);
                 if (new == NULL)
                         return -ENOMEM;
-                map_groups__insert(self, new);
+                map_groups__insert(mg, new);
         }
         return 0;
 }
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index b397c0383728..890d85545d0f 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -123,17 +123,17 @@ void map__fixup_end(struct map *self);
 
 void map__reloc_vmlinux(struct map *self);
 
-size_t __map_groups__fprintf_maps(struct map_groups *self,
+size_t __map_groups__fprintf_maps(struct map_groups *mg,
                                   enum map_type type, int verbose, FILE *fp);
 void maps__insert(struct rb_root *maps, struct map *map);
-void maps__remove(struct rb_root *self, struct map *map);
+void maps__remove(struct rb_root *maps, struct map *map);
 struct map *maps__find(struct rb_root *maps, u64 addr);
-void map_groups__init(struct map_groups *self);
-void map_groups__exit(struct map_groups *self);
-int map_groups__clone(struct map_groups *self,
+void map_groups__init(struct map_groups *mg);
+void map_groups__exit(struct map_groups *mg);
+int map_groups__clone(struct map_groups *mg,
                       struct map_groups *parent, enum map_type type);
-size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
-size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
+size_t map_groups__fprintf(struct map_groups *mg, int verbose, FILE *fp);
+size_t map_groups__fprintf_maps(struct map_groups *mg, int verbose, FILE *fp);
 
 typedef void (*machine__process_t)(struct machine *self, void *data);
 
@@ -162,29 +162,29 @@ static inline bool machine__is_host(struct machine *self)
         return self ? self->pid == HOST_KERNEL_ID : false;
 }
 
-static inline void map_groups__insert(struct map_groups *self, struct map *map)
+static inline void map_groups__insert(struct map_groups *mg, struct map *map)
 {
-        maps__insert(&self->maps[map->type], map);
-        map->groups = self;
+        maps__insert(&mg->maps[map->type], map);
+        map->groups = mg;
 }
 
-static inline void map_groups__remove(struct map_groups *self, struct map *map)
+static inline void map_groups__remove(struct map_groups *mg, struct map *map)
 {
-        maps__remove(&self->maps[map->type], map);
+        maps__remove(&mg->maps[map->type], map);
 }
 
-static inline struct map *map_groups__find(struct map_groups *self,
+static inline struct map *map_groups__find(struct map_groups *mg,
                                            enum map_type type, u64 addr)
 {
-        return maps__find(&self->maps[type], addr);
+        return maps__find(&mg->maps[type], addr);
 }
 
-struct symbol *map_groups__find_symbol(struct map_groups *self,
+struct symbol *map_groups__find_symbol(struct map_groups *mg,
                                        enum map_type type, u64 addr,
                                        struct map **mapp,
                                        symbol_filter_t filter);
 
-struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *mg,
                                                enum map_type type,
                                                const char *name,
                                                struct map **mapp,
@@ -208,11 +208,11 @@ struct symbol *machine__find_kernel_function(struct machine *self, u64 addr,
 }
 
 static inline
-struct symbol *map_groups__find_function_by_name(struct map_groups *self,
+struct symbol *map_groups__find_function_by_name(struct map_groups *mg,
                                                  const char *name, struct map **mapp,
                                                  symbol_filter_t filter)
 {
-        return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
+        return map_groups__find_symbol_by_name(mg, MAP__FUNCTION, name, mapp, filter);
 }
 
 static inline
@@ -225,13 +225,13 @@ struct symbol *machine__find_kernel_function_by_name(struct machine *self,
                                                  filter);
 }
 
-int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+int map_groups__fixup_overlappings(struct map_groups *mg, struct map *map,
                                    int verbose, FILE *fp);
 
-struct map *map_groups__find_by_name(struct map_groups *self,
+struct map *map_groups__find_by_name(struct map_groups *mg,
                                      enum map_type type, const char *name);
 struct map *machine__new_module(struct machine *self, u64 start, const char *filename);
 
-void map_groups__flush(struct map_groups *self);
+void map_groups__flush(struct map_groups *mg);
 
 #endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 4ea7e19f5251..928918b796b2 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -697,7 +697,11 @@ parse_raw_event(const char **strp, struct perf_event_attr *attr)
                 return EVT_FAILED;
         n = hex2u64(str + 1, &config);
         if (n > 0) {
-                *strp = str + n + 1;
+                const char *end = str + n + 1;
+                if (*end != '\0' && *end != ',' && *end != ':')
+                        return EVT_FAILED;
+
+                *strp = end;
                 attr->type = PERF_TYPE_RAW;
                 attr->config = config;
                 return EVT_HANDLED;
@@ -1097,6 +1101,4 @@ void print_events(const char *event_glob)
         printf("\n");
 
         print_tracepoint_events(NULL, NULL);
-
-        exit(129);
 }
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index b82d54fa2c56..eb25900e2211 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1820,11 +1820,15 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                 ret = -ENOMEM;
                 goto error;
         }
-        tev->point.module = strdup(module);
-        if (tev->point.module == NULL) {
-                ret = -ENOMEM;
-                goto error;
+
+        if (module) {
+                tev->point.module = strdup(module);
+                if (tev->point.module == NULL) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
         }
+
         tev->point.offset = pev->point.offset;
         tev->point.retprobe = pev->point.retprobe;
         tev->nargs = pev->nargs;
@@ -1952,8 +1956,10 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
 
         pr_debug("Writing event: %s\n", buf);
         ret = write(fd, buf, strlen(buf));
-        if (ret < 0)
+        if (ret < 0) {
+                ret = -errno;
                 goto error;
+        }
 
         printf("Remove event: %s\n", ent->s);
         return 0;
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 3e44a3e36519..5d732621a462 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -612,12 +612,12 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
         return ret;
 }
 
-/* Find a variable in a subprogram die */
-static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
+/* Find a variable in a scope DIE */
+static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
-        Dwarf_Die vr_die, *scopes;
+        Dwarf_Die vr_die;
         char buf[32], *ptr;
-        int ret, nscopes;
+        int ret = 0;
 
         if (!is_c_varname(pf->pvar->var)) {
                 /* Copy raw parameters */
@@ -652,30 +652,16 @@ static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
         if (pf->tvar->name == NULL)
                 return -ENOMEM;
 
-        pr_debug("Searching '%s' variable in context.\n",
-                 pf->pvar->var);
+        pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
         /* Search child die for local variables and parameters. */
-        if (die_find_variable_at(sp_die, pf->pvar->var, pf->addr, &vr_die))
-                ret = convert_variable(&vr_die, pf);
-        else {
-                /* Search upper class */
-                nscopes = dwarf_getscopes_die(sp_die, &scopes);
-                while (nscopes-- > 1) {
-                        pr_debug("Searching variables in %s\n",
-                                 dwarf_diename(&scopes[nscopes]));
-                        /* We should check this scope, so give dummy address */
-                        if (die_find_variable_at(&scopes[nscopes],
-                                                 pf->pvar->var, 0,
-                                                 &vr_die)) {
-                                ret = convert_variable(&vr_die, pf);
-                                goto found;
-                        }
-                }
-                if (scopes)
-                        free(scopes);
-                ret = -ENOENT;
+        if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
+                /* Search again in global variables */
+                if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
+                        ret = -ENOENT;
         }
-found:
+        if (ret >= 0)
+                ret = convert_variable(&vr_die, pf);
+
         if (ret < 0)
                 pr_warning("Failed to find '%s' in this function.\n",
                            pf->pvar->var);
@@ -718,26 +704,30 @@ static int convert_to_trace_point(Dwarf_Die *sp_die, Dwarf_Addr paddr,
         return 0;
 }
 
-/* Call probe_finder callback with real subprogram DIE */
-static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
+/* Call probe_finder callback with scope DIE */
+static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
-        Dwarf_Die die_mem;
         Dwarf_Attribute fb_attr;
         size_t nops;
         int ret;
 
-        /* If no real subprogram, find a real one */
-        if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
-                sp_die = die_find_realfunc(&pf->cu_die, pf->addr, &die_mem);
-                if (!sp_die) {
+        if (!sc_die) {
+                pr_err("Caller must pass a scope DIE. Program error.\n");
+                return -EINVAL;
+        }
+
+        /* If not a real subprogram, find a real one */
+        if (dwarf_tag(sc_die) != DW_TAG_subprogram) {
+                if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
                         pr_warning("Failed to find probe point in any "
                                    "functions.\n");
                         return -ENOENT;
                 }
-        }
+        } else
+                memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
 
-        /* Get the frame base attribute/ops */
-        dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
+        /* Get the frame base attribute/ops from subprogram */
+        dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
         ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
         if (ret <= 0 || nops == 0) {
                 pf->fb_ops = NULL;
@@ -755,7 +745,7 @@ static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
 
         /* Call finder's callback handler */
-        ret = pf->callback(sp_die, pf);
+        ret = pf->callback(sc_die, pf);
 
         /* *pf->fb_ops will be cached in libdw. Don't free it. */
         pf->fb_ops = NULL;
@@ -763,17 +753,82 @@ static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
         return ret;
 }
 
+struct find_scope_param {
+        const char *function;
+        const char *file;
+        int line;
+        int diff;
+        Dwarf_Die *die_mem;
+        bool found;
+};
+
+static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
+{
+        struct find_scope_param *fsp = data;
+        const char *file;
+        int lno;
+
+        /* Skip if declared file name does not match */
+        if (fsp->file) {
+                file = dwarf_decl_file(fn_die);
+                if (!file || strcmp(fsp->file, file) != 0)
+                        return 0;
+        }
+        /* If the function name is given, that's what user expects */
+        if (fsp->function) {
+                if (die_compare_name(fn_die, fsp->function)) {
+                        memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
+                        fsp->found = true;
+                        return 1;
+                }
+        } else {
+                /* With the line number, find the nearest declared DIE */
+                dwarf_decl_line(fn_die, &lno);
+                if (lno < fsp->line && fsp->diff > fsp->line - lno) {
+                        /* Keep a candidate and continue */
+                        fsp->diff = fsp->line - lno;
+                        memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
+                        fsp->found = true;
+                }
+        }
+        return 0;
+}
+
+/* Find an appropriate scope fits to given conditions */
+static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
+{
+        struct find_scope_param fsp = {
+                .function = pf->pev->point.function,
+                .file = pf->fname,
+                .line = pf->lno,
+                .diff = INT_MAX,
+                .die_mem = die_mem,
+                .found = false,
+        };
+
+        cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);
+
+        return fsp.found ? die_mem : NULL;
+}
+
 static int probe_point_line_walker(const char *fname, int lineno,
                                    Dwarf_Addr addr, void *data)
 {
         struct probe_finder *pf = data;
+        Dwarf_Die *sc_die, die_mem;
         int ret;
 
         if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
                 return 0;
 
         pf->addr = addr;
-        ret = call_probe_finder(NULL, pf);
+        sc_die = find_best_scope(pf, &die_mem);
+        if (!sc_die) {
+                pr_warning("Failed to find scope of probe point.\n");
+                return -ENOENT;
+        }
+
+        ret = call_probe_finder(sc_die, pf);
 
         /* Continue if no error, because the line will be in inline function */
         return ret < 0 ? ret : 0;
@@ -827,6 +882,7 @@ static int probe_point_lazy_walker(const char *fname, int lineno,
                                    Dwarf_Addr addr, void *data)
 {
         struct probe_finder *pf = data;
+        Dwarf_Die *sc_die, die_mem;
         int ret;
 
         if (!line_list__has_line(&pf->lcache, lineno) ||
@@ -836,7 +892,14 @@ static int probe_point_lazy_walker(const char *fname, int lineno,
         pr_debug("Probe line found: line:%d addr:0x%llx\n",
                  lineno, (unsigned long long)addr);
         pf->addr = addr;
-        ret = call_probe_finder(NULL, pf);
+        pf->lno = lineno;
+        sc_die = find_best_scope(pf, &die_mem);
+        if (!sc_die) {
+                pr_warning("Failed to find scope of probe point.\n");
+                return -ENOENT;
+        }
+
+        ret = call_probe_finder(sc_die, pf);
 
         /*
          * Continue if no error, because the lazy pattern will match
@@ -861,42 +924,39 @@ 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);
 }
 
-/* Callback parameter with return value */
-struct dwarf_callback_param {
-        void *data;
-        int retval;
-};
-
 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct dwarf_callback_param *param = data;
-        struct probe_finder *pf = param->data;
+        struct probe_finder *pf = data;
         struct perf_probe_point *pp = &pf->pev->point;
         Dwarf_Addr addr;
+        int ret;
 
         if (pp->lazy_line)
-                param->retval = find_probe_point_lazy(in_die, pf);
+                ret = find_probe_point_lazy(in_die, pf);
         else {
                 /* Get probe address */
                 if (dwarf_entrypc(in_die, &addr) != 0) {
                         pr_warning("Failed to get entry address of %s.\n",
                                    dwarf_diename(in_die));
-                        param->retval = -ENOENT;
-                        return DWARF_CB_ABORT;
+                        return -ENOENT;
                 }
                 pf->addr = addr;
                 pf->addr += pp->offset;
                 pr_debug("found inline addr: 0x%jx\n",
                          (uintmax_t)pf->addr);
 
-                param->retval = call_probe_finder(in_die, pf);
-                if (param->retval < 0)
-                        return DWARF_CB_ABORT;
+                ret = call_probe_finder(in_die, pf);
         }
 
-        return DWARF_CB_OK;
+        return ret;
 }
 
+/* Callback parameter with return value for libdw */
+struct dwarf_callback_param {
+        void *data;
+        int retval;
+};
+
 /* Search function from function name */
 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
 {
@@ -933,14 +993,10 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
                         /* TODO: Check the address in this function */
                         param->retval = call_probe_finder(sp_die, pf);
                 }
-        } else {
-                struct dwarf_callback_param _param = {.data = (void *)pf,
-                                                      .retval = 0};
+        } else
                 /* Inlined function: search instances */
-                dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
-                                            &_param);
-                param->retval = _param.retval;
-        }
+                param->retval = die_walk_instances(sp_die,
+                                        probe_point_inline_cb, (void *)pf);
 
         return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
 }
@@ -1060,7 +1116,7 @@ found:
 }
 
 /* Add a found probe point into trace event list */
-static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
         struct trace_event_finder *tf =
                         container_of(pf, struct trace_event_finder, pf);
@@ -1075,8 +1131,9 @@ static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
         tev = &tf->tevs[tf->ntevs++];
 
-        ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
-                                     &tev->point);
+        /* Trace point should be converted from subprogram DIE */
+        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+                                     pf->pev->point.retprobe, &tev->point);
         if (ret < 0)
                 return ret;
 
@@ -1091,7 +1148,8 @@ static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
         for (i = 0; i < pf->pev->nargs; i++) {
                 pf->pvar = &pf->pev->args[i];
                 pf->tvar = &tev->args[i];
-                ret = find_variable(sp_die, pf);
+                /* Variable should be found from scope DIE */
+                ret = find_variable(sc_die, pf);
                 if (ret != 0)
                         return ret;
         }
@@ -1159,13 +1217,13 @@ static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
 }
 
 /* Add a found vars into available variables list */
-static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
         struct available_var_finder *af =
                         container_of(pf, struct available_var_finder, pf);
         struct variable_list *vl;
-        Dwarf_Die die_mem, *scopes = NULL;
-        int ret, nscopes;
+        Dwarf_Die die_mem;
+        int ret;
 
         /* Check number of tevs */
         if (af->nvls == af->max_vls) {
@@ -1174,8 +1232,9 @@ static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
         vl = &af->vls[af->nvls++];
 
-        ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
-                                     &vl->point);
+        /* Trace point should be converted from subprogram DIE */
+        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+                                     pf->pev->point.retprobe, &vl->point);
         if (ret < 0)
                 return ret;
 
@@ -1187,19 +1246,14 @@ static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
         if (vl->vars == NULL)
                 return -ENOMEM;
         af->child = true;
-        die_find_child(sp_die, collect_variables_cb, (void *)af, &die_mem);
+        die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
 
         /* Find external variables */
         if (!af->externs)
                 goto out;
         /* Don't need to search child DIE for externs. */
         af->child = false;
-        nscopes = dwarf_getscopes_die(sp_die, &scopes);
-        while (nscopes-- > 1)
-                die_find_child(&scopes[nscopes], collect_variables_cb,
-                               (void *)af, &die_mem);
-        if (scopes)
-                free(scopes);
+        die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
 
 out:
         if (strlist__empty(vl->vars)) {
@@ -1391,10 +1445,14 @@ static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
 
 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct dwarf_callback_param *param = data;
+        find_line_range_by_line(in_die, data);
 
-        param->retval = find_line_range_by_line(in_die, param->data);
-        return DWARF_CB_ABORT;  /* No need to find other instances */
+        /*
+         * We have to check all instances of inlined function, because
+         * some execution paths can be optimized out depends on the
+         * function argument of instances
+         */
+        return 0;
 }
 
 /* Search function from function name */
@@ -1422,15 +1480,10 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
                 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
                 lr->start = lf->lno_s;
                 lr->end = lf->lno_e;
-                if (dwarf_func_inline(sp_die)) {
-                        struct dwarf_callback_param _param;
-                        _param.data = (void *)lf;
-                        _param.retval = 0;
-                        dwarf_func_inline_instances(sp_die,
-                                                    line_range_inline_cb,
-                                                    &_param);
-                        param->retval = _param.retval;
-                } else
+                if (dwarf_func_inline(sp_die))
+                        param->retval = die_walk_instances(sp_die,
+                                                line_range_inline_cb, lf);
+                else
                         param->retval = find_line_range_by_line(sp_die, lf);
                 return DWARF_CB_ABORT;
         }
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index c478b42a2473..1132c8f0ce89 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -57,7 +57,7 @@ struct probe_finder {
         struct perf_probe_event *pev;           /* Target probe event */
 
         /* Callback when a probe point is found */
-        int (*callback)(Dwarf_Die *sp_die, struct probe_finder *pf);
+        int (*callback)(Dwarf_Die *sc_die, struct probe_finder *pf);
 
         /* For function searching */
         int                     lno;            /* Line number */
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 8e0b5a39d8a7..7624324efad4 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -187,16 +187,119 @@ static PyTypeObject pyrf_throttle_event__type = {
         .tp_repr        = (reprfunc)pyrf_throttle_event__repr,
 };
 
+static char pyrf_lost_event__doc[] = PyDoc_STR("perf lost event object.");
+
+static PyMemberDef pyrf_lost_event__members[] = {
+        sample_members
+        member_def(lost_event, id, T_ULONGLONG, "event id"),
+        member_def(lost_event, lost, T_ULONGLONG, "number of lost events"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_lost_event__repr(struct pyrf_event *pevent)
+{
+        PyObject *ret;
+        char *s;
+
+        if (asprintf(&s, "{ type: lost, id: %#" PRIx64 ", "
+                         "lost: %#" PRIx64 " }",
+                     pevent->event.lost.id, pevent->event.lost.lost) < 0) {
+                ret = PyErr_NoMemory();
+        } else {
+                ret = PyString_FromString(s);
+                free(s);
+        }
+        return ret;
+}
+
+static PyTypeObject pyrf_lost_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.lost_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_lost_event__doc,
+        .tp_members     = pyrf_lost_event__members,
+        .tp_repr        = (reprfunc)pyrf_lost_event__repr,
+};
+
+static char pyrf_read_event__doc[] = PyDoc_STR("perf read event object.");
+
+static PyMemberDef pyrf_read_event__members[] = {
+        sample_members
+        member_def(read_event, pid, T_UINT, "event pid"),
+        member_def(read_event, tid, T_UINT, "event tid"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_read_event__repr(struct pyrf_event *pevent)
+{
+        return PyString_FromFormat("{ type: read, pid: %u, tid: %u }",
+                                   pevent->event.read.pid,
+                                   pevent->event.read.tid);
+        /*
+         * FIXME: return the array of read values,
+         * making this method useful ;-)
+         */
+}
+
+static PyTypeObject pyrf_read_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.read_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_read_event__doc,
+        .tp_members     = pyrf_read_event__members,
+        .tp_repr        = (reprfunc)pyrf_read_event__repr,
+};
+
+static char pyrf_sample_event__doc[] = PyDoc_STR("perf sample event object.");
+
+static PyMemberDef pyrf_sample_event__members[] = {
+        sample_members
+        member_def(perf_event_header, type, T_UINT, "event type"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent)
+{
+        PyObject *ret;
+        char *s;
+
+        if (asprintf(&s, "{ type: sample }") < 0) {
+                ret = PyErr_NoMemory();
+        } else {
+                ret = PyString_FromString(s);
+                free(s);
+        }
+        return ret;
+}
+
+static PyTypeObject pyrf_sample_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.sample_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_sample_event__doc,
+        .tp_members     = pyrf_sample_event__members,
+        .tp_repr        = (reprfunc)pyrf_sample_event__repr,
+};
+
 static int pyrf_event__setup_types(void)
 {
         int err;
         pyrf_mmap_event__type.tp_new =
         pyrf_task_event__type.tp_new =
         pyrf_comm_event__type.tp_new =
+        pyrf_lost_event__type.tp_new =
+        pyrf_read_event__type.tp_new =
+        pyrf_sample_event__type.tp_new =
         pyrf_throttle_event__type.tp_new = PyType_GenericNew;
         err = PyType_Ready(&pyrf_mmap_event__type);
         if (err < 0)
                 goto out;
+        err = PyType_Ready(&pyrf_lost_event__type);
+        if (err < 0)
+                goto out;
         err = PyType_Ready(&pyrf_task_event__type);
         if (err < 0)
                 goto out;
@@ -206,20 +309,26 @@ static int pyrf_event__setup_types(void)
         err = PyType_Ready(&pyrf_throttle_event__type);
         if (err < 0)
                 goto out;
+        err = PyType_Ready(&pyrf_read_event__type);
+        if (err < 0)
+                goto out;
+        err = PyType_Ready(&pyrf_sample_event__type);
+        if (err < 0)
+                goto out;
 out:
         return err;
 }
 
 static PyTypeObject *pyrf_event__type[] = {
         [PERF_RECORD_MMAP]       = &pyrf_mmap_event__type,
-        [PERF_RECORD_LOST]       = &pyrf_mmap_event__type,
+        [PERF_RECORD_LOST]       = &pyrf_lost_event__type,
         [PERF_RECORD_COMM]       = &pyrf_comm_event__type,
         [PERF_RECORD_EXIT]       = &pyrf_task_event__type,
         [PERF_RECORD_THROTTLE]   = &pyrf_throttle_event__type,
         [PERF_RECORD_UNTHROTTLE] = &pyrf_throttle_event__type,
         [PERF_RECORD_FORK]       = &pyrf_task_event__type,
-        [PERF_RECORD_READ]       = &pyrf_mmap_event__type,
-        [PERF_RECORD_SAMPLE]     = &pyrf_mmap_event__type,
+        [PERF_RECORD_READ]       = &pyrf_read_event__type,
+        [PERF_RECORD_SAMPLE]     = &pyrf_sample_event__type,
 };
 
 static PyObject *pyrf_event__new(union perf_event *event)
@@ -694,7 +803,7 @@ static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
                 first = list_entry(evlist->entries.next, struct perf_evsel, node);
                 err = perf_event__parse_sample(event, first->attr.sample_type,
                                                perf_evsel__sample_size(first),
-                                               sample_id_all, &pevent->sample);
+                                               sample_id_all, &pevent->sample, false);
                 if (err)
                         return PyErr_Format(PyExc_OSError,
                                             "perf: can't parse sample, err=%d", err);
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 72458d9da5b1..20e011c99a94 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1326,3 +1326,22 @@ int perf_session__cpu_bitmap(struct perf_session *session,
 
         return 0;
 }
+
+void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
+                                bool full)
+{
+        struct stat st;
+        int ret;
+
+        if (session == NULL || fp == NULL)
+                return;
+
+        ret = fstat(session->fd, &st);
+        if (ret == -1)
+                return;
+
+        fprintf(fp, "# ========\n");
+        fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));
+        perf_header__fprintf_info(session, fp, full);
+        fprintf(fp, "# ========\n#\n");
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 170601e67d6b..514b06d41f05 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -162,7 +162,8 @@ static inline int perf_session__parse_sample(struct perf_session *session,
 {
         return perf_event__parse_sample(event, session->sample_type,
                                         session->sample_size,
-                                        session->sample_id_all, sample);
+                                        session->sample_id_all, sample,
+                                        session->header.needs_swap);
 }
 
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
@@ -176,4 +177,5 @@ void perf_session__print_ip(union perf_event *event,
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
 
+void perf_session__fprintf_info(struct perf_session *s, FILE *fp, bool full);
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index bbc982f5dd8b..95d370074928 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -3,9 +3,27 @@
 from distutils.core import setup, Extension
 from os import getenv
 
+from distutils.command.build_ext   import build_ext   as _build_ext
+from distutils.command.install_lib import install_lib as _install_lib
+
+class build_ext(_build_ext):
+    def finalize_options(self):
+        _build_ext.finalize_options(self)
+        self.build_lib  = build_lib
+        self.build_temp = build_tmp
+
+class install_lib(_install_lib):
+    def finalize_options(self):
+        _install_lib.finalize_options(self)
+        self.build_dir = build_lib
+
+
 cflags = ['-fno-strict-aliasing', '-Wno-write-strings']
 cflags += getenv('CFLAGS', '').split()
 
+build_lib = getenv('PYTHON_EXTBUILD_LIB')
+build_tmp = getenv('PYTHON_EXTBUILD_TMP')
+
 perf = Extension('perf',
                   sources = ['util/python.c', 'util/ctype.c', 'util/evlist.c',
                              'util/evsel.c', 'util/cpumap.c', 'util/thread_map.c',
@@ -21,4 +39,5 @@ setup(name='perf',
       author_email='acme@redhat.com',
       license='GPLv2',
       url='http://perf.wiki.kernel.org',
-      ext_modules=[perf])
+      ext_modules=[perf],
+      cmdclass={'build_ext': build_ext, 'install_lib': install_lib})
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 401e220566fd..16da30d8d765 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -151,11 +151,17 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         u64 ip_l, ip_r;
 
+        if (!left->ms.sym && !right->ms.sym)
+                return right->level - left->level;
+
+        if (!left->ms.sym || !right->ms.sym)
+                return cmp_null(left->ms.sym, right->ms.sym);
+
         if (left->ms.sym == right->ms.sym)
                 return 0;
 
-        ip_l = left->ms.sym ? left->ms.sym->start : left->ip;
-        ip_r = right->ms.sym ? right->ms.sym->start : right->ip;
+        ip_l = left->ms.sym->start;
+        ip_r = right->ms.sym->start;
 
         return (int64_t)(ip_r - ip_l);
 }
@@ -171,7 +177,9 @@ static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
                                        BITS_PER_LONG / 4, self->ip, o);
         }
 
-        ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
+        if (!sort_dso.elide)
+                ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
+
         if (self->ms.sym)
                 ret += repsep_snprintf(bf + ret, size - ret, "%s",
                                        self->ms.sym->name);
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 77d0388ad415..3f67ae395752 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -45,6 +45,7 @@ extern enum sort_type sort__first_dimension;
  * @nr_rows - rows expanded in callchain, recalculated on folding/unfolding
  */
 struct hist_entry {
+        struct rb_node          rb_node_in;
         struct rb_node          rb_node;
         u64                     period;
         u64                     period_sys;
@@ -63,6 +64,7 @@ struct hist_entry {
 
         bool                    init_have_children;
         char                    level;
+        bool                    used;
         u8                      filtered;
         struct symbol           *parent;
         union {
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index eec196329fd9..632b50c7bc26 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -24,7 +24,7 @@
 #include <sys/utsname.h>
 
 #ifndef KSYM_NAME_LEN
-#define KSYM_NAME_LEN 128
+#define KSYM_NAME_LEN 256
 #endif
 
 #ifndef NT_GNU_BUILD_ID
@@ -46,6 +46,7 @@ struct symbol_conf symbol_conf = {
         .exclude_other    = true,
         .use_modules      = true,
         .try_vmlinux_path = true,
+        .annotate_src     = true,
         .symfs            = "",
 };
 
@@ -74,16 +75,104 @@ static void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
 
 bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
+        symbol_type = toupper(symbol_type);
+
         switch (map_type) {
         case MAP__FUNCTION:
                 return symbol_type == 'T' || symbol_type == 'W';
         case MAP__VARIABLE:
-                return symbol_type == 'D' || symbol_type == 'd';
+                return symbol_type == 'D';
         default:
                 return false;
         }
 }
 
+static int prefix_underscores_count(const char *str)
+{
+        const char *tail = str;
+
+        while (*tail == '_')
+                tail++;
+
+        return tail - str;
+}
+
+#define SYMBOL_A 0
+#define SYMBOL_B 1
+
+static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
+{
+        s64 a;
+        s64 b;
+
+        /* Prefer a symbol with non zero length */
+        a = syma->end - syma->start;
+        b = symb->end - symb->start;
+        if ((b == 0) && (a > 0))
+                return SYMBOL_A;
+        else if ((a == 0) && (b > 0))
+                return SYMBOL_B;
+
+        /* Prefer a non weak symbol over a weak one */
+        a = syma->binding == STB_WEAK;
+        b = symb->binding == STB_WEAK;
+        if (b && !a)
+                return SYMBOL_A;
+        if (a && !b)
+                return SYMBOL_B;
+
+        /* Prefer a global symbol over a non global one */
+        a = syma->binding == STB_GLOBAL;
+        b = symb->binding == STB_GLOBAL;
+        if (a && !b)
+                return SYMBOL_A;
+        if (b && !a)
+                return SYMBOL_B;
+
+        /* Prefer a symbol with less underscores */
+        a = prefix_underscores_count(syma->name);
+        b = prefix_underscores_count(symb->name);
+        if (b > a)
+                return SYMBOL_A;
+        else if (a > b)
+                return SYMBOL_B;
+
+        /* If all else fails, choose the symbol with the longest name */
+        if (strlen(syma->name) >= strlen(symb->name))
+                return SYMBOL_A;
+        else
+                return SYMBOL_B;
+}
+
+static void symbols__fixup_duplicate(struct rb_root *symbols)
+{
+        struct rb_node *nd;
+        struct symbol *curr, *next;
+
+        nd = rb_first(symbols);
+
+        while (nd) {
+                curr = rb_entry(nd, struct symbol, rb_node);
+again:
+                nd = rb_next(&curr->rb_node);
+                next = rb_entry(nd, struct symbol, rb_node);
+
+                if (!nd)
+                        break;
+
+                if (curr->start != next->start)
+                        continue;
+
+                if (choose_best_symbol(curr, next) == SYMBOL_A) {
+                        rb_erase(&next->rb_node, symbols);
+                        goto again;
+                } else {
+                        nd = rb_next(&curr->rb_node);
+                        rb_erase(&curr->rb_node, symbols);
+                }
+        }
+}
+
 static void symbols__fixup_end(struct rb_root *symbols)
 {
         struct rb_node *nd, *prevnd = rb_first(symbols);
@@ -438,18 +527,11 @@ int kallsyms__parse(const char *filename, void *arg,
         char *line = NULL;
         size_t n;
         int err = -1;
-        u64 prev_start = 0;
-        char prev_symbol_type = 0;
-        char *prev_symbol_name;
         FILE *file = fopen(filename, "r");
 
         if (file == NULL)
                 goto out_failure;
 
-        prev_symbol_name = malloc(KSYM_NAME_LEN);
-        if (prev_symbol_name == NULL)
-                goto out_close;
-
         err = 0;
 
         while (!feof(file)) {
@@ -470,7 +552,7 @@ int kallsyms__parse(const char *filename, void *arg,
                 if (len + 2 >= line_len)
                         continue;
 
-                symbol_type = toupper(line[len]);
+                symbol_type = line[len];
                 len += 2;
                 symbol_name = line + len;
                 len = line_len - len;
@@ -480,24 +562,18 @@ int kallsyms__parse(const char *filename, void *arg,
                         break;
                 }
 
-                if (prev_symbol_type) {
-                        u64 end = start;
-                        if (end != prev_start)
-                                --end;
-                        err = process_symbol(arg, prev_symbol_name,
-                                             prev_symbol_type, prev_start, end);
-                        if (err)
-                                break;
-                }
-
-                memcpy(prev_symbol_name, symbol_name, len + 1);
-                prev_symbol_type = symbol_type;
-                prev_start = start;
+                /*
+                 * module symbols are not sorted so we add all
+                 * symbols with zero length and rely on
+                 * symbols__fixup_end() to fix it up.
+                 */
+                err = process_symbol(arg, symbol_name,
+                                     symbol_type, start, start);
+                if (err)
+                        break;
         }
 
-        free(prev_symbol_name);
         free(line);
-out_close:
         fclose(file);
         return err;
 
@@ -703,6 +779,9 @@ int dso__load_kallsyms(struct dso *dso, const char *filename,
         if (dso__load_all_kallsyms(dso, filename, map) < 0)
                 return -1;
 
+        symbols__fixup_duplicate(&dso->symbols[map->type]);
+        symbols__fixup_end(&dso->symbols[map->type]);
+
         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
                 dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
         else
@@ -1092,8 +1171,7 @@ static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
         if (dso->has_build_id) {
                 u8 build_id[BUILD_ID_SIZE];
 
-                if (elf_read_build_id(elf, build_id,
-                                      BUILD_ID_SIZE) != BUILD_ID_SIZE)
+                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
                         goto out_elf_end;
 
                 if (!dso__build_id_equal(dso, build_id))
@@ -1111,6 +1189,8 @@ static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
         }
 
         opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
+        if (opdshdr.sh_type != SHT_PROGBITS)
+                opdsec = NULL;
         if (opdsec)
                 opddata = elf_rawdata(opdsec, NULL);
 
@@ -1276,6 +1356,7 @@ new_symbol:
          * For misannotated, zeroed, ASM function sizes.
          */
         if (nr > 0) {
+                symbols__fixup_duplicate(&dso->symbols[map->type]);
                 symbols__fixup_end(&dso->symbols[map->type]);
                 if (kmap) {
                         /*
@@ -1362,8 +1443,8 @@ static int elf_read_build_id(Elf *elf, void *bf, size_t size)
         ptr = data->d_buf;
         while (ptr < (data->d_buf + data->d_size)) {
                 GElf_Nhdr *nhdr = ptr;
-                int namesz = NOTE_ALIGN(nhdr->n_namesz),
-                    descsz = NOTE_ALIGN(nhdr->n_descsz);
+                size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
+                       descsz = NOTE_ALIGN(nhdr->n_descsz);
                 const char *name;
 
                 ptr += sizeof(*nhdr);
@@ -1372,8 +1453,10 @@ static int elf_read_build_id(Elf *elf, void *bf, size_t size)
                 if (nhdr->n_type == NT_GNU_BUILD_ID &&
                     nhdr->n_namesz == sizeof("GNU")) {
                         if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
-                                memcpy(bf, ptr, BUILD_ID_SIZE);
-                                err = BUILD_ID_SIZE;
+                                size_t sz = min(size, descsz);
+                                memcpy(bf, ptr, sz);
+                                memset(bf + sz, 0, size - sz);
+                                err = descsz;
                                 break;
                         }
                 }
@@ -1425,7 +1508,7 @@ int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
         while (1) {
                 char bf[BUFSIZ];
                 GElf_Nhdr nhdr;
-                int namesz, descsz;
+                size_t namesz, descsz;
 
                 if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
                         break;
@@ -1434,15 +1517,16 @@ int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
                 descsz = NOTE_ALIGN(nhdr.n_descsz);
                 if (nhdr.n_type == NT_GNU_BUILD_ID &&
                     nhdr.n_namesz == sizeof("GNU")) {
-                        if (read(fd, bf, namesz) != namesz)
+                        if (read(fd, bf, namesz) != (ssize_t)namesz)
                                 break;
                         if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
-                                if (read(fd, build_id,
-                                    BUILD_ID_SIZE) == BUILD_ID_SIZE) {
+                                size_t sz = min(descsz, size);
+                                if (read(fd, build_id, sz) == (ssize_t)sz) {
+                                        memset(build_id + sz, 0, size - sz);
                                         err = 0;
                                         break;
                                 }
-                        } else if (read(fd, bf, descsz) != descsz)
+                        } else if (read(fd, bf, descsz) != (ssize_t)descsz)
                                 break;
                 } else {
                         int n = namesz + descsz;
@@ -1504,6 +1588,17 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         dso->adjust_symbols = 0;
 
         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
+                struct stat st;
+
+                if (lstat(dso->name, &st) < 0)
+                        return -1;
+
+                if (st.st_uid && (st.st_uid != geteuid())) {
+                        pr_warning("File %s not owned by current user or root, "
+                                "ignoring it.\n", dso->name);
+                        return -1;
+                }
+
                 ret = dso__load_perf_map(dso, map, filter);
                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
                                               SYMTAB__NOT_FOUND;
@@ -2170,27 +2265,22 @@ size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
         return ret;
 }
 
-struct dso *dso__new_kernel(const char *name)
+static struct dso*
+dso__kernel_findnew(struct machine *machine, const char *name,
+                    const char *short_name, int dso_type)
 {
-        struct dso *dso = dso__new(name ?: "[kernel.kallsyms]");
-
-        if (dso != NULL) {
-                dso__set_short_name(dso, "[kernel]");
-                dso->kernel = DSO_TYPE_KERNEL;
-        }
-
-        return dso;
-}
+        /*
+         * The kernel dso could be created by build_id processing.
+         */
+        struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
 
-static struct dso *dso__new_guest_kernel(struct machine *machine,
-                                        const char *name)
-{
-        char bf[PATH_MAX];
-        struct dso *dso = dso__new(name ?: machine__mmap_name(machine, bf,
-                                                              sizeof(bf)));
+        /*
+         * We need to run this in all cases, since during the build_id
+         * processing we had no idea this was the kernel dso.
+         */
         if (dso != NULL) {
-                dso__set_short_name(dso, "[guest.kernel]");
-                dso->kernel = DSO_TYPE_GUEST_KERNEL;
+                dso__set_short_name(dso, short_name);
+                dso->kernel = dso_type;
         }
 
         return dso;
@@ -2208,24 +2298,36 @@ void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
                 dso->has_build_id = true;
 }
 
-static struct dso *machine__create_kernel(struct machine *machine)
+static struct dso *machine__get_kernel(struct machine *machine)
 {
         const char *vmlinux_name = NULL;
         struct dso *kernel;
 
         if (machine__is_host(machine)) {
                 vmlinux_name = symbol_conf.vmlinux_name;
-                kernel = dso__new_kernel(vmlinux_name);
+                if (!vmlinux_name)
+                        vmlinux_name = "[kernel.kallsyms]";
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[kernel]",
+                                             DSO_TYPE_KERNEL);
         } else {
+                char bf[PATH_MAX];
+
                 if (machine__is_default_guest(machine))
                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
-                kernel = dso__new_guest_kernel(machine, vmlinux_name);
+                if (!vmlinux_name)
+                        vmlinux_name = machine__mmap_name(machine, bf,
+                                                          sizeof(bf));
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[guest.kernel]",
+                                             DSO_TYPE_GUEST_KERNEL);
         }
 
-        if (kernel != NULL) {
+        if (kernel != NULL && (!kernel->has_build_id))
                 dso__read_running_kernel_build_id(kernel, machine);
-                dsos__add(&machine->kernel_dsos, kernel);
-        }
+
         return kernel;
 }
 
@@ -2329,7 +2431,7 @@ void machine__destroy_kernel_maps(struct machine *machine)
 
 int machine__create_kernel_maps(struct machine *machine)
 {
-        struct dso *kernel = machine__create_kernel(machine);
+        struct dso *kernel = machine__get_kernel(machine);
 
         if (kernel == NULL ||
             __machine__create_kernel_maps(machine, kernel) < 0)
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 325ee36a9d29..29f8d742e92f 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -72,11 +72,14 @@ struct symbol_conf {
                         use_modules,
                         sort_by_name,
                         show_nr_samples,
+                        show_total_period,
                         use_callchain,
                         exclude_other,
                         show_cpu_utilization,
                         initialized,
-                        kptr_restrict;
+                        kptr_restrict,
+                        annotate_asm_raw,
+                        annotate_src;
         const char      *vmlinux_name,
                         *kallsyms_name,
                         *source_prefix,
@@ -155,7 +158,6 @@ struct dso {
 };
 
 struct dso *dso__new(const char *name);
-struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *dso);
 
 int dso__name_len(const struct dso *dso);
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index a11f60735a18..500471dffa4f 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -15,52 +15,6 @@
 #include "top.h"
 #include <inttypes.h>
 
-/*
- * Ordering weight: count-1 * count-2 * ... / count-n
- */
-static double sym_weight(const struct sym_entry *sym, struct perf_top *top)
-{
-        double weight = sym->snap_count;
-        int counter;
-
-        if (!top->display_weighted)
-                return weight;
-
-        for (counter = 1; counter < top->evlist->nr_entries - 1; counter++)
-                weight *= sym->count[counter];
-
-        weight /= (sym->count[counter] + 1);
-
-        return weight;
-}
-
-static void perf_top__remove_active_sym(struct perf_top *top, struct sym_entry *syme)
-{
-        pthread_mutex_lock(&top->active_symbols_lock);
-        list_del_init(&syme->node);
-        pthread_mutex_unlock(&top->active_symbols_lock);
-}
-
-static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
-{
-        struct rb_node **p = &tree->rb_node;
-        struct rb_node *parent = NULL;
-        struct sym_entry *iter;
-
-        while (*p != NULL) {
-                parent = *p;
-                iter = rb_entry(parent, struct sym_entry, rb_node);
-
-                if (se->weight > iter->weight)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&se->rb_node, parent, p);
-        rb_insert_color(&se->rb_node, tree);
-}
-
 #define SNPRINTF(buf, size, fmt, args...) \
 ({ \
         size_t r = snprintf(buf, size, fmt, ## args); \
@@ -69,7 +23,6 @@ static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
 {
-        struct perf_evsel *counter;
         float samples_per_sec = top->samples / top->delay_secs;
         float ksamples_per_sec = top->kernel_samples / top->delay_secs;
         float esamples_percent = (100.0 * top->exact_samples) / top->samples;
@@ -104,7 +57,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
                                esamples_percent);
         }
 
-        if (top->evlist->nr_entries == 1 || !top->display_weighted) {
+        if (top->evlist->nr_entries == 1) {
                 struct perf_evsel *first;
                 first = list_entry(top->evlist->entries.next, struct perf_evsel, node);
                 ret += SNPRINTF(bf + ret, size - ret, "%" PRIu64 "%s ",
@@ -112,27 +65,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
                                 top->freq ? "Hz" : "");
         }
 
-        if (!top->display_weighted) {
-                ret += SNPRINTF(bf + ret, size - ret, "%s",
-                                event_name(top->sym_evsel));
-        } else {
-                /*
-                 * Don't let events eat all the space. Leaving 30 bytes
-                 * for the rest should be enough.
-                 */
-                size_t last_pos = size - 30;
-
-                list_for_each_entry(counter, &top->evlist->entries, node) {
-                        ret += SNPRINTF(bf + ret, size - ret, "%s%s",
-                                        counter->idx ? "/" : "",
-                                        event_name(counter));
-                        if (ret > last_pos) {
-                                sprintf(bf + last_pos - 3, "..");
-                                ret = last_pos - 1;
-                                break;
-                        }
-                }
-        }
+        ret += SNPRINTF(bf + ret, size - ret, "%s", event_name(top->sym_evsel));
 
         ret += SNPRINTF(bf + ret, size - ret, "], ");
 
@@ -166,73 +99,3 @@ void perf_top__reset_sample_counters(struct perf_top *top)
         top->exact_samples = top->guest_kernel_samples =
         top->guest_us_samples = 0;
 }
-
-float perf_top__decay_samples(struct perf_top *top, struct rb_root *root)
-{
-        struct sym_entry *syme, *n;
-        float sum_ksamples = 0.0;
-        int snap = !top->display_weighted ? top->sym_evsel->idx : 0, j;
-
-        /* Sort the active symbols */
-        pthread_mutex_lock(&top->active_symbols_lock);
-        syme = list_entry(top->active_symbols.next, struct sym_entry, node);
-        pthread_mutex_unlock(&top->active_symbols_lock);
-
-        top->rb_entries = 0;
-        list_for_each_entry_safe_from(syme, n, &top->active_symbols, node) {
-                syme->snap_count = syme->count[snap];
-                if (syme->snap_count != 0) {
-
-                        if ((top->hide_user_symbols &&
-                             syme->map->dso->kernel == DSO_TYPE_USER) ||
-                            (top->hide_kernel_symbols &&
-                             syme->map->dso->kernel == DSO_TYPE_KERNEL)) {
-                                perf_top__remove_active_sym(top, syme);
-                                continue;
-                        }
-                        syme->weight = sym_weight(syme, top);
-
-                        if ((int)syme->snap_count >= top->count_filter) {
-                                rb_insert_active_sym(root, syme);
-                                ++top->rb_entries;
-                        }
-                        sum_ksamples += syme->snap_count;
-
-                        for (j = 0; j < top->evlist->nr_entries; j++)
-                                syme->count[j] = top->zero ? 0 : syme->count[j] * 7 / 8;
-                } else
-                        perf_top__remove_active_sym(top, syme);
-        }
-
-        return sum_ksamples;
-}
-
-/*
- * Find the longest symbol name that will be displayed
- */
-void perf_top__find_widths(struct perf_top *top, struct rb_root *root,
-                           int *dso_width, int *dso_short_width, int *sym_width)
-{
-        struct rb_node *nd;
-        int printed = 0;
-
-        *sym_width = *dso_width = *dso_short_width = 0;
-
-        for (nd = rb_first(root); nd; nd = rb_next(nd)) {
-                struct sym_entry *syme = rb_entry(nd, struct sym_entry, rb_node);
-                struct symbol *sym = sym_entry__symbol(syme);
-
-                if (++printed > top->print_entries ||
-                    (int)syme->snap_count < top->count_filter)
-                        continue;
-
-                if (syme->map->dso->long_name_len > *dso_width)
-                        *dso_width = syme->map->dso->long_name_len;
-
-                if (syme->map->dso->short_name_len > *dso_short_width)
-                        *dso_short_width = syme->map->dso->short_name_len;
-
-                if (sym->namelen > *sym_width)
-                        *sym_width = sym->namelen;
-        }
-}
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index bfbf95bcc603..01d1057f3074 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -4,26 +4,10 @@
 #include "types.h"
 #include "../perf.h"
 #include <stddef.h>
-#include <pthread.h>
-#include <linux/list.h>
-#include <linux/rbtree.h>
 
 struct perf_evlist;
 struct perf_evsel;
-
-struct sym_entry {
-        struct rb_node          rb_node;
-        struct list_head        node;
-        unsigned long           snap_count;
-        double                  weight;
-        struct map              *map;
-        unsigned long           count[0];
-};
-
-static inline struct symbol *sym_entry__symbol(struct sym_entry *self)
-{
-       return ((void *)self) + symbol_conf.priv_size;
-}
+struct perf_session;
 
 struct perf_top {
         struct perf_evlist *evlist;
@@ -31,34 +15,21 @@ struct perf_top {
          * Symbols will be added here in perf_event__process_sample and will
          * get out after decayed.
          */
-        struct list_head   active_symbols;
-        pthread_mutex_t    active_symbols_lock;
-        pthread_cond_t     active_symbols_cond;
         u64                samples;
         u64                kernel_samples, us_samples;
         u64                exact_samples;
         u64                guest_us_samples, guest_kernel_samples;
+        u64                total_lost_warned;
         int                print_entries, count_filter, delay_secs;
-        int                display_weighted, freq, rb_entries;
+        int                freq;
         pid_t              target_pid, target_tid;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
         const char         *cpu_list;
-        struct sym_entry   *sym_filter_entry;
+        struct hist_entry  *sym_filter_entry;
         struct perf_evsel  *sym_evsel;
+        struct perf_session *session;
 };
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
 void perf_top__reset_sample_counters(struct perf_top *top);
-float perf_top__decay_samples(struct perf_top *top, struct rb_root *root);
-void perf_top__find_widths(struct perf_top *top, struct rb_root *root,
-                           int *dso_width, int *dso_short_width, int *sym_width);
-
-#ifdef NO_NEWT_SUPPORT
-static inline int perf_top__tui_browser(struct perf_top *top __used)
-{
-        return 0;
-}
-#else
-int perf_top__tui_browser(struct perf_top *top);
-#endif
 #endif /* __PERF_TOP_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 3403f814ad72..2d530cf74f43 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -196,7 +196,8 @@ static void record_file(const char *file, size_t hdr_sz)
                 die("Can't read '%s'", file);
 
         /* put in zeros for file size, then fill true size later */
-        write_or_die(&size, hdr_sz);
+        if (hdr_sz)
+                write_or_die(&size, hdr_sz);
 
         do {
                 r = read(fd, buf, BUFSIZ);
@@ -212,7 +213,7 @@ static void record_file(const char *file, size_t hdr_sz)
         if (bigendian())
                 sizep += sizeof(u64) - hdr_sz;
 
-        if (pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0)
+        if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0)
                 die("writing to %s", output_file);
 }
 
@@ -428,6 +429,19 @@ get_tracepoints_path(struct list_head *pattrs)
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
+static void
+put_tracepoints_path(struct tracepoint_path *tps)
+{
+        while (tps) {
+                struct tracepoint_path *t = tps;
+
+                tps = tps->next;
+                free(t->name);
+                free(t->system);
+                free(t);
+        }
+}
+
 bool have_tracepoints(struct list_head *pattrs)
 {
         struct perf_evsel *pos;
@@ -439,19 +453,11 @@ bool have_tracepoints(struct list_head *pattrs)
         return false;
 }
 
-int read_tracing_data(int fd, struct list_head *pattrs)
+static void tracing_data_header(void)
 {
-        char buf[BUFSIZ];
-        struct tracepoint_path *tps = get_tracepoints_path(pattrs);
-
-        /*
-         * What? No tracepoints? No sense writing anything here, bail out.
-         */
-        if (tps == NULL)
-                return -1;
-
-        output_fd = fd;
+        char buf[20];
 
+        /* just guessing this is someone's birthday.. ;) */
         buf[0] = 23;
         buf[1] = 8;
         buf[2] = 68;
@@ -476,28 +482,86 @@ int read_tracing_data(int fd, struct list_head *pattrs)
         /* save page_size */
         page_size = sysconf(_SC_PAGESIZE);
         write_or_die(&page_size, 4);
+}
+
+struct tracing_data *tracing_data_get(struct list_head *pattrs,
+                                      int fd, bool temp)
+{
+        struct tracepoint_path *tps;
+        struct tracing_data *tdata;
+
+        output_fd = fd;
+
+        tps = get_tracepoints_path(pattrs);
+        if (!tps)
+                return NULL;
 
+        tdata = malloc_or_die(sizeof(*tdata));
+        tdata->temp = temp;
+        tdata->size = 0;
+
+        if (temp) {
+                int temp_fd;
+
+                snprintf(tdata->temp_file, sizeof(tdata->temp_file),
+                         "/tmp/perf-XXXXXX");
+                if (!mkstemp(tdata->temp_file))
+                        die("Can't make temp file");
+
+                temp_fd = open(tdata->temp_file, O_RDWR);
+                if (temp_fd < 0)
+                        die("Can't read '%s'", tdata->temp_file);
+
+                /*
+                 * Set the temp file the default output, so all the
+                 * tracing data are stored into it.
+                 */
+                output_fd = temp_fd;
+        }
+
+        tracing_data_header();
         read_header_files();
         read_ftrace_files(tps);
         read_event_files(tps);
         read_proc_kallsyms();
         read_ftrace_printk();
 
-        return 0;
+        /*
+         * All tracing data are stored by now, we can restore
+         * the default output file in case we used temp file.
+         */
+        if (temp) {
+                tdata->size = lseek(output_fd, 0, SEEK_CUR);
+                close(output_fd);
+                output_fd = fd;
+        }
+
+        put_tracepoints_path(tps);
+        return tdata;
 }
 
-ssize_t read_tracing_data_size(int fd, struct list_head *pattrs)
+void tracing_data_put(struct tracing_data *tdata)
 {
-        ssize_t size;
-        int err = 0;
+        if (tdata->temp) {
+                record_file(tdata->temp_file, 0);
+                unlink(tdata->temp_file);
+        }
 
-        calc_data_size = 1;
-        err = read_tracing_data(fd, pattrs);
-        size = calc_data_size - 1;
-        calc_data_size = 0;
+        free(tdata);
+}
 
-        if (err < 0)
-                return err;
+int read_tracing_data(int fd, struct list_head *pattrs)
+{
+        struct tracing_data *tdata;
 
-        return size;
+        /*
+         * We work over the real file, so we can write data
+         * directly, no temp file is needed.
+         */
+        tdata = tracing_data_get(pattrs, fd, false);
+        if (!tdata)
+                return -ENOMEM;
+
+        tracing_data_put(tdata);
+        return 0;
 }
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index f674dda3363b..a84100817649 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -263,7 +263,18 @@ void *raw_field_ptr(struct event *event, const char *name, void *data);
 unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct list_head *pattrs);
-ssize_t read_tracing_data_size(int fd, struct list_head *pattrs);
+
+struct tracing_data {
+        /* size is only valid if temp is 'true' */
+        ssize_t size;
+        bool temp;
+        char temp_file[50];
+};
+
+struct tracing_data *tracing_data_get(struct list_head *pattrs,
+                                      int fd, bool temp);
+void tracing_data_put(struct tracing_data *tdata);
+
 
 /* taken from kernel/trace/trace.h */
 enum trace_flag_type {
diff --git a/tools/perf/util/ui/browser.c b/tools/perf/util/ui/browser.c
index 611219f80680..5359f371d30a 100644
--- a/tools/perf/util/ui/browser.c
+++ b/tools/perf/util/ui/browser.c
@@ -1,4 +1,8 @@
+#include "../util.h"
+#include "../cache.h"
+#include "../../perf.h"
 #include "libslang.h"
+#include <newt.h>
 #include "ui.h"
 #include <linux/compiler.h>
 #include <linux/list.h>
@@ -7,13 +11,13 @@
 #include <sys/ttydefaults.h>
 #include "browser.h"
 #include "helpline.h"
+#include "keysyms.h"
 #include "../color.h"
-#include "../util.h"
-#include <stdio.h>
 
-static int ui_browser__percent_color(double percent, bool current)
+static int ui_browser__percent_color(struct ui_browser *browser,
+                                     double percent, bool current)
 {
-        if (current)
+        if (current && (!browser->use_navkeypressed || browser->navkeypressed))
                 return HE_COLORSET_SELECTED;
         if (percent >= MIN_RED)
                 return HE_COLORSET_TOP;
@@ -30,7 +34,7 @@ void ui_browser__set_color(struct ui_browser *self __used, int color)
 void ui_browser__set_percent_color(struct ui_browser *self,
                                    double percent, bool current)
 {
-         int color = ui_browser__percent_color(percent, current);
+         int color = ui_browser__percent_color(self, percent, current);
          ui_browser__set_color(self, color);
 }
 
@@ -39,31 +43,62 @@ void ui_browser__gotorc(struct ui_browser *self, int y, int x)
         SLsmg_gotorc(self->y + y, self->x + x);
 }
 
+static struct list_head *
+ui_browser__list_head_filter_entries(struct ui_browser *browser,
+                                     struct list_head *pos)
+{
+        do {
+                if (!browser->filter || !browser->filter(browser, pos))
+                        return pos;
+                pos = pos->next;
+        } while (pos != browser->entries);
+
+        return NULL;
+}
+
+static struct list_head *
+ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
+                                          struct list_head *pos)
+{
+        do {
+                if (!browser->filter || !browser->filter(browser, pos))
+                        return pos;
+                pos = pos->prev;
+        } while (pos != browser->entries);
+
+        return NULL;
+}
+
 void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
 {
         struct list_head *head = self->entries;
         struct list_head *pos;
 
+        if (self->nr_entries == 0)
+                return;
+
         switch (whence) {
         case SEEK_SET:
-                pos = head->next;
+                pos = ui_browser__list_head_filter_entries(self, head->next);
                 break;
         case SEEK_CUR:
                 pos = self->top;
                 break;
         case SEEK_END:
-                pos = head->prev;
+                pos = ui_browser__list_head_filter_prev_entries(self, head->prev);
                 break;
         default:
                 return;
         }
 
+        assert(pos != NULL);
+
         if (offset > 0) {
                 while (offset-- != 0)
-                        pos = pos->next;
+                        pos = ui_browser__list_head_filter_entries(self, pos->next);
         } else {
                 while (offset++ != 0)
-                        pos = pos->prev;
+                        pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);
         }
 
         self->top = pos;
@@ -127,11 +162,8 @@ bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
 
 void ui_browser__refresh_dimensions(struct ui_browser *self)
 {
-        int cols, rows;
-        newtGetScreenSize(&cols, &rows);
-
-        self->width = cols - 1;
-        self->height = rows - 2;
+        self->width = SLtt_Screen_Cols - 1;
+        self->height = SLtt_Screen_Rows - 2;
         self->y = 1;
         self->x = 0;
 }
@@ -142,26 +174,11 @@ void ui_browser__reset_index(struct ui_browser *self)
         self->seek(self, 0, SEEK_SET);
 }
 
-void ui_browser__add_exit_key(struct ui_browser *self, int key)
-{
-        newtFormAddHotKey(self->form, key);
-}
-
-void ui_browser__add_exit_keys(struct ui_browser *self, int keys[])
-{
-        int i = 0;
-
-        while (keys[i] && i < 64) {
-                ui_browser__add_exit_key(self, keys[i]);
-                ++i;
-        }
-}
-
 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
 {
         SLsmg_gotorc(0, 0);
         ui_browser__set_color(browser, NEWT_COLORSET_ROOT);
-        slsmg_write_nstring(title, browser->width);
+        slsmg_write_nstring(title, browser->width + 1);
 }
 
 void ui_browser__show_title(struct ui_browser *browser, const char *title)
@@ -174,78 +191,189 @@ void ui_browser__show_title(struct ui_browser *browser, const char *title)
 int ui_browser__show(struct ui_browser *self, const char *title,
                      const char *helpline, ...)
 {
+        int err;
         va_list ap;
-        int keys[] = { NEWT_KEY_UP, NEWT_KEY_DOWN, NEWT_KEY_PGUP,
-                       NEWT_KEY_PGDN, NEWT_KEY_HOME, NEWT_KEY_END, ' ',
-                       NEWT_KEY_LEFT, NEWT_KEY_ESCAPE, 'q', CTRL('c'), 0 };
-
-        if (self->form != NULL)
-                newtFormDestroy(self->form);
 
         ui_browser__refresh_dimensions(self);
-        self->form = newtForm(NULL, NULL, 0);
-        if (self->form == NULL)
-                return -1;
-
-        self->sb = newtVerticalScrollbar(self->width, 1, self->height,
-                                         HE_COLORSET_NORMAL,
-                                         HE_COLORSET_SELECTED);
-        if (self->sb == NULL)
-                return -1;
 
         pthread_mutex_lock(&ui__lock);
         __ui_browser__show_title(self, title);
 
-        ui_browser__add_exit_keys(self, keys);
-        newtFormAddComponent(self->form, self->sb);
+        self->title = title;
+        free(self->helpline);
+        self->helpline = NULL;
 
         va_start(ap, helpline);
-        ui_helpline__vpush(helpline, ap);
+        err = vasprintf(&self->helpline, helpline, ap);
         va_end(ap);
+        if (err > 0)
+                ui_helpline__push(self->helpline);
         pthread_mutex_unlock(&ui__lock);
-        return 0;
+        return err ? 0 : -1;
 }
 
-void ui_browser__hide(struct ui_browser *self)
+void ui_browser__hide(struct ui_browser *browser __used)
 {
         pthread_mutex_lock(&ui__lock);
-        newtFormDestroy(self->form);
-        self->form = NULL;
         ui_helpline__pop();
         pthread_mutex_unlock(&ui__lock);
 }
 
-int ui_browser__refresh(struct ui_browser *self)
+static void ui_browser__scrollbar_set(struct ui_browser *browser)
+{
+        int height = browser->height, h = 0, pct = 0,
+            col = browser->width,
+            row = browser->y - 1;
+
+        if (browser->nr_entries > 1) {
+                pct = ((browser->index * (browser->height - 1)) /
+                       (browser->nr_entries - 1));
+        }
+
+        while (h < height) {
+                ui_browser__gotorc(browser, row++, col);
+                SLsmg_set_char_set(1);
+                SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_BOARD_CHAR);
+                SLsmg_set_char_set(0);
+                ++h;
+        }
+}
+
+static int __ui_browser__refresh(struct ui_browser *browser)
 {
         int row;
+        int width = browser->width;
+
+        row = browser->refresh(browser);
+        ui_browser__set_color(browser, HE_COLORSET_NORMAL);
+
+        if (!browser->use_navkeypressed || browser->navkeypressed)
+                ui_browser__scrollbar_set(browser);
+        else
+                width += 1;
 
+        SLsmg_fill_region(browser->y + row, browser->x,
+                          browser->height - row, width, ' ');
+
+        return 0;
+}
+
+int ui_browser__refresh(struct ui_browser *browser)
+{
         pthread_mutex_lock(&ui__lock);
-        newtScrollbarSet(self->sb, self->index, self->nr_entries - 1);
-        row = self->refresh(self);
-        ui_browser__set_color(self, HE_COLORSET_NORMAL);
-        SLsmg_fill_region(self->y + row, self->x,
-                          self->height - row, self->width, ' ');
+        __ui_browser__refresh(browser);
         pthread_mutex_unlock(&ui__lock);
 
         return 0;
 }
 
-int ui_browser__run(struct ui_browser *self)
+/*
+ * Here we're updating nr_entries _after_ we started browsing, i.e.  we have to
+ * forget about any reference to any entry in the underlying data structure,
+ * that is why we do a SEEK_SET. Think about 'perf top' in the hists browser
+ * after an output_resort and hist decay.
+ */
+void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
 {
-        struct newtExitStruct es;
+        off_t offset = nr_entries - browser->nr_entries;
+
+        browser->nr_entries = nr_entries;
 
-        if (ui_browser__refresh(self) < 0)
-                return -1;
+        if (offset < 0) {
+                if (browser->top_idx < (u64)-offset)
+                        offset = -browser->top_idx;
+
+                browser->index += offset;
+                browser->top_idx += offset;
+        }
+
+        browser->top = NULL;
+        browser->seek(browser, browser->top_idx, SEEK_SET);
+}
+
+static int ui__getch(int delay_secs)
+{
+        struct timeval timeout, *ptimeout = delay_secs ? &timeout : NULL;
+        fd_set read_set;
+        int err, key;
+
+        FD_ZERO(&read_set);
+        FD_SET(0, &read_set);
+
+        if (delay_secs) {
+                timeout.tv_sec = delay_secs;
+                timeout.tv_usec = 0;
+        }
+
+        err = select(1, &read_set, NULL, NULL, ptimeout);
+
+        if (err == 0)
+                return K_TIMER;
+
+        if (err == -1) {
+                if (errno == EINTR)
+                        return K_RESIZE;
+                return K_ERROR;
+        }
+
+        key = SLang_getkey();
+        if (key != K_ESC)
+                return key;
+
+        FD_ZERO(&read_set);
+        FD_SET(0, &read_set);
+        timeout.tv_sec = 0;
+        timeout.tv_usec = 20;
+        err = select(1, &read_set, NULL, NULL, &timeout);
+        if (err == 0)
+                return K_ESC;
+
+        SLang_ungetkey(key);
+        return SLkp_getkey();
+}
+
+int ui_browser__run(struct ui_browser *self, int delay_secs)
+{
+        int err, key;
+
+        pthread__unblock_sigwinch();
 
         while (1) {
                 off_t offset;
 
-                newtFormRun(self->form, &es);
-
-                if (es.reason != NEWT_EXIT_HOTKEY)
+                pthread_mutex_lock(&ui__lock);
+                err = __ui_browser__refresh(self);
+                SLsmg_refresh();
+                pthread_mutex_unlock(&ui__lock);
+                if (err < 0)
                         break;
-                switch (es.u.key) {
-                case NEWT_KEY_DOWN:
+
+                key = ui__getch(delay_secs);
+
+                if (key == K_RESIZE) {
+                        pthread_mutex_lock(&ui__lock);
+                        SLtt_get_screen_size();
+                        SLsmg_reinit_smg();
+                        pthread_mutex_unlock(&ui__lock);
+                        ui_browser__refresh_dimensions(self);
+                        __ui_browser__show_title(self, self->title);
+                        ui_helpline__puts(self->helpline);
+                        continue;
+                }
+
+                if (self->use_navkeypressed && !self->navkeypressed) {
+                        if (key == K_DOWN || key == K_UP ||
+                            key == K_PGDN || key == K_PGUP ||
+                            key == K_HOME || key == K_END ||
+                            key == ' ') {
+                                self->navkeypressed = true;
+                                continue;
+                        } else
+                                return key;
+                }
+
+                switch (key) {
+                case K_DOWN:
                         if (self->index == self->nr_entries - 1)
                                 break;
                         ++self->index;
@@ -254,7 +382,7 @@ int ui_browser__run(struct ui_browser *self)
                                 self->seek(self, +1, SEEK_CUR);
                         }
                         break;
-                case NEWT_KEY_UP:
+                case K_UP:
                         if (self->index == 0)
                                 break;
                         --self->index;
@@ -263,7 +391,7 @@ int ui_browser__run(struct ui_browser *self)
                                 self->seek(self, -1, SEEK_CUR);
                         }
                         break;
-                case NEWT_KEY_PGDN:
+                case K_PGDN:
                 case ' ':
                         if (self->top_idx + self->height > self->nr_entries - 1)
                                 break;
@@ -275,7 +403,7 @@ int ui_browser__run(struct ui_browser *self)
                         self->top_idx += offset;
                         self->seek(self, +offset, SEEK_CUR);
                         break;
-                case NEWT_KEY_PGUP:
+                case K_PGUP:
                         if (self->top_idx == 0)
                                 break;
 
@@ -288,10 +416,10 @@ int ui_browser__run(struct ui_browser *self)
                         self->top_idx -= offset;
                         self->seek(self, -offset, SEEK_CUR);
                         break;
-                case NEWT_KEY_HOME:
+                case K_HOME:
                         ui_browser__reset_index(self);
                         break;
-                case NEWT_KEY_END:
+                case K_END:
                         offset = self->height - 1;
                         if (offset >= self->nr_entries)
                                 offset = self->nr_entries - 1;
@@ -301,10 +429,8 @@ int ui_browser__run(struct ui_browser *self)
                         self->seek(self, -offset, SEEK_END);
                         break;
                 default:
-                        return es.u.key;
+                        return key;
                 }
-                if (ui_browser__refresh(self) < 0)
-                        return -1;
         }
         return -1;
 }
@@ -316,41 +442,105 @@ unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
         int row = 0;
 
         if (self->top == NULL || self->top == self->entries)
-                self->top = head->next;
+                self->top = ui_browser__list_head_filter_entries(self, head->next);
 
         pos = self->top;
 
         list_for_each_from(pos, head) {
-                ui_browser__gotorc(self, row, 0);
-                self->write(self, pos, row);
-                if (++row == self->height)
-                        break;
+                if (!self->filter || !self->filter(self, pos)) {
+                        ui_browser__gotorc(self, row, 0);
+                        self->write(self, pos, row);
+                        if (++row == self->height)
+                                break;
+                }
         }
 
         return row;
 }
 
-static struct newtPercentTreeColors {
-        const char *topColorFg, *topColorBg;
-        const char *mediumColorFg, *mediumColorBg;
-        const char *normalColorFg, *normalColorBg;
-        const char *selColorFg, *selColorBg;
-        const char *codeColorFg, *codeColorBg;
-} defaultPercentTreeColors = {
-        "red",       "lightgray",
-        "green",     "lightgray",
-        "black",     "lightgray",
-        "lightgray", "magenta",
-        "blue",      "lightgray",
+static struct ui_browser__colorset {
+        const char *name, *fg, *bg;
+        int colorset;
+} ui_browser__colorsets[] = {
+        {
+                .colorset = HE_COLORSET_TOP,
+                .name     = "top",
+                .fg       = "red",
+                .bg       = "default",
+        },
+        {
+                .colorset = HE_COLORSET_MEDIUM,
+                .name     = "medium",
+                .fg       = "green",
+                .bg       = "default",
+        },
+        {
+                .colorset = HE_COLORSET_NORMAL,
+                .name     = "normal",
+                .fg       = "default",
+                .bg       = "default",
+        },
+        {
+                .colorset = HE_COLORSET_SELECTED,
+                .name     = "selected",
+                .fg       = "black",
+                .bg       = "lightgray",
+        },
+        {
+                .colorset = HE_COLORSET_CODE,
+                .name     = "code",
+                .fg       = "blue",
+                .bg       = "default",
+        },
+        {
+                .name = NULL,
+        }
 };
 
+
+static int ui_browser__color_config(const char *var, const char *value,
+                                    void *data __used)
+{
+        char *fg = NULL, *bg;
+        int i;
+
+        /* same dir for all commands */
+        if (prefixcmp(var, "colors.") != 0)
+                return 0;
+
+        for (i = 0; ui_browser__colorsets[i].name != NULL; ++i) {
+                const char *name = var + 7;
+
+                if (strcmp(ui_browser__colorsets[i].name, name) != 0)
+                        continue;
+
+                fg = strdup(value);
+                if (fg == NULL)
+                        break;
+
+                bg = strchr(fg, ',');
+                if (bg == NULL)
+                        break;
+
+                *bg = '\0';
+                while (isspace(*++bg));
+                ui_browser__colorsets[i].bg = bg;
+                ui_browser__colorsets[i].fg = fg;
+                return 0;
+        }
+
+        free(fg);
+        return -1;
+}
+
 void ui_browser__init(void)
 {
-        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
+        int i = 0;
 
-        sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
-        sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
-        sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
-        sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
-        sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
+        perf_config(ui_browser__color_config, NULL);
+
+        while (ui_browser__colorsets[i].name) {
+                struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
+                sltt_set_color(c->colorset, c->name, c->fg, c->bg);
+        }
 }
diff --git a/tools/perf/util/ui/browser.h b/tools/perf/util/ui/browser.h
index fc63dda10910..a2c707d33c5e 100644
--- a/tools/perf/util/ui/browser.h
+++ b/tools/perf/util/ui/browser.h
@@ -2,7 +2,6 @@
 #define _PERF_UI_BROWSER_H_ 1
 
 #include <stdbool.h>
-#include <newt.h>
 #include <sys/types.h>
 #include "../types.h"
 
@@ -13,15 +12,19 @@
 #define HE_COLORSET_CODE        54
 
 struct ui_browser {
-        newtComponent form, sb;
         u64           index, top_idx;
         void          *top, *entries;
         u16           y, x, width, height;
         void          *priv;
+        const char    *title;
+        char          *helpline;
         unsigned int  (*refresh)(struct ui_browser *self);
         void          (*write)(struct ui_browser *self, void *entry, int row);
         void          (*seek)(struct ui_browser *self, off_t offset, int whence);
+        bool          (*filter)(struct ui_browser *self, void *entry);
         u32           nr_entries;
+        bool          navkeypressed;
+        bool          use_navkeypressed;
 };
 
 void ui_browser__set_color(struct ui_browser *self, int color);
@@ -32,15 +35,14 @@ void ui_browser__refresh_dimensions(struct ui_browser *self);
 void ui_browser__reset_index(struct ui_browser *self);
 
 void ui_browser__gotorc(struct ui_browser *self, int y, int x);
-void ui_browser__add_exit_key(struct ui_browser *self, int key);
-void ui_browser__add_exit_keys(struct ui_browser *self, int keys[]);
 void __ui_browser__show_title(struct ui_browser *browser, const char *title);
 void ui_browser__show_title(struct ui_browser *browser, const char *title);
 int ui_browser__show(struct ui_browser *self, const char *title,
                      const char *helpline, ...);
 void ui_browser__hide(struct ui_browser *self);
 int ui_browser__refresh(struct ui_browser *self);
-int ui_browser__run(struct ui_browser *self);
+int ui_browser__run(struct ui_browser *browser, int delay_secs);
+void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries);
 
 void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence);
 unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self);
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
index 0229723aceb3..4e0cb7fea7d9 100644
--- a/tools/perf/util/ui/browsers/annotate.c
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -6,6 +6,7 @@
 #include "../../sort.h"
 #include "../../symbol.h"
 #include <pthread.h>
+#include <newt.h>
 
 static void ui__error_window(const char *fmt, ...)
 {
@@ -20,12 +21,17 @@ struct annotate_browser {
         struct ui_browser b;
         struct rb_root    entries;
         struct rb_node    *curr_hot;
+        struct objdump_line *selection;
+        int                 nr_asm_entries;
+        int                 nr_entries;
+        bool                hide_src_code;
 };
 
 struct objdump_line_rb_node {
         struct rb_node  rb_node;
         double          percent;
         u32             idx;
+        int             idx_asm;
 };
 
 static inline
@@ -34,9 +40,22 @@ struct objdump_line_rb_node *objdump_line__rb(struct objdump_line *self)
         return (struct objdump_line_rb_node *)(self + 1);
 }
 
+static bool objdump_line__filter(struct ui_browser *browser, void *entry)
+{
+        struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
+
+        if (ab->hide_src_code) {
+                struct objdump_line *ol = list_entry(entry, struct objdump_line, node);
+                return ol->offset == -1;
+        }
+
+        return false;
+}
+
 static void annotate_browser__write(struct ui_browser *self, void *entry, int row)
 {
-        struct objdump_line *ol = rb_entry(entry, struct objdump_line, node);
+        struct annotate_browser *ab = container_of(self, struct annotate_browser, b);
+        struct objdump_line *ol = list_entry(entry, struct objdump_line, node);
         bool current_entry = ui_browser__is_current_entry(self, row);
         int width = self->width;
 
@@ -51,6 +70,11 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro
 
         SLsmg_write_char(':');
         slsmg_write_nstring(" ", 8);
+
+        /* The scroll bar isn't being used */
+        if (!self->navkeypressed)
+                width += 1;
+
         if (!*ol->line)
                 slsmg_write_nstring(" ", width - 18);
         else
@@ -58,6 +82,8 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro
 
         if (!current_entry)
                 ui_browser__set_color(self, HE_COLORSET_CODE);
+        else
+                ab->selection = ol;
 }
 
 static double objdump_line__calc_percent(struct objdump_line *self,
@@ -141,7 +167,8 @@ static void annotate_browser__set_top(struct annotate_browser *self,
 static void annotate_browser__calc_percent(struct annotate_browser *browser,
                                            int evidx)
 {
-        struct symbol *sym = browser->b.priv;
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
         struct annotation *notes = symbol__annotation(sym);
         struct objdump_line *pos;
 
@@ -163,25 +190,60 @@ static void annotate_browser__calc_percent(struct annotate_browser *browser,
         browser->curr_hot = rb_last(&browser->entries);
 }
 
+static bool annotate_browser__toggle_source(struct annotate_browser *browser)
+{
+        struct objdump_line *ol;
+        struct objdump_line_rb_node *olrb;
+        off_t offset = browser->b.index - browser->b.top_idx;
+
+        browser->b.seek(&browser->b, offset, SEEK_CUR);
+        ol = list_entry(browser->b.top, struct objdump_line, node);
+        olrb = objdump_line__rb(ol);
+
+        if (browser->hide_src_code) {
+                if (olrb->idx_asm < offset)
+                        offset = olrb->idx;
+
+                browser->b.nr_entries = browser->nr_entries;
+                browser->hide_src_code = false;
+                browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                browser->b.top_idx = olrb->idx - offset;
+                browser->b.index = olrb->idx;
+        } else {
+                if (olrb->idx_asm < 0) {
+                        ui_helpline__puts("Only available for assembly lines.");
+                        browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                        return false;
+                }
+
+                if (olrb->idx_asm < offset)
+                        offset = olrb->idx_asm;
+
+                browser->b.nr_entries = browser->nr_asm_entries;
+                browser->hide_src_code = true;
+                browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                browser->b.top_idx = olrb->idx_asm - offset;
+                browser->b.index = olrb->idx_asm;
+        }
+
+        return true;
+}
+
 static int annotate_browser__run(struct annotate_browser *self, int evidx,
-                                 int refresh)
+                                 int nr_events, void(*timer)(void *arg),
+                                 void *arg, int delay_secs)
 {
         struct rb_node *nd = NULL;
-        struct symbol *sym = self->b.priv;
-        /*
-         * RIGHT To allow builtin-annotate to cycle thru multiple symbols by
-         * examining the exit key for this function.
-         */
-        int exit_keys[] = { 'H', NEWT_KEY_TAB, NEWT_KEY_UNTAB,
-                            NEWT_KEY_RIGHT, 0 };
+        struct map_symbol *ms = self->b.priv;
+        struct symbol *sym = ms->sym;
+        const char *help = "<-, ESC: exit, TAB/shift+TAB: cycle hottest lines, "
+                           "H: Hottest, -> Line action, S -> Toggle source "
+                           "code view";
         int key;
 
-        if (ui_browser__show(&self->b, sym->name,
-                             "<-, -> or ESC: exit, TAB/shift+TAB: "
-                             "cycle hottest lines, H: Hottest") < 0)
+        if (ui_browser__show(&self->b, sym->name, help) < 0)
                 return -1;
 
-        ui_browser__add_exit_keys(&self->b, exit_keys);
         annotate_browser__calc_percent(self, evidx);
 
         if (self->curr_hot)
@@ -189,13 +251,10 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
 
         nd = self->curr_hot;
 
-        if (refresh != 0)
-                newtFormSetTimer(self->b.form, refresh);
-
         while (1) {
-                key = ui_browser__run(&self->b);
+                key = ui_browser__run(&self->b, delay_secs);
 
-                if (refresh != 0) {
+                if (delay_secs != 0) {
                         annotate_browser__calc_percent(self, evidx);
                         /*
                          * Current line focus got out of the list of most active
@@ -207,15 +266,14 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                 }
 
                 switch (key) {
-                case -1:
-                        /*
-                         * FIXME we need to check if it was
-                         * es.reason == NEWT_EXIT_TIMER
-                         */
-                        if (refresh != 0)
+                case K_TIMER:
+                        if (timer != NULL)
+                                timer(arg);
+
+                        if (delay_secs != 0)
                                 symbol__annotate_decay_histogram(sym, evidx);
                         continue;
-                case NEWT_KEY_TAB:
+                case K_TAB:
                         if (nd != NULL) {
                                 nd = rb_prev(nd);
                                 if (nd == NULL)
@@ -223,7 +281,7 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                         } else
                                 nd = self->curr_hot;
                         break;
-                case NEWT_KEY_UNTAB:
+                case K_UNTAB:
                         if (nd != NULL)
                                 nd = rb_next(nd);
                                 if (nd == NULL)
@@ -234,8 +292,68 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                 case 'H':
                         nd = self->curr_hot;
                         break;
-                default:
+                case 'S':
+                        if (annotate_browser__toggle_source(self))
+                                ui_helpline__puts(help);
+                        continue;
+                case K_ENTER:
+                case K_RIGHT:
+                        if (self->selection == NULL) {
+                                ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
+                                continue;
+                        }
+
+                        if (self->selection->offset == -1) {
+                                ui_helpline__puts("Actions are only available for assembly lines.");
+                                continue;
+                        } else {
+                                char *s = strstr(self->selection->line, "callq ");
+                                struct annotation *notes;
+                                struct symbol *target;
+                                u64 ip;
+
+                                if (s == NULL) {
+                                        ui_helpline__puts("Actions are only available for the 'callq' instruction.");
+                                        continue;
+                                }
+
+                                s = strchr(s, ' ');
+                                if (s++ == NULL) {
+                                        ui_helpline__puts("Invallid callq instruction.");
+                                        continue;
+                                }
+
+                                ip = strtoull(s, NULL, 16);
+                                ip = ms->map->map_ip(ms->map, ip);
+                                target = map__find_symbol(ms->map, ip, NULL);
+                                if (target == NULL) {
+                                        ui_helpline__puts("The called function was not found.");
+                                        continue;
+                                }
+
+                                notes = symbol__annotation(target);
+                                pthread_mutex_lock(&notes->lock);
+
+                                if (notes->src == NULL &&
+                                    symbol__alloc_hist(target, nr_events) < 0) {
+                                        pthread_mutex_unlock(&notes->lock);
+                                        ui__warning("Not enough memory for annotating '%s' symbol!\n",
+                                                    target->name);
+                                        continue;
+                                }
+
+                                pthread_mutex_unlock(&notes->lock);
+                                symbol__tui_annotate(target, ms->map, evidx, nr_events,
+                                                     timer, arg, delay_secs);
+                        }
+                        continue;
+                case K_LEFT:
+                case K_ESC:
+                case 'q':
+                case CTRL('c'):
                         goto out;
+                default:
+                        continue;
                 }
 
                 if (nd != NULL)
@@ -246,22 +364,31 @@ out:
         return key;
 }
 
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx)
+int hist_entry__tui_annotate(struct hist_entry *he, int evidx, int nr_events,
+                             void(*timer)(void *arg), void *arg, int delay_secs)
 {
-        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx, 0);
+        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx, nr_events,
+                                    timer, arg, delay_secs);
 }
 
 int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
-                         int refresh)
+                         int nr_events, void(*timer)(void *arg), void *arg,
+                         int delay_secs)
 {
         struct objdump_line *pos, *n;
         struct annotation *notes;
+        struct map_symbol ms = {
+                .map = map,
+                .sym = sym,
+        };
         struct annotate_browser browser = {
                 .b = {
                         .refresh = ui_browser__list_head_refresh,
                         .seek    = ui_browser__list_head_seek,
                         .write   = annotate_browser__write,
-                        .priv    = sym,
+                        .filter  = objdump_line__filter,
+                        .priv    = &ms,
+                        .use_navkeypressed = true,
                 },
         };
         int ret;
@@ -288,12 +415,18 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
                 if (browser.b.width < line_len)
                         browser.b.width = line_len;
                 rbpos = objdump_line__rb(pos);
-                rbpos->idx = browser.b.nr_entries++;
+                rbpos->idx = browser.nr_entries++;
+                if (pos->offset != -1)
+                        rbpos->idx_asm = browser.nr_asm_entries++;
+                else
+                        rbpos->idx_asm = -1;
         }
 
+        browser.b.nr_entries = browser.nr_entries;
         browser.b.entries = &notes->src->source,
         browser.b.width += 18; /* Percentage */
-        ret = annotate_browser__run(&browser, evidx, refresh);
+        ret = annotate_browser__run(&browser, evidx, nr_events,
+                                    timer, arg, delay_secs);
         list_for_each_entry_safe(pos, n, &notes->src->source, node) {
                 list_del(&pos->node);
                 objdump_line__free(pos);
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
index 5d767c622dfc..4663dcb2a19b 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -24,8 +24,12 @@ struct hist_browser {
         struct hists        *hists;
         struct hist_entry   *he_selection;
         struct map_symbol   *selection;
+        bool                 has_symbols;
 };
 
+static int hists__browser_title(struct hists *self, char *bf, size_t size,
+                                const char *ev_name);
+
 static void hist_browser__refresh_dimensions(struct hist_browser *self)
 {
         /* 3 == +/- toggle symbol before actual hist_entry rendering */
@@ -290,28 +294,34 @@ static void hist_browser__set_folding(struct hist_browser *self, bool unfold)
         ui_browser__reset_index(&self->b);
 }
 
-static int hist_browser__run(struct hist_browser *self, const char *title)
+static int hist_browser__run(struct hist_browser *self, const char *ev_name,
+                             void(*timer)(void *arg), void *arg, int delay_secs)
 {
         int key;
-        int exit_keys[] = { 'a', '?', 'h', 'C', 'd', 'D', 'E', 't',
-                            NEWT_KEY_ENTER, NEWT_KEY_RIGHT, NEWT_KEY_LEFT,
-                            NEWT_KEY_TAB, NEWT_KEY_UNTAB, 0, };
+        char title[160];
 
         self->b.entries = &self->hists->entries;
         self->b.nr_entries = self->hists->nr_entries;
 
         hist_browser__refresh_dimensions(self);
+        hists__browser_title(self->hists, title, sizeof(title), ev_name);
 
         if (ui_browser__show(&self->b, title,
                              "Press '?' for help on key bindings") < 0)
                 return -1;
 
-        ui_browser__add_exit_keys(&self->b, exit_keys);
-
         while (1) {
-                key = ui_browser__run(&self->b);
+                key = ui_browser__run(&self->b, delay_secs);
 
                 switch (key) {
+                case -1:
+                        /* FIXME we need to check if it was es.reason == NEWT_EXIT_TIMER */
+                        timer(arg);
+                        ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
+                        hists__browser_title(self->hists, title, sizeof(title),
+                                             ev_name);
+                        ui_browser__show_title(&self->b, title);
+                        continue;
                 case 'D': { /* Debug */
                         static int seq;
                         struct hist_entry *h = rb_entry(self->b.top,
@@ -334,7 +344,7 @@ static int hist_browser__run(struct hist_browser *self, const char *title)
                         /* Expand the whole world. */
                         hist_browser__set_folding(self, true);
                         break;
-                case NEWT_KEY_ENTER:
+                case K_ENTER:
                         if (hist_browser__toggle_fold(self))
                                 break;
                         /* fall thru */
@@ -532,7 +542,7 @@ static int hist_browser__show_entry(struct hist_browser *self,
         char s[256];
         double percent;
         int printed = 0;
-        int color, width = self->b.width;
+        int width = self->b.width - 6; /* The percentage */
         char folded_sign = ' ';
         bool current_entry = ui_browser__is_current_entry(&self->b, row);
         off_t row_offset = entry->row_offset;
@@ -548,26 +558,35 @@ static int hist_browser__show_entry(struct hist_browser *self,
         }
 
         if (row_offset == 0) {
-                hist_entry__snprintf(entry, s, sizeof(s), self->hists, NULL, false,
-                                     0, false, self->hists->stats.total_period);
+                hist_entry__snprintf(entry, s, sizeof(s), self->hists);
                 percent = (entry->period * 100.0) / self->hists->stats.total_period;
 
-                color = HE_COLORSET_SELECTED;
-                if (!current_entry) {
-                        if (percent >= MIN_RED)
-                                color = HE_COLORSET_TOP;
-                        else if (percent >= MIN_GREEN)
-                                color = HE_COLORSET_MEDIUM;
-                        else
-                                color = HE_COLORSET_NORMAL;
-                }
-
-                ui_browser__set_color(&self->b, color);
+                ui_browser__set_percent_color(&self->b, percent, current_entry);
                 ui_browser__gotorc(&self->b, row, 0);
                 if (symbol_conf.use_callchain) {
                         slsmg_printf("%c ", folded_sign);
                         width -= 2;
                 }
+
+                slsmg_printf(" %5.2f%%", percent);
+
+                /* The scroll bar isn't being used */
+                if (!self->b.navkeypressed)
+                        width += 1;
+
+                if (!current_entry || !self->b.navkeypressed)
+                        ui_browser__set_color(&self->b, HE_COLORSET_NORMAL);
+
+                if (symbol_conf.show_nr_samples) {
+                        slsmg_printf(" %11u", entry->nr_events);
+                        width -= 12;
+                }
+
+                if (symbol_conf.show_total_period) {
+                        slsmg_printf(" %12" PRIu64, entry->period);
+                        width -= 13;
+                }
+
                 slsmg_write_nstring(s, width);
                 ++row;
                 ++printed;
@@ -585,14 +604,23 @@ static int hist_browser__show_entry(struct hist_browser *self,
         return printed;
 }
 
+static void ui_browser__hists_init_top(struct ui_browser *browser)
+{
+        if (browser->top == NULL) {
+                struct hist_browser *hb;
+
+                hb = container_of(browser, struct hist_browser, b);
+                browser->top = rb_first(&hb->hists->entries);
+        }
+}
+
 static unsigned int hist_browser__refresh(struct ui_browser *self)
 {
         unsigned row = 0;
         struct rb_node *nd;
         struct hist_browser *hb = container_of(self, struct hist_browser, b);
 
-        if (self->top == NULL)
-                self->top = rb_first(&hb->hists->entries);
+        ui_browser__hists_init_top(self);
 
         for (nd = self->top; nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
@@ -644,6 +672,8 @@ static void ui_browser__hists_seek(struct ui_browser *self,
         if (self->nr_entries == 0)
                 return;
 
+        ui_browser__hists_init_top(self);
+
         switch (whence) {
         case SEEK_SET:
                 nd = hists__filter_entries(rb_first(self->entries));
@@ -761,6 +791,8 @@ static struct hist_browser *hist_browser__new(struct hists *hists)
                 self->hists = hists;
                 self->b.refresh = hist_browser__refresh;
                 self->b.seek = ui_browser__hists_seek;
+                self->b.use_navkeypressed = true,
+                self->has_symbols = sort_sym.list.next != NULL;
         }
 
         return self;
@@ -782,11 +814,12 @@ static struct thread *hist_browser__selected_thread(struct hist_browser *self)
 }
 
 static int hists__browser_title(struct hists *self, char *bf, size_t size,
-                                const char *ev_name, const struct dso *dso,
-                                const struct thread *thread)
+                                const char *ev_name)
 {
         char unit;
         int printed;
+        const struct dso *dso = self->dso_filter;
+        const struct thread *thread = self->thread_filter;
         unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 
         nr_events = convert_unit(nr_events, &unit);
@@ -803,16 +836,15 @@ static int hists__browser_title(struct hists *self, char *bf, size_t size,
         return printed;
 }
 
-static int perf_evsel__hists_browse(struct perf_evsel *evsel,
+static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     const char *helpline, const char *ev_name,
-                                    bool left_exits)
+                                    bool left_exits,
+                                    void(*timer)(void *arg), void *arg,
+                                    int delay_secs)
 {
         struct hists *self = &evsel->hists;
         struct hist_browser *browser = hist_browser__new(self);
         struct pstack *fstack;
-        const struct thread *thread_filter = NULL;
-        const struct dso *dso_filter = NULL;
-        char msg[160];
         int key = -1;
 
         if (browser == NULL)
@@ -824,8 +856,6 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
 
         ui_helpline__push(helpline);
 
-        hists__browser_title(self, msg, sizeof(msg), ev_name,
-                             dso_filter, thread_filter);
         while (1) {
                 const struct thread *thread = NULL;
                 const struct dso *dso = NULL;
@@ -834,7 +864,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
                     annotate = -2, zoom_dso = -2, zoom_thread = -2,
                     browse_map = -2;
 
-                key = hist_browser__run(browser, msg);
+                key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
 
                 if (browser->he_selection != NULL) {
                         thread = hist_browser__selected_thread(browser);
@@ -842,14 +872,23 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
                 }
 
                 switch (key) {
-                case NEWT_KEY_TAB:
-                case NEWT_KEY_UNTAB:
+                case K_TAB:
+                case K_UNTAB:
+                        if (nr_events == 1)
+                                continue;
                         /*
                          * Exit the browser, let hists__browser_tree
                          * go to the next or previous
                          */
                         goto out_free_stack;
                 case 'a':
+                        if (!browser->has_symbols) {
+                                ui__warning(
+                        "Annotation is only available for symbolic views, "
+                        "include \"sym\" in --sort to use it.");
+                                continue;
+                        }
+
                         if (browser->selection == NULL ||
                             browser->selection->sym == NULL ||
                             browser->selection->map->dso->annotate_warned)
@@ -859,25 +898,29 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
                         goto zoom_dso;
                 case 't':
                         goto zoom_thread;
-                case NEWT_KEY_F1:
+                case K_F1:
                 case 'h':
                 case '?':
-                        ui__help_window("->        Zoom into DSO/Threads & Annotate current symbol\n"
-                                        "<-        Zoom out\n"
-                                        "a         Annotate current symbol\n"
-                                        "h/?/F1    Show this window\n"
-                                        "C         Collapse all callchains\n"
-                                        "E         Expand all callchains\n"
-                                        "d         Zoom into current DSO\n"
-                                        "t         Zoom into current Thread\n"
-                                        "TAB/UNTAB Switch events\n"
-                                        "q/CTRL+C  Exit browser");
+                        ui__help_window("h/?/F1        Show this window\n"
+                                        "UP/DOWN/PGUP\n"
+                                        "PGDN/SPACE    Navigate\n"
+                                        "q/ESC/CTRL+C  Exit browser\n\n"
+                                        "For multiple event sessions:\n\n"
+                                        "TAB/UNTAB Switch events\n\n"
+                                        "For symbolic views (--sort has sym):\n\n"
+                                        "->            Zoom into DSO/Threads & Annotate current symbol\n"
+                                        "<-            Zoom out\n"
+                                        "a             Annotate current symbol\n"
+                                        "C             Collapse all callchains\n"
+                                        "E             Expand all callchains\n"
+                                        "d             Zoom into current DSO\n"
+                                        "t             Zoom into current Thread\n");
                         continue;
-                case NEWT_KEY_ENTER:
-                case NEWT_KEY_RIGHT:
+                case K_ENTER:
+                case K_RIGHT:
                         /* menu */
                         break;
-                case NEWT_KEY_LEFT: {
+                case K_LEFT: {
                         const void *top;
 
                         if (pstack__empty(fstack)) {
@@ -889,21 +932,27 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
                                 continue;
                         }
                         top = pstack__pop(fstack);
-                        if (top == &dso_filter)
+                        if (top == &browser->hists->dso_filter)
                                 goto zoom_out_dso;
-                        if (top == &thread_filter)
+                        if (top == &browser->hists->thread_filter)
                                 goto zoom_out_thread;
                         continue;
                 }
-                case NEWT_KEY_ESCAPE:
+                case K_ESC:
                         if (!left_exits &&
                             !ui__dialog_yesno("Do you really want to exit?"))
                                 continue;
                         /* Fall thru */
-                default:
+                case 'q':
+                case CTRL('c'):
                         goto out_free_stack;
+                default:
+                        continue;
                 }
 
+                if (!browser->has_symbols)
+                        goto add_exit_option;
+
                 if (browser->selection != NULL &&
                     browser->selection->sym != NULL &&
                     !browser->selection->map->dso->annotate_warned &&
@@ -913,14 +962,14 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
 
                 if (thread != NULL &&
                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
-                             (thread_filter ? "out of" : "into"),
+                             (browser->hists->thread_filter ? "out of" : "into"),
                              (thread->comm_set ? thread->comm : ""),
                              thread->pid) > 0)
                         zoom_thread = nr_options++;
 
                 if (dso != NULL &&
                     asprintf(&options[nr_options], "Zoom %s %s DSO",
-                             (dso_filter ? "out of" : "into"),
+                             (browser->hists->dso_filter ? "out of" : "into"),
                              (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
                         zoom_dso = nr_options++;
 
@@ -928,7 +977,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
                     browser->selection->map != NULL &&
                     asprintf(&options[nr_options], "Browse map details") > 0)
                         browse_map = nr_options++;
-
+add_exit_option:
                 options[nr_options++] = (char *)"Exit";
 
                 choice = ui__popup_menu(nr_options, options);
@@ -948,46 +997,52 @@ do_annotate:
                         he = hist_browser__selected_entry(browser);
                         if (he == NULL)
                                 continue;
-
-                        hist_entry__tui_annotate(he, evsel->idx);
+                        /*
+                         * Don't let this be freed, say, by hists__decay_entry.
+                         */
+                        he->used = true;
+                        hist_entry__tui_annotate(he, evsel->idx, nr_events,
+                                                 timer, arg, delay_secs);
+                        he->used = false;
+                        ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
                 } else if (choice == browse_map)
                         map__browse(browser->selection->map);
                 else if (choice == zoom_dso) {
 zoom_dso:
-                        if (dso_filter) {
-                                pstack__remove(fstack, &dso_filter);
+                        if (browser->hists->dso_filter) {
+                                pstack__remove(fstack, &browser->hists->dso_filter);
 zoom_out_dso:
                                 ui_helpline__pop();
-                                dso_filter = NULL;
+                                browser->hists->dso_filter = NULL;
+                                sort_dso.elide = false;
                         } else {
                                 if (dso == NULL)
                                         continue;
                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
                                                    dso->kernel ? "the Kernel" : dso->short_name);
-                                dso_filter = dso;
-                                pstack__push(fstack, &dso_filter);
+                                browser->hists->dso_filter = dso;
+                                sort_dso.elide = true;
+                                pstack__push(fstack, &browser->hists->dso_filter);
                         }
-                        hists__filter_by_dso(self, dso_filter);
-                        hists__browser_title(self, msg, sizeof(msg), ev_name,
-                                             dso_filter, thread_filter);
+                        hists__filter_by_dso(self);
                         hist_browser__reset(browser);
                 } else if (choice == zoom_thread) {
 zoom_thread:
-                        if (thread_filter) {
-                                pstack__remove(fstack, &thread_filter);
+                        if (browser->hists->thread_filter) {
+                                pstack__remove(fstack, &browser->hists->thread_filter);
 zoom_out_thread:
                                 ui_helpline__pop();
-                                thread_filter = NULL;
+                                browser->hists->thread_filter = NULL;
+                                sort_thread.elide = false;
                         } else {
                                 ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
                                                    thread->comm_set ? thread->comm : "",
                                                    thread->pid);
-                                thread_filter = thread;
-                                pstack__push(fstack, &thread_filter);
+                                browser->hists->thread_filter = thread;
+                                sort_thread.elide = true;
+                                pstack__push(fstack, &browser->hists->thread_filter);
                         }
-                        hists__filter_by_thread(self, thread_filter);
-                        hists__browser_title(self, msg, sizeof(msg), ev_name,
-                                             dso_filter, thread_filter);
+                        hists__filter_by_thread(self);
                         hist_browser__reset(browser);
                 }
         }
@@ -1026,9 +1081,10 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
                 menu->selection = evsel;
 }
 
-static int perf_evsel_menu__run(struct perf_evsel_menu *menu, const char *help)
+static int perf_evsel_menu__run(struct perf_evsel_menu *menu,
+                                int nr_events, const char *help,
+                                void(*timer)(void *arg), void *arg, int delay_secs)
 {
-        int exit_keys[] = { NEWT_KEY_ENTER, NEWT_KEY_RIGHT, 0, };
         struct perf_evlist *evlist = menu->b.priv;
         struct perf_evsel *pos;
         const char *ev_name, *title = "Available samples";
@@ -1038,50 +1094,65 @@ static int perf_evsel_menu__run(struct perf_evsel_menu *menu, const char *help)
                              "ESC: exit, ENTER|->: Browse histograms") < 0)
                 return -1;
 
-        ui_browser__add_exit_keys(&menu->b, exit_keys);
-
         while (1) {
-                key = ui_browser__run(&menu->b);
+                key = ui_browser__run(&menu->b, delay_secs);
 
                 switch (key) {
-                case NEWT_KEY_RIGHT:
-                case NEWT_KEY_ENTER:
+                case K_TIMER:
+                        timer(arg);
+                        continue;
+                case K_RIGHT:
+                case K_ENTER:
                         if (!menu->selection)
                                 continue;
                         pos = menu->selection;
 browse_hists:
+                        perf_evlist__set_selected(evlist, pos);
+                        /*
+                         * Give the calling tool a chance to populate the non
+                         * default evsel resorted hists tree.
+                         */
+                        if (timer)
+                                timer(arg);
                         ev_name = event_name(pos);
-                        key = perf_evsel__hists_browse(pos, help, ev_name, true);
+                        key = perf_evsel__hists_browse(pos, nr_events, help,
+                                                       ev_name, true, timer,
+                                                       arg, delay_secs);
                         ui_browser__show_title(&menu->b, title);
-                        break;
-                case NEWT_KEY_LEFT:
+                        switch (key) {
+                        case K_TAB:
+                                if (pos->node.next == &evlist->entries)
+                                        pos = list_entry(evlist->entries.next, struct perf_evsel, node);
+                                else
+                                        pos = list_entry(pos->node.next, struct perf_evsel, node);
+                                goto browse_hists;
+                        case K_UNTAB:
+                                if (pos->node.prev == &evlist->entries)
+                                        pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
+                                else
+                                        pos = list_entry(pos->node.prev, struct perf_evsel, node);
+                                goto browse_hists;
+                        case K_ESC:
+                                if (!ui__dialog_yesno("Do you really want to exit?"))
+                                        continue;
+                                /* Fall thru */
+                        case 'q':
+                        case CTRL('c'):
+                                goto out;
+                        default:
+                                continue;
+                        }
+                case K_LEFT:
                         continue;
-                case NEWT_KEY_ESCAPE:
+                case K_ESC:
                         if (!ui__dialog_yesno("Do you really want to exit?"))
                                 continue;
                         /* Fall thru */
-                default:
-                        goto out;
-                }
-
-                switch (key) {
-                case NEWT_KEY_TAB:
-                        if (pos->node.next == &evlist->entries)
-                                pos = list_entry(evlist->entries.next, struct perf_evsel, node);
-                        else
-                                pos = list_entry(pos->node.next, struct perf_evsel, node);
-                        goto browse_hists;
-                case NEWT_KEY_UNTAB:
-                        if (pos->node.prev == &evlist->entries)
-                                pos = list_entry(evlist->entries.prev, struct perf_evsel, node);
-                        else
-                                pos = list_entry(pos->node.prev, struct perf_evsel, node);
-                        goto browse_hists;
                 case 'q':
                 case CTRL('c'):
                         goto out;
                 default:
-                        break;
+                        continue;
                 }
         }
 
@@ -1091,7 +1162,9 @@ out:
 }
 
 static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
-                                           const char *help)
+                                           const char *help,
+                                           void(*timer)(void *arg), void *arg,
+                                           int delay_secs)
 {
         struct perf_evsel *pos;
         struct perf_evsel_menu menu = {
@@ -1121,18 +1194,24 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
                         pos->name = strdup(ev_name);
         }
 
-        return perf_evsel_menu__run(&menu, help);
+        return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
+                                    arg, delay_secs);
 }
 
-int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help)
+int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
+                                  void(*timer)(void *arg), void *arg,
+                                  int delay_secs)
 {
 
         if (evlist->nr_entries == 1) {
                 struct perf_evsel *first = list_entry(evlist->entries.next,
                                                       struct perf_evsel, node);
                 const char *ev_name = event_name(first);
-                return perf_evsel__hists_browse(first, help, ev_name, false);
+                return perf_evsel__hists_browse(first, evlist->nr_entries, help,
+                                                ev_name, false, timer, arg,
+                                                delay_secs);
         }
 
-        return __perf_evlist__tui_browse_hists(evlist, help);
+        return __perf_evlist__tui_browse_hists(evlist, help,
+                                               timer, arg, delay_secs);
 }
diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/util/ui/browsers/map.c
index 8462bffe20bc..6905bcc8be2d 100644
--- a/tools/perf/util/ui/browsers/map.c
+++ b/tools/perf/util/ui/browsers/map.c
@@ -1,5 +1,6 @@
 #include "../libslang.h"
 #include <elf.h>
+#include <newt.h>
 #include <inttypes.h>
 #include <sys/ttydefaults.h>
 #include <ctype.h>
@@ -108,11 +109,8 @@ static int map_browser__run(struct map_browser *self)
                              verbose ? "" : "restart with -v to use") < 0)
                 return -1;
 
-        if (verbose)
-                ui_browser__add_exit_key(&self->b, '/');
-
         while (1) {
-                key = ui_browser__run(&self->b);
+                key = ui_browser__run(&self->b, 0);
 
                 if (verbose && key == '/')
                         map_browser__search(self);
diff --git a/tools/perf/util/ui/browsers/top.c b/tools/perf/util/ui/browsers/top.c
deleted file mode 100644
index 5a06538532af..000000000000
--- a/tools/perf/util/ui/browsers/top.c
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
- *
- * Parts came from builtin-{top,stat,record}.c, see those files for further
- * copyright notes.
- *
- * Released under the GPL v2. (and only v2, not any later version)
- */
-#include "../browser.h"
-#include "../../annotate.h"
-#include "../helpline.h"
-#include "../libslang.h"
-#include "../util.h"
-#include "../../evlist.h"
-#include "../../hist.h"
-#include "../../sort.h"
-#include "../../symbol.h"
-#include "../../top.h"
-
-struct perf_top_browser {
-        struct ui_browser b;
-        struct rb_root    root;
-        struct sym_entry  *selection;
-        float             sum_ksamples;
-        int               dso_width;
-        int               dso_short_width;
-        int               sym_width;
-};
-
-static void perf_top_browser__write(struct ui_browser *browser, void *entry, int row)
-{
-        struct perf_top_browser *top_browser = container_of(browser, struct perf_top_browser, b);
-        struct sym_entry *syme = rb_entry(entry, struct sym_entry, rb_node);
-        bool current_entry = ui_browser__is_current_entry(browser, row);
-        struct symbol *symbol = sym_entry__symbol(syme);
-        struct perf_top *top = browser->priv;
-        int width = browser->width;
-        double pcnt;
-
-        pcnt = 100.0 - (100.0 * ((top_browser->sum_ksamples - syme->snap_count) /
-                                 top_browser->sum_ksamples));
-        ui_browser__set_percent_color(browser, pcnt, current_entry);
-
-        if (top->evlist->nr_entries == 1 || !top->display_weighted) {
-                slsmg_printf("%20.2f ", syme->weight);
-                width -= 24;
-        } else {
-                slsmg_printf("%9.1f %10ld ", syme->weight, syme->snap_count);
-                width -= 23;
-        }
-
-        slsmg_printf("%4.1f%%", pcnt);
-        width -= 7;
-
-        if (verbose) {
-                slsmg_printf(" %016" PRIx64, symbol->start);
-                width -= 17;
-        }
-
-        slsmg_printf(" %-*.*s ", top_browser->sym_width, top_browser->sym_width,
-                     symbol->name);
-        width -= top_browser->sym_width;
-        slsmg_write_nstring(width >= syme->map->dso->long_name_len ?
-                                syme->map->dso->long_name :
-                                syme->map->dso->short_name, width);
-
-        if (current_entry)
-                top_browser->selection = syme;
-}
-
-static void perf_top_browser__update_rb_tree(struct perf_top_browser *browser)
-{
-        struct perf_top *top = browser->b.priv;
-        u64 top_idx = browser->b.top_idx;
-
-        browser->root = RB_ROOT;
-        browser->b.top = NULL;
-        browser->sum_ksamples = perf_top__decay_samples(top, &browser->root);
-        /*
-         * No active symbols
-         */
-        if (top->rb_entries == 0)
-                return;
-
-        perf_top__find_widths(top, &browser->root, &browser->dso_width,
-                              &browser->dso_short_width,
-                              &browser->sym_width);
-        if (browser->sym_width + browser->dso_width > browser->b.width - 29) {
-                browser->dso_width = browser->dso_short_width;
-                if (browser->sym_width + browser->dso_width > browser->b.width - 29)
-                        browser->sym_width = browser->b.width - browser->dso_width - 29;
-        }
-
-        /*
-         * Adjust the ui_browser indexes since the entries in the browser->root
-         * rb_tree may have changed, then seek it from start, so that we get a
-         * possible new top of the screen.
-         */
-        browser->b.nr_entries = top->rb_entries;
-
-        if (top_idx >= browser->b.nr_entries) {
-                if (browser->b.height >= browser->b.nr_entries)
-                        top_idx = browser->b.nr_entries - browser->b.height;
-                else
-                        top_idx = 0;
-        }
-
-        if (browser->b.index >= top_idx + browser->b.height)
-                browser->b.index = top_idx + browser->b.index - browser->b.top_idx;
-
-        if (browser->b.index >= browser->b.nr_entries)
-                browser->b.index = browser->b.nr_entries - 1;
-
-        browser->b.top_idx = top_idx;
-        browser->b.seek(&browser->b, top_idx, SEEK_SET);
-}
-
-static void perf_top_browser__annotate(struct perf_top_browser *browser)
-{
-        struct sym_entry *syme = browser->selection;
-        struct symbol *sym = sym_entry__symbol(syme);
-        struct annotation *notes = symbol__annotation(sym);
-        struct perf_top *top = browser->b.priv;
-
-        if (notes->src != NULL)
-                goto do_annotation;
-
-        pthread_mutex_lock(&notes->lock);
-
-        top->sym_filter_entry = NULL;
-
-        if (symbol__alloc_hist(sym, top->evlist->nr_entries) < 0) {
-                pr_err("Not enough memory for annotating '%s' symbol!\n",
-                       sym->name);
-                pthread_mutex_unlock(&notes->lock);
-                return;
-        }
-
-        top->sym_filter_entry = syme;
-
-        pthread_mutex_unlock(&notes->lock);
-do_annotation:
-        symbol__tui_annotate(sym, syme->map, 0, top->delay_secs * 1000);
-}
-
-static int perf_top_browser__run(struct perf_top_browser *browser)
-{
-        int key;
-        char title[160];
-        struct perf_top *top = browser->b.priv;
-        int delay_msecs = top->delay_secs * 1000;
-        int exit_keys[] = { 'a', NEWT_KEY_ENTER, NEWT_KEY_RIGHT, 0, };
-
-        perf_top_browser__update_rb_tree(browser);
-        perf_top__header_snprintf(top, title, sizeof(title));
-        perf_top__reset_sample_counters(top);
-
-        if (ui_browser__show(&browser->b, title,
-                             "ESC: exit, ENTER|->|a: Live Annotate") < 0)
-                return -1;
-
-        newtFormSetTimer(browser->b.form, delay_msecs);
-        ui_browser__add_exit_keys(&browser->b, exit_keys);
-
-        while (1) {
-                key = ui_browser__run(&browser->b);
-
-                switch (key) {
-                case -1:
-                        /* FIXME we need to check if it was es.reason == NEWT_EXIT_TIMER */
-                        perf_top_browser__update_rb_tree(browser);
-                        perf_top__header_snprintf(top, title, sizeof(title));
-                        perf_top__reset_sample_counters(top);
-                        ui_browser__set_color(&browser->b, NEWT_COLORSET_ROOT);
-                        SLsmg_gotorc(0, 0);
-                        slsmg_write_nstring(title, browser->b.width);
-                        break;
-                case 'a':
-                case NEWT_KEY_RIGHT:
-                case NEWT_KEY_ENTER:
-                        if (browser->selection)
-                                perf_top_browser__annotate(browser);
-                        break;
-                case NEWT_KEY_LEFT:
-                        continue;
-                case NEWT_KEY_ESCAPE:
-                        if (!ui__dialog_yesno("Do you really want to exit?"))
-                                continue;
-                        /* Fall thru */
-                default:
-                        goto out;
-                }
-        }
-out:
-        ui_browser__hide(&browser->b);
-        return key;
-}
-
-int perf_top__tui_browser(struct perf_top *top)
-{
-        struct perf_top_browser browser = {
-                .b = {
-                        .entries = &browser.root,
-                        .refresh = ui_browser__rb_tree_refresh,
-                        .seek    = ui_browser__rb_tree_seek,
-                        .write   = perf_top_browser__write,
-                        .priv    = top,
-                },
-        };
-
-        ui_helpline__push("Press <- or ESC to exit");
-        return perf_top_browser__run(&browser);
-}
diff --git a/tools/perf/util/ui/helpline.h b/tools/perf/util/ui/helpline.h
index ab6028d0c401..fdcbc0270acd 100644
--- a/tools/perf/util/ui/helpline.h
+++ b/tools/perf/util/ui/helpline.h
@@ -1,6 +1,9 @@
 #ifndef _PERF_UI_HELPLINE_H_
 #define _PERF_UI_HELPLINE_H_ 1
 
+#include <stdio.h>
+#include <stdarg.h>
+
 void ui_helpline__init(void);
 void ui_helpline__pop(void);
 void ui_helpline__push(const char *msg);
diff --git a/tools/perf/util/ui/keysyms.h b/tools/perf/util/ui/keysyms.h
new file mode 100644
index 000000000000..3458b1985761
--- /dev/null
+++ b/tools/perf/util/ui/keysyms.h
@@ -0,0 +1,25 @@
+#ifndef _PERF_KEYSYMS_H_
+#define _PERF_KEYSYMS_H_ 1
+
+#include "libslang.h"
+
+#define K_DOWN  SL_KEY_DOWN
+#define K_END   SL_KEY_END
+#define K_ENTER '\r'
+#define K_ESC   033
+#define K_F1    SL_KEY_F(1)
+#define K_HOME  SL_KEY_HOME
+#define K_LEFT  SL_KEY_LEFT
+#define K_PGDN  SL_KEY_NPAGE
+#define K_PGUP  SL_KEY_PPAGE
+#define K_RIGHT SL_KEY_RIGHT
+#define K_TAB   '\t'
+#define K_UNTAB SL_KEY_UNTAB
+#define K_UP    SL_KEY_UP
+
+/* Not really keys */
+#define K_TIMER  -1
+#define K_ERROR  -2
+#define K_RESIZE -3
+
+#endif /* _PERF_KEYSYMS_H_ */
diff --git a/tools/perf/util/ui/libslang.h b/tools/perf/util/ui/libslang.h
index 2b63e1c9b181..4d54b6450f5b 100644
--- a/tools/perf/util/ui/libslang.h
+++ b/tools/perf/util/ui/libslang.h
@@ -24,4 +24,6 @@
 #define sltt_set_color SLtt_set_color
 #endif
 
+#define SL_KEY_UNTAB 0x1000
+
 #endif /* _PERF_UI_SLANG_H_ */
diff --git a/tools/perf/util/ui/setup.c b/tools/perf/util/ui/setup.c
index ee46d671db59..1e6ba06980c4 100644
--- a/tools/perf/util/ui/setup.c
+++ b/tools/perf/util/ui/setup.c
@@ -7,6 +7,7 @@
 #include "browser.h"
 #include "helpline.h"
 #include "ui.h"
+#include "libslang.h"
 
 pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
@@ -17,6 +18,33 @@ static void newt_suspend(void *d __used)
         newtResume();
 }
 
+static int ui__init(void)
+{
+        int err = SLkp_init();
+
+        if (err < 0)
+                goto out;
+
+        SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
+out:
+        return err;
+}
+
+static void ui__exit(void)
+{
+        SLtt_set_cursor_visibility(1);
+        SLsmg_refresh();
+        SLsmg_reset_smg();
+        SLang_reset_tty();
+}
+
+static void ui__signal(int sig)
+{
+        ui__exit();
+        psignal(sig, "perf");
+        exit(0);
+}
+
 void setup_browser(bool fallback_to_pager)
 {
         if (!isatty(1) || !use_browser || dump_trace) {
@@ -28,10 +56,16 @@ void setup_browser(bool fallback_to_pager)
 
         use_browser = 1;
         newtInit();
-        newtCls();
+        ui__init();
         newtSetSuspendCallback(newt_suspend, NULL);
         ui_helpline__init();
         ui_browser__init();
+
+        signal(SIGSEGV, ui__signal);
+        signal(SIGFPE, ui__signal);
+        signal(SIGINT, ui__signal);
+        signal(SIGQUIT, ui__signal);
+        signal(SIGTERM, ui__signal);
 }
 
 void exit_browser(bool wait_for_ok)
@@ -41,6 +75,6 @@ void exit_browser(bool wait_for_ok)
                         char title[] = "Fatal Error", ok[] = "Ok";
                         newtWinMessage(title, ok, ui_helpline__last_msg);
                 }
-                newtFinished();
+                ui__exit();
         }
 }
diff --git a/tools/power/cpupower/Makefile b/tools/power/cpupower/Makefile
index 94c2cf0a98b8..e8a03aceceb1 100644
--- a/tools/power/cpupower/Makefile
+++ b/tools/power/cpupower/Makefile
@@ -24,7 +24,7 @@
 
 # Set the following to `true' to make a unstripped, unoptimized
 # binary. Leave this set to `false' for production use.
-DEBUG ?=        false
+DEBUG ?=        true
 
 # make the build silent. Set this to something else to make it noisy again.
 V ?=            false
@@ -35,7 +35,7 @@ NLS ?=		true
 
 # Set the following to 'true' to build/install the
 # cpufreq-bench benchmarking tool
-CPUFRQ_BENCH ?= true
+CPUFREQ_BENCH ?= true
 
 # Prefix to the directories we're installing to
 DESTDIR ?=
@@ -137,9 +137,10 @@ CFLAGS +=	-pipe
 ifeq ($(strip $(NLS)),true)
         INSTALL_NLS += install-gmo
         COMPILE_NLS += create-gmo
+        CFLAGS += -DNLS
 endif
 
-ifeq ($(strip $(CPUFRQ_BENCH)),true)
+ifeq ($(strip $(CPUFREQ_BENCH)),true)
         INSTALL_BENCH += install-bench
         COMPILE_BENCH += compile-bench
 endif
diff --git a/tools/power/cpupower/debug/x86_64/Makefile b/tools/power/cpupower/debug/x86_64/Makefile
index dbf13998462a..3326217dd311 100644
--- a/tools/power/cpupower/debug/x86_64/Makefile
+++ b/tools/power/cpupower/debug/x86_64/Makefile
@@ -1,10 +1,10 @@
 default: all
 
-centrino-decode: centrino-decode.c
-        $(CC) $(CFLAGS) -o centrino-decode centrino-decode.c
+centrino-decode: ../i386/centrino-decode.c
+        $(CC) $(CFLAGS) -o $@ $<
 
-powernow-k8-decode: powernow-k8-decode.c
-        $(CC) $(CFLAGS) -o powernow-k8-decode powernow-k8-decode.c
+powernow-k8-decode: ../i386/powernow-k8-decode.c
+        $(CC) $(CFLAGS) -o $@ $<
 
 all: centrino-decode powernow-k8-decode
 
diff --git a/tools/power/cpupower/debug/x86_64/centrino-decode.c b/tools/power/cpupower/debug/x86_64/centrino-decode.c
deleted file mode 120000
index 26fb3f1d8fc7..000000000000
--- a/tools/power/cpupower/debug/x86_64/centrino-decode.c
+++ /dev/null
@@ -1 +0,0 @@
-../i386/centrino-decode.c
\ No newline at end of file
diff --git a/tools/power/cpupower/debug/x86_64/powernow-k8-decode.c b/tools/power/cpupower/debug/x86_64/powernow-k8-decode.c
deleted file mode 120000
index eb30c79cf9df..000000000000
--- a/tools/power/cpupower/debug/x86_64/powernow-k8-decode.c
+++ /dev/null
@@ -1 +0,0 @@
-../i386/powernow-k8-decode.c
\ No newline at end of file
diff --git a/tools/power/cpupower/man/cpupower-frequency-info.1 b/tools/power/cpupower/man/cpupower-frequency-info.1
index 3194811d58f5..bb60a8d1e45a 100644
--- a/tools/power/cpupower/man/cpupower-frequency-info.1
+++ b/tools/power/cpupower/man/cpupower-frequency-info.1
@@ -1,10 +1,10 @@
-.TH "cpufreq-info" "1" "0.1" "Mattia Dongili" ""
+.TH "cpupower-frequency-info" "1" "0.1" "Mattia Dongili" ""
 .SH "NAME"
 .LP 
-cpufreq\-info \- Utility to retrieve cpufreq kernel information
+cpupower frequency\-info \- Utility to retrieve cpufreq kernel information
 .SH "SYNTAX"
 .LP 
-cpufreq\-info [\fIoptions\fP]
+cpupower [ \-c cpulist ] frequency\-info [\fIoptions\fP]
 .SH "DESCRIPTION"
 .LP 
 A small tool which prints out cpufreq information helpful to developers and interested users.
diff --git a/tools/power/cpupower/man/cpupower-frequency-set.1 b/tools/power/cpupower/man/cpupower-frequency-set.1
index 26e3e13eee3b..685f469093ad 100644
--- a/tools/power/cpupower/man/cpupower-frequency-set.1
+++ b/tools/power/cpupower/man/cpupower-frequency-set.1
@@ -1,13 +1,13 @@
-.TH "cpufreq-set" "1" "0.1" "Mattia Dongili" ""
+.TH "cpupower-freqency-set" "1" "0.1" "Mattia Dongili" ""
 .SH "NAME"
 .LP 
-cpufreq\-set \- A small tool which allows to modify cpufreq settings.
+cpupower frequency\-set \- A small tool which allows to modify cpufreq settings.
 .SH "SYNTAX"
 .LP 
-cpufreq\-set [\fIoptions\fP]
+cpupower [ \-c cpu ] frequency\-set [\fIoptions\fP]
 .SH "DESCRIPTION"
 .LP 
-cpufreq\-set allows you to modify cpufreq settings without having to type e.g. "/sys/devices/system/cpu/cpu0/cpufreq/scaling_set_speed" all the time.
+cpupower frequency\-set allows you to modify cpufreq settings without having to type e.g. "/sys/devices/system/cpu/cpu0/cpufreq/scaling_set_speed" all the time.
 .SH "OPTIONS"
 .LP 
 .TP 
diff --git a/tools/power/cpupower/man/cpupower.1 b/tools/power/cpupower/man/cpupower.1
index 78c20feab85c..baf741d06e82 100644
--- a/tools/power/cpupower/man/cpupower.1
+++ b/tools/power/cpupower/man/cpupower.1
@@ -3,7 +3,7 @@
 cpupower \- Shows and sets processor power related values
 .SH SYNOPSIS
 .ft B
-.B cpupower [ \-c cpulist ] subcommand [ARGS]
+.B cpupower [ \-c cpulist ] <command> [ARGS]
 
 .B cpupower \-v|\-\-version
 
@@ -13,24 +13,24 @@ cpupower \- Shows and sets processor power related values
 \fBcpupower \fP is a collection of tools to examine and tune power saving
 related features of your processor.
 
-The manpages of the subcommands (cpupower\-<subcommand>(1)) provide detailed
+The manpages of the commands (cpupower\-<command>(1)) provide detailed
 descriptions of supported features. Run \fBcpupower help\fP to get an overview
-of supported subcommands.
+of supported commands.
 
 .SH Options
 .PP
 \-\-help, \-h
 .RS 4
-Shows supported subcommands and general usage.
+Shows supported commands and general usage.
 .RE
 .PP
 \-\-cpu cpulist,  \-c cpulist
 .RS 4
 Only show or set values for specific cores.
-This option is not supported by all subcommands, details can be found in the
-manpages of the subcommands.
+This option is not supported by all commands, details can be found in the
+manpages of the commands.
 
-Some subcommands access all cores (typically the *\-set commands), some only
+Some commands access all cores (typically the *\-set commands), some only
 the first core (typically the *\-info commands) by default.
 
 The syntax for <cpulist> is based on how the kernel exports CPU bitmasks via
diff --git a/tools/power/cpupower/utils/builtin.h b/tools/power/cpupower/utils/builtin.h
index c870ffba5219..c10496fbe3c6 100644
--- a/tools/power/cpupower/utils/builtin.h
+++ b/tools/power/cpupower/utils/builtin.h
@@ -8,11 +8,4 @@ extern int cmd_freq_info(int argc, const char **argv);
 extern int cmd_idle_info(int argc, const char **argv);
 extern int cmd_monitor(int argc, const char **argv);
 
-extern void set_help(void);
-extern void info_help(void);
-extern void freq_set_help(void);
-extern void freq_info_help(void);
-extern void idle_info_help(void);
-extern void monitor_help(void);
-
 #endif
diff --git a/tools/power/cpupower/utils/cpufreq-info.c b/tools/power/cpupower/utils/cpufreq-info.c
index 5a1d25f056b3..28953c9a7bd5 100644
--- a/tools/power/cpupower/utils/cpufreq-info.c
+++ b/tools/power/cpupower/utils/cpufreq-info.c
@@ -510,37 +510,6 @@ static int get_latency(unsigned int cpu, unsigned int human)
         return 0;
 }
 
-void freq_info_help(void)
-{
-        printf(_("Usage: cpupower freqinfo [options]\n"));
-        printf(_("Options:\n"));
-        printf(_("  -e, --debug          Prints out debug information [default]\n"));
-        printf(_("  -f, --freq           Get frequency the CPU currently runs at, according\n"
-               "                       to the cpufreq core *\n"));
-        printf(_("  -w, --hwfreq         Get frequency the CPU currently runs at, by reading\n"
-               "                       it from hardware (only available to root) *\n"));
-        printf(_("  -l, --hwlimits       Determine the minimum and maximum CPU frequency allowed *\n"));
-        printf(_("  -d, --driver         Determines the used cpufreq kernel driver *\n"));
-        printf(_("  -p, --policy         Gets the currently used cpufreq policy *\n"));
-        printf(_("  -g, --governors      Determines available cpufreq governors *\n"));
-        printf(_("  -r, --related-cpus   Determines which CPUs run at the same hardware frequency *\n"));
-        printf(_("  -a, --affected-cpus  Determines which CPUs need to have their frequency\n"
-                        "                       coordinated by software *\n"));
-        printf(_("  -s, --stats          Shows cpufreq statistics if available\n"));
-        printf(_("  -y, --latency        Determines the maximum latency on CPU frequency changes *\n"));
-        printf(_("  -b, --boost          Checks for turbo or boost modes  *\n"));
-        printf(_("  -o, --proc           Prints out information like provided by the /proc/cpufreq\n"
-               "                       interface in 2.4. and early 2.6. kernels\n"));
-        printf(_("  -m, --human          human-readable output for the -f, -w, -s and -y parameters\n"));
-        printf(_("  -h, --help           Prints out this screen\n"));
-
-        printf("\n");
-        printf(_("If no argument is given, full output about\n"
-               "cpufreq is printed which is useful e.g. for reporting bugs.\n\n"));
-        printf(_("By default info of CPU 0 is shown which can be overridden\n"
-                 "with the cpupower --cpu main command option.\n"));
-}
-
 static struct option info_opts[] = {
         { .name = "debug",      .has_arg = no_argument,         .flag = NULL,   .val = 'e'},
         { .name = "boost",      .has_arg = no_argument,         .flag = NULL,   .val = 'b'},
@@ -556,7 +525,6 @@ static struct option info_opts[] = {
         { .name = "latency",    .has_arg = no_argument,         .flag = NULL,   .val = 'y'},
         { .name = "proc",       .has_arg = no_argument,         .flag = NULL,   .val = 'o'},
         { .name = "human",      .has_arg = no_argument,         .flag = NULL,   .val = 'm'},
-        { .name = "help",       .has_arg = no_argument,         .flag = NULL,   .val = 'h'},
         { },
 };
 
@@ -570,16 +538,12 @@ int cmd_freq_info(int argc, char **argv)
         int output_param = 0;
 
         do {
-                ret = getopt_long(argc, argv, "hoefwldpgrasmyb", info_opts, NULL);
+                ret = getopt_long(argc, argv, "oefwldpgrasmyb", info_opts, NULL);
                 switch (ret) {
                 case '?':
                         output_param = '?';
                         cont = 0;
                         break;
-                case 'h':
-                        output_param = 'h';
-                        cont = 0;
-                        break;
                 case -1:
                         cont = 0;
                         break;
@@ -642,11 +606,7 @@ int cmd_freq_info(int argc, char **argv)
                 return -EINVAL;
         case '?':
                 printf(_("invalid or unknown argument\n"));
-                freq_info_help();
                 return -EINVAL;
-        case 'h':
-                freq_info_help();
-                return EXIT_SUCCESS;
         case 'o':
                 proc_cpufreq_output();
                 return EXIT_SUCCESS;
diff --git a/tools/power/cpupower/utils/cpufreq-set.c b/tools/power/cpupower/utils/cpufreq-set.c
index 5f783622bf31..dd1539eb8c63 100644
--- a/tools/power/cpupower/utils/cpufreq-set.c
+++ b/tools/power/cpupower/utils/cpufreq-set.c
@@ -20,34 +20,11 @@
 
 #define NORM_FREQ_LEN 32
 
-void freq_set_help(void)
-{
-        printf(_("Usage: cpupower frequency-set [options]\n"));
-        printf(_("Options:\n"));
-        printf(_("  -d FREQ, --min FREQ      new minimum CPU frequency the governor may select\n"));
-        printf(_("  -u FREQ, --max FREQ      new maximum CPU frequency the governor may select\n"));
-        printf(_("  -g GOV, --governor GOV   new cpufreq governor\n"));
-        printf(_("  -f FREQ, --freq FREQ     specific frequency to be set. Requires userspace\n"
-               "                           governor to be available and loaded\n"));
-        printf(_("  -r, --related            Switches all hardware-related CPUs\n"));
-        printf(_("  -h, --help               Prints out this screen\n"));
-        printf("\n");
-        printf(_("Notes:\n"
-               "1. Omitting the -c or --cpu argument is equivalent to setting it to \"all\"\n"));
-        printf(_("2. The -f FREQ, --freq FREQ parameter cannot be combined with any other parameter\n"
-               "   except the -c CPU, --cpu CPU parameter\n"
-               "3. FREQuencies can be passed in Hz, kHz (default), MHz, GHz, or THz\n"
-               "   by postfixing the value with the wanted unit name, without any space\n"
-               "   (FREQuency in kHz =^ Hz * 0.001 =^ MHz * 1000 =^ GHz * 1000000).\n"));
-
-}
-
 static struct option set_opts[] = {
         { .name = "min",        .has_arg = required_argument,   .flag = NULL,   .val = 'd'},
         { .name = "max",        .has_arg = required_argument,   .flag = NULL,   .val = 'u'},
         { .name = "governor",   .has_arg = required_argument,   .flag = NULL,   .val = 'g'},
         { .name = "freq",       .has_arg = required_argument,   .flag = NULL,   .val = 'f'},
-        { .name = "help",       .has_arg = no_argument,         .flag = NULL,   .val = 'h'},
         { .name = "related",    .has_arg = no_argument,         .flag = NULL,   .val='r'},
         { },
 };
@@ -80,7 +57,6 @@ const struct freq_units def_units[] = {
 static void print_unknown_arg(void)
 {
         printf(_("invalid or unknown argument\n"));
-        freq_set_help();
 }
 
 static unsigned long string_to_frequency(const char *str)
@@ -231,14 +207,11 @@ int cmd_freq_set(int argc, char **argv)
 
         /* parameter parsing */
         do {
-                ret = getopt_long(argc, argv, "d:u:g:f:hr", set_opts, NULL);
+                ret = getopt_long(argc, argv, "d:u:g:f:r", set_opts, NULL);
                 switch (ret) {
                 case '?':
                         print_unknown_arg();
                         return -EINVAL;
-                case 'h':
-                        freq_set_help();
-                        return 0;
                 case -1:
                         cont = 0;
                         break;
diff --git a/tools/power/cpupower/utils/cpuidle-info.c b/tools/power/cpupower/utils/cpuidle-info.c
index 70da3574f1e9..b028267c1376 100644
--- a/tools/power/cpupower/utils/cpuidle-info.c
+++ b/tools/power/cpupower/utils/cpuidle-info.c
@@ -139,30 +139,14 @@ static void proc_cpuidle_cpu_output(unsigned int cpu)
         }
 }
 
-/* --freq / -f */
-
-void idle_info_help(void)
-{
-        printf(_ ("Usage: cpupower idleinfo [options]\n"));
-        printf(_ ("Options:\n"));
-        printf(_ ("  -s, --silent         Only show general C-state information\n"));
-        printf(_ ("  -o, --proc           Prints out information like provided by the /proc/acpi/processor/*/power\n"
-               "                       interface in older kernels\n"));
-        printf(_ ("  -h, --help           Prints out this screen\n"));
-
-        printf("\n");
-}
-
 static struct option info_opts[] = {
         { .name = "silent",     .has_arg = no_argument, .flag = NULL,   .val = 's'},
         { .name = "proc",       .has_arg = no_argument, .flag = NULL,   .val = 'o'},
-        { .name = "help",       .has_arg = no_argument, .flag = NULL,   .val = 'h'},
         { },
 };
 
 static inline void cpuidle_exit(int fail)
 {
-        idle_info_help();
         exit(EXIT_FAILURE);
 }
 
@@ -174,7 +158,7 @@ int cmd_idle_info(int argc, char **argv)
         unsigned int cpu = 0;
 
         do {
-                ret = getopt_long(argc, argv, "hos", info_opts, NULL);
+                ret = getopt_long(argc, argv, "os", info_opts, NULL);
                 if (ret == -1)
                         break;
                 switch (ret) {
@@ -182,10 +166,6 @@ int cmd_idle_info(int argc, char **argv)
                         output_param = '?';
                         cont = 0;
                         break;
-                case 'h':
-                        output_param = 'h';
-                        cont = 0;
-                        break;
                 case 's':
                         verbose = 0;
                         break;
@@ -211,8 +191,6 @@ int cmd_idle_info(int argc, char **argv)
         case '?':
                 printf(_("invalid or unknown argument\n"));
                 cpuidle_exit(EXIT_FAILURE);
-        case 'h':
-                cpuidle_exit(EXIT_SUCCESS);
         }
 
         /* Default is: show output of CPU 0 only */
diff --git a/tools/power/cpupower/utils/cpupower-info.c b/tools/power/cpupower/utils/cpupower-info.c
index 85253cb7600e..3f68632c28c7 100644
--- a/tools/power/cpupower/utils/cpupower-info.c
+++ b/tools/power/cpupower/utils/cpupower-info.c
@@ -16,31 +16,16 @@
 #include "helpers/helpers.h"
 #include "helpers/sysfs.h"
 
-void info_help(void)
-{
-        printf(_("Usage: cpupower info [ -b ] [ -m ] [ -s ]\n"));
-        printf(_("Options:\n"));
-        printf(_("  -b, --perf-bias    Gets CPU's power vs performance policy on some\n"
-               "                           Intel models [0-15], see manpage for details\n"));
-        printf(_("  -m, --sched-mc     Gets the kernel's multi core scheduler policy.\n"));
-        printf(_("  -s, --sched-smt    Gets the kernel's thread sibling scheduler policy.\n"));
-        printf(_("  -h, --help               Prints out this screen\n"));
-        printf(_("\nPassing no option will show all info, by default only on core 0\n"));
-        printf("\n");
-}
-
 static struct option set_opts[] = {
         { .name = "perf-bias",  .has_arg = optional_argument,   .flag = NULL,   .val = 'b'},
         { .name = "sched-mc",   .has_arg = optional_argument,   .flag = NULL,   .val = 'm'},
         { .name = "sched-smt",  .has_arg = optional_argument,   .flag = NULL,   .val = 's'},
-        { .name = "help",       .has_arg = no_argument,         .flag = NULL,   .val = 'h'},
         { },
 };
 
 static void print_wrong_arg_exit(void)
 {
         printf(_("invalid or unknown argument\n"));
-        info_help();
         exit(EXIT_FAILURE);
 }
 
@@ -64,11 +49,8 @@ int cmd_info(int argc, char **argv)
         textdomain(PACKAGE);
 
         /* parameter parsing */
-        while ((ret = getopt_long(argc, argv, "msbh", set_opts, NULL)) != -1) {
+        while ((ret = getopt_long(argc, argv, "msb", set_opts, NULL)) != -1) {
                 switch (ret) {
-                case 'h':
-                        info_help();
-                        return 0;
                 case 'b':
                         if (params.perf_bias)
                                 print_wrong_arg_exit();
diff --git a/tools/power/cpupower/utils/cpupower-set.c b/tools/power/cpupower/utils/cpupower-set.c
index bc1b391e46f0..dc4de3762111 100644
--- a/tools/power/cpupower/utils/cpupower-set.c
+++ b/tools/power/cpupower/utils/cpupower-set.c
@@ -17,30 +17,16 @@
 #include "helpers/sysfs.h"
 #include "helpers/bitmask.h"
 
-void set_help(void)
-{
-        printf(_("Usage: cpupower set [ -b val ] [ -m val ] [ -s val ]\n"));
-        printf(_("Options:\n"));
-        printf(_("  -b, --perf-bias [VAL]    Sets CPU's power vs performance policy on some\n"
-               "                           Intel models [0-15], see manpage for details\n"));
-        printf(_("  -m, --sched-mc  [VAL]    Sets the kernel's multi core scheduler policy.\n"));
-        printf(_("  -s, --sched-smt [VAL]    Sets the kernel's thread sibling scheduler policy.\n"));
-        printf(_("  -h, --help               Prints out this screen\n"));
-        printf("\n");
-}
-
 static struct option set_opts[] = {
         { .name = "perf-bias",  .has_arg = optional_argument,   .flag = NULL,   .val = 'b'},
         { .name = "sched-mc",   .has_arg = optional_argument,   .flag = NULL,   .val = 'm'},
         { .name = "sched-smt",  .has_arg = optional_argument,   .flag = NULL,   .val = 's'},
-        { .name = "help",       .has_arg = no_argument,         .flag = NULL,   .val = 'h'},
         { },
 };
 
 static void print_wrong_arg_exit(void)
 {
         printf(_("invalid or unknown argument\n"));
-        set_help();
         exit(EXIT_FAILURE);
 }
 
@@ -66,12 +52,9 @@ int cmd_set(int argc, char **argv)
 
         params.params = 0;
         /* parameter parsing */
-        while ((ret = getopt_long(argc, argv, "m:s:b:h",
+        while ((ret = getopt_long(argc, argv, "m:s:b:",
                                                 set_opts, NULL)) != -1) {
                 switch (ret) {
-                case 'h':
-                        set_help();
-                        return 0;
                 case 'b':
                         if (params.perf_bias)
                                 print_wrong_arg_exit();
@@ -110,10 +93,8 @@ int cmd_set(int argc, char **argv)
                 }
         };
 
-        if (!params.params) {
-                set_help();
-                return -EINVAL;
-        }
+        if (!params.params)
+                print_wrong_arg_exit();
 
         if (params.sched_mc) {
                 ret = sysfs_set_sched("mc", sched_mc);
diff --git a/tools/power/cpupower/utils/cpupower.c b/tools/power/cpupower/utils/cpupower.c
index 5844ae0f786f..52bee591c1c5 100644
--- a/tools/power/cpupower/utils/cpupower.c
+++ b/tools/power/cpupower/utils/cpupower.c
@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#include <errno.h>
 
 #include "builtin.h"
 #include "helpers/helpers.h"
@@ -19,13 +20,12 @@
 struct cmd_struct {
         const char *cmd;
         int (*main)(int, const char **);
-        void (*usage)(void);
         int needs_root;
 };
 
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 
-int cmd_help(int argc, const char **argv);
+static int cmd_help(int argc, const char **argv);
 
 /* Global cpu_info object available for all binaries
  * Info only retrieved from CPU 0
@@ -44,55 +44,66 @@ int be_verbose;
 static void print_help(void);
 
 static struct cmd_struct commands[] = {
-        { "frequency-info",     cmd_freq_info,  freq_info_help, 0       },
-        { "frequency-set",      cmd_freq_set,   freq_set_help,  1       },
-        { "idle-info",          cmd_idle_info,  idle_info_help, 0       },
-        { "set",                cmd_set,        set_help,       1       },
-        { "info",               cmd_info,       info_help,      0       },
-        { "monitor",            cmd_monitor,    monitor_help,   0       },
-        { "help",               cmd_help,       print_help,     0       },
-        /*      { "bench",      cmd_bench,      NULL,           1       }, */
+        { "frequency-info",     cmd_freq_info,  0       },
+        { "frequency-set",      cmd_freq_set,   1       },
+        { "idle-info",          cmd_idle_info,  0       },
+        { "set",                cmd_set,        1       },
+        { "info",               cmd_info,       0       },
+        { "monitor",            cmd_monitor,    0       },
+        { "help",               cmd_help,       0       },
+        /*      { "bench",      cmd_bench,      1       }, */
 };
 
-int cmd_help(int argc, const char **argv)
-{
-        unsigned int i;
-
-        if (argc > 1) {
-                for (i = 0; i < ARRAY_SIZE(commands); i++) {
-                        struct cmd_struct *p = commands + i;
-                        if (strcmp(p->cmd, argv[1]))
-                                continue;
-                        if (p->usage) {
-                                p->usage();
-                                return EXIT_SUCCESS;
-                        }
-                }
-        }
-        print_help();
-        if (argc == 1)
-                return EXIT_SUCCESS; /* cpupower help */
-        return EXIT_FAILURE;
-}
-
 static void print_help(void)
 {
         unsigned int i;
 
 #ifdef DEBUG
-        printf(_("cpupower [ -d ][ -c cpulist ] subcommand [ARGS]\n"));
-        printf(_("  -d, --debug      May increase output (stderr) on some subcommands\n"));
+        printf(_("Usage:\tcpupower [-d|--debug] [-c|--cpu cpulist ] <command> [<args>]\n"));
 #else
-        printf(_("cpupower [ -c cpulist ] subcommand [ARGS]\n"));
+        printf(_("Usage:\tcpupower [-c|--cpu cpulist ] <command> [<args>]\n"));
 #endif
-        printf(_("cpupower --version\n"));
-        printf(_("Supported subcommands are:\n"));
+        printf(_("Supported commands are:\n"));
         for (i = 0; i < ARRAY_SIZE(commands); i++)
                 printf("\t%s\n", commands[i].cmd);
-        printf(_("\nSome subcommands can make use of the -c cpulist option.\n"));
-        printf(_("Look at the general cpupower manpage how to use it\n"));
-        printf(_("and read up the subcommand's manpage whether it is supported.\n"));
-        printf(_("\nUse cpupower help subcommand for getting help for above subcommands.\n"));
+        printf(_("\nNot all commands can make use of the -c cpulist option.\n"));
+        printf(_("\nUse 'cpupower help <command>' for getting help for above commands.\n"));
+}
+
+static int print_man_page(const char *subpage)
+{
+        int len;
+        char *page;
+
+        len = 10; /* enough for "cpupower-" */
+        if (subpage != NULL)
+                len += strlen(subpage);
+
+        page = malloc(len);
+        if (!page)
+                return -ENOMEM;
+
+        sprintf(page, "cpupower");
+        if ((subpage != NULL) && strcmp(subpage, "help")) {
+                strcat(page, "-");
+                strcat(page, subpage);
+        }
+
+        execlp("man", "man", page, NULL);
+
+        /* should not be reached */
+        return -EINVAL;
+}
+
+static int cmd_help(int argc, const char **argv)
+{
+        if (argc > 1) {
+                print_man_page(argv[1]); /* exits within execlp() */
+                return EXIT_FAILURE;
+        }
+
+        print_help();
+        return EXIT_SUCCESS;
 }
 
 static void print_version(void)
diff --git a/tools/power/cpupower/utils/helpers/helpers.h b/tools/power/cpupower/utils/helpers/helpers.h
index 592ee362b877..2747e738efb0 100644
--- a/tools/power/cpupower/utils/helpers/helpers.h
+++ b/tools/power/cpupower/utils/helpers/helpers.h
@@ -16,11 +16,20 @@
 #include "helpers/bitmask.h"
 
 /* Internationalization ****************************/
+#ifdef NLS
+
 #define _(String) gettext(String)
 #ifndef gettext_noop
 #define gettext_noop(String) String
 #endif
 #define N_(String) gettext_noop(String)
+
+#else /* !NLS */
+
+#define _(String) String
+#define N_(String) String
+
+#endif
 /* Internationalization ****************************/
 
 extern int run_as_root;
@@ -96,6 +105,9 @@ struct cpupower_topology {
                 int pkg;
                 int core;
                 int cpu;
+
+                /* flags */
+                unsigned int is_online:1;
         } *core_info;
 };
 
diff --git a/tools/power/cpupower/utils/helpers/sysfs.c b/tools/power/cpupower/utils/helpers/sysfs.c
index 55e2466674c6..c6343024a611 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.c
+++ b/tools/power/cpupower/utils/helpers/sysfs.c
@@ -56,6 +56,56 @@ static unsigned int sysfs_write_file(const char *path,
         return (unsigned int) numwrite;
 }
 
+/*
+ * Detect whether a CPU is online
+ *
+ * Returns:
+ *     1 -> if CPU is online
+ *     0 -> if CPU is offline
+ *     negative errno values in error case
+ */
+int sysfs_is_cpu_online(unsigned int cpu)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numread;
+        unsigned long long value;
+        char linebuf[MAX_LINE_LEN];
+        char *endp;
+        struct stat statbuf;
+
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u", cpu);
+
+        if (stat(path, &statbuf) != 0)
+                return 0;
+
+        /*
+         * kernel without CONFIG_HOTPLUG_CPU
+         * -> cpuX directory exists, but not cpuX/online file
+         */
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/online", cpu);
+        if (stat(path, &statbuf) != 0)
+                return 1;
+
+        fd = open(path, O_RDONLY);
+        if (fd == -1)
+                return -errno;
+
+        numread = read(fd, linebuf, MAX_LINE_LEN - 1);
+        if (numread < 1) {
+                close(fd);
+                return -EIO;
+        }
+        linebuf[numread] = '\0';
+        close(fd);
+
+        value = strtoull(linebuf, &endp, 0);
+        if (value > 1 || value < 0)
+                return -EINVAL;
+
+        return value;
+}
+
 /* CPUidle idlestate specific /sys/devices/system/cpu/cpuX/cpuidle/ access */
 
 /*
diff --git a/tools/power/cpupower/utils/helpers/sysfs.h b/tools/power/cpupower/utils/helpers/sysfs.h
index f9373e090637..8cb797bbceb0 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.h
+++ b/tools/power/cpupower/utils/helpers/sysfs.h
@@ -7,6 +7,8 @@
 
 extern unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen);
 
+extern int sysfs_is_cpu_online(unsigned int cpu);
+
 extern unsigned long sysfs_get_idlestate_latency(unsigned int cpu,
                                                 unsigned int idlestate);
 extern unsigned long sysfs_get_idlestate_usage(unsigned int cpu,
diff --git a/tools/power/cpupower/utils/helpers/topology.c b/tools/power/cpupower/utils/helpers/topology.c
index 385ee5c7570c..4eae2c47ba48 100644
--- a/tools/power/cpupower/utils/helpers/topology.c
+++ b/tools/power/cpupower/utils/helpers/topology.c
@@ -41,6 +41,8 @@ struct cpuid_core_info {
         unsigned int pkg;
         unsigned int thread;
         unsigned int cpu;
+        /* flags */
+        unsigned int is_online:1;
 };
 
 static int __compare(const void *t1, const void *t2)
@@ -78,6 +80,8 @@ int get_cpu_topology(struct cpupower_topology *cpu_top)
                 return -ENOMEM;
         cpu_top->pkgs = cpu_top->cores = 0;
         for (cpu = 0; cpu < cpus; cpu++) {
+                cpu_top->core_info[cpu].cpu = cpu;
+                cpu_top->core_info[cpu].is_online = sysfs_is_cpu_online(cpu);
                 cpu_top->core_info[cpu].pkg =
                         sysfs_topology_read_file(cpu, "physical_package_id");
                 if ((int)cpu_top->core_info[cpu].pkg != -1 &&
@@ -85,7 +89,6 @@ int get_cpu_topology(struct cpupower_topology *cpu_top)
                         cpu_top->pkgs = cpu_top->core_info[cpu].pkg;
                 cpu_top->core_info[cpu].core =
                         sysfs_topology_read_file(cpu, "core_id");
-                cpu_top->core_info[cpu].cpu = cpu;
         }
         cpu_top->pkgs++;
 
diff --git a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
index d048b96a6155..bcd22a1a3970 100644
--- a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
+++ b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
@@ -134,7 +134,7 @@ static struct cpuidle_monitor *cpuidle_register(void)
         /* Assume idle state count is the same for all CPUs */
         cpuidle_sysfs_monitor.hw_states_num = sysfs_get_idlestate_count(0);
 
-        if (cpuidle_sysfs_monitor.hw_states_num == 0)
+        if (cpuidle_sysfs_monitor.hw_states_num <= 0)
                 return NULL;
 
         for (num = 0; num < cpuidle_sysfs_monitor.hw_states_num; num++) {
diff --git a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c
index ba4bf068380d..0d6571e418db 100644
--- a/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c
+++ b/tools/power/cpupower/utils/idle_monitor/cpupower-monitor.c
@@ -43,6 +43,12 @@ static struct cpupower_topology cpu_top;
 /* ToDo: Document this in the manpage */
 static char range_abbr[RANGE_MAX] = { 'T', 'C', 'P', 'M', };
 
+static void print_wrong_arg_exit(void)
+{
+        printf(_("invalid or unknown argument\n"));
+        exit(EXIT_FAILURE);
+}
+
 long long timespec_diff_us(struct timespec start, struct timespec end)
 {
         struct timespec temp;
@@ -56,21 +62,6 @@ long long timespec_diff_us(struct timespec start, struct timespec end)
         return (temp.tv_sec * 1000000) + (temp.tv_nsec / 1000);
 }
 
-void monitor_help(void)
-{
-        printf(_("cpupower monitor: [-m <mon1>,[<mon2>],.. ] command\n"));
-        printf(_("cpupower monitor: [-m <mon1>,[<mon2>],.. ] [ -i interval_sec ]\n"));
-        printf(_("cpupower monitor: -l\n"));
-        printf(_("\t command: pass an arbitrary command to measure specific workload\n"));
-        printf(_("\t -i: time intervall to measure for in seconds (default 1)\n"));
-        printf(_("\t -l: list available CPU sleep monitors (for use with -m)\n"));
-        printf(_("\t -m: show specific CPU sleep monitors only (in same order)\n"));
-        printf(_("\t -h: print this help\n"));
-        printf("\n");
-        printf(_("only one of: -l, -m are allowed\nIf none of them is passed,"));
-        printf(_(" all supported monitors are shown\n"));
-}
-
 void print_n_spaces(int n)
 {
         int x;
@@ -149,6 +140,10 @@ void print_results(int topology_depth, int cpu)
         unsigned long long result;
         cstate_t s;
 
+        /* Be careful CPUs may got resorted for pkg value do not just use cpu */
+        if (!bitmask_isbitset(cpus_chosen, cpu_top.core_info[cpu].cpu))
+                return;
+
         if (topology_depth > 2)
                 printf("%4d|", cpu_top.core_info[cpu].pkg);
         if (topology_depth > 1)
@@ -190,9 +185,13 @@ void print_results(int topology_depth, int cpu)
                         }
                 }
         }
-        /* cpu offline */
-        if (cpu_top.core_info[cpu].pkg == -1 ||
-            cpu_top.core_info[cpu].core == -1) {
+        /*
+         * The monitor could still provide useful data, for example
+         * AMD HW counters partly sit in PCI config space.
+         * It's up to the monitor plug-in to check .is_online, this one
+         * is just for additional info.
+         */
+        if (!cpu_top.core_info[cpu].is_online) {
                 printf(_(" *is offline\n"));
                 return;
         } else
@@ -238,7 +237,6 @@ static void parse_monitor_param(char *param)
         if (hits == 0) {
                 printf(_("No matching monitor found in %s, "
                          "try -l option\n"), param);
-                monitor_help();
                 exit(EXIT_FAILURE);
         }
         /* Override detected/registerd monitors array with requested one */
@@ -335,37 +333,27 @@ static void cmdline(int argc, char *argv[])
         int opt;
         progname = basename(argv[0]);
 
-        while ((opt = getopt(argc, argv, "+hli:m:")) != -1) {
+        while ((opt = getopt(argc, argv, "+li:m:")) != -1) {
                 switch (opt) {
-                case 'h':
-                        monitor_help();
-                        exit(EXIT_SUCCESS);
                 case 'l':
-                        if (mode) {
-                                monitor_help();
-                                exit(EXIT_FAILURE);
-                        }
+                        if (mode)
+                                print_wrong_arg_exit();
                         mode = list;
                         break;
                 case 'i':
                         /* only allow -i with -m or no option */
-                        if (mode && mode != show) {
-                                monitor_help();
-                                exit(EXIT_FAILURE);
-                        }
+                        if (mode && mode != show)
+                                print_wrong_arg_exit();
                         interval = atoi(optarg);
                         break;
                 case 'm':
-                        if (mode) {
-                                monitor_help();
-                                exit(EXIT_FAILURE);
-                        }
+                        if (mode)
+                                print_wrong_arg_exit();
                         mode = show;
                         show_monitors_param = optarg;
                         break;
                 default:
-                        monitor_help();
-                        exit(EXIT_FAILURE);
+                        print_wrong_arg_exit();
                 }
         }
         if (!mode)
@@ -385,6 +373,10 @@ int cmd_monitor(int argc, char **argv)
                 return EXIT_FAILURE;
         }
 
+        /* Default is: monitor all CPUs */
+        if (bitmask_isallclear(cpus_chosen))
+                bitmask_setall(cpus_chosen);
+
         dprint("System has up to %d CPU cores\n", cpu_count);
 
         for (num = 0; all_monitors[num]; num++) {
diff --git a/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c b/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
index 63ca87a05e5f..5650ab5a2c20 100644
--- a/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
+++ b/tools/power/cpupower/utils/idle_monitor/mperf_monitor.c
@@ -22,12 +22,15 @@
 
 #define MSR_TSC 0x10
 
+#define MSR_AMD_HWCR 0xc0010015
+
 enum mperf_id { C0 = 0, Cx, AVG_FREQ, MPERF_CSTATE_COUNT };
 
 static int mperf_get_count_percent(unsigned int self_id, double *percent,
                                    unsigned int cpu);
 static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
                                 unsigned int cpu);
+static struct timespec time_start, time_end;
 
 static cstate_t mperf_cstates[MPERF_CSTATE_COUNT] = {
         {
@@ -54,19 +57,33 @@ static cstate_t mperf_cstates[MPERF_CSTATE_COUNT] = {
         },
 };
 
+enum MAX_FREQ_MODE { MAX_FREQ_SYSFS, MAX_FREQ_TSC_REF };
+static int max_freq_mode;
+/*
+ * The max frequency mperf is ticking at (in C0), either retrieved via:
+ *   1) calculated after measurements if we know TSC ticks at mperf/P0 frequency
+ *   2) cpufreq /sys/devices/.../cpu0/cpufreq/cpuinfo_max_freq at init time
+ * 1. Is preferred as it also works without cpufreq subsystem (e.g. on Xen)
+ */
+static unsigned long max_frequency;
+
 static unsigned long long tsc_at_measure_start;
 static unsigned long long tsc_at_measure_end;
-static unsigned long max_frequency;
 static unsigned long long *mperf_previous_count;
 static unsigned long long *aperf_previous_count;
 static unsigned long long *mperf_current_count;
 static unsigned long long *aperf_current_count;
+
 /* valid flag for all CPUs. If a MSR read failed it will be zero */
 static int *is_valid;
 
 static int mperf_get_tsc(unsigned long long *tsc)
 {
-        return read_msr(0, MSR_TSC, tsc);
+        int ret;
+        ret = read_msr(0, MSR_TSC, tsc);
+        if (ret)
+                dprint("Reading TSC MSR failed, returning %llu\n", *tsc);
+        return ret;
 }
 
 static int mperf_init_stats(unsigned int cpu)
@@ -97,36 +114,11 @@ static int mperf_measure_stats(unsigned int cpu)
         return 0;
 }
 
-/*
- * get_average_perf()
- *
- * Returns the average performance (also considers boosted frequencies)
- *
- * Input:
- *   aperf_diff: Difference of the aperf register over a time period
- *   mperf_diff: Difference of the mperf register over the same time period
- *   max_freq:   Maximum frequency (P0)
- *
- * Returns:
- *   Average performance over the time period
- */
-static unsigned long get_average_perf(unsigned long long aperf_diff,
-                                      unsigned long long mperf_diff)
-{
-        unsigned int perf_percent = 0;
-        if (((unsigned long)(-1) / 100) < aperf_diff) {
-                int shift_count = 7;
-                aperf_diff >>= shift_count;
-                mperf_diff >>= shift_count;
-        }
-        perf_percent = (aperf_diff * 100) / mperf_diff;
-        return (max_frequency * perf_percent) / 100;
-}
-
 static int mperf_get_count_percent(unsigned int id, double *percent,
                                    unsigned int cpu)
 {
         unsigned long long aperf_diff, mperf_diff, tsc_diff;
+        unsigned long long timediff;
 
         if (!is_valid[cpu])
                 return -1;
@@ -136,11 +128,19 @@ static int mperf_get_count_percent(unsigned int id, double *percent,
 
         mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
         aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
-        tsc_diff = tsc_at_measure_end - tsc_at_measure_start;
 
-        *percent = 100.0 * mperf_diff / tsc_diff;
-        dprint("%s: mperf_diff: %llu, tsc_diff: %llu\n",
-               mperf_cstates[id].name, mperf_diff, tsc_diff);
+        if (max_freq_mode == MAX_FREQ_TSC_REF) {
+                tsc_diff = tsc_at_measure_end - tsc_at_measure_start;
+                *percent = 100.0 * mperf_diff / tsc_diff;
+                dprint("%s: TSC Ref - mperf_diff: %llu, tsc_diff: %llu\n",
+                       mperf_cstates[id].name, mperf_diff, tsc_diff);
+        } else if (max_freq_mode == MAX_FREQ_SYSFS) {
+                timediff = timespec_diff_us(time_start, time_end);
+                *percent = 100.0 * mperf_diff / timediff;
+                dprint("%s: MAXFREQ - mperf_diff: %llu, time_diff: %llu\n",
+                       mperf_cstates[id].name, mperf_diff, timediff);
+        } else
+                return -1;
 
         if (id == Cx)
                 *percent = 100.0 - *percent;
@@ -154,7 +154,7 @@ static int mperf_get_count_percent(unsigned int id, double *percent,
 static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
                                 unsigned int cpu)
 {
-        unsigned long long aperf_diff, mperf_diff;
+        unsigned long long aperf_diff, mperf_diff, time_diff, tsc_diff;
 
         if (id != AVG_FREQ)
                 return 1;
@@ -165,11 +165,21 @@ static int mperf_get_count_freq(unsigned int id, unsigned long long *count,
         mperf_diff = mperf_current_count[cpu] - mperf_previous_count[cpu];
         aperf_diff = aperf_current_count[cpu] - aperf_previous_count[cpu];
 
-        /* Return MHz for now, might want to return KHz if column width is more
-           generic */
-        *count = get_average_perf(aperf_diff, mperf_diff) / 1000;
-        dprint("%s: %llu\n", mperf_cstates[id].name, *count);
+        if (max_freq_mode == MAX_FREQ_TSC_REF) {
+                /* Calculate max_freq from TSC count */
+                tsc_diff = tsc_at_measure_end - tsc_at_measure_start;
+                time_diff = timespec_diff_us(time_start, time_end);
+                max_frequency = tsc_diff / time_diff;
+        }
 
+        *count = max_frequency * ((double)aperf_diff / mperf_diff);
+        dprint("%s: Average freq based on %s maximum frequency:\n",
+               mperf_cstates[id].name,
+               (max_freq_mode == MAX_FREQ_TSC_REF) ? "TSC calculated" : "sysfs read");
+        dprint("%max_frequency: %lu", max_frequency);
+        dprint("aperf_diff: %llu\n", aperf_diff);
+        dprint("mperf_diff: %llu\n", mperf_diff);
+        dprint("avg freq:   %llu\n", *count);
         return 0;
 }
 
@@ -178,6 +188,7 @@ static int mperf_start(void)
         int cpu;
         unsigned long long dbg;
 
+        clock_gettime(CLOCK_REALTIME, &time_start);
         mperf_get_tsc(&tsc_at_measure_start);
 
         for (cpu = 0; cpu < cpu_count; cpu++)
@@ -193,32 +204,104 @@ static int mperf_stop(void)
         unsigned long long dbg;
         int cpu;
 
-        mperf_get_tsc(&tsc_at_measure_end);
-
         for (cpu = 0; cpu < cpu_count; cpu++)
                 mperf_measure_stats(cpu);
 
+        mperf_get_tsc(&tsc_at_measure_end);
+        clock_gettime(CLOCK_REALTIME, &time_end);
+
         mperf_get_tsc(&dbg);
         dprint("TSC diff: %llu\n", dbg - tsc_at_measure_end);
 
         return 0;
 }
 
-struct cpuidle_monitor mperf_monitor;
-
-struct cpuidle_monitor *mperf_register(void)
+/*
+ * Mperf register is defined to tick at P0 (maximum) frequency
+ *
+ * Instead of reading out P0 which can be tricky to read out from HW,
+ * we use TSC counter if it reliably ticks at P0/mperf frequency.
+ *
+ * Still try to fall back to:
+ * /sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq
+ * on older Intel HW without invariant TSC feature.
+ * Or on AMD machines where TSC does not tick at P0 (do not exist yet, but
+ * it's still double checked (MSR_AMD_HWCR)).
+ *
+ * On these machines the user would still get useful mperf
+ * stats when acpi-cpufreq driver is loaded.
+ */
+static int init_maxfreq_mode(void)
 {
+        int ret;
+        unsigned long long hwcr;
         unsigned long min;
 
-        if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
-                return NULL;
-
-        /* Assume min/max all the same on all cores */
+        if (!cpupower_cpu_info.caps & CPUPOWER_CAP_INV_TSC)
+                goto use_sysfs;
+
+        if (cpupower_cpu_info.vendor == X86_VENDOR_AMD) {
+                /* MSR_AMD_HWCR tells us whether TSC runs at P0/mperf
+                 * freq.
+                 * A test whether hwcr is accessable/available would be:
+                 * (cpupower_cpu_info.family > 0x10 ||
+                 *   cpupower_cpu_info.family == 0x10 &&
+                 *   cpupower_cpu_info.model >= 0x2))
+                 * This should be the case for all aperf/mperf
+                 * capable AMD machines and is therefore safe to test here.
+                 * Compare with Linus kernel git commit: acf01734b1747b1ec4
+                 */
+                ret = read_msr(0, MSR_AMD_HWCR, &hwcr);
+                /*
+                 * If the MSR read failed, assume a Xen system that did
+                 * not explicitly provide access to it and assume TSC works
+                */
+                if (ret != 0) {
+                        dprint("TSC read 0x%x failed - assume TSC working\n",
+                               MSR_AMD_HWCR);
+                        return 0;
+                } else if (1 & (hwcr >> 24)) {
+                        max_freq_mode = MAX_FREQ_TSC_REF;
+                        return 0;
+                } else { /* Use sysfs max frequency if available */ }
+        } else if (cpupower_cpu_info.vendor == X86_VENDOR_INTEL) {
+                /*
+                 * On Intel we assume mperf (in C0) is ticking at same
+                 * rate than TSC
+                 */
+                max_freq_mode = MAX_FREQ_TSC_REF;
+                return 0;
+        }
+use_sysfs:
         if (cpufreq_get_hardware_limits(0, &min, &max_frequency)) {
                 dprint("Cannot retrieve max freq from cpufreq kernel "
                        "subsystem\n");
-                return NULL;
+                return -1;
         }
+        max_freq_mode = MAX_FREQ_SYSFS;
+        return 0;
+}
+
+/*
+ * This monitor provides:
+ *
+ * 1) Average frequency a CPU resided in
+ *    This always works if the CPU has aperf/mperf capabilities
+ *
+ * 2) C0 and Cx (any sleep state) time a CPU resided in
+ *    Works if mperf timer stops ticking in sleep states which
+ *    seem to be the case on all current HW.
+ * Both is directly retrieved from HW registers and is independent
+ * from kernel statistics.
+ */
+struct cpuidle_monitor mperf_monitor;
+struct cpuidle_monitor *mperf_register(void)
+{
+        if (!(cpupower_cpu_info.caps & CPUPOWER_CAP_APERF))
+                return NULL;
+
+        if (init_maxfreq_mode())
+                return NULL;
 
         /* Free this at program termination */
         is_valid = calloc(cpu_count, sizeof(int));
diff --git a/tools/slub/slabinfo.c b/tools/slub/slabinfo.c
index 868cc93f7ac2..164cbcf61106 100644
--- a/tools/slub/slabinfo.c
+++ b/tools/slub/slabinfo.c
@@ -42,6 +42,7 @@ struct slabinfo {
         unsigned long deactivate_remote_frees, order_fallback;
         unsigned long cmpxchg_double_cpu_fail, cmpxchg_double_fail;
         unsigned long alloc_node_mismatch, deactivate_bypass;
+        unsigned long cpu_partial_alloc, cpu_partial_free;
         int numa[MAX_NODES];
         int numa_partial[MAX_NODES];
 } slabinfo[MAX_SLABS];
@@ -455,6 +456,11 @@ static void slab_stats(struct slabinfo *s)
                 s->alloc_from_partial * 100 / total_alloc,
                 s->free_remove_partial * 100 / total_free);
 
+        printf("Cpu partial list     %8lu %8lu %3lu %3lu\n",
+                s->cpu_partial_alloc, s->cpu_partial_free,
+                s->cpu_partial_alloc * 100 / total_alloc,
+                s->cpu_partial_free * 100 / total_free);
+
         printf("RemoteObj/SlabFrozen %8lu %8lu %3lu %3lu\n",
                 s->deactivate_remote_frees, s->free_frozen,
                 s->deactivate_remote_frees * 100 / total_alloc,
@@ -1145,7 +1151,7 @@ static void read_slab_dir(void)
                 switch (de->d_type) {
                    case DT_LNK:
                         alias->name = strdup(de->d_name);
-                        count = readlink(de->d_name, buffer, sizeof(buffer));
+                        count = readlink(de->d_name, buffer, sizeof(buffer)-1);
 
                         if (count < 0)
                                 fatal("Cannot read symlink %s\n", de->d_name);
@@ -1209,6 +1215,8 @@ static void read_slab_dir(void)
                         slab->order_fallback = get_obj("order_fallback");
                         slab->cmpxchg_double_cpu_fail = get_obj("cmpxchg_double_cpu_fail");
                         slab->cmpxchg_double_fail = get_obj("cmpxchg_double_fail");
+                        slab->cpu_partial_alloc = get_obj("cpu_partial_alloc");
+                        slab->cpu_partial_free = get_obj("cpu_partial_free");
                         slab->alloc_node_mismatch = get_obj("alloc_node_mismatch");
                         slab->deactivate_bypass = get_obj("deactivate_bypass");
                         chdir("..");