Merge branch 'next' into for-linus

81 files changed, 5302 insertions, 1599 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 3b8f7b80376b..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)
@@ -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
@@ -722,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 $<
 
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-record.c b/tools/perf/builtin-record.c
index 6b0519f885e4..6ab58cc99d53 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -73,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)
 {
@@ -137,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;
@@ -161,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 |
@@ -248,13 +262,16 @@ static bool perf_evlist__equal(struct perf_evlist *evlist,
 
 static void open_counters(struct perf_evlist *evlist)
 {
-        struct perf_evsel *pos;
+        struct perf_evsel *pos, *first;
 
         if (evlist->cpus->map[0] < 0)
                 no_inherit = true;
 
+        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+
         list_for_each_entry(pos, &evlist->entries, node) {
                 struct perf_event_attr *attr = &pos->attr;
+                struct xyarray *group_fd = NULL;
                 /*
                  * Check if parse_single_tracepoint_event has already asked for
                  * PERF_SAMPLE_TIME.
@@ -269,15 +286,19 @@ static void open_counters(struct perf_evlist *evlist)
                  */
                 bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
 
+                if (group && pos != first)
+                        group_fd = first->fd;
+
                 config_attr(pos, evlist);
 retry_sample_id:
                 attr->sample_id_all = sample_id_all_avail ? 1 : 0;
 try_again:
-                if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group) < 0) {
+                if (perf_evsel__open(pos, evlist->cpus, evlist->threads, group,
+                                     group_fd) < 0) {
                         int err = errno;
 
                         if (err == EPERM || err == EACCES) {
-                                ui__warning_paranoid();
+                                ui__error_paranoid();
                                 exit(EXIT_FAILURE);
                         } else if (err ==  ENODEV && cpu_list) {
                                 die("No such device - did you specify"
@@ -445,6 +466,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);
@@ -513,6 +536,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;
@@ -671,6 +707,8 @@ static int __cmd_record(int argc, const char **argv)
                 }
         }
 
+        perf_evlist__enable(evsel_list);
+
         /*
          * Let the child rip
          */
@@ -782,6 +820,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 d7ff277bdb78..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;
@@ -229,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");
         }
 
@@ -276,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);
 
@@ -330,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:
@@ -487,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-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 5deb17d9e795..7d98676808d8 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -194,6 +194,9 @@ 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;
 
@@ -251,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);
 }
@@ -270,9 +278,14 @@ struct stats			runtime_itlb_cache_stats[MAX_NR_CPUS];
 struct stats                    runtime_dtlb_cache_stats[MAX_NR_CPUS];
 struct stats                    walltime_nsecs_stats;
 
-static int create_perf_stat_counter(struct perf_evsel *evsel)
+static int create_perf_stat_counter(struct perf_evsel *evsel,
+                                    struct perf_evsel *first)
 {
         struct perf_event_attr *attr = &evsel->attr;
+        struct xyarray *group_fd = NULL;
+
+        if (group && evsel != first)
+                group_fd = first->fd;
 
         if (scale)
                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
@@ -281,14 +294,15 @@ 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, group);
-
+                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
+                                                group, group_fd);
         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, group);
+        return perf_evsel__open_per_thread(evsel, evsel_list->threads,
+                                           group, group_fd);
 }
 
 /*
@@ -352,7 +366,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]);
         }
 
@@ -388,7 +402,7 @@ static int read_counter(struct perf_evsel *counter)
 static int run_perf_stat(int argc __used, const char **argv)
 {
         unsigned long long t0, t1;
-        struct perf_evsel *counter;
+        struct perf_evsel *counter, *first;
         int status = 0;
         int child_ready_pipe[2], go_pipe[2];
         const bool forks = (argc > 0);
@@ -445,8 +459,10 @@ static int run_perf_stat(int argc __used, const char **argv)
                 close(child_ready_pipe[0]);
         }
 
+        first = list_entry(evsel_list->entries.next, struct perf_evsel, node);
+
         list_for_each_entry(counter, &evsel_list->entries, node) {
-                if (create_perf_stat_counter(counter) < 0) {
+                if (create_perf_stat_counter(counter, first) < 0) {
                         if (errno == EINVAL || errno == ENOSYS || errno == ENOENT) {
                                 if (verbose)
                                         ui__warning("%s event is not supported by the kernel.\n",
@@ -487,6 +503,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);
         }
@@ -519,9 +537,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)
@@ -546,16 +564,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)
@@ -576,9 +595,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)
@@ -599,9 +618,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)
@@ -622,9 +641,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)
@@ -645,9 +664,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)
@@ -668,9 +687,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)
@@ -691,9 +710,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)
@@ -714,9 +733,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)
@@ -737,9 +756,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)
@@ -762,10 +781,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;
@@ -776,14 +795,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) &&
@@ -831,7 +850,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);
@@ -843,16 +862,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, "                                   ");
         }
 }
 
@@ -867,7 +886,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,
@@ -875,9 +894,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;
         }
 
@@ -889,7 +908,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
         print_noise(counter, avg);
 
         if (csv_output) {
-                fputc('\n', stderr);
+                fputc('\n', output);
                 return;
         }
 
@@ -899,9 +918,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");
 }
 
 /*
@@ -918,7 +937,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,
@@ -928,9 +947,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;
                 }
 
@@ -943,9 +963,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);
         }
 }
 
@@ -957,21 +978,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) {
@@ -984,15 +1005,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");
         }
 }
 
@@ -1030,6 +1051,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",
@@ -1070,6 +1093,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()
 };
 
@@ -1141,6 +1169,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, "");
 
@@ -1151,16 +1180,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);
@@ -1226,7 +1285,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..831d1baeac37 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -291,7 +291,7 @@ static int test__open_syscall_event(void)
                 goto out_thread_map_delete;
         }
 
-        if (perf_evsel__open_per_thread(evsel, threads, false) < 0) {
+        if (perf_evsel__open_per_thread(evsel, threads, false, NULL) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
                          strerror(errno));
@@ -366,7 +366,7 @@ static int test__open_syscall_event_on_all_cpus(void)
                 goto out_thread_map_delete;
         }
 
-        if (perf_evsel__open(evsel, cpus, threads, false) < 0) {
+        if (perf_evsel__open(evsel, cpus, threads, false, NULL) < 0) {
                 pr_debug("failed to open counter: %s, "
                          "tweak /proc/sys/kernel/perf_event_paranoid?\n",
                          strerror(errno));
@@ -531,7 +531,7 @@ static int test__basic_mmap(void)
 
                 perf_evlist__add(evlist, evsels[i]);
 
-                if (perf_evsel__open(evsels[i], cpus, threads, false) < 0) {
+                if (perf_evsel__open(evsels[i], cpus, threads, false, NULL) < 0) {
                         pr_debug("failed to open counter: %s, "
                                  "tweak /proc/sys/kernel/perf_event_paranoid?\n",
                                  strerror(errno));
@@ -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..c9cdedb58134 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,7 @@ static bool			vmlinux_warned;
 static bool                     inherit                         =  false;
 static int                      realtime_prio                   =      0;
 static bool                     group                           =  false;
-static unsigned int             page_size;
+static bool                     sample_id_all_avail             =   true;
 static unsigned int             mmap_pages                      =    128;
 
 static bool                     dump_symtab                     =  false;
@@ -93,7 +97,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 +139,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 +178,63 @@ 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 ||
+            ((top.sym_filter_entry == NULL ||
+              top.sym_filter_entry->ms.sym != he->ms.sym) && 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 +245,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 +259,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 +291,14 @@ 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) {
-                color_fprintf(stdout, PERF_COLOR_RED, "WARNING:");
-                printf(" LOST %" PRIu64 " events, Check IO/CPU overload\n",
-                       session->hists.stats.total_lost);
+        if (top.sym_evsel->hists.stats.nr_lost_warned !=
+            top.sym_evsel->hists.stats.nr_events[PERF_RECORD_LOST]) {
+                top.sym_evsel->hists.stats.nr_lost_warned =
+                        top.sym_evsel->hists.stats.nr_events[PERF_RECORD_LOST];
+                color_fprintf(stdout, PERF_COLOR_RED,
+                              "WARNING: LOST %d chunks, Check IO/CPU overload",
+                              top.sym_evsel->hists.stats.nr_lost_warned);
+                ++printed;
         }
 
         if (top.sym_filter_entry) {
@@ -281,58 +306,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 +352,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 +373,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 +399,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 +416,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 +442,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 +450,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 +526,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 +535,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 +544,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 +552,30 @@ 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);
+}
+
 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 +586,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 +593,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 +642,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 +663,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;
@@ -687,13 +674,15 @@ static int symbol_filter(struct map *map, struct symbol *sym)
 }
 
 static void perf_event__process_sample(const union perf_event *event,
+                                       struct perf_evsel *evsel,
                                        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,51 +771,43 @@ 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);
+        if (al.sym == NULL || !al.sym->ignore) {
+                struct hist_entry *he;
+
+                if ((sort__has_parent || symbol_conf.use_callchain) &&
+                    sample->callchain) {
+                        err = perf_session__resolve_callchain(session, al.thread,
+                                                              sample->callchain, &parent);
+                        if (err)
+                                return;
                 }
-        }
 
-        syme = symbol__priv(al.sym);
-        if (!al.sym->ignore) {
-                struct perf_evsel *evsel;
+                he = perf_session__add_hist_entry(session, &al, sample, evsel);
+                if (he == NULL) {
+                        pr_err("Problem incrementing symbol period, skipping event\n");
+                        return;
+                }
 
-                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 (symbol_conf.use_callchain) {
+                        err = callchain_append(he->callchain, &session->callchain_cursor,
+                                               sample->period);
+                        if (err)
+                                return;
                 }
-                pthread_mutex_unlock(&top.active_symbols_lock);
+
+                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)
 {
         struct perf_sample sample;
+        struct perf_evsel *evsel;
         union perf_event *event;
         int ret;
 
@@ -837,10 +818,16 @@ static void perf_session__mmap_read_idx(struct perf_session *self, int idx)
                         continue;
                 }
 
+                evsel = perf_evlist__id2evsel(self->evlist, sample.id);
+                assert(evsel != NULL);
+
                 if (event->header.type == PERF_RECORD_SAMPLE)
-                        perf_event__process_sample(event, &sample, self);
-                else
+                        perf_event__process_sample(event, evsel, &sample, self);
+                else if (event->header.type < PERF_RECORD_MAX) {
+                        hists__inc_nr_events(&evsel->hists, event->header.type);
                         perf_event__process(event, &sample, self);
+                } else
+                        ++self->hists.stats.nr_unknown_events;
         }
 }
 
@@ -854,10 +841,16 @@ static void perf_session__mmap_read(struct perf_session *self)
 
 static void start_counters(struct perf_evlist *evlist)
 {
-        struct perf_evsel *counter;
+        struct perf_evsel *counter, *first;
+
+        first = list_entry(evlist->entries.next, struct perf_evsel, node);
 
         list_for_each_entry(counter, &evlist->entries, node) {
                 struct perf_event_attr *attr = &counter->attr;
+                struct xyarray *group_fd = NULL;
+
+                if (group && counter != first)
+                        group_fd = first->fd;
 
                 attr->sample_type = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 
@@ -872,16 +865,29 @@ 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;
+retry_sample_id:
+                attr->sample_id_all = sample_id_all_avail ? 1 : 0;
 try_again:
                 if (perf_evsel__open(counter, top.evlist->cpus,
-                                     top.evlist->threads, group) < 0) {
+                                     top.evlist->threads, group,
+                                     group_fd) < 0) {
                         int err = errno;
 
                         if (err == EPERM || err == EACCES) {
-                                ui__warning_paranoid();
+                                ui__error_paranoid();
                                 goto out_err;
+                        } else if (err == EINVAL && sample_id_all_avail) {
+                                /*
+                                 * Old kernel, no attr->sample_id_type_all field
+                                 */
+                                sample_id_all_avail = false;
+                                goto retry_sample_id;
                         }
                         /*
                          * If it's cycles then fall back to hrtimer
@@ -927,35 +933,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 +1000,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 +1129,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 +1143,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 +1177,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 +1249,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..119e996035c8 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);
@@ -308,9 +310,12 @@ fallback:
                 }
                 err = -ENOENT;
                 dso->annotate_warned = 1;
-                pr_err("Can't annotate %s: No vmlinux file%s was found in the "
-                       "path.\nPlease use 'perf buildid-cache -av vmlinux' or "
-                       "--vmlinux vmlinux.\n",
+                pr_err("Can't annotate %s:\n\n"
+                       "No vmlinux file%s\nwas found in the path.\n\n"
+                       "Please use:\n\n"
+                       "  perf buildid-cache -av vmlinux\n\n"
+                       "or:\n\n"
+                       "  --vmlinux vmlinux",
                        sym->name, build_id_msg ?: "");
                 goto out_free_filename;
         }
@@ -323,10 +328,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 fe02903f7d0f..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;
 }
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 155749d74350..26817daa2961 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -47,19 +47,20 @@ int dump_printf(const char *fmt, ...)
 }
 
 #ifdef NO_NEWT_SUPPORT
-void ui__warning(const char *format, ...)
+int ui__warning(const char *format, ...)
 {
         va_list args;
 
         va_start(args, format);
         vfprintf(stderr, format, args);
         va_end(args);
+        return 0;
 }
 #endif
 
-void ui__warning_paranoid(void)
+int ui__error_paranoid(void)
 {
-        ui__warning("Permission error - are you root?\n"
+        return ui__error("Permission error - are you root?\n"
                     "Consider tweaking /proc/sys/kernel/perf_event_paranoid:\n"
                     " -1 - Not paranoid at all\n"
                     "  0 - Disallow raw tracepoint access for unpriv\n"
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index fd53db47e3de..f2ce88d04f54 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -19,23 +19,18 @@ static inline int ui_helpline__show_help(const char *format __used, va_list ap _
         return 0;
 }
 
-static inline struct ui_progress *ui_progress__new(const char *title __used,
-                                                   u64 total __used)
-{
-        return (struct ui_progress *)1;
-}
-
-static inline void ui_progress__update(struct ui_progress *self __used,
-                                       u64 curr __used) {}
+static inline void ui_progress__update(u64 curr __used, u64 total __used,
+                                       const char *title __used) {}
 
-static inline void ui_progress__delete(struct ui_progress *self __used) {}
+#define ui__error(format, arg...) ui__warning(format, ##arg)
 #else
 extern char ui_helpline__last_msg[];
 int ui_helpline__show_help(const char *format, va_list ap);
 #include "ui/progress.h"
+int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
 #endif
 
-void ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
-void ui__warning_paranoid(void);
+int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
+int ui__error_paranoid(void);
 
 #endif  /* __PERF_DEBUG_H */
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 c12bd476c6f7..fbb4b4ab9cc6 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -113,6 +113,19 @@ void perf_evlist__disable(struct perf_evlist *evlist)
         }
 }
 
+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)
 {
         int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
@@ -520,3 +533,39 @@ 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;
+}
+
+int perf_evlist__open(struct perf_evlist *evlist, bool group)
+{
+        struct perf_evsel *evsel, *first;
+        int err, ncpus, nthreads;
+
+        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                struct xyarray *group_fd = NULL;
+
+                if (group && evsel != first)
+                        group_fd = first->fd;
+
+                err = perf_evsel__open(evsel, evlist->cpus, evlist->threads,
+                                       group, group_fd);
+                if (err < 0)
+                        goto out_err;
+        }
+
+        return 0;
+out_err:
+        ncpus = evlist->cpus ? evlist->cpus->nr : 1;
+        nthreads = evlist->threads ? evlist->threads->nr : 1;
+
+        list_for_each_entry_reverse(evsel, &evlist->entries, node)
+                perf_evsel__close(evsel, ncpus, nthreads);
+
+        return err;
+}
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index ce85ae9ae57a..1779ffef7828 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;
@@ -49,11 +50,17 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
+int perf_evlist__open(struct perf_evlist *evlist, bool group);
+
 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,
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index a03a36b7908a..e42626422587 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"
@@ -14,6 +16,7 @@
 #include "thread_map.h"
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
+#define GROUP_FD(group_fd, cpu) (*(int *)xyarray__entry(group_fd, cpu, 0))
 
 int __perf_evsel__sample_size(u64 sample_type)
 {
@@ -37,6 +40,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)
@@ -201,15 +205,16 @@ int __perf_evsel__read(struct perf_evsel *evsel,
 }
 
 static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                              struct thread_map *threads, bool group)
+                              struct thread_map *threads, bool group,
+                              struct xyarray *group_fds)
 {
         int cpu, thread;
         unsigned long flags = 0;
-        int pid = -1;
+        int pid = -1, err;
 
         if (evsel->fd == NULL &&
             perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
-                return -1;
+                return -ENOMEM;
 
         if (evsel->cgrp) {
                 flags = PERF_FLAG_PID_CGROUP;
@@ -217,7 +222,7 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         }
 
         for (cpu = 0; cpu < cpus->nr; cpu++) {
-                int group_fd = -1;
+                int group_fd = group_fds ? GROUP_FD(group_fds, cpu) : -1;
 
                 for (thread = 0; thread < threads->nr; thread++) {
 
@@ -228,8 +233,10 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                                                                      pid,
                                                                      cpus->map[cpu],
                                                                      group_fd, flags);
-                        if (FD(evsel, cpu, thread) < 0)
+                        if (FD(evsel, cpu, thread) < 0) {
+                                err = -errno;
                                 goto out_close;
+                        }
 
                         if (group && group_fd == -1)
                                 group_fd = FD(evsel, cpu, thread);
@@ -246,7 +253,17 @@ out_close:
                 }
                 thread = threads->nr;
         } while (--cpu >= 0);
-        return -1;
+        return err;
+}
+
+void perf_evsel__close(struct perf_evsel *evsel, int ncpus, int nthreads)
+{
+        if (evsel->fd == NULL)
+                return;
+
+        perf_evsel__close_fd(evsel, ncpus, nthreads);
+        perf_evsel__free_fd(evsel);
+        evsel->fd = NULL;
 }
 
 static struct {
@@ -266,7 +283,8 @@ static struct {
 };
 
 int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                     struct thread_map *threads, bool group)
+                     struct thread_map *threads, bool group,
+                     struct xyarray *group_fd)
 {
         if (cpus == NULL) {
                 /* Work around old compiler warnings about strict aliasing */
@@ -276,19 +294,23 @@ int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         if (threads == NULL)
                 threads = &empty_thread_map.map;
 
-        return __perf_evsel__open(evsel, cpus, threads, group);
+        return __perf_evsel__open(evsel, cpus, threads, group, group_fd);
 }
 
 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
-                             struct cpu_map *cpus, bool group)
+                             struct cpu_map *cpus, bool group,
+                             struct xyarray *group_fd)
 {
-        return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group);
+        return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group,
+                                  group_fd);
 }
 
 int perf_evsel__open_per_thread(struct perf_evsel *evsel,
-                                struct thread_map *threads, bool group)
+                                struct thread_map *threads, bool group,
+                                struct xyarray *group_fd)
 {
-        return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group);
+        return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group,
+                                  group_fd);
 }
 
 static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
@@ -342,10 +364,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 +398,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 +434,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 +469,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/evsel.h b/tools/perf/util/evsel.h
index e9a31554e265..b1d15e6f7ae3 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -82,11 +82,15 @@ void perf_evsel__free_id(struct perf_evsel *evsel);
 void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 
 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
-                             struct cpu_map *cpus, bool group);
+                             struct cpu_map *cpus, bool group,
+                             struct xyarray *group_fds);
 int perf_evsel__open_per_thread(struct perf_evsel *evsel,
-                                struct thread_map *threads, bool group);
+                                struct thread_map *threads, bool group,
+                                struct xyarray *group_fds);
 int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                     struct thread_map *threads, bool group);
+                     struct thread_map *threads, bool group,
+                     struct xyarray *group_fds);
+void perf_evsel__close(struct perf_evsel *evsel, int ncpus, int nthreads);
 
 #define perf_evsel__match(evsel, t, c)          \
         (evsel->attr.type == PERF_TYPE_##t &&   \
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index b6c1ad123ca9..bcd05d05b4f0 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,5 +1,6 @@
 #define _FILE_OFFSET_BITS 64
 
+#include "util.h"
 #include <sys/types.h>
 #include <byteswap.h>
 #include <unistd.h>
@@ -7,22 +8,29 @@
 #include <stdlib.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
+#include <sys/utsname.h>
 
 #include "evlist.h"
 #include "evsel.h"
-#include "util.h"
 #include "header.h"
 #include "../perf.h"
 #include "trace-event.h"
 #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)         \
@@ -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;
@@ -796,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 "
@@ -813,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);
         }
@@ -935,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);
 
@@ -1100,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);
@@ -1116,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..a36a3fa81ffb 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,68 @@ 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);
 
         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);
+                }
         }
+}
 
-        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 +422,44 @@ 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->stats.total_period = 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 +714,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 +799,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 +840,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 +896,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 +908,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 +924,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 +973,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 +995,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 +1009,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 +1039,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 +1063,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 +1080,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 +1093,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 +1184,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 +1198,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 +1206,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..c86c1d27bd1e 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;
@@ -27,6 +28,7 @@ struct events_stats {
         u64 total_lost;
         u64 total_invalid_chains;
         u32 nr_events[PERF_RECORD_HEADER_MAX];
+        u32 nr_lost_warned;
         u32 nr_unknown_events;
         u32 nr_invalid_chains;
         u32 nr_unknown_id;
@@ -42,9 +44,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 +63,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 +109,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/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/probe-event.c b/tools/perf/util/probe-event.c
index 1c7bfa5fe0a8..eb25900e2211 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1956,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 555fc3864b90..5d732621a462 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -659,7 +659,7 @@ static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
                 if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
                         ret = -ENOENT;
         }
-        if (ret == 0)
+        if (ret >= 0)
                 ret = convert_variable(&vr_die, pf);
 
         if (ret < 0)
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index cbc8f215d4b7..9dd47a4f2596 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -623,7 +623,11 @@ static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel,
                 cpus = ((struct pyrf_cpu_map *)pcpus)->cpus;
 
         evsel->attr.inherit = inherit;
-        if (perf_evsel__open(evsel, cpus, threads, group) < 0) {
+        /*
+         * This will group just the fds for this single evsel, to group
+         * multiple events, use evlist.open().
+         */
+        if (perf_evsel__open(evsel, cpus, threads, group, NULL) < 0) {
                 PyErr_SetFromErrno(PyExc_OSError);
                 return NULL;
         }
@@ -803,7 +807,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);
@@ -814,6 +818,25 @@ static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
         return Py_None;
 }
 
+static PyObject *pyrf_evlist__open(struct pyrf_evlist *pevlist,
+                                   PyObject *args, PyObject *kwargs)
+{
+        struct perf_evlist *evlist = &pevlist->evlist;
+        int group = 0;
+        static char *kwlist[] = { "group", NULL };
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist, &group))
+                return NULL;
+
+        if (perf_evlist__open(evlist, group) < 0) {
+                PyErr_SetFromErrno(PyExc_OSError);
+                return NULL;
+        }
+
+        Py_INCREF(Py_None);
+        return Py_None;
+}
+
 static PyMethodDef pyrf_evlist__methods[] = {
         {
                 .ml_name  = "mmap",
@@ -822,6 +845,12 @@ static PyMethodDef pyrf_evlist__methods[] = {
                 .ml_doc   = PyDoc_STR("mmap the file descriptor table.")
         },
         {
+                .ml_name  = "open",
+                .ml_meth  = (PyCFunction)pyrf_evlist__open,
+                .ml_flags = METH_VARARGS | METH_KEYWORDS,
+                .ml_doc   = PyDoc_STR("open the file descriptors.")
+        },
+        {
                 .ml_name  = "poll",
                 .ml_meth  = (PyCFunction)pyrf_evlist__poll,
                 .ml_flags = METH_VARARGS | METH_KEYWORDS,
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 72458d9da5b1..85c1e6b76f0a 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -502,6 +502,7 @@ static void flush_sample_queue(struct perf_session *s,
         struct perf_sample sample;
         u64 limit = os->next_flush;
         u64 last_ts = os->last_sample ? os->last_sample->timestamp : 0ULL;
+        unsigned idx = 0, progress_next = os->nr_samples / 16;
         int ret;
 
         if (!ops->ordered_samples || !limit)
@@ -521,6 +522,11 @@ static void flush_sample_queue(struct perf_session *s,
                 os->last_flush = iter->timestamp;
                 list_del(&iter->list);
                 list_add(&iter->list, &os->sample_cache);
+                if (++idx >= progress_next) {
+                        progress_next += os->nr_samples / 16;
+                        ui_progress__update(idx, os->nr_samples,
+                                            "Processing time ordered events...");
+                }
         }
 
         if (list_empty(head)) {
@@ -529,6 +535,8 @@ static void flush_sample_queue(struct perf_session *s,
                 os->last_sample =
                         list_entry(head->prev, struct sample_queue, list);
         }
+
+        os->nr_samples = 0;
 }
 
 /*
@@ -588,6 +596,7 @@ static void __queue_event(struct sample_queue *new, struct perf_session *s)
         u64 timestamp = new->timestamp;
         struct list_head *p;
 
+        ++os->nr_samples;
         os->last_sample = new;
 
         if (!sample) {
@@ -738,10 +747,27 @@ static int perf_session_deliver_event(struct perf_session *session,
 
         dump_event(session, event, file_offset, sample);
 
+        evsel = perf_evlist__id2evsel(session->evlist, sample->id);
+        if (evsel != NULL && event->header.type != PERF_RECORD_SAMPLE) {
+                /*
+                 * XXX We're leaving PERF_RECORD_SAMPLE unnacounted here
+                 * because the tools right now may apply filters, discarding
+                 * some of the samples. For consistency, in the future we
+                 * should have something like nr_filtered_samples and remove
+                 * the sample->period from total_sample_period, etc, KISS for
+                 * now tho.
+                 *
+                 * Also testing against NULL allows us to handle files without
+                 * attr.sample_id_all and/or without PERF_SAMPLE_ID. In the
+                 * future probably it'll be a good idea to restrict event
+                 * processing via perf_session to files with both set.
+                 */
+                hists__inc_nr_events(&evsel->hists, event->header.type);
+        }
+
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
                 dump_sample(session, event, sample);
-                evsel = perf_evlist__id2evsel(session->evlist, sample->id);
                 if (evsel == NULL) {
                         ++session->hists.stats.nr_unknown_id;
                         return -1;
@@ -874,11 +900,11 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
                                             const struct perf_event_ops *ops)
 {
         if (ops->lost == perf_event__process_lost &&
-            session->hists.stats.total_lost != 0) {
-                ui__warning("Processed %" PRIu64 " events and LOST %" PRIu64
-                            "!\n\nCheck IO/CPU overload!\n\n",
-                            session->hists.stats.total_period,
-                            session->hists.stats.total_lost);
+            session->hists.stats.nr_events[PERF_RECORD_LOST] != 0) {
+                ui__warning("Processed %d events and lost %d chunks!\n\n"
+                            "Check IO/CPU overload!\n\n",
+                            session->hists.stats.nr_events[0],
+                            session->hists.stats.nr_events[PERF_RECORD_LOST]);
         }
 
         if (session->hists.stats.nr_unknown_events != 0) {
@@ -1012,7 +1038,6 @@ int __perf_session__process_events(struct perf_session *session,
 {
         u64 head, page_offset, file_offset, file_pos, progress_next;
         int err, mmap_prot, mmap_flags, map_idx = 0;
-        struct ui_progress *progress;
         size_t  page_size, mmap_size;
         char *buf, *mmaps[8];
         union perf_event *event;
@@ -1030,9 +1055,6 @@ int __perf_session__process_events(struct perf_session *session,
                 file_size = data_offset + data_size;
 
         progress_next = file_size / 16;
-        progress = ui_progress__new("Processing events...", file_size);
-        if (progress == NULL)
-                return -1;
 
         mmap_size = session->mmap_window;
         if (mmap_size > file_size)
@@ -1095,7 +1117,8 @@ more:
 
         if (file_pos >= progress_next) {
                 progress_next += file_size / 16;
-                ui_progress__update(progress, file_pos);
+                ui_progress__update(file_pos, file_size,
+                                    "Processing events...");
         }
 
         if (file_pos < file_size)
@@ -1106,7 +1129,6 @@ more:
         session->ordered_samples.next_flush = ULLONG_MAX;
         flush_sample_queue(session, ops);
 out_err:
-        ui_progress__delete(progress);
         perf_session__warn_about_errors(session, ops);
         perf_session_free_sample_buffers(session);
         return err;
@@ -1326,3 +1348,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..6e393c98eb34 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -23,6 +23,7 @@ struct ordered_samples {
         struct sample_queue     *sample_buffer;
         struct sample_queue     *last_sample;
         int                     sample_buffer_idx;
+        unsigned int            nr_samples;
 };
 
 struct perf_session {
@@ -162,7 +163,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 +178,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/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 469c0264ed29..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;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 4f377d92e75a..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,
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..399650967958 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,20 @@ 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;
         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..d2655f08bcc0 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -80,7 +80,7 @@ static void die(const char *fmt, ...)
         int ret = errno;
 
         if (errno)
-                perror("trace-cmd");
+                perror("perf");
         else
                 ret = -1;
 
@@ -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..556829124b02 100644
--- a/tools/perf/util/ui/browser.c
+++ b/tools/perf/util/ui/browser.c
@@ -1,5 +1,10 @@
+#include "../util.h"
+#include "../cache.h"
+#include "../../perf.h"
 #include "libslang.h"
+#include <newt.h>
 #include "ui.h"
+#include "util.h"
 #include <linux/compiler.h>
 #include <linux/list.h>
 #include <linux/rbtree.h>
@@ -7,13 +12,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 +35,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 +44,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,41 +163,76 @@ 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;
 }
 
-void ui_browser__reset_index(struct ui_browser *self)
+void ui_browser__handle_resize(struct ui_browser *browser)
 {
-        self->index = self->top_idx = 0;
-        self->seek(self, 0, SEEK_SET);
+        ui__refresh_dimensions(false);
+        ui_browser__show(browser, browser->title, ui_helpline__current);
+        ui_browser__refresh(browser);
 }
 
-void ui_browser__add_exit_key(struct ui_browser *self, int key)
+int ui_browser__warning(struct ui_browser *browser, int timeout,
+                        const char *format, ...)
 {
-        newtFormAddHotKey(self->form, key);
+        va_list args;
+        char *text;
+        int key = 0, err;
+
+        va_start(args, format);
+        err = vasprintf(&text, format, args);
+        va_end(args);
+
+        if (err < 0) {
+                va_start(args, format);
+                ui_helpline__vpush(format, args);
+                va_end(args);
+        } else {
+                while ((key == ui__question_window("Warning!", text,
+                                                   "Press any key...",
+                                                   timeout)) == K_RESIZE)
+                        ui_browser__handle_resize(browser);
+                free(text);
+        }
+
+        return key;
 }
 
-void ui_browser__add_exit_keys(struct ui_browser *self, int keys[])
+int ui_browser__help_window(struct ui_browser *browser, const char *text)
 {
-        int i = 0;
+        int key;
 
-        while (keys[i] && i < 64) {
-                ui_browser__add_exit_key(self, keys[i]);
-                ++i;
-        }
+        while ((key = ui__help_window(text)) == K_RESIZE)
+                ui_browser__handle_resize(browser);
+
+        return key;
+}
+
+bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
+{
+        int key;
+
+        while ((key = ui__dialog_yesno(text)) == K_RESIZE)
+                ui_browser__handle_resize(browser);
+
+        return key == K_ENTER || toupper(key) == 'Y';
+}
+
+void ui_browser__reset_index(struct ui_browser *self)
+{
+        self->index = self->top_idx = 0;
+        self->seek(self, 0, SEEK_SET);
 }
 
 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 +245,145 @@ 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));
+        }
+
+        SLsmg_set_char_set(1);
+
+        while (h < height) {
+                ui_browser__gotorc(browser, row++, col);
+                SLsmg_write_char(h == pct ? SLSMG_DIAMOND_CHAR : SLSMG_CKBRD_CHAR);
+                ++h;
+        }
+
+        SLsmg_set_char_set(0);
+}
+
+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);
+}
+
+int ui_browser__run(struct ui_browser *self, int delay_secs)
+{
+        int err, key;
 
         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) {
+                        ui__refresh_dimensions(false);
+                        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 +392,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 +401,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 +413,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 +426,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 +439,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 +452,146 @@ 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__argv_seek(struct ui_browser *browser, off_t offset, int whence)
+{
+        switch (whence) {
+        case SEEK_SET:
+                browser->top = browser->entries;
+                break;
+        case SEEK_CUR:
+                browser->top = browser->top + browser->top_idx + offset;
+                break;
+        case SEEK_END:
+                browser->top = browser->top + browser->nr_entries + offset;
+                break;
+        default:
+                return;
+        }
+}
+
+unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
+{
+        unsigned int row = 0, idx = browser->top_idx;
+        char **pos;
+
+        if (browser->top == NULL)
+                browser->top = browser->entries;
+
+        pos = (char **)browser->top;
+        while (idx < browser->nr_entries) {
+                if (!browser->filter || !browser->filter(browser, *pos)) {
+                        ui_browser__gotorc(browser, row, 0);
+                        browser->write(browser, pos, row);
+                        if (++row == browser->height)
+                                break;
+                }
+
+                ++idx;
+                ++pos;
+        }
+
+        return row;
+}
+
 void ui_browser__init(void)
 {
-        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
+        int i = 0;
+
+        perf_config(ui_browser__color_config, NULL);
 
-        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);
+        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..84d761b730c1 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,23 @@ 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__handle_resize(struct ui_browser *browser);
+
+int ui_browser__warning(struct ui_browser *browser, int timeout,
+                        const char *format, ...);
+int ui_browser__help_window(struct ui_browser *browser, const char *text);
+bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text);
+
+void ui_browser__argv_seek(struct ui_browser *browser, off_t offset, int whence);
+unsigned int ui_browser__argv_refresh(struct ui_browser *browser);
 
 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..0575905d1205 100644
--- a/tools/perf/util/ui/browsers/annotate.c
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -1,31 +1,31 @@
+#include "../../util.h"
 #include "../browser.h"
 #include "../helpline.h"
 #include "../libslang.h"
+#include "../ui.h"
+#include "../util.h"
 #include "../../annotate.h"
 #include "../../hist.h"
 #include "../../sort.h"
 #include "../../symbol.h"
 #include <pthread.h>
-
-static void ui__error_window(const char *fmt, ...)
-{
-        va_list ap;
-
-        va_start(ap, fmt);
-        newtWinMessagev((char *)"Error", (char *)"Ok", (char *)fmt, ap);
-        va_end(ap);
-}
+#include <newt.h>
 
 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 +34,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 +64,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 +76,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 +161,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 +184,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 +245,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 +260,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 +275,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 +286,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 +358,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;
@@ -273,7 +394,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
                 return -1;
 
         if (symbol__annotate(sym, map, sizeof(struct objdump_line_rb_node)) < 0) {
-                ui__error_window(ui_helpline__last_msg);
+                ui__error("%s", ui_helpline__last_msg);
                 return -1;
         }
 
@@ -288,12 +409,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..d0c94b459685 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -17,6 +17,7 @@
 #include "../browser.h"
 #include "../helpline.h"
 #include "../util.h"
+#include "../ui.h"
 #include "map.h"
 
 struct hist_browser {
@@ -24,8 +25,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 +295,49 @@ 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 void ui_browser__warn_lost_events(struct ui_browser *browser)
+{
+        ui_browser__warning(browser, 4,
+                "Events are being lost, check IO/CPU overload!\n\n"
+                "You may want to run 'perf' using a RT scheduler policy:\n\n"
+                " perf top -r 80\n\n"
+                "Or reduce the sampling frequency.");
+}
+
+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 K_TIMER:
+                        timer(arg);
+                        ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
+
+                        if (self->hists->stats.nr_lost_warned !=
+                            self->hists->stats.nr_events[PERF_RECORD_LOST]) {
+                                self->hists->stats.nr_lost_warned =
+                                        self->hists->stats.nr_events[PERF_RECORD_LOST];
+                                ui_browser__warn_lost_events(&self->b);
+                        }
+
+                        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 +360,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 +558,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 +574,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 +620,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 +688,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 +807,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 +830,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 +852,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 +872,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 +880,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 +888,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_browser__warning(&browser->b, delay_secs * 2,
+                        "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 +914,30 @@ 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_browser__help_window(&browser->b,
+                                        "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");
                         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 +949,28 @@ 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?"))
+                            !ui_browser__dialog_yesno(&browser->b,
+                                               "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 +980,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 +995,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);
@@ -944,50 +1011,59 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel,
 
                 if (choice == annotate) {
                         struct hist_entry *he;
+                        int err;
 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;
+                        err = 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);
+                        if (err)
+                                ui_browser__handle_resize(&browser->b);
                 } 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);
                 }
         }
@@ -1001,6 +1077,7 @@ out:
 struct perf_evsel_menu {
         struct ui_browser b;
         struct perf_evsel *selection;
+        bool lost_events, lost_events_warned;
 };
 
 static void perf_evsel_menu__write(struct ui_browser *browser,
@@ -1013,22 +1090,38 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
         unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
         const char *ev_name = event_name(evsel);
         char bf[256], unit;
+        const char *warn = " ";
+        size_t printed;
 
         ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
                                                        HE_COLORSET_NORMAL);
 
         nr_events = convert_unit(nr_events, &unit);
-        snprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
-                 unit, unit == ' ' ? "" : " ", ev_name);
-        slsmg_write_nstring(bf, browser->width);
+        printed = snprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
+                           unit, unit == ' ' ? "" : " ", ev_name);
+        slsmg_printf("%s", bf);
+
+        nr_events = evsel->hists.stats.nr_events[PERF_RECORD_LOST];
+        if (nr_events != 0) {
+                menu->lost_events = true;
+                if (!current_entry)
+                        ui_browser__set_color(browser, HE_COLORSET_TOP);
+                nr_events = convert_unit(nr_events, &unit);
+                snprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!", nr_events,
+                         unit, unit == ' ' ? "" : " ");
+                warn = bf;
+        }
+
+        slsmg_write_nstring(warn, browser->width - printed);
 
         if (current_entry)
                 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 +1131,72 @@ 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);
+
+                        if (!menu->lost_events_warned && menu->lost_events) {
+                                ui_browser__warn_lost_events(&menu->b);
+                                menu->lost_events_warned = true;
+                        }
+                        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_browser__dialog_yesno(&menu->b,
+                                                "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:
-                        if (!ui__dialog_yesno("Do you really want to exit?"))
+                case K_ESC:
+                        if (!ui_browser__dialog_yesno(&menu->b,
+                                               "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 +1206,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 +1238,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 88403cf8396a..000000000000
--- a/tools/perf/util/ui/browsers/top.c
+++ /dev/null
@@ -1,212 +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,
-                },
-        };
-
-        return perf_top_browser__run(&browser);
-}
diff --git a/tools/perf/util/ui/helpline.c b/tools/perf/util/ui/helpline.c
index f36d2ff509ed..6ef3c5691762 100644
--- a/tools/perf/util/ui/helpline.c
+++ b/tools/perf/util/ui/helpline.c
@@ -1,20 +1,28 @@
 #define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
-#include <newt.h>
+#include <string.h>
 
 #include "../debug.h"
 #include "helpline.h"
 #include "ui.h"
+#include "libslang.h"
 
 void ui_helpline__pop(void)
 {
-        newtPopHelpLine();
 }
 
+char ui_helpline__current[512];
+
 void ui_helpline__push(const char *msg)
 {
-        newtPushHelpLine(msg);
+        const size_t sz = sizeof(ui_helpline__current);
+
+        SLsmg_gotorc(SLtt_Screen_Rows - 1, 0);
+        SLsmg_set_color(0);
+        SLsmg_write_nstring((char *)msg, SLtt_Screen_Cols);
+        SLsmg_refresh();
+        strncpy(ui_helpline__current, msg, sz)[sz - 1] = '\0';
 }
 
 void ui_helpline__vpush(const char *fmt, va_list ap)
@@ -63,7 +71,7 @@ int ui_helpline__show_help(const char *format, va_list ap)
 
         if (ui_helpline__last_msg[backlog - 1] == '\n') {
                 ui_helpline__puts(ui_helpline__last_msg);
-                newtRefresh();
+                SLsmg_refresh();
                 backlog = 0;
         }
         pthread_mutex_unlock(&ui__lock);
diff --git a/tools/perf/util/ui/helpline.h b/tools/perf/util/ui/helpline.h
index ab6028d0c401..7bab6b34e35e 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);
@@ -8,4 +11,6 @@ void ui_helpline__vpush(const char *fmt, va_list ap);
 void ui_helpline__fpush(const char *fmt, ...);
 void ui_helpline__puts(const char *msg);
 
+extern char ui_helpline__current[];
+
 #endif /* _PERF_UI_HELPLINE_H_ */
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/progress.c b/tools/perf/util/ui/progress.c
index d7fc399d36b3..295e366b6311 100644
--- a/tools/perf/util/ui/progress.c
+++ b/tools/perf/util/ui/progress.c
@@ -1,60 +1,29 @@
-#include <stdlib.h>
-#include <newt.h>
 #include "../cache.h"
 #include "progress.h"
+#include "libslang.h"
+#include "ui.h"
+#include "browser.h"
 
-struct ui_progress {
-        newtComponent form, scale;
-};
-
-struct ui_progress *ui_progress__new(const char *title, u64 total)
-{
-        struct ui_progress *self = malloc(sizeof(*self));
-
-        if (self != NULL) {
-                int cols;
-
-                if (use_browser <= 0)
-                        return self;
-                newtGetScreenSize(&cols, NULL);
-                cols -= 4;
-                newtCenteredWindow(cols, 1, title);
-                self->form  = newtForm(NULL, NULL, 0);
-                if (self->form == NULL)
-                        goto out_free_self;
-                self->scale = newtScale(0, 0, cols, total);
-                if (self->scale == NULL)
-                        goto out_free_form;
-                newtFormAddComponent(self->form, self->scale);
-                newtRefresh();
-        }
-
-        return self;
-
-out_free_form:
-        newtFormDestroy(self->form);
-out_free_self:
-        free(self);
-        return NULL;
-}
-
-void ui_progress__update(struct ui_progress *self, u64 curr)
+void ui_progress__update(u64 curr, u64 total, const char *title)
 {
+        int bar, y;
         /*
          * FIXME: We should have a per UI backend way of showing progress,
          * stdio will just show a percentage as NN%, etc.
          */
         if (use_browser <= 0)
                 return;
-        newtScaleSet(self->scale, curr);
-        newtRefresh();
-}
 
-void ui_progress__delete(struct ui_progress *self)
-{
-        if (use_browser > 0) {
-                newtFormDestroy(self->form);
-                newtPopWindow();
-        }
-        free(self);
+        ui__refresh_dimensions(true);
+        pthread_mutex_lock(&ui__lock);
+        y = SLtt_Screen_Rows / 2 - 2;
+        SLsmg_set_color(0);
+        SLsmg_draw_box(y, 0, 3, SLtt_Screen_Cols);
+        SLsmg_gotorc(y++, 1);
+        SLsmg_write_string((char *)title);
+        SLsmg_set_color(HE_COLORSET_SELECTED);
+        bar = ((SLtt_Screen_Cols - 2) * curr) / total;
+        SLsmg_fill_region(y, 1, 1, bar, ' ');
+        SLsmg_refresh();
+        pthread_mutex_unlock(&ui__lock);
 }
diff --git a/tools/perf/util/ui/progress.h b/tools/perf/util/ui/progress.h
index a3820a0beb5b..d9c205b59aa1 100644
--- a/tools/perf/util/ui/progress.h
+++ b/tools/perf/util/ui/progress.h
@@ -1,11 +1,8 @@
 #ifndef _PERF_UI_PROGRESS_H_
 #define _PERF_UI_PROGRESS_H_ 1
 
-struct ui_progress;
+#include <../types.h>
 
-struct ui_progress *ui_progress__new(const char *title, u64 total);
-void ui_progress__delete(struct ui_progress *self);
-
-void ui_progress__update(struct ui_progress *self, u64 curr);
+void ui_progress__update(u64 curr, u64 total, const char *title);
 
 #endif
diff --git a/tools/perf/util/ui/setup.c b/tools/perf/util/ui/setup.c
index ee46d671db59..85a69faa09aa 100644
--- a/tools/perf/util/ui/setup.c
+++ b/tools/perf/util/ui/setup.c
@@ -7,9 +7,85 @@
 #include "browser.h"
 #include "helpline.h"
 #include "ui.h"
+#include "util.h"
+#include "libslang.h"
+#include "keysyms.h"
 
 pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
+static volatile int ui__need_resize;
+
+void ui__refresh_dimensions(bool force)
+{
+        if (force || ui__need_resize) {
+                ui__need_resize = 0;
+                pthread_mutex_lock(&ui__lock);
+                SLtt_get_screen_size();
+                SLsmg_reinit_smg();
+                pthread_mutex_unlock(&ui__lock);
+        }
+}
+
+static void ui__sigwinch(int sig __used)
+{
+        ui__need_resize = 1;
+}
+
+static void ui__setup_sigwinch(void)
+{
+        static bool done;
+
+        if (done)
+                return;
+
+        done = true;
+        pthread__unblock_sigwinch();
+        signal(SIGWINCH, ui__sigwinch);
+}
+
+int ui__getch(int delay_secs)
+{
+        struct timeval timeout, *ptimeout = delay_secs ? &timeout : NULL;
+        fd_set read_set;
+        int err, key;
+
+        ui__setup_sigwinch();
+
+        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();
+}
+
 static void newt_suspend(void *d __used)
 {
         newtSuspend();
@@ -17,6 +93,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,19 +131,25 @@ 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)
 {
         if (use_browser > 0) {
-                if (wait_for_ok) {
-                        char title[] = "Fatal Error", ok[] = "Ok";
-                        newtWinMessage(title, ok, ui_helpline__last_msg);
-                }
-                newtFinished();
+                if (wait_for_ok)
+                        ui__question_window("Fatal Error",
+                                            ui_helpline__last_msg,
+                                            "Press any key...", 0);
+                ui__exit();
         }
 }
diff --git a/tools/perf/util/ui/ui.h b/tools/perf/util/ui/ui.h
index d264e059c829..7b67045479f6 100644
--- a/tools/perf/util/ui/ui.h
+++ b/tools/perf/util/ui/ui.h
@@ -2,7 +2,10 @@
 #define _PERF_UI_H_ 1
 
 #include <pthread.h>
+#include <stdbool.h>
 
 extern pthread_mutex_t ui__lock;
 
+void ui__refresh_dimensions(bool force);
+
 #endif /* _PERF_UI_H_ */
diff --git a/tools/perf/util/ui/util.c b/tools/perf/util/ui/util.c
index fdf1fc8f08bc..45daa7c41dad 100644
--- a/tools/perf/util/ui/util.c
+++ b/tools/perf/util/ui/util.c
@@ -1,6 +1,5 @@
-#include <newt.h>
+#include "../util.h"
 #include <signal.h>
-#include <stdio.h>
 #include <stdbool.h>
 #include <string.h>
 #include <sys/ttydefaults.h>
@@ -8,72 +7,75 @@
 #include "../cache.h"
 #include "../debug.h"
 #include "browser.h"
+#include "keysyms.h"
 #include "helpline.h"
 #include "ui.h"
 #include "util.h"
+#include "libslang.h"
 
-static void newt_form__set_exit_keys(newtComponent self)
+static void ui_browser__argv_write(struct ui_browser *browser,
+                                   void *entry, int row)
 {
-        newtFormAddHotKey(self, NEWT_KEY_LEFT);
-        newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
-        newtFormAddHotKey(self, 'Q');
-        newtFormAddHotKey(self, 'q');
-        newtFormAddHotKey(self, CTRL('c'));
-}
+        char **arg = entry;
+        bool current_entry = ui_browser__is_current_entry(browser, row);
 
-static newtComponent newt_form__new(void)
-{
-        newtComponent self = newtForm(NULL, NULL, 0);
-        if (self)
-                newt_form__set_exit_keys(self);
-        return self;
+        ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
+                                                       HE_COLORSET_NORMAL);
+        slsmg_write_nstring(*arg, browser->width);
 }
 
-int ui__popup_menu(int argc, char * const argv[])
+static int popup_menu__run(struct ui_browser *menu)
 {
-        struct newtExitStruct es;
-        int i, rc = -1, max_len = 5;
-        newtComponent listbox, form = newt_form__new();
+        int key;
 
-        if (form == NULL)
+        if (ui_browser__show(menu, " ", "ESC: exit, ENTER|->: Select option") < 0)
                 return -1;
 
-        listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
-        if (listbox == NULL)
-                goto out_destroy_form;
+        while (1) {
+                key = ui_browser__run(menu, 0);
 
-        newtFormAddComponent(form, listbox);
+                switch (key) {
+                case K_RIGHT:
+                case K_ENTER:
+                        key = menu->index;
+                        break;
+                case K_LEFT:
+                case K_ESC:
+                case 'q':
+                case CTRL('c'):
+                        key = -1;
+                        break;
+                default:
+                        continue;
+                }
 
-        for (i = 0; i < argc; ++i) {
-                int len = strlen(argv[i]);
-                if (len > max_len)
-                        max_len = len;
-                if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
-                        goto out_destroy_form;
+                break;
         }
 
-        newtCenteredWindow(max_len, argc, NULL);
-        newtFormRun(form, &es);
-        rc = newtListboxGetCurrent(listbox) - NULL;
-        if (es.reason == NEWT_EXIT_HOTKEY)
-                rc = -1;
-        newtPopWindow();
-out_destroy_form:
-        newtFormDestroy(form);
-        return rc;
+        ui_browser__hide(menu);
+        return key;
 }
 
-int ui__help_window(const char *text)
+int ui__popup_menu(int argc, char * const argv[])
 {
-        struct newtExitStruct es;
-        newtComponent tb, form = newt_form__new();
-        int rc = -1;
+        struct ui_browser menu = {
+                .entries    = (void *)argv,
+                .refresh    = ui_browser__argv_refresh,
+                .seek       = ui_browser__argv_seek,
+                .write      = ui_browser__argv_write,
+                .nr_entries = argc,
+        };
+
+        return popup_menu__run(&menu);
+}
+
+int ui__question_window(const char *title, const char *text,
+                        const char *exit_msg, int delay_secs)
+{
+        int x, y;
         int max_len = 0, nr_lines = 0;
         const char *t;
 
-        if (form == NULL)
-                return -1;
-
         t = text;
         while (1) {
                 const char *sep = strchr(t, '\n');
@@ -90,41 +92,77 @@ int ui__help_window(const char *text)
                 t = sep + 1;
         }
 
-        tb = newtTextbox(0, 0, max_len, nr_lines, 0);
-        if (tb == NULL)
-                goto out_destroy_form;
-
-        newtTextboxSetText(tb, text);
-        newtFormAddComponent(form, tb);
-        newtCenteredWindow(max_len, nr_lines, NULL);
-        newtFormRun(form, &es);
-        newtPopWindow();
-        rc = 0;
-out_destroy_form:
-        newtFormDestroy(form);
-        return rc;
+        max_len += 2;
+        nr_lines += 4;
+        y = SLtt_Screen_Rows / 2 - nr_lines / 2,
+        x = SLtt_Screen_Cols / 2 - max_len / 2;
+
+        SLsmg_set_color(0);
+        SLsmg_draw_box(y, x++, nr_lines, max_len);
+        if (title) {
+                SLsmg_gotorc(y, x + 1);
+                SLsmg_write_string((char *)title);
+        }
+        SLsmg_gotorc(++y, x);
+        nr_lines -= 2;
+        max_len -= 2;
+        SLsmg_write_wrapped_string((unsigned char *)text, y, x,
+                                   nr_lines, max_len, 1);
+        SLsmg_gotorc(y + nr_lines - 2, x);
+        SLsmg_write_nstring((char *)" ", max_len);
+        SLsmg_gotorc(y + nr_lines - 1, x);
+        SLsmg_write_nstring((char *)exit_msg, max_len);
+        SLsmg_refresh();
+        return ui__getch(delay_secs);
 }
 
-static const char yes[] = "Yes", no[] = "No",
-                  warning_str[] = "Warning!", ok[] = "Ok";
+int ui__help_window(const char *text)
+{
+        return ui__question_window("Help", text, "Press any key...", 0);
+}
 
-bool ui__dialog_yesno(const char *msg)
+int ui__dialog_yesno(const char *msg)
 {
-        /* newtWinChoice should really be accepting const char pointers... */
-        return newtWinChoice(NULL, (char *)yes, (char *)no, (char *)msg) == 1;
+        return ui__question_window(NULL, msg, "Enter: Yes, ESC: No", 0);
 }
 
-void ui__warning(const char *format, ...)
+int __ui__warning(const char *title, const char *format, va_list args)
 {
-        va_list args;
+        char *s;
+
+        if (use_browser > 0 && vasprintf(&s, format, args) > 0) {
+                int key;
 
-        va_start(args, format);
-        if (use_browser > 0) {
                 pthread_mutex_lock(&ui__lock);
-                newtWinMessagev((char *)warning_str, (char *)ok,
-                                (char *)format, args);
+                key = ui__question_window(title, s, "Press any key...", 0);
                 pthread_mutex_unlock(&ui__lock);
-        } else
-                vfprintf(stderr, format, args);
+                free(s);
+                return key;
+        }
+
+        fprintf(stderr, "%s:\n", title);
+        vfprintf(stderr, format, args);
+        return K_ESC;
+}
+
+int ui__warning(const char *format, ...)
+{
+        int key;
+        va_list args;
+
+        va_start(args, format);
+        key = __ui__warning("Warning", format, args);
+        va_end(args);
+        return key;
+}
+
+int ui__error(const char *format, ...)
+{
+        int key;
+        va_list args;
+
+        va_start(args, format);
+        key = __ui__warning("Error", format, args);
         va_end(args);
+        return key;
 }
diff --git a/tools/perf/util/ui/util.h b/tools/perf/util/ui/util.h
index afcbc1d99531..2d1738bd71c8 100644
--- a/tools/perf/util/ui/util.h
+++ b/tools/perf/util/ui/util.h
@@ -1,10 +1,14 @@
 #ifndef _PERF_UI_UTIL_H_
 #define _PERF_UI_UTIL_H_ 1
 
-#include <stdbool.h>
+#include <stdarg.h>
 
+int ui__getch(int delay_secs);
 int ui__popup_menu(int argc, char * const argv[]);
 int ui__help_window(const char *text);
-bool ui__dialog_yesno(const char *msg);
+int ui__dialog_yesno(const char *msg);
+int ui__question_window(const char *title, const char *text,
+                        const char *exit_msg, int delay_secs);
+int __ui__warning(const char *title, const char *format, va_list args);
 
 #endif /* _PERF_UI_UTIL_H_ */
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 8b2d37b59c9e..3c6f7808efae 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -162,19 +162,21 @@ void print_header(void)
 
 void dump_cnt(struct counters *cnt)
 {
-        fprintf(stderr, "package: %d ", cnt->pkg);
-        fprintf(stderr, "core:: %d ", cnt->core);
-        fprintf(stderr, "CPU: %d ", cnt->cpu);
-        fprintf(stderr, "TSC: %016llX\n", cnt->tsc);
-        fprintf(stderr, "c3: %016llX\n", cnt->c3);
-        fprintf(stderr, "c6: %016llX\n", cnt->c6);
-        fprintf(stderr, "c7: %016llX\n", cnt->c7);
-        fprintf(stderr, "aperf: %016llX\n", cnt->aperf);
-        fprintf(stderr, "pc2: %016llX\n", cnt->pc2);
-        fprintf(stderr, "pc3: %016llX\n", cnt->pc3);
-        fprintf(stderr, "pc6: %016llX\n", cnt->pc6);
-        fprintf(stderr, "pc7: %016llX\n", cnt->pc7);
-        fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, cnt->extra_msr);
+        if (!cnt)
+                return;
+        if (cnt->pkg) fprintf(stderr, "package: %d ", cnt->pkg);
+        if (cnt->core) fprintf(stderr, "core:: %d ", cnt->core);
+        if (cnt->cpu) fprintf(stderr, "CPU: %d ", cnt->cpu);
+        if (cnt->tsc) fprintf(stderr, "TSC: %016llX\n", cnt->tsc);
+        if (cnt->c3) fprintf(stderr, "c3: %016llX\n", cnt->c3);
+        if (cnt->c6) fprintf(stderr, "c6: %016llX\n", cnt->c6);
+        if (cnt->c7) fprintf(stderr, "c7: %016llX\n", cnt->c7);
+        if (cnt->aperf) fprintf(stderr, "aperf: %016llX\n", cnt->aperf);
+        if (cnt->pc2) fprintf(stderr, "pc2: %016llX\n", cnt->pc2);
+        if (cnt->pc3) fprintf(stderr, "pc3: %016llX\n", cnt->pc3);
+        if (cnt->pc6) fprintf(stderr, "pc6: %016llX\n", cnt->pc6);
+        if (cnt->pc7) fprintf(stderr, "pc7: %016llX\n", cnt->pc7);
+        if (cnt->extra_msr) fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, cnt->extra_msr);
 }
 
 void dump_list(struct counters *cnt)
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("..");
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 8d02ccb10c59..8b4c2535b266 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -42,6 +42,7 @@ $default{"BISECT_MANUAL"}	= 0;
 $default{"BISECT_SKIP"}         = 1;
 $default{"SUCCESS_LINE"}        = "login:";
 $default{"DETECT_TRIPLE_FAULT"} = 1;
+$default{"NO_INSTALL"}          = 0;
 $default{"BOOTED_TIMEOUT"}      = 1;
 $default{"DIE_ON_FAILURE"}      = 1;
 $default{"SSH_EXEC"}            = "ssh \$SSH_USER\@\$MACHINE \$SSH_COMMAND";
@@ -84,6 +85,7 @@ my $grub_number;
 my $target;
 my $make;
 my $post_install;
+my $no_install;
 my $noclean;
 my $minconfig;
 my $start_minconfig;
@@ -115,6 +117,7 @@ my $timeout;
 my $booted_timeout;
 my $detect_triplefault;
 my $console;
+my $reboot_success_line;
 my $success_line;
 my $stop_after_success;
 my $stop_after_failure;
@@ -130,6 +133,12 @@ my %config_help;
 my %variable;
 my %force_config;
 
+# do not force reboots on config problems
+my $no_reboot = 1;
+
+# default variables that can be used
+chomp ($variable{"PWD"} = `pwd`);
+
 $config_help{"MACHINE"} = << "EOF"
  The machine hostname that you will test.
 EOF
@@ -241,6 +250,7 @@ sub read_yn {
 
 sub get_ktest_config {
     my ($config) = @_;
+    my $ans;
 
     return if (defined($opt{$config}));
 
@@ -254,16 +264,17 @@ sub get_ktest_config {
         if (defined($default{$config})) {
             print "\[$default{$config}\] ";
         }
-        $entered_configs{$config} = <STDIN>;
-        $entered_configs{$config} =~ s/^\s*(.*\S)\s*$/$1/;
-        if ($entered_configs{$config} =~ /^\s*$/) {
+        $ans = <STDIN>;
+        $ans =~ s/^\s*(.*\S)\s*$/$1/;
+        if ($ans =~ /^\s*$/) {
             if ($default{$config}) {
-                $entered_configs{$config} = $default{$config};
+                $ans = $default{$config};
             } else {
                 print "Your answer can not be blank\n";
                 next;
             }
         }
+        $entered_configs{$config} = process_variables($ans);
         last;
     }
 }
@@ -298,7 +309,7 @@ sub get_ktest_configs {
 }
 
 sub process_variables {
-    my ($value) = @_;
+    my ($value, $remove_undef) = @_;
     my $retval = "";
 
     # We want to check for '\', and it is just easier
@@ -316,6 +327,10 @@ sub process_variables {
         $retval = "$retval$begin";
         if (defined($variable{$var})) {
             $retval = "$retval$variable{$var}";
+        } elsif (defined($remove_undef) && $remove_undef) {
+            # for if statements, any variable that is not defined,
+            # we simple convert to 0
+            $retval = "${retval}0";
         } else {
             # put back the origin piece.
             $retval = "$retval\$\{$var\}";
@@ -331,10 +346,17 @@ sub process_variables {
 }
 
 sub set_value {
-    my ($lvalue, $rvalue) = @_;
+    my ($lvalue, $rvalue, $override, $overrides, $name) = @_;
 
     if (defined($opt{$lvalue})) {
-        die "Error: Option $lvalue defined more than once!\n";
+        if (!$override || defined(${$overrides}{$lvalue})) {
+            my $extra = "";
+            if ($override) {
+                $extra = "In the same override section!\n";
+            }
+            die "$name: $.: Option $lvalue defined more than once!\n$extra";
+        }
+        ${$overrides}{$lvalue} = $rvalue;
     }
     if ($rvalue =~ /^\s*$/) {
         delete $opt{$lvalue};
@@ -355,86 +377,274 @@ sub set_variable {
     }
 }
 
-sub read_config {
-    my ($config) = @_;
+sub process_compare {
+    my ($lval, $cmp, $rval) = @_;
+
+    # remove whitespace
+
+    $lval =~ s/^\s*//;
+    $lval =~ s/\s*$//;
+
+    $rval =~ s/^\s*//;
+    $rval =~ s/\s*$//;
+
+    if ($cmp eq "==") {
+        return $lval eq $rval;
+    } elsif ($cmp eq "!=") {
+        return $lval ne $rval;
+    }
+
+    my $statement = "$lval $cmp $rval";
+    my $ret = eval $statement;
+
+    # $@ stores error of eval
+    if ($@) {
+        return -1;
+    }
+
+    return $ret;
+}
+
+sub value_defined {
+    my ($val) = @_;
+
+    return defined($variable{$2}) ||
+        defined($opt{$2});
+}
+
+my $d = 0;
+sub process_expression {
+    my ($name, $val) = @_;
+
+    my $c = $d++;
+
+    while ($val =~ s/\(([^\(]*?)\)/\&\&\&\&VAL\&\&\&\&/) {
+        my $express = $1;
+
+        if (process_expression($name, $express)) {
+            $val =~ s/\&\&\&\&VAL\&\&\&\&/ 1 /;
+        } else {
+            $val =~ s/\&\&\&\&VAL\&\&\&\&/ 0 /;
+        }
+    }
+
+    $d--;
+    my $OR = "\\|\\|";
+    my $AND = "\\&\\&";
+
+    while ($val =~ s/^(.*?)($OR|$AND)//) {
+        my $express = $1;
+        my $op = $2;
+
+        if (process_expression($name, $express)) {
+            if ($op eq "||") {
+                return 1;
+            }
+        } else {
+            if ($op eq "&&") {
+                return 0;
+            }
+        }
+    }
+
+    if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
+        my $ret = process_compare($1, $2, $3);
+        if ($ret < 0) {
+            die "$name: $.: Unable to process comparison\n";
+        }
+        return $ret;
+    }
+
+    if ($val =~ /^\s*(NOT\s*)?DEFINED\s+(\S+)\s*$/) {
+        if (defined $1) {
+            return !value_defined($2);
+        } else {
+            return value_defined($2);
+        }
+    }
+
+    if ($val =~ /^\s*0\s*$/) {
+        return 0;
+    } elsif ($val =~ /^\s*\d+\s*$/) {
+        return 1;
+    }
+
+    die ("$name: $.: Undefined content $val in if statement\n");
+}
+
+sub process_if {
+    my ($name, $value) = @_;
 
-    open(IN, $config) || die "can't read file $config";
+    # Convert variables and replace undefined ones with 0
+    my $val = process_variables($value, 1);
+    my $ret = process_expression $name, $val;
+
+    return $ret;
+}
+
+sub __read_config {
+    my ($config, $current_test_num) = @_;
+
+    my $in;
+    open($in, $config) || die "can't read file $config";
 
     my $name = $config;
     $name =~ s,.*/(.*),$1,;
 
-    my $test_num = 0;
+    my $test_num = $$current_test_num;
     my $default = 1;
     my $repeat = 1;
     my $num_tests_set = 0;
     my $skip = 0;
     my $rest;
+    my $line;
     my $test_case = 0;
+    my $if = 0;
+    my $if_set = 0;
+    my $override = 0;
 
-    while (<IN>) {
+    my %overrides;
+
+    while (<$in>) {
 
         # ignore blank lines and comments
         next if (/^\s*$/ || /\s*\#/);
 
-        if (/^\s*TEST_START(.*)/) {
+        if (/^\s*(TEST_START|DEFAULTS)\b(.*)/) {
 
-            $rest = $1;
+            my $type = $1;
+            $rest = $2;
+            $line = $2;
 
-            if ($num_tests_set) {
-                die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
-            }
+            my $old_test_num;
+            my $old_repeat;
+            $override = 0;
+
+            if ($type eq "TEST_START") {
 
-            my $old_test_num = $test_num;
-            my $old_repeat = $repeat;
+                if ($num_tests_set) {
+                    die "$name: $.: Can not specify both NUM_TESTS and TEST_START\n";
+                }
 
-            $test_num += $repeat;
-            $default = 0;
-            $repeat = 1;
+                $old_test_num = $test_num;
+                $old_repeat = $repeat;
 
-            if ($rest =~ /\s+SKIP(.*)/) {
-                $rest = $1;
+                $test_num += $repeat;
+                $default = 0;
+                $repeat = 1;
+            } else {
+                $default = 1;
+            }
+
+            # If SKIP is anywhere in the line, the command will be skipped
+            if ($rest =~ s/\s+SKIP\b//) {
                 $skip = 1;
             } else {
                 $test_case = 1;
                 $skip = 0;
             }
 
-            if ($rest =~ /\s+ITERATE\s+(\d+)(.*)$/) {
-                $repeat = $1;
-                $rest = $2;
-                $repeat_tests{"$test_num"} = $repeat;
+            if ($rest =~ s/\sELSE\b//) {
+                if (!$if) {
+                    die "$name: $.: ELSE found with out matching IF section\n$_";
+                }
+                $if = 0;
+
+                if ($if_set) {
+                    $skip = 1;
+                } else {
+                    $skip = 0;
+                }
             }
 
-            if ($rest =~ /\s+SKIP(.*)/) {
-                $rest = $1;
-                $skip = 1;
+            if ($rest =~ s/\sIF\s+(.*)//) {
+                if (process_if($name, $1)) {
+                    $if_set = 1;
+                } else {
+                    $skip = 1;
+                }
+                $if = 1;
+            } else {
+                $if = 0;
+                $if_set = 0;
             }
 
-            if ($rest !~ /^\s*$/) {
-                die "$name: $.: Gargbage found after TEST_START\n$_";
+            if (!$skip) {
+                if ($type eq "TEST_START") {
+                    if ($rest =~ s/\s+ITERATE\s+(\d+)//) {
+                        $repeat = $1;
+                        $repeat_tests{"$test_num"} = $repeat;
+                    }
+                } elsif ($rest =~ s/\sOVERRIDE\b//) {
+                    # DEFAULT only
+                    $override = 1;
+                    # Clear previous overrides
+                    %overrides = ();
+                }
+            }
+
+            if (!$skip && $rest !~ /^\s*$/) {
+                die "$name: $.: Gargbage found after $type\n$_";
             }
 
-            if ($skip) {
+            if ($skip && $type eq "TEST_START") {
                 $test_num = $old_test_num;
                 $repeat = $old_repeat;
             }
 
-        } elsif (/^\s*DEFAULTS(.*)$/) {
-            $default = 1;
-
+        } elsif (/^\s*ELSE\b(.*)$/) {
+            if (!$if) {
+                die "$name: $.: ELSE found with out matching IF section\n$_";
+            }
             $rest = $1;
-
-            if ($rest =~ /\s+SKIP(.*)/) {
-                $rest = $1;
+            if ($if_set) {
                 $skip = 1;
+                $rest = "";
             } else {
                 $skip = 0;
+
+                if ($rest =~ /\sIF\s+(.*)/) {
+                    # May be a ELSE IF section.
+                    if (!process_if($name, $1)) {
+                        $skip = 1;
+                    }
+                    $rest = "";
+                } else {
+                    $if = 0;
+                }
             }
 
             if ($rest !~ /^\s*$/) {
                 die "$name: $.: Gargbage found after DEFAULTS\n$_";
             }
 
+        } elsif (/^\s*INCLUDE\s+(\S+)/) {
+
+            next if ($skip);
+
+            if (!$default) {
+                die "$name: $.: INCLUDE can only be done in default sections\n$_";
+            }
+
+            my $file = process_variables($1);
+
+            if ($file !~ m,^/,) {
+                # check the path of the config file first
+                if ($config =~ m,(.*)/,) {
+                    if (-f "$1/$file") {
+                        $file = "$1/$file";
+                    }
+                }
+            }
+                
+            if ( ! -r $file ) {
+                die "$name: $.: Can't read file $file\n$_";
+            }
+
+            if (__read_config($file, \$test_num)) {
+                $test_case = 1;
+            }
+
         } elsif (/^\s*([A-Z_\[\]\d]+)\s*=\s*(.*?)\s*$/) {
 
             next if ($skip);
@@ -460,10 +670,10 @@ sub read_config {
             }
 
             if ($default || $lvalue =~ /\[\d+\]$/) {
-                set_value($lvalue, $rvalue);
+                set_value($lvalue, $rvalue, $override, \%overrides, $name);
             } else {
                 my $val = "$lvalue\[$test_num\]";
-                set_value($val, $rvalue);
+                set_value($val, $rvalue, $override, \%overrides, $name);
 
                 if ($repeat > 1) {
                     $repeats{$val} = $repeat;
@@ -490,13 +700,26 @@ sub read_config {
         }
     }
 
-    close(IN);
-
     if ($test_num) {
         $test_num += $repeat - 1;
         $opt{"NUM_TESTS"} = $test_num;
     }
 
+    close($in);
+
+    $$current_test_num = $test_num;
+
+    return $test_case;
+}
+
+sub read_config {
+    my ($config) = @_;
+
+    my $test_case;
+    my $test_num = 0;
+
+    $test_case = __read_config $config, \$test_num;
+
     # make sure we have all mandatory configs
     get_ktest_configs;
 
@@ -524,6 +747,18 @@ sub __eval_option {
     # Add space to evaluate the character before $
     $option = " $option";
     my $retval = "";
+    my $repeated = 0;
+    my $parent = 0;
+
+    foreach my $test (keys %repeat_tests) {
+        if ($i >= $test &&
+            $i < $test + $repeat_tests{$test}) {
+
+            $repeated = 1;
+            $parent = $test;
+            last;
+        }
+    }
 
     while ($option =~ /(.*?[^\\])\$\{(.*?)\}(.*)/) {
         my $start = $1;
@@ -537,10 +772,14 @@ sub __eval_option {
         # otherwise see if the default OPT (without [$i]) exists.
 
         my $o = "$var\[$i\]";
+        my $parento = "$var\[$parent\]";
 
         if (defined($opt{$o})) {
             $o = $opt{$o};
             $retval = "$retval$o";
+        } elsif ($repeated && defined($opt{$parento})) {
+            $o = $opt{$parento};
+            $retval = "$retval$o";
         } elsif (defined($opt{$var})) {
             $o = $opt{$var};
             $retval = "$retval$o";
@@ -603,8 +842,20 @@ sub doprint {
 }
 
 sub run_command;
+sub start_monitor;
+sub end_monitor;
+sub wait_for_monitor;
 
 sub reboot {
+    my ($time) = @_;
+
+    if (defined($time)) {
+        start_monitor;
+        # flush out current monitor
+        # May contain the reboot success line
+        wait_for_monitor 1;
+    }
+
     # try to reboot normally
     if (run_command $reboot) {
         if (defined($powercycle_after_reboot)) {
@@ -615,12 +866,17 @@ sub reboot {
         # nope? power cycle it.
         run_command "$power_cycle";
     }
+
+    if (defined($time)) {
+        wait_for_monitor($time, $reboot_success_line);
+        end_monitor;
+    }
 }
 
 sub do_not_reboot {
     my $i = $iteration;
 
-    return $test_type eq "build" ||
+    return $test_type eq "build" || $no_reboot ||
         ($test_type eq "patchcheck" && $opt{"PATCHCHECK_TYPE[$i]"} eq "build") ||
         ($test_type eq "bisect" && $opt{"BISECT_TYPE[$i]"} eq "build");
 }
@@ -693,16 +949,29 @@ sub end_monitor {
 }
 
 sub wait_for_monitor {
-    my ($time) = @_;
+    my ($time, $stop) = @_;
+    my $full_line = "";
     my $line;
+    my $booted = 0;
 
     doprint "** Wait for monitor to settle down **\n";
 
     # read the monitor and wait for the system to calm down
-    do {
+    while (!$booted) {
         $line = wait_for_input($monitor_fp, $time);
-        print "$line" if (defined($line));
-    } while (defined($line));
+        last if (!defined($line));
+        print "$line";
+        $full_line .= $line;
+
+        if (defined($stop) && $full_line =~ /$stop/) {
+            doprint "wait for monitor detected $stop\n";
+            $booted = 1;
+        }
+
+        if ($line =~ /\n/) {
+            $full_line = "";
+        }
+    }
     print "** Monitor flushed **\n";
 }
 
@@ -719,10 +988,7 @@ sub fail {
         # no need to reboot for just building.
         if (!do_not_reboot) {
             doprint "REBOOTING\n";
-            reboot;
-            start_monitor;
-            wait_for_monitor $sleep_time;
-            end_monitor;
+            reboot $sleep_time;
         }
 
         my $name = "";
@@ -854,9 +1120,12 @@ sub get_grub_index {
     open(IN, "$ssh_grub |")
         or die "unable to get menu.lst";
 
+    my $found = 0;
+
     while (<IN>) {
         if (/^\s*title\s+$grub_menu\s*$/) {
             $grub_number++;
+            $found = 1;
             last;
         } elsif (/^\s*title\s/) {
             $grub_number++;
@@ -865,7 +1134,7 @@ sub get_grub_index {
     close(IN);
 
     die "Could not find '$grub_menu' in /boot/grub/menu on $machine"
-        if ($grub_number < 0);
+        if (!$found);
     doprint "$grub_number\n";
 }
 
@@ -902,7 +1171,8 @@ sub wait_for_input
 
 sub reboot_to {
     if ($reboot_type eq "grub") {
-        run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch && reboot)'";
+        run_ssh "'(echo \"savedefault --default=$grub_number --once\" | grub --batch)'";
+        reboot;
         return;
     }
 
@@ -1083,6 +1353,8 @@ sub do_post_install {
 
 sub install {
 
+    return if ($no_install);
+
     run_scp "$outputdir/$build_target", "$target_image" or
         dodie "failed to copy image";
 
@@ -1140,6 +1412,11 @@ sub get_version {
 }
 
 sub start_monitor_and_boot {
+    # Make sure the stable kernel has finished booting
+    start_monitor;
+    wait_for_monitor 5;
+    end_monitor;
+
     get_grub_index;
     get_version;
     install;
@@ -1250,6 +1527,10 @@ sub build {
 
     unlink $buildlog;
 
+    # Failed builds should not reboot the target
+    my $save_no_reboot = $no_reboot;
+    $no_reboot = 1;
+
     if (defined($pre_build)) {
         my $ret = run_command $pre_build;
         if (!$ret && defined($pre_build_die) &&
@@ -1272,15 +1553,15 @@ sub build {
         # allow for empty configs
         run_command "touch $output_config";
 
-        run_command "mv $output_config $outputdir/config_temp" or
-            dodie "moving .config";
+        if (!$noclean) {
+            run_command "mv $output_config $outputdir/config_temp" or
+                dodie "moving .config";
 
-        if (!$noclean && !run_command "$make mrproper") {
-            dodie "make mrproper";
-        }
+            run_command "$make mrproper" or dodie "make mrproper";
 
-        run_command "mv $outputdir/config_temp $output_config" or
-            dodie "moving config_temp";
+            run_command "mv $outputdir/config_temp $output_config" or
+                dodie "moving config_temp";
+        }
 
     } elsif (!$noclean) {
         unlink "$output_config";
@@ -1318,10 +1599,15 @@ sub build {
 
     if (!$build_ret) {
         # bisect may need this to pass
-        return 0 if ($in_bisect);
+        if ($in_bisect) {
+            $no_reboot = $save_no_reboot;
+            return 0;
+        }
         fail "failed build" and return 0;
     }
 
+    $no_reboot = $save_no_reboot;
+
     return 1;
 }
 
@@ -1356,10 +1642,7 @@ sub success {
 
     if ($i != $opt{"NUM_TESTS"} && !do_not_reboot) {
         doprint "Reboot and wait $sleep_time seconds\n";
-        reboot;
-        start_monitor;
-        wait_for_monitor $sleep_time;
-        end_monitor;
+        reboot $sleep_time;
     }
 }
 
@@ -1500,10 +1783,7 @@ sub run_git_bisect {
 
 sub bisect_reboot {
     doprint "Reboot and sleep $bisect_sleep_time seconds\n";
-    reboot;
-    start_monitor;
-    wait_for_monitor $bisect_sleep_time;
-    end_monitor;
+    reboot $bisect_sleep_time;
 }
 
 # returns 1 on success, 0 on failure, -1 on skip
@@ -2066,10 +2346,7 @@ sub config_bisect {
 
 sub patchcheck_reboot {
     doprint "Reboot and sleep $patchcheck_sleep_time seconds\n";
-    reboot;
-    start_monitor;
-    wait_for_monitor $patchcheck_sleep_time;
-    end_monitor;
+    reboot $patchcheck_sleep_time;
 }
 
 sub patchcheck {
@@ -2178,12 +2455,31 @@ sub patchcheck {
 }
 
 my %depends;
+my %depcount;
 my $iflevel = 0;
 my @ifdeps;
 
 # prevent recursion
 my %read_kconfigs;
 
+sub add_dep {
+    # $config depends on $dep
+    my ($config, $dep) = @_;
+
+    if (defined($depends{$config})) {
+        $depends{$config} .= " " . $dep;
+    } else {
+        $depends{$config} = $dep;
+    }
+
+    # record the number of configs depending on $dep
+    if (defined $depcount{$dep}) {
+        $depcount{$dep}++;
+    } else {
+        $depcount{$dep} = 1;
+    } 
+}
+
 # taken from streamline_config.pl
 sub read_kconfig {
     my ($kconfig) = @_;
@@ -2230,30 +2526,19 @@ sub read_kconfig {
             $config = $2;
 
             for (my $i = 0; $i < $iflevel; $i++) {
-                if ($i) {
-                    $depends{$config} .= " " . $ifdeps[$i];
-                } else {
-                    $depends{$config} = $ifdeps[$i];
-                }
-                $state = "DEP";
+                add_dep $config, $ifdeps[$i];
             }
 
         # collect the depends for the config
         } elsif ($state eq "NEW" && /^\s*depends\s+on\s+(.*)$/) {
 
-            if (defined($depends{$1})) {
-                $depends{$config} .= " " . $1;
-            } else {
-                $depends{$config} = $1;
-            }
+            add_dep $config, $1;
 
         # Get the configs that select this config
-        } elsif ($state ne "NONE" && /^\s*select\s+(\S+)/) {
-            if (defined($depends{$1})) {
-                $depends{$1} .= " " . $config;
-            } else {
-                $depends{$1} = $config;
-            }
+        } elsif ($state eq "NEW" && /^\s*select\s+(\S+)/) {
+
+            # selected by depends on config
+            add_dep $1, $config;
 
         # Check for if statements
         } elsif (/^if\s+(.*\S)\s*$/) {
@@ -2365,11 +2650,18 @@ sub make_new_config {
     close OUT;
 }
 
+sub chomp_config {
+    my ($config) = @_;
+
+    $config =~ s/CONFIG_//;
+
+    return $config;
+}
+
 sub get_depends {
     my ($dep) = @_;
 
-    my $kconfig = $dep;
-    $kconfig =~ s/CONFIG_//;
+    my $kconfig = chomp_config $dep;
 
     $dep = $depends{"$kconfig"};
 
@@ -2419,8 +2711,7 @@ sub test_this_config {
         return undef;
     }
 
-    my $kconfig = $config;
-    $kconfig =~ s/CONFIG_//;
+    my $kconfig = chomp_config $config;
 
     # Test dependencies first
     if (defined($depends{"$kconfig"})) {
@@ -2510,6 +2801,14 @@ sub make_min_config {
 
     my @config_keys = keys %min_configs;
 
+    # All configs need a depcount
+    foreach my $config (@config_keys) {
+        my $kconfig = chomp_config $config;
+        if (!defined $depcount{$kconfig}) {
+                $depcount{$kconfig} = 0;
+        }
+    }
+
     # Remove anything that was set by the make allnoconfig
     # we shouldn't need them as they get set for us anyway.
     foreach my $config (@config_keys) {
@@ -2548,8 +2847,13 @@ sub make_min_config {
         # Now disable each config one by one and do a make oldconfig
         # till we find a config that changes our list.
 
-        # Put configs that did not modify the config at the end.
         my @test_configs = keys %min_configs;
+
+        # Sort keys by who is most dependent on
+        @test_configs = sort  { $depcount{chomp_config($b)} <=> $depcount{chomp_config($a)} }
+                          @test_configs ;
+
+        # Put configs that did not modify the config at the end.
         my $reset = 1;
         for (my $i = 0; $i < $#test_configs; $i++) {
             if (!defined($nochange_config{$test_configs[0]})) {
@@ -2659,10 +2963,7 @@ sub make_min_config {
         }
 
         doprint "Reboot and wait $sleep_time seconds\n";
-        reboot;
-        start_monitor;
-        wait_for_monitor $sleep_time;
-        end_monitor;
+        reboot $sleep_time;
     }
 
     success $i;
@@ -2783,6 +3084,9 @@ sub set_test_option {
 # First we need to do is the builds
 for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
+    # Do not reboot on failing test options
+    $no_reboot = 1;
+
     $iteration = $i;
 
     my $makecmd = set_test_option("MAKE_CMD", $i);
@@ -2811,6 +3115,7 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     $reboot_type = set_test_option("REBOOT_TYPE", $i);
     $grub_menu = set_test_option("GRUB_MENU", $i);
     $post_install = set_test_option("POST_INSTALL", $i);
+    $no_install = set_test_option("NO_INSTALL", $i);
     $reboot_script = set_test_option("REBOOT_SCRIPT", $i);
     $reboot_on_error = set_test_option("REBOOT_ON_ERROR", $i);
     $poweroff_on_error = set_test_option("POWEROFF_ON_ERROR", $i);
@@ -2832,6 +3137,7 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     $console = set_test_option("CONSOLE", $i);
     $detect_triplefault = set_test_option("DETECT_TRIPLE_FAULT", $i);
     $success_line = set_test_option("SUCCESS_LINE", $i);
+    $reboot_success_line = set_test_option("REBOOT_SUCCESS_LINE", $i);
     $stop_after_success = set_test_option("STOP_AFTER_SUCCESS", $i);
     $stop_after_failure = set_test_option("STOP_AFTER_FAILURE", $i);
     $stop_test_after = set_test_option("STOP_TEST_AFTER", $i);
@@ -2850,9 +3156,11 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     chdir $builddir || die "can't change directory to $builddir";
 
-    if (!-d $tmpdir) {
-        mkpath($tmpdir) or
-            die "can't create $tmpdir";
+    foreach my $dir ($tmpdir, $outputdir) {
+        if (!-d $dir) {
+            mkpath($dir) or
+                die "can't create $dir";
+        }
     }
 
     $ENV{"SSH_USER"} = $ssh_user;
@@ -2889,8 +3197,11 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
         $run_type = "ERROR";
     }
 
+    my $installme = "";
+    $installme = " no_install" if ($no_install);
+
     doprint "\n\n";
-    doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type\n\n";
+    doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
 
     unlink $dmesg;
     unlink $buildlog;
@@ -2911,6 +3222,9 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
             die "failed to checkout $checkout";
     }
 
+    $no_reboot = 0;
+
+
     if ($test_type eq "bisect") {
         bisect $i;
         next;
@@ -2929,6 +3243,13 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
         build $build_type or next;
     }
 
+    if ($test_type eq "install") {
+        get_version;
+        install;
+        success $i;
+        next;
+    }
+
     if ($test_type ne "build") {
         my $failed = 0;
         start_monitor_and_boot or $failed = 1;
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index b8bcd14b5a4d..dbedfa196727 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -72,6 +72,128 @@
 # the same option name under the same test or as default
 # ktest will fail to execute, and no tests will run.
 #
+# DEFAULTS OVERRIDE
+#
+# Options defined in the DEFAULTS section can not be duplicated
+# even if they are defined in two different DEFAULT sections.
+# This is done to catch mistakes where an option is added but
+# the previous option was forgotten about and not commented.
+#
+# The OVERRIDE keyword can be added to a section to allow this
+# section to override other DEFAULT sections values that have
+# been defined previously. It will only override options that
+# have been defined before its use. Options defined later
+# in a non override section will still error. The same option
+# can not be defined in the same section even if that section
+# is marked OVERRIDE.
+#
+#
+#
+# Both TEST_START and DEFAULTS sections can also have the IF keyword
+# The value after the IF must evaluate into a 0 or non 0 positive
+# integer, and can use the config variables (explained below).
+#
+# DEFAULTS IF ${IS_X86_32}
+#
+# The above will process the DEFAULTS section if the config
+# variable IS_X86_32 evaluates to a non zero positive integer
+# otherwise if it evaluates to zero, it will act the same
+# as if the SKIP keyword was used.
+#
+# The ELSE keyword can be used directly after a section with
+# a IF statement.
+#
+# TEST_START IF ${RUN_NET_TESTS}
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-network
+#
+# ELSE
+#
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-normal
+#
+#
+# The ELSE keyword can also contain an IF statement to allow multiple
+# if then else sections. But all the sections must be either
+# DEFAULT or TEST_START, they can not be a mixture.
+#
+# TEST_START IF ${RUN_NET_TESTS}
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-network
+#
+# ELSE IF ${RUN_DISK_TESTS}
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-tests
+#
+# ELSE IF ${RUN_CPU_TESTS}
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-cpu
+#
+# ELSE
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-network
+#
+# The if statement may also have comparisons that will and for
+# == and !=, strings may be used for both sides.
+#
+# BOX_TYPE := x86_32
+#
+# DEFAULTS IF ${BOX_TYPE} == x86_32
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-32
+# ELSE
+# BUILD_TYPE = useconfig:${CONFIG_DIR}/config-64
+#
+# The DEFINED keyword can be used by the IF statements too.
+# It returns true if the given config variable or option has been defined
+# or false otherwise.
+#
+# 
+# DEFAULTS IF DEFINED USE_CC
+# CC := ${USE_CC}
+# ELSE
+# CC := gcc
+#
+#
+# As well as NOT DEFINED.
+#
+# DEFAULTS IF NOT DEFINED MAKE_CMD
+# MAKE_CMD := make ARCH=x86
+#
+#
+# And/or ops (&&,||) may also be used to make complex conditionals.
+#
+# TEST_START IF (DEFINED ALL_TESTS || ${MYTEST} == boottest) && ${MACHINE} == gandalf
+#
+# Notice the use of paranthesis. Without any paranthesis the above would be
+# processed the same as:
+#
+# TEST_START IF DEFINED ALL_TESTS || (${MYTEST} == boottest && ${MACHINE} == gandalf)
+#
+#
+#
+# INCLUDE file
+#
+# The INCLUDE keyword may be used in DEFAULT sections. This will
+# read another config file and process that file as well. The included
+# file can include other files, add new test cases or default
+# statements. Config variables will be passed to these files and changes
+# to config variables will be seen by top level config files. Including
+# a file is processed just like the contents of the file was cut and pasted
+# into the top level file, except, that include files that end with
+# TEST_START sections will have that section ended at the end of
+# the include file. That is, an included file is included followed
+# by another DEFAULT keyword.
+#
+# Unlike other files referenced in this config, the file path does not need
+# to be absolute. If the file does not start with '/', then the directory
+# that the current config file was located in is used. If no config by the
+# given name is found there, then the current directory is searched.
+#
+# INCLUDE myfile
+# DEFAULT
+#
+# is the same as:
+#
+# INCLUDE myfile
+#
+# Note, if the include file does not contain a full path, the file is
+# searched first by the location of the original include file, and then
+# by the location that ktest.pl was executed in.
+#
 
 #### Config variables ####
 #
@@ -253,9 +375,10 @@
 
 # The default test type (default test)
 # The test types may be:
-#   build - only build the kernel, do nothing else
-#   boot - build and boot the kernel
-#   test - build, boot and if TEST is set, run the test script
+#   build   - only build the kernel, do nothing else
+#   install - build and install, but do nothing else (does not reboot)
+#   boot    - build, install, and boot the kernel
+#   test    - build, boot and if TEST is set, run the test script
 #          (If TEST is not set, it defaults back to boot)
 #   bisect - Perform a bisect on the kernel (see BISECT_TYPE below)
 #   patchcheck - Do a test on a series of commits in git (see PATCHCHECK below)
@@ -293,6 +416,13 @@
 # or on some systems:
 #POST_INSTALL = ssh user@target /sbin/dracut -f /boot/initramfs-test.img $KERNEL_VERSION
 
+# If for some reason you just want to boot the kernel and you do not
+# want the test to install anything new. For example, you may just want
+# to boot test the same kernel over and over and do not want to go through
+# the hassle of installing anything, you can set this option to 1
+# (default 0)
+#NO_INSTALL = 1
+
 # If there is a script that you require to run before the build is done
 # you can specify it with PRE_BUILD.
 #
@@ -415,6 +545,14 @@
 # (default "login:")
 #SUCCESS_LINE = login:
 
+# To speed up between reboots, defining a line that the
+# default kernel produces that represents that the default
+# kernel has successfully booted and can be used to pass
+# a new test kernel to it. Otherwise ktest.pl will wait till
+# SLEEP_TIME to continue.
+# (default undefined)
+#REBOOT_SUCCESS_LINE = login:
+
 # In case the console constantly fills the screen, having
 # a specified time to stop the test after success is recommended.
 # (in seconds)
@@ -480,6 +618,8 @@
 # another test. If a reboot to the reliable kernel happens,
 # we wait SLEEP_TIME for the console to stop producing output
 # before starting the next test.
+#
+# You can speed up reboot times even more by setting REBOOT_SUCCESS_LINE.
 # (default 60)
 #SLEEP_TIME = 60