117 files changed, 8077 insertions, 3241 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/examples.txt b/tools/perf/Documentation/examples.txt
index 8eb6c489fb15..77f952762426 100644
--- a/tools/perf/Documentation/examples.txt
+++ b/tools/perf/Documentation/examples.txt
@@ -17,8 +17,8 @@ titan:~> perf list
   kmem:kmem_cache_alloc_node               [Tracepoint event]
   kmem:kfree                               [Tracepoint event]
   kmem:kmem_cache_free                     [Tracepoint event]
-  kmem:mm_page_free_direct                 [Tracepoint event]
-  kmem:mm_pagevec_free                     [Tracepoint event]
+  kmem:mm_page_free                        [Tracepoint event]
+  kmem:mm_page_free_batched                [Tracepoint event]
   kmem:mm_page_alloc                       [Tracepoint event]
   kmem:mm_page_alloc_zone_locked           [Tracepoint event]
   kmem:mm_page_pcpu_drain                  [Tracepoint event]
@@ -29,15 +29,15 @@ measured. For example the page alloc/free properties of a 'hackbench
 run' are:
 
  titan:~> perf stat -e kmem:mm_page_pcpu_drain -e kmem:mm_page_alloc
- -e kmem:mm_pagevec_free -e kmem:mm_page_free_direct ./hackbench 10
+ -e kmem:mm_page_free_batched -e kmem:mm_page_free ./hackbench 10
  Time: 0.575
 
  Performance counter stats for './hackbench 10':
 
           13857  kmem:mm_page_pcpu_drain
           27576  kmem:mm_page_alloc
-           6025  kmem:mm_pagevec_free
-          20934  kmem:mm_page_free_direct
+           6025  kmem:mm_page_free_batched
+          20934  kmem:mm_page_free
 
     0.613972165  seconds time elapsed
 
@@ -45,8 +45,8 @@ You can observe the statistical properties as well, by using the
 'repeat the workload N times' feature of perf stat:
 
  titan:~> perf stat --repeat 5 -e kmem:mm_page_pcpu_drain -e
-   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-   kmem:mm_page_free_direct ./hackbench 10
+   kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+   kmem:mm_page_free ./hackbench 10
  Time: 0.627
  Time: 0.644
  Time: 0.564
@@ -57,8 +57,8 @@ You can observe the statistical properties as well, by using the
 
           12920  kmem:mm_page_pcpu_drain    ( +-   3.359% )
           25035  kmem:mm_page_alloc         ( +-   3.783% )
-           6104  kmem:mm_pagevec_free       ( +-   0.934% )
-          18376  kmem:mm_page_free_direct   ( +-   4.941% )
+           6104  kmem:mm_page_free_batched  ( +-   0.934% )
+          18376  kmem:mm_page_free          ( +-   4.941% )
 
     0.643954516  seconds time elapsed   ( +-   2.363% )
 
@@ -158,15 +158,15 @@ Or you can observe the whole system's page allocations for 10
 seconds:
 
 titan:~/git> perf stat -a -e kmem:mm_page_pcpu_drain -e
-kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-kmem:mm_page_free_direct sleep 10
+kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+kmem:mm_page_free sleep 10
 
  Performance counter stats for 'sleep 10':
 
          171585  kmem:mm_page_pcpu_drain
          322114  kmem:mm_page_alloc
-          73623  kmem:mm_pagevec_free
-         254115  kmem:mm_page_free_direct
+          73623  kmem:mm_page_free_batched
+         254115  kmem:mm_page_free
 
    10.000591410  seconds time elapsed
 
@@ -174,15 +174,15 @@ Or observe how fluctuating the page allocations are, via statistical
 analysis done over ten 1-second intervals:
 
  titan:~/git> perf stat --repeat 10 -a -e kmem:mm_page_pcpu_drain -e
-   kmem:mm_page_alloc -e kmem:mm_pagevec_free -e
-   kmem:mm_page_free_direct sleep 1
+   kmem:mm_page_alloc -e kmem:mm_page_free_batched -e
+   kmem:mm_page_free sleep 1
 
  Performance counter stats for 'sleep 1' (10 runs):
 
           17254  kmem:mm_page_pcpu_drain    ( +-   3.709% )
           34394  kmem:mm_page_alloc         ( +-   4.617% )
-           7509  kmem:mm_pagevec_free       ( +-   4.820% )
-          25653  kmem:mm_page_free_direct   ( +-   3.672% )
+           7509  kmem:mm_page_free_batched  ( +-   4.820% )
+          25653  kmem:mm_page_free          ( +-   3.672% )
 
     1.058135029  seconds time elapsed   ( +-   3.089% )
 
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
index 85c5f026930d..c89f9e1453f7 100644
--- a/tools/perf/Documentation/perf-annotate.txt
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -22,7 +22,7 @@ OPTIONS
 -------
 -i::
 --input=::
-        Input file name. (default: perf.data)
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 -d::
 --dsos=<dso[,dso...]>::
@@ -66,12 +66,25 @@ OPTIONS
         used. This interfaces starts by centering on the line with more
         samples, TAB/UNTAB cycles through the lines with more samples.
 
--c::
+-C::
 --cpu:: Only report samples for the list of CPUs provided. Multiple CPUs can
         be provided as a comma-separated list with no space: 0,1. Ranges of
         CPUs are specified with -: 0-2. 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..25c52efcc7f0 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::
@@ -23,10 +26,13 @@ OPTIONS
         Show only DSOs with hits.
 -i::
 --input=::
-        Input file name. (default: perf.data)
+        Input file name. (default: perf.data unless stdin is a fifo)
 -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-evlist.txt b/tools/perf/Documentation/perf-evlist.txt
index 0cada9e053dc..0507ec7bad71 100644
--- a/tools/perf/Documentation/perf-evlist.txt
+++ b/tools/perf/Documentation/perf-evlist.txt
@@ -18,7 +18,7 @@ OPTIONS
 -------
 -i::
 --input=::
-        Input file name. (default: perf.data)
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
index a52fcde894c7..7c8fbbf3f61c 100644
--- a/tools/perf/Documentation/perf-kmem.txt
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -23,7 +23,7 @@ OPTIONS
 -------
 -i <file>::
 --input=<file>::
-        Select the input file (default: perf.data)
+        Select the input file (default: perf.data unless stdin is a fifo)
 
 --caller::
         Show per-callsite statistics
diff --git a/tools/perf/Documentation/perf-lock.txt b/tools/perf/Documentation/perf-lock.txt
index 4a26a2f3a6a3..d6b2a4f2108b 100644
--- a/tools/perf/Documentation/perf-lock.txt
+++ b/tools/perf/Documentation/perf-lock.txt
@@ -29,7 +29,7 @@ COMMON OPTIONS
 
 -i::
 --input=<file>::
-        Input file name.
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 -v::
 --verbose::
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 5a520f825295..2937f7e14bb7 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -89,7 +89,7 @@ OPTIONS
 
 -m::
 --mmap-pages=::
-        Number of mmap data pages.
+        Number of mmap data pages. Must be a power of two.
 
 -g::
 --call-graph::
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 04253c07d19a..9b430e98712e 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -19,7 +19,7 @@ OPTIONS
 -------
 -i::
 --input=::
-        Input file name. (default: perf.data)
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 -v::
 --verbose::
@@ -39,7 +39,7 @@ OPTIONS
 -T::
 --threads::
         Show per-thread event counters
--C::
+-c::
 --comms=::
         Only consider symbols in these comms. CSV that understands
         file://filename entries.
@@ -80,9 +80,10 @@ OPTIONS
 --dump-raw-trace::
         Dump raw trace in ASCII.
 
--g [type,min,order]::
+-g [type,min[,limit],order]::
 --call-graph::
-        Display call chains using type, min percent threshold and order.
+        Display call chains using type, min percent threshold, optional print
+        limit and order.
         type can be either:
         - flat: single column, linear exposure of call chains.
         - graph: use a graph tree, displaying absolute overhead rates.
@@ -128,12 +129,30 @@ OPTIONS
 --symfs=<directory>::
         Look for files with symbols relative to this directory.
 
--c::
+-C::
 --cpu:: Only report samples for the list of CPUs provided. Multiple CPUs can
         be provided as a comma-separated list with no space: 0,1. Ranges of
         CPUs are specified with -: 0-2. 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..8ff4df956951 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
@@ -40,7 +40,7 @@ OPTIONS
 -------
 -i::
 --input=<file>::
-        Input file name. (default: perf.data)
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 -v::
 --verbose::
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index db017867d9e8..2f6cef43da25 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -106,7 +106,7 @@ OPTIONS
 
 -i::
 --input=::
-        Input file name.
+        Input file name. (default: perf.data unless stdin is a fifo)
 
 -d::
 --debug-mode::
@@ -182,12 +182,24 @@ OPTIONS
 --hide-call-graph::
         When printing symbols do not display call chain.
 
--c::
+-C::
 --cpu:: Only report samples for the list of CPUs provided. Multiple CPUs can
         be provided as a comma-separated list with no space: 0,1. Ranges of
         CPUs are specified with -: 0-2. Default is to report samples on all
         CPUs.
 
+-c::
+--comms=::
+        Only display events for these comms. CSV that understands
+        file://filename entries.
+
+-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-test.txt b/tools/perf/Documentation/perf-test.txt
index 2c3b462f64b0..b24ac40fcd58 100644
--- a/tools/perf/Documentation/perf-test.txt
+++ b/tools/perf/Documentation/perf-test.txt
@@ -8,13 +8,19 @@ perf-test - Runs sanity tests.
 SYNOPSIS
 --------
 [verse]
-'perf test <options>'
+'perf test [<options>] [{list <test-name-fragment>|[<test-name-fragments>|<test-numbers>]}]'
 
 DESCRIPTION
 -----------
 This command does assorted sanity tests, initially through linked routines but
 also will look for a directory with more tests in the form of scripts.
 
+To get a list of available tests use 'perf test list', specifying a test name
+fragment will show all tests that have it.
+
+To run just specific tests, inform test name fragments or the numbers obtained
+from 'perf test list'.
+
 OPTIONS
 -------
 -v::
diff --git a/tools/perf/Documentation/perf-timechart.txt b/tools/perf/Documentation/perf-timechart.txt
index d7b79e2ba2ad..1632b0efc757 100644
--- a/tools/perf/Documentation/perf-timechart.txt
+++ b/tools/perf/Documentation/perf-timechart.txt
@@ -27,7 +27,7 @@ OPTIONS
         Select the output file (default: output.svg)
 -i::
 --input=::
-        Select the input file (default: perf.data)
+        Select the input file (default: perf.data unless stdin is a fifo)
 -w::
 --width=::
         Select the width of the SVG file (default: 1000)
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 e9d5c271db69..ac86d67b636e 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -278,6 +278,7 @@ LIB_H += util/strbuf.h
 LIB_H += util/strlist.h
 LIB_H += util/strfilter.h
 LIB_H += util/svghelper.h
+LIB_H += util/tool.h
 LIB_H += util/run-command.h
 LIB_H += util/sigchain.h
 LIB_H += util/symbol.h
@@ -466,13 +467,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
@@ -729,9 +730,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/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/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
index 48ae0c5e3f73..7cdd61d0e27c 100644
--- a/tools/perf/arch/powerpc/util/dwarf-regs.c
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -9,7 +9,10 @@
  * 2 of the License, or (at your option) any later version.
  */
 
+#include <stdlib.h>
+#ifndef __UCLIBC__
 #include <libio.h>
+#endif
 #include <dwarf-regs.h>
 
 
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..214ba7f9f577 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -27,32 +27,32 @@
 #include "util/sort.h"
 #include "util/hist.h"
 #include "util/session.h"
+#include "util/tool.h"
 
 #include <linux/bitmap.h>
 
-static char             const *input_name = "perf.data";
-
-static bool             force, use_tui, use_stdio;
-
-static bool             full_paths;
-
-static bool             print_line;
-
-static const char *sym_hist_filter;
-
-static const char       *cpu_list;
-static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
+struct perf_annotate {
+        struct perf_tool tool;
+        char const *input_name;
+        bool       force, use_tui, use_stdio;
+        bool       full_paths;
+        bool       print_line;
+        const char *sym_hist_filter;
+        const char *cpu_list;
+        DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
+};
 
-static int perf_evlist__add_sample(struct perf_evlist *evlist,
-                                   struct perf_sample *sample,
-                                   struct perf_evsel *evsel,
-                                   struct addr_location *al)
+static int perf_evsel__add_sample(struct perf_evsel *evsel,
+                                  struct perf_sample *sample,
+                                  struct addr_location *al,
+                                  struct perf_annotate *ann)
 {
         struct hist_entry *he;
         int ret;
 
-        if (sym_hist_filter != NULL &&
-            (al->sym == NULL || strcmp(sym_hist_filter, al->sym->name) != 0)) {
+        if (ann->sym_hist_filter != NULL &&
+            (al->sym == NULL ||
+             strcmp(ann->sym_hist_filter, al->sym->name) != 0)) {
                 /* We're only interested in a symbol named sym_hist_filter */
                 if (al->sym != NULL) {
                         rb_erase(&al->sym->rb_node,
@@ -69,8 +69,7 @@ static int perf_evlist__add_sample(struct perf_evlist *evlist,
         ret = 0;
         if (he->ms.sym != NULL) {
                 struct annotation *notes = symbol__annotation(he->ms.sym);
-                if (notes->src == NULL &&
-                    symbol__alloc_hist(he->ms.sym, evlist->nr_entries) < 0)
+                if (notes->src == NULL && symbol__alloc_hist(he->ms.sym) < 0)
                         return -ENOMEM;
 
                 ret = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
@@ -81,25 +80,26 @@ static int perf_evlist__add_sample(struct perf_evlist *evlist,
         return ret;
 }
 
-static int process_sample_event(union perf_event *event,
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *event,
                                 struct perf_sample *sample,
                                 struct perf_evsel *evsel,
-                                struct perf_session *session)
+                                struct machine *machine)
 {
+        struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool);
         struct addr_location al;
 
-        if (perf_event__preprocess_sample(event, session, &al, sample,
+        if (perf_event__preprocess_sample(event, machine, &al, sample,
                                           symbol__annotate_init) < 0) {
                 pr_warning("problem processing %d event, skipping it.\n",
                            event->header.type);
                 return -1;
         }
 
-        if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
+        if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap))
                 return 0;
 
-        if (!al.filtered &&
-            perf_evlist__add_sample(session->evlist, sample, evsel, &al)) {
+        if (!al.filtered && perf_evsel__add_sample(evsel, sample, &al, ann)) {
                 pr_warning("problem incrementing symbol count, "
                            "skipping event\n");
                 return -1;
@@ -108,16 +108,18 @@ static int process_sample_event(union perf_event *event,
         return 0;
 }
 
-static int hist_entry__tty_annotate(struct hist_entry *he, int evidx)
+static int hist_entry__tty_annotate(struct hist_entry *he, int evidx,
+                                    struct perf_annotate *ann)
 {
         return symbol__tty_annotate(he->ms.sym, he->ms.map, evidx,
-                                    print_line, full_paths, 0, 0);
+                                    ann->print_line, ann->full_paths, 0, 0);
 }
 
-static void hists__find_annotations(struct hists *self, int evidx)
+static void hists__find_annotations(struct hists *self, int evidx,
+                                    struct perf_annotate *ann)
 {
         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 +131,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 +139,12 @@ find_next:
                 }
 
                 if (use_browser > 0) {
-                        key = hist_entry__tui_annotate(he, evidx);
+                        key = hist_entry__tui_annotate(he, evidx, 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:
@@ -152,7 +154,7 @@ find_next:
                         if (next != NULL)
                                 nd = next;
                 } else {
-                        hist_entry__tty_annotate(he, evidx);
+                        hist_entry__tty_annotate(he, evidx, ann);
                         nd = rb_next(nd);
                         /*
                          * Since we have a hist_entry per IP for the same
@@ -165,33 +167,26 @@ find_next:
         }
 }
 
-static struct perf_event_ops event_ops = {
-        .sample = process_sample_event,
-        .mmap   = perf_event__process_mmap,
-        .comm   = perf_event__process_comm,
-        .fork   = perf_event__process_task,
-        .ordered_samples = true,
-        .ordering_requires_timestamps = true,
-};
-
-static int __cmd_annotate(void)
+static int __cmd_annotate(struct perf_annotate *ann)
 {
         int ret;
         struct perf_session *session;
         struct perf_evsel *pos;
         u64 total_nr_samples;
 
-        session = perf_session__new(input_name, O_RDONLY, force, false, &event_ops);
+        session = perf_session__new(ann->input_name, O_RDONLY,
+                                    ann->force, false, &ann->tool);
         if (session == NULL)
                 return -ENOMEM;
 
-        if (cpu_list) {
-                ret = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
+        if (ann->cpu_list) {
+                ret = perf_session__cpu_bitmap(session, ann->cpu_list,
+                                               ann->cpu_bitmap);
                 if (ret)
                         goto out_delete;
         }
 
-        ret = perf_session__process_events(session, &event_ops);
+        ret = perf_session__process_events(session, &ann->tool);
         if (ret)
                 goto out_delete;
 
@@ -215,12 +210,12 @@ 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, ann);
                 }
         }
 
         if (total_nr_samples == 0) {
-                ui__warning("The %s file has no samples!\n", input_name);
+                ui__warning("The %s file has no samples!\n", session->filename);
                 goto out_delete;
         }
 out_delete:
@@ -244,39 +239,57 @@ static const char * const annotate_usage[] = {
         NULL
 };
 
-static const struct option options[] = {
-        OPT_STRING('i', "input", &input_name, "file",
+int cmd_annotate(int argc, const char **argv, const char *prefix __used)
+{
+        struct perf_annotate annotate = {
+                .tool = {
+                        .sample = process_sample_event,
+                        .mmap   = perf_event__process_mmap,
+                        .comm   = perf_event__process_comm,
+                        .fork   = perf_event__process_task,
+                        .ordered_samples = true,
+                        .ordering_requires_timestamps = true,
+                },
+        };
+        const struct option options[] = {
+        OPT_STRING('i', "input", &annotate.input_name, "file",
                     "input file name"),
         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                    "only consider symbols in these dsos"),
-        OPT_STRING('s', "symbol", &sym_hist_filter, "symbol",
+        OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol",
                     "symbol to annotate"),
-        OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
+        OPT_BOOLEAN('f', "force", &annotate.force, "don't complain, do it"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"),
-        OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
+        OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"),
+        OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"),
         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
                    "file", "vmlinux pathname"),
         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
-        OPT_BOOLEAN('l', "print-line", &print_line,
+        OPT_BOOLEAN('l', "print-line", &annotate.print_line,
                     "print matching source lines (may be slow)"),
-        OPT_BOOLEAN('P', "full-paths", &full_paths,
+        OPT_BOOLEAN('P', "full-paths", &annotate.full_paths,
                     "Don't shorten the displayed pathnames"),
-        OPT_STRING('c', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
+        OPT_STRING('C', "cpu", &annotate.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()
-};
+        };
 
-int cmd_annotate(int argc, const char **argv, const char *prefix __used)
-{
         argc = parse_options(argc, argv, options, annotate_usage, 0);
 
-        if (use_stdio)
+        if (annotate.use_stdio)
                 use_browser = 0;
-        else if (use_tui)
+        else if (annotate.use_tui)
                 use_browser = 1;
 
         setup_browser(true);
@@ -297,7 +310,7 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 if (argc > 1)
                         usage_with_options(annotate_usage, options);
 
-                sym_hist_filter = argv[0];
+                annotate.sym_hist_filter = argv[0];
         }
 
         if (field_sep && *field_sep == '.') {
@@ -305,5 +318,5 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 return -1;
         }
 
-        return __cmd_annotate();
+        return __cmd_annotate(&annotate);
 }
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 5af32ae9031e..52480467e9ff 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"
 
-static char const *input_name = "perf.data";
+#include <libelf.h>
+
+static const char *input_name;
 static bool force;
+static bool show_kernel;
 static bool with_hits;
 
 static const char * const buildid_list_usage[] = {
@@ -29,29 +33,74 @@ 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 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 perf_session__list_build_ids(void)
 {
         struct perf_session *session;
 
+        elf_version(EV_CURRENT);
+
         session = perf_session__new(input_name, O_RDONLY, force, false,
                                     &build_id__mark_dso_hit_ops);
         if (session == NULL)
                 return -1;
 
+        /*
+         * See if this is an ELF file first:
+         */
+        if (filename__fprintf_build_id(session->filename, stdout))
+                goto out;
+
         if (with_hits)
                 perf_session__process_events(session, &build_id__mark_dso_hit_ops);
 
         perf_session__fprintf_dsos_buildid(session, stdout, with_hits);
-
+out:
         perf_session__delete(session);
         return 0;
 }
 
+static int __cmd_buildid_list(void)
+{
+        if (show_kernel)
+                return sysfs__fprintf_build_id(stdout);
+
+        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..4f19513d7dda 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -9,7 +9,9 @@
 #include "util/debug.h"
 #include "util/event.h"
 #include "util/hist.h"
+#include "util/evsel.h"
 #include "util/session.h"
+#include "util/tool.h"
 #include "util/sort.h"
 #include "util/symbol.h"
 #include "util/util.h"
@@ -30,14 +32,15 @@ static int hists__add_entry(struct hists *self,
         return -ENOMEM;
 }
 
-static int diff__process_sample_event(union perf_event *event,
+static int diff__process_sample_event(struct perf_tool *tool __used,
+                                      union perf_event *event,
                                       struct perf_sample *sample,
                                       struct perf_evsel *evsel __used,
-                                      struct perf_session *session)
+                                      struct machine *machine)
 {
         struct addr_location al;
 
-        if (perf_event__preprocess_sample(event, session, &al, sample, NULL) < 0) {
+        if (perf_event__preprocess_sample(event, machine, &al, sample, NULL) < 0) {
                 pr_warning("problem processing %d event, skipping it.\n",
                            event->header.type);
                 return -1;
@@ -46,16 +49,16 @@ static int diff__process_sample_event(union perf_event *event,
         if (al.filtered || al.sym == NULL)
                 return 0;
 
-        if (hists__add_entry(&session->hists, &al, sample->period)) {
+        if (hists__add_entry(&evsel->hists, &al, sample->period)) {
                 pr_warning("problem incrementing symbol period, skipping event\n");
                 return -1;
         }
 
-        session->hists.stats.total_period += sample->period;
+        evsel->hists.stats.total_period += sample->period;
         return 0;
 }
 
-static struct perf_event_ops event_ops = {
+static struct perf_tool perf_diff = {
         .sample = diff__process_sample_event,
         .mmap   = perf_event__process_mmap,
         .comm   = perf_event__process_comm,
@@ -145,13 +148,13 @@ static int __cmd_diff(void)
         int ret, i;
         struct perf_session *session[2];
 
-        session[0] = perf_session__new(input_old, O_RDONLY, force, false, &event_ops);
-        session[1] = perf_session__new(input_new, O_RDONLY, force, false, &event_ops);
+        session[0] = perf_session__new(input_old, O_RDONLY, force, false, &perf_diff);
+        session[1] = perf_session__new(input_new, O_RDONLY, force, false, &perf_diff);
         if (session[0] == NULL || session[1] == NULL)
                 return -ENOMEM;
 
         for (i = 0; i < 2; ++i) {
-                ret = perf_session__process_events(session[i], &event_ops);
+                ret = perf_session__process_events(session[i], &perf_diff);
                 if (ret)
                         goto out_delete;
         }
@@ -162,7 +165,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-evlist.c b/tools/perf/builtin-evlist.c
index 4c5e9e04a41f..26760322c4f4 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -15,7 +15,7 @@
 #include "util/parse-options.h"
 #include "util/session.h"
 
-static char const *input_name = "perf.data";
+static const char *input_name;
 
 static int __cmd_evlist(void)
 {
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 8dfc12bb119b..09c106193e65 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -9,6 +9,7 @@
 
 #include "perf.h"
 #include "util/session.h"
+#include "util/tool.h"
 #include "util/debug.h"
 
 #include "util/parse-options.h"
@@ -16,8 +17,9 @@
 static char             const *input_name = "-";
 static bool             inject_build_ids;
 
-static int perf_event__repipe_synth(union perf_event *event,
-                                    struct perf_session *session __used)
+static int perf_event__repipe_synth(struct perf_tool *tool __used,
+                                    union perf_event *event,
+                                    struct machine *machine __used)
 {
         uint32_t size;
         void *buf = event;
@@ -36,41 +38,70 @@ static int perf_event__repipe_synth(union perf_event *event,
         return 0;
 }
 
-static int perf_event__repipe(union perf_event *event,
+static int perf_event__repipe_op2_synth(struct perf_tool *tool,
+                                        union perf_event *event,
+                                        struct perf_session *session __used)
+{
+        return perf_event__repipe_synth(tool, event, NULL);
+}
+
+static int perf_event__repipe_event_type_synth(struct perf_tool *tool,
+                                               union perf_event *event)
+{
+        return perf_event__repipe_synth(tool, event, NULL);
+}
+
+static int perf_event__repipe_tracing_data_synth(union perf_event *event,
+                                                 struct perf_session *session __used)
+{
+        return perf_event__repipe_synth(NULL, event, NULL);
+}
+
+static int perf_event__repipe_attr(union perf_event *event,
+                                   struct perf_evlist **pevlist __used)
+{
+        return perf_event__repipe_synth(NULL, event, NULL);
+}
+
+static int perf_event__repipe(struct perf_tool *tool,
+                              union perf_event *event,
                               struct perf_sample *sample __used,
-                              struct perf_session *session)
+                              struct machine *machine)
 {
-        return perf_event__repipe_synth(event, session);
+        return perf_event__repipe_synth(tool, event, machine);
 }
 
-static int perf_event__repipe_sample(union perf_event *event,
+static int perf_event__repipe_sample(struct perf_tool *tool,
+                                     union perf_event *event,
                               struct perf_sample *sample __used,
                               struct perf_evsel *evsel __used,
-                              struct perf_session *session)
+                              struct machine *machine)
 {
-        return perf_event__repipe_synth(event, session);
+        return perf_event__repipe_synth(tool, event, machine);
 }
 
-static int perf_event__repipe_mmap(union perf_event *event,
+static int perf_event__repipe_mmap(struct perf_tool *tool,
+                                   union perf_event *event,
                                    struct perf_sample *sample,
-                                   struct perf_session *session)
+                                   struct machine *machine)
 {
         int err;
 
-        err = perf_event__process_mmap(event, sample, session);
-        perf_event__repipe(event, sample, session);
+        err = perf_event__process_mmap(tool, event, sample, machine);
+        perf_event__repipe(tool, event, sample, machine);
 
         return err;
 }
 
-static int perf_event__repipe_task(union perf_event *event,
+static int perf_event__repipe_task(struct perf_tool *tool,
+                                   union perf_event *event,
                                    struct perf_sample *sample,
-                                   struct perf_session *session)
+                                   struct machine *machine)
 {
         int err;
 
-        err = perf_event__process_task(event, sample, session);
-        perf_event__repipe(event, sample, session);
+        err = perf_event__process_task(tool, event, sample, machine);
+        perf_event__repipe(tool, event, sample, machine);
 
         return err;
 }
@@ -80,7 +111,7 @@ static int perf_event__repipe_tracing_data(union perf_event *event,
 {
         int err;
 
-        perf_event__repipe_synth(event, session);
+        perf_event__repipe_synth(NULL, event, NULL);
         err = perf_event__process_tracing_data(event, session);
 
         return err;
@@ -100,10 +131,10 @@ static int dso__read_build_id(struct dso *self)
         return -1;
 }
 
-static int dso__inject_build_id(struct dso *self, struct perf_session *session)
+static int dso__inject_build_id(struct dso *self, struct perf_tool *tool,
+                                struct machine *machine)
 {
         u16 misc = PERF_RECORD_MISC_USER;
-        struct machine *machine;
         int err;
 
         if (dso__read_build_id(self) < 0) {
@@ -111,17 +142,11 @@ static int dso__inject_build_id(struct dso *self, struct perf_session *session)
                 return -1;
         }
 
-        machine = perf_session__find_host_machine(session);
-        if (machine == NULL) {
-                pr_err("Can't find machine for session\n");
-                return -1;
-        }
-
         if (self->kernel)
                 misc = PERF_RECORD_MISC_KERNEL;
 
-        err = perf_event__synthesize_build_id(self, misc, perf_event__repipe,
-                                              machine, session);
+        err = perf_event__synthesize_build_id(tool, self, misc, perf_event__repipe,
+                                              machine);
         if (err) {
                 pr_err("Can't synthesize build_id event for %s\n", self->long_name);
                 return -1;
@@ -130,10 +155,11 @@ static int dso__inject_build_id(struct dso *self, struct perf_session *session)
         return 0;
 }
 
-static int perf_event__inject_buildid(union perf_event *event,
+static int perf_event__inject_buildid(struct perf_tool *tool,
+                                      union perf_event *event,
                                       struct perf_sample *sample,
                                       struct perf_evsel *evsel __used,
-                                      struct perf_session *session)
+                                      struct machine *machine)
 {
         struct addr_location al;
         struct thread *thread;
@@ -141,21 +167,21 @@ static int perf_event__inject_buildid(union perf_event *event,
 
         cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        thread = perf_session__findnew(session, event->ip.pid);
+        thread = machine__findnew_thread(machine, event->ip.pid);
         if (thread == NULL) {
                 pr_err("problem processing %d event, skipping it.\n",
                        event->header.type);
                 goto repipe;
         }
 
-        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
-                              event->ip.pid, event->ip.ip, &al);
+        thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
+                              event->ip.ip, &al);
 
         if (al.map != NULL) {
                 if (!al.map->dso->hit) {
                         al.map->dso->hit = 1;
                         if (map__load(al.map, NULL) >= 0) {
-                                dso__inject_build_id(al.map->dso, session);
+                                dso__inject_build_id(al.map->dso, tool, machine);
                                 /*
                                  * If this fails, too bad, let the other side
                                  * account this as unresolved.
@@ -168,24 +194,24 @@ static int perf_event__inject_buildid(union perf_event *event,
         }
 
 repipe:
-        perf_event__repipe(event, sample, session);
+        perf_event__repipe(tool, event, sample, machine);
         return 0;
 }
 
-struct perf_event_ops inject_ops = {
+struct perf_tool perf_inject = {
         .sample         = perf_event__repipe_sample,
         .mmap           = perf_event__repipe,
         .comm           = perf_event__repipe,
         .fork           = perf_event__repipe,
         .exit           = perf_event__repipe,
         .lost           = perf_event__repipe,
-        .read           = perf_event__repipe,
+        .read           = perf_event__repipe_sample,
         .throttle       = perf_event__repipe,
         .unthrottle     = perf_event__repipe,
-        .attr           = perf_event__repipe_synth,
-        .event_type     = perf_event__repipe_synth,
-        .tracing_data   = perf_event__repipe_synth,
-        .build_id       = perf_event__repipe_synth,
+        .attr           = perf_event__repipe_attr,
+        .event_type     = perf_event__repipe_event_type_synth,
+        .tracing_data   = perf_event__repipe_tracing_data_synth,
+        .build_id       = perf_event__repipe_op2_synth,
 };
 
 extern volatile int session_done;
@@ -203,17 +229,17 @@ static int __cmd_inject(void)
         signal(SIGINT, sig_handler);
 
         if (inject_build_ids) {
-                inject_ops.sample       = perf_event__inject_buildid;
-                inject_ops.mmap         = perf_event__repipe_mmap;
-                inject_ops.fork         = perf_event__repipe_task;
-                inject_ops.tracing_data = perf_event__repipe_tracing_data;
+                perf_inject.sample       = perf_event__inject_buildid;
+                perf_inject.mmap         = perf_event__repipe_mmap;
+                perf_inject.fork         = perf_event__repipe_task;
+                perf_inject.tracing_data = perf_event__repipe_tracing_data;
         }
 
-        session = perf_session__new(input_name, O_RDONLY, false, true, &inject_ops);
+        session = perf_session__new(input_name, O_RDONLY, false, true, &perf_inject);
         if (session == NULL)
                 return -ENOMEM;
 
-        ret = perf_session__process_events(session, &inject_ops);
+        ret = perf_session__process_events(session, &perf_inject);
 
         perf_session__delete(session);
 
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 225e963df105..fe1ad8f21961 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -7,6 +7,7 @@
 #include "util/thread.h"
 #include "util/header.h"
 #include "util/session.h"
+#include "util/tool.h"
 
 #include "util/parse-options.h"
 #include "util/trace-event.h"
@@ -18,7 +19,7 @@
 struct alloc_stat;
 typedef int (*sort_fn_t)(struct alloc_stat *, struct alloc_stat *);
 
-static char const               *input_name = "perf.data";
+static const char               *input_name;
 
 static int                      alloc_flag;
 static int                      caller_flag;
@@ -303,12 +304,13 @@ static void process_raw_event(union perf_event *raw_event __used, void *data,
         }
 }
 
-static int process_sample_event(union perf_event *event,
+static int process_sample_event(struct perf_tool *tool __used,
+                                union perf_event *event,
                                 struct perf_sample *sample,
                                 struct perf_evsel *evsel __used,
-                                struct perf_session *session)
+                                struct machine *machine)
 {
-        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+        struct thread *thread = machine__findnew_thread(machine, event->ip.pid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
@@ -324,7 +326,7 @@ static int process_sample_event(union perf_event *event,
         return 0;
 }
 
-static struct perf_event_ops event_ops = {
+static struct perf_tool perf_kmem = {
         .sample                 = process_sample_event,
         .comm                   = perf_event__process_comm,
         .ordered_samples        = true,
@@ -483,7 +485,7 @@ static int __cmd_kmem(void)
 {
         int err = -EINVAL;
         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
-                                                         0, false, &event_ops);
+                                                         0, false, &perf_kmem);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -494,7 +496,7 @@ static int __cmd_kmem(void)
                 goto out_delete;
 
         setup_pager();
-        err = perf_session__process_events(session, &event_ops);
+        err = perf_session__process_events(session, &perf_kmem);
         if (err != 0)
                 goto out_delete;
         sort_result();
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
index 34d1e853829d..032324a76b87 100644
--- a/tools/perf/builtin-kvm.c
+++ b/tools/perf/builtin-kvm.c
@@ -38,7 +38,7 @@ static const struct option kvm_options[] = {
         OPT_BOOLEAN(0, "guest", &perf_guest,
                     "Collect guest os data"),
         OPT_BOOLEAN(0, "host", &perf_host,
-                    "Collect guest os data"),
+                    "Collect host os data"),
         OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
                    "guest mount directory under which every guest os"
                    " instance has a subdir"),
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 899080ace267..2296c391d0f5 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -12,6 +12,7 @@
 
 #include "util/debug.h"
 #include "util/session.h"
+#include "util/tool.h"
 
 #include <sys/types.h>
 #include <sys/prctl.h>
@@ -325,7 +326,7 @@ alloc_failed:
         die("memory allocation failed\n");
 }
 
-static char                     const *input_name = "perf.data";
+static const char *input_name;
 
 struct raw_event_sample {
         u32                     size;
@@ -845,12 +846,13 @@ static void dump_info(void)
                 die("Unknown type of information\n");
 }
 
-static int process_sample_event(union perf_event *event,
+static int process_sample_event(struct perf_tool *tool __used,
+                                union perf_event *event,
                                 struct perf_sample *sample,
                                 struct perf_evsel *evsel __used,
-                                struct perf_session *s)
+                                struct machine *machine)
 {
-        struct thread *thread = perf_session__findnew(s, sample->tid);
+        struct thread *thread = machine__findnew_thread(machine, sample->tid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %d event, skipping it.\n",
@@ -863,7 +865,7 @@ static int process_sample_event(union perf_event *event,
         return 0;
 }
 
-static struct perf_event_ops eops = {
+static struct perf_tool eops = {
         .sample                 = process_sample_event,
         .comm                   = perf_event__process_comm,
         .ordered_samples        = true,
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 710ae3d0a489..59d43abfbfec 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -46,7 +46,6 @@
 
 #define DEFAULT_VAR_FILTER "!__k???tab_* & !__crc_*"
 #define DEFAULT_FUNC_FILTER "!_*"
-#define MAX_PATH_LEN 256
 
 /* Session management structure */
 static struct {
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index f4c3fbee4bad..0abfb18b911f 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -22,6 +22,7 @@
 #include "util/evsel.h"
 #include "util/debug.h"
 #include "util/session.h"
+#include "util/tool.h"
 #include "util/symbol.h"
 #include "util/cpumap.h"
 #include "util/thread_map.h"
@@ -35,54 +36,36 @@ enum write_mode_t {
         WRITE_APPEND
 };
 
-static u64                      user_interval                   = ULLONG_MAX;
-static u64                      default_interval                =      0;
-
-static unsigned int             page_size;
-static unsigned int             mmap_pages                      = UINT_MAX;
-static unsigned int             user_freq                       = UINT_MAX;
-static int                      freq                            =   1000;
-static int                      output;
-static int                      pipe_output                     =      0;
-static const char               *output_name                    = NULL;
-static bool                     group                           =  false;
-static int                      realtime_prio                   =      0;
-static bool                     nodelay                         =  false;
-static bool                     raw_samples                     =  false;
-static bool                     sample_id_all_avail             =   true;
-static bool                     system_wide                     =  false;
-static pid_t                    target_pid                      =     -1;
-static pid_t                    target_tid                      =     -1;
-static pid_t                    child_pid                       =     -1;
-static bool                     no_inherit                      =  false;
-static enum write_mode_t        write_mode                      = WRITE_FORCE;
-static bool                     call_graph                      =  false;
-static bool                     inherit_stat                    =  false;
-static bool                     no_samples                      =  false;
-static bool                     sample_address                  =  false;
-static bool                     sample_time                     =  false;
-static bool                     no_buildid                      =  false;
-static bool                     no_buildid_cache                =  false;
-static struct perf_evlist       *evsel_list;
-
-static long                     samples                         =      0;
-static u64                      bytes_written                   =      0;
-
-static int                      file_new                        =      1;
-static off_t                    post_processing_offset;
-
-static struct perf_session      *session;
-static const char               *cpu_list;
-
-static void advance_output(size_t size)
+struct perf_record {
+        struct perf_tool        tool;
+        struct perf_record_opts opts;
+        u64                     bytes_written;
+        const char              *output_name;
+        struct perf_evlist      *evlist;
+        struct perf_session     *session;
+        const char              *progname;
+        int                     output;
+        unsigned int            page_size;
+        int                     realtime_prio;
+        enum write_mode_t       write_mode;
+        bool                    no_buildid;
+        bool                    no_buildid_cache;
+        bool                    force;
+        bool                    file_new;
+        bool                    append_file;
+        long                    samples;
+        off_t                   post_processing_offset;
+};
+
+static void advance_output(struct perf_record *rec, size_t size)
 {
-        bytes_written += size;
+        rec->bytes_written += size;
 }
 
-static void write_output(void *buf, size_t size)
+static void write_output(struct perf_record *rec, void *buf, size_t size)
 {
         while (size) {
-                int ret = write(output, buf, size);
+                int ret = write(rec->output, buf, size);
 
                 if (ret < 0)
                         die("failed to write");
@@ -90,30 +73,33 @@ static void write_output(void *buf, size_t size)
                 size -= ret;
                 buf += ret;
 
-                bytes_written += ret;
+                rec->bytes_written += ret;
         }
 }
 
-static int process_synthesized_event(union perf_event *event,
+static int process_synthesized_event(struct perf_tool *tool,
+                                     union perf_event *event,
                                      struct perf_sample *sample __used,
-                                     struct perf_session *self __used)
+                                     struct machine *machine __used)
 {
-        write_output(event, event->header.size);
+        struct perf_record *rec = container_of(tool, struct perf_record, tool);
+        write_output(rec, event, event->header.size);
         return 0;
 }
 
-static void mmap_read(struct perf_mmap *md)
+static void perf_record__mmap_read(struct perf_record *rec,
+                                   struct perf_mmap *md)
 {
         unsigned int head = perf_mmap__read_head(md);
         unsigned int old = md->prev;
-        unsigned char *data = md->base + page_size;
+        unsigned char *data = md->base + rec->page_size;
         unsigned long size;
         void *buf;
 
         if (old == head)
                 return;
 
-        samples++;
+        rec->samples++;
 
         size = head - old;
 
@@ -122,14 +108,14 @@ static void mmap_read(struct perf_mmap *md)
                 size = md->mask + 1 - (old & md->mask);
                 old += size;
 
-                write_output(buf, size);
+                write_output(rec, buf, size);
         }
 
         buf = &data[old & md->mask];
         size = head - old;
         old += size;
 
-        write_output(buf, size);
+        write_output(rec, buf, size);
 
         md->prev = old;
         perf_mmap__write_tail(md, old);
@@ -137,17 +123,30 @@ 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)
+static void perf_record__sig_exit(int exit_status __used, void *arg)
 {
-        if (child_pid > 0)
-                kill(child_pid, SIGTERM);
+        struct perf_record *rec = arg;
+        int status;
+
+        if (rec->evlist->workload.pid > 0) {
+                if (!child_finished)
+                        kill(rec->evlist->workload.pid, SIGTERM);
+
+                wait(&status);
+                if (WIFSIGNALED(status))
+                        psignal(WTERMSIG(status), rec->progname);
+        }
 
         if (signr == -1 || signr == SIGUSR1)
                 return;
@@ -156,78 +155,6 @@ static void sig_atexit(void)
         kill(getpid(), signr);
 }
 
-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 |
-                                  PERF_FORMAT_ID;
-
-        attr->sample_type       |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
-
-        if (evlist->nr_entries > 1)
-                attr->sample_type |= PERF_SAMPLE_ID;
-
-        /*
-         * We default some events to a 1 default interval. But keep
-         * it a weak assumption overridable by the user.
-         */
-        if (!attr->sample_period || (user_freq != UINT_MAX &&
-                                     user_interval != ULLONG_MAX)) {
-                if (freq) {
-                        attr->sample_type       |= PERF_SAMPLE_PERIOD;
-                        attr->freq              = 1;
-                        attr->sample_freq       = freq;
-                } else {
-                        attr->sample_period = default_interval;
-                }
-        }
-
-        if (no_samples)
-                attr->sample_freq = 0;
-
-        if (inherit_stat)
-                attr->inherit_stat = 1;
-
-        if (sample_address) {
-                attr->sample_type       |= PERF_SAMPLE_ADDR;
-                attr->mmap_data = track;
-        }
-
-        if (call_graph)
-                attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
-
-        if (system_wide)
-                attr->sample_type       |= PERF_SAMPLE_CPU;
-
-        if (sample_id_all_avail &&
-            (sample_time || system_wide || !no_inherit || cpu_list))
-                attr->sample_type       |= PERF_SAMPLE_TIME;
-
-        if (raw_samples) {
-                attr->sample_type       |= PERF_SAMPLE_TIME;
-                attr->sample_type       |= PERF_SAMPLE_RAW;
-                attr->sample_type       |= PERF_SAMPLE_CPU;
-        }
-
-        if (nodelay) {
-                attr->watermark = 0;
-                attr->wakeup_events = 1;
-        }
-
-        attr->mmap              = track;
-        attr->comm              = track;
-
-        if (target_pid == -1 && target_tid == -1 && !system_wide) {
-                attr->disabled = 1;
-                attr->enable_on_exec = 1;
-        }
-}
-
 static bool perf_evlist__equal(struct perf_evlist *evlist,
                                struct perf_evlist *other)
 {
@@ -247,15 +174,20 @@ static bool perf_evlist__equal(struct perf_evlist *evlist,
         return true;
 }
 
-static void open_counters(struct perf_evlist *evlist)
+static void perf_record__open(struct perf_record *rec)
 {
-        struct perf_evsel *pos;
+        struct perf_evsel *pos, *first;
+        struct perf_evlist *evlist = rec->evlist;
+        struct perf_session *session = rec->session;
+        struct perf_record_opts *opts = &rec->opts;
+
+        first = list_entry(evlist->entries.next, struct perf_evsel, node);
 
-        if (evlist->cpus->map[0] < 0)
-                no_inherit = true;
+        perf_evlist__config_attrs(evlist, opts);
 
         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.
@@ -270,25 +202,27 @@ static void open_counters(struct perf_evlist *evlist)
                  */
                 bool time_needed = attr->sample_type & PERF_SAMPLE_TIME;
 
-                config_attr(pos, evlist);
+                if (opts->group && pos != first)
+                        group_fd = first->fd;
 retry_sample_id:
-                attr->sample_id_all = sample_id_all_avail ? 1 : 0;
+                attr->sample_id_all = opts->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,
+                                     opts->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) {
+                        } else if (err ==  ENODEV && opts->cpu_list) {
                                 die("No such device - did you specify"
                                         " an out-of-range profile CPU?\n");
-                        } else if (err == EINVAL && sample_id_all_avail) {
+                        } else if (err == EINVAL && opts->sample_id_all_avail) {
                                 /*
                                  * Old kernel, no attr->sample_id_type_all field
                                  */
-                                sample_id_all_avail = false;
-                                if (!sample_time && !raw_samples && !time_needed)
+                                opts->sample_id_all_avail = false;
+                                if (!opts->sample_time && !opts->raw_samples && !time_needed)
                                         attr->sample_type &= ~PERF_SAMPLE_TIME;
 
                                 goto retry_sample_id;
@@ -338,10 +272,20 @@ try_again:
                 exit(-1);
         }
 
-        if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
+        if (perf_evlist__mmap(evlist, opts->mmap_pages, false) < 0) {
+                if (errno == EPERM)
+                        die("Permission error mapping pages.\n"
+                            "Consider increasing "
+                            "/proc/sys/kernel/perf_event_mlock_kb,\n"
+                            "or try again with a smaller value of -m/--mmap_pages.\n"
+                            "(current value: %d)\n", opts->mmap_pages);
+                else if (!is_power_of_2(opts->mmap_pages))
+                        die("--mmap_pages/-m value must be a power of two.");
+
                 die("failed to mmap with %d (%s)\n", errno, strerror(errno));
+        }
 
-        if (file_new)
+        if (rec->file_new)
                 session->evlist = evlist;
         else {
                 if (!perf_evlist__equal(session->evlist, evlist)) {
@@ -353,29 +297,32 @@ try_again:
         perf_session__update_sample_type(session);
 }
 
-static int process_buildids(void)
+static int process_buildids(struct perf_record *rec)
 {
-        u64 size = lseek(output, 0, SEEK_CUR);
+        u64 size = lseek(rec->output, 0, SEEK_CUR);
 
         if (size == 0)
                 return 0;
 
-        session->fd = output;
-        return __perf_session__process_events(session, post_processing_offset,
-                                              size - post_processing_offset,
+        rec->session->fd = rec->output;
+        return __perf_session__process_events(rec->session, rec->post_processing_offset,
+                                              size - rec->post_processing_offset,
                                               size, &build_id__mark_dso_hit_ops);
 }
 
-static void atexit_header(void)
+static void perf_record__exit(int status __used, void *arg)
 {
-        if (!pipe_output) {
-                session->header.data_size += bytes_written;
-
-                if (!no_buildid)
-                        process_buildids();
-                perf_session__write_header(session, evsel_list, output, true);
-                perf_session__delete(session);
-                perf_evlist__delete(evsel_list);
+        struct perf_record *rec = arg;
+
+        if (!rec->opts.pipe_output) {
+                rec->session->header.data_size += rec->bytes_written;
+
+                if (!rec->no_buildid)
+                        process_buildids(rec);
+                perf_session__write_header(rec->session, rec->evlist,
+                                           rec->output, true);
+                perf_session__delete(rec->session);
+                perf_evlist__delete(rec->evlist);
                 symbol__exit();
         }
 }
@@ -383,7 +330,7 @@ static void atexit_header(void)
 static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
 {
         int err;
-        struct perf_session *psession = data;
+        struct perf_tool *tool = data;
 
         if (machine__is_host(machine))
                 return;
@@ -396,8 +343,8 @@ static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
          *method is used to avoid symbol missing when the first addr is
          *in module instead of in guest kernel.
          */
-        err = perf_event__synthesize_modules(process_synthesized_event,
-                                             psession, machine);
+        err = perf_event__synthesize_modules(tool, process_synthesized_event,
+                                             machine);
         if (err < 0)
                 pr_err("Couldn't record guest kernel [%d]'s reference"
                        " relocation symbol.\n", machine->pid);
@@ -406,12 +353,11 @@ static void perf_event__synthesize_guest_os(struct machine *machine, void *data)
          * We use _stext for guest kernel because guest kernel's /proc/kallsyms
          * have no _text sometimes.
          */
-        err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
-                                                 psession, machine, "_text");
+        err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
+                                                 machine, "_text");
         if (err < 0)
-                err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
-                                                         psession, machine,
-                                                         "_stext");
+                err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
+                                                         machine, "_stext");
         if (err < 0)
                 pr_err("Couldn't record guest kernel [%d]'s reference"
                        " relocation symbol.\n", machine->pid);
@@ -422,71 +368,71 @@ static struct perf_event_header finished_round_event = {
         .type = PERF_RECORD_FINISHED_ROUND,
 };
 
-static void mmap_read_all(void)
+static void perf_record__mmap_read_all(struct perf_record *rec)
 {
         int i;
 
-        for (i = 0; i < evsel_list->nr_mmaps; i++) {
-                if (evsel_list->mmap[i].base)
-                        mmap_read(&evsel_list->mmap[i]);
+        for (i = 0; i < rec->evlist->nr_mmaps; i++) {
+                if (rec->evlist->mmap[i].base)
+                        perf_record__mmap_read(rec, &rec->evlist->mmap[i]);
         }
 
-        if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
-                write_output(&finished_round_event, sizeof(finished_round_event));
+        if (perf_header__has_feat(&rec->session->header, HEADER_TRACE_INFO))
+                write_output(rec, &finished_round_event, sizeof(finished_round_event));
 }
 
-static int __cmd_record(int argc, const char **argv)
+static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 {
         struct stat st;
         int flags;
-        int err;
+        int err, output;
         unsigned long waking = 0;
-        int child_ready_pipe[2], go_pipe[2];
         const bool forks = argc > 0;
-        char buf;
         struct machine *machine;
+        struct perf_tool *tool = &rec->tool;
+        struct perf_record_opts *opts = &rec->opts;
+        struct perf_evlist *evsel_list = rec->evlist;
+        const char *output_name = rec->output_name;
+        struct perf_session *session;
+
+        rec->progname = argv[0];
 
-        page_size = sysconf(_SC_PAGE_SIZE);
+        rec->page_size = sysconf(_SC_PAGE_SIZE);
 
-        atexit(sig_atexit);
+        on_exit(perf_record__sig_exit, rec);
         signal(SIGCHLD, sig_handler);
         signal(SIGINT, sig_handler);
         signal(SIGUSR1, sig_handler);
 
-        if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
-                perror("failed to create pipes");
-                exit(-1);
-        }
-
         if (!output_name) {
                 if (!fstat(STDOUT_FILENO, &st) && S_ISFIFO(st.st_mode))
-                        pipe_output = 1;
+                        opts->pipe_output = true;
                 else
-                        output_name = "perf.data";
+                        rec->output_name = output_name = "perf.data";
         }
         if (output_name) {
                 if (!strcmp(output_name, "-"))
-                        pipe_output = 1;
+                        opts->pipe_output = true;
                 else if (!stat(output_name, &st) && st.st_size) {
-                        if (write_mode == WRITE_FORCE) {
+                        if (rec->write_mode == WRITE_FORCE) {
                                 char oldname[PATH_MAX];
                                 snprintf(oldname, sizeof(oldname), "%s.old",
                                          output_name);
                                 unlink(oldname);
                                 rename(output_name, oldname);
                         }
-                } else if (write_mode == WRITE_APPEND) {
-                        write_mode = WRITE_FORCE;
+                } else if (rec->write_mode == WRITE_APPEND) {
+                        rec->write_mode = WRITE_FORCE;
                 }
         }
 
         flags = O_CREAT|O_RDWR;
-        if (write_mode == WRITE_APPEND)
-                file_new = 0;
+        if (rec->write_mode == WRITE_APPEND)
+                rec->file_new = 0;
         else
                 flags |= O_TRUNC;
 
-        if (pipe_output)
+        if (opts->pipe_output)
                 output = STDOUT_FILENO;
         else
                 output = open(output_name, flags, S_IRUSR | S_IWUSR);
@@ -495,17 +441,21 @@ static int __cmd_record(int argc, const char **argv)
                 exit(-1);
         }
 
+        rec->output = output;
+
         session = perf_session__new(output_name, O_WRONLY,
-                                    write_mode == WRITE_FORCE, false, NULL);
+                                    rec->write_mode == WRITE_FORCE, false, NULL);
         if (session == NULL) {
                 pr_err("Not enough memory for reading perf file header\n");
                 return -1;
         }
 
-        if (!no_buildid)
+        rec->session = session;
+
+        if (!rec->no_buildid)
                 perf_header__set_feat(&session->header, HEADER_BUILD_ID);
 
-        if (!file_new) {
+        if (!rec->file_new) {
                 err = perf_session__read_header(session, output);
                 if (err < 0)
                         goto out_delete_session;
@@ -514,94 +464,70 @@ static int __cmd_record(int argc, const char **argv)
         if (have_tracepoints(&evsel_list->entries))
                 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
 
-        /* 512 kiB: default amount of unprivileged mlocked memory */
-        if (mmap_pages == UINT_MAX)
-                mmap_pages = (512 * 1024) / page_size;
+        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);
 
         if (forks) {
-                child_pid = fork();
-                if (child_pid < 0) {
-                        perror("failed to fork");
-                        exit(-1);
-                }
-
-                if (!child_pid) {
-                        if (pipe_output)
-                                dup2(2, 1);
-                        close(child_ready_pipe[0]);
-                        close(go_pipe[1]);
-                        fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
-
-                        /*
-                         * Do a dummy execvp to get the PLT entry resolved,
-                         * so we avoid the resolver overhead on the real
-                         * execvp call.
-                         */
-                        execvp("", (char **)argv);
-
-                        /*
-                         * Tell the parent we're ready to go
-                         */
-                        close(child_ready_pipe[1]);
-
-                        /*
-                         * Wait until the parent tells us to go.
-                         */
-                        if (read(go_pipe[0], &buf, 1) == -1)
-                                perror("unable to read pipe");
-
-                        execvp(argv[0], (char **)argv);
-
-                        perror(argv[0]);
-                        kill(getppid(), SIGUSR1);
-                        exit(-1);
-                }
-
-                if (!system_wide && target_tid == -1 && target_pid == -1)
-                        evsel_list->threads->map[0] = child_pid;
-
-                close(child_ready_pipe[1]);
-                close(go_pipe[0]);
-                /*
-                 * wait for child to settle
-                 */
-                if (read(child_ready_pipe[0], &buf, 1) == -1) {
-                        perror("unable to read pipe");
-                        exit(-1);
+                err = perf_evlist__prepare_workload(evsel_list, opts, argv);
+                if (err < 0) {
+                        pr_err("Couldn't run the workload!\n");
+                        goto out_delete_session;
                 }
-                close(child_ready_pipe[0]);
         }
 
-        open_counters(evsel_list);
+        perf_record__open(rec);
 
         /*
-         * perf_session__delete(session) will be called at atexit_header()
+         * perf_session__delete(session) will be called at perf_record__exit()
          */
-        atexit(atexit_header);
+        on_exit(perf_record__exit, rec);
 
-        if (pipe_output) {
+        if (opts->pipe_output) {
                 err = perf_header__write_pipe(output);
                 if (err < 0)
                         return err;
-        } else if (file_new) {
+        } else if (rec->file_new) {
                 err = perf_session__write_header(session, evsel_list,
                                                  output, false);
                 if (err < 0)
                         return err;
         }
 
-        post_processing_offset = lseek(output, 0, SEEK_CUR);
+        if (!!rec->no_buildid
+            && !perf_header__has_feat(&session->header, HEADER_BUILD_ID)) {
+                pr_err("Couldn't generating buildids. "
+                       "Use --no-buildid to profile anyway.\n");
+                return -1;
+        }
+
+        rec->post_processing_offset = lseek(output, 0, SEEK_CUR);
 
-        if (pipe_output) {
-                err = perf_session__synthesize_attrs(session,
-                                                     process_synthesized_event);
+        machine = perf_session__find_host_machine(session);
+        if (!machine) {
+                pr_err("Couldn't find native kernel information.\n");
+                return -1;
+        }
+
+        if (opts->pipe_output) {
+                err = perf_event__synthesize_attrs(tool, session,
+                                                   process_synthesized_event);
                 if (err < 0) {
                         pr_err("Couldn't synthesize attrs.\n");
                         return err;
                 }
 
-                err = perf_event__synthesize_event_types(process_synthesized_event,
-                                                         session);
+                err = perf_event__synthesize_event_types(tool, process_synthesized_event,
+                                                         machine);
                 if (err < 0) {
                         pr_err("Couldn't synthesize event_types.\n");
                         return err;
@@ -616,56 +542,49 @@ static int __cmd_record(int argc, const char **argv)
                          * return this more properly and also
                          * propagate errors that now are calling die()
                          */
-                        err = perf_event__synthesize_tracing_data(output, evsel_list,
-                                                                  process_synthesized_event,
-                                                                  session);
+                        err = perf_event__synthesize_tracing_data(tool, output, evsel_list,
+                                                                  process_synthesized_event);
                         if (err <= 0) {
                                 pr_err("Couldn't record tracing data.\n");
                                 return err;
                         }
-                        advance_output(err);
+                        advance_output(rec, err);
                 }
         }
 
-        machine = perf_session__find_host_machine(session);
-        if (!machine) {
-                pr_err("Couldn't find native kernel information.\n");
-                return -1;
-        }
-
-        err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
-                                                 session, machine, "_text");
+        err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
+                                                 machine, "_text");
         if (err < 0)
-                err = perf_event__synthesize_kernel_mmap(process_synthesized_event,
-                                                         session, machine, "_stext");
+                err = perf_event__synthesize_kernel_mmap(tool, process_synthesized_event,
+                                                         machine, "_stext");
         if (err < 0)
                 pr_err("Couldn't record kernel reference relocation symbol\n"
                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
                        "Check /proc/kallsyms permission or run as root.\n");
 
-        err = perf_event__synthesize_modules(process_synthesized_event,
-                                             session, machine);
+        err = perf_event__synthesize_modules(tool, process_synthesized_event,
+                                             machine);
         if (err < 0)
                 pr_err("Couldn't record kernel module information.\n"
                        "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
                        "Check /proc/modules permission or run as root.\n");
 
         if (perf_guest)
-                perf_session__process_machines(session,
+                perf_session__process_machines(session, tool,
                                                perf_event__synthesize_guest_os);
 
-        if (!system_wide)
-                perf_event__synthesize_thread_map(evsel_list->threads,
+        if (!opts->system_wide)
+                perf_event__synthesize_thread_map(tool, evsel_list->threads,
                                                   process_synthesized_event,
-                                                  session);
+                                                  machine);
         else
-                perf_event__synthesize_threads(process_synthesized_event,
-                                               session);
+                perf_event__synthesize_threads(tool, process_synthesized_event,
+                                               machine);
 
-        if (realtime_prio) {
+        if (rec->realtime_prio) {
                 struct sched_param param;
 
-                param.sched_priority = realtime_prio;
+                param.sched_priority = rec->realtime_prio;
                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
                         pr_err("Could not set realtime priority.\n");
                         exit(-1);
@@ -678,14 +597,14 @@ static int __cmd_record(int argc, const char **argv)
          * Let the child rip
          */
         if (forks)
-                close(go_pipe[1]);
+                perf_evlist__start_workload(evsel_list);
 
         for (;;) {
-                int hits = samples;
+                int hits = rec->samples;
 
-                mmap_read_all();
+                perf_record__mmap_read_all(rec);
 
-                if (hits == samples) {
+                if (hits == rec->samples) {
                         if (done)
                                 break;
                         err = poll(evsel_list->pollfd, evsel_list->nr_fds, -1);
@@ -706,9 +625,9 @@ static int __cmd_record(int argc, const char **argv)
          */
         fprintf(stderr,
                 "[ perf record: Captured and wrote %.3f MB %s (~%" PRIu64 " samples) ]\n",
-                (double)bytes_written / 1024.0 / 1024.0,
+                (double)rec->bytes_written / 1024.0 / 1024.0,
                 output_name,
-                bytes_written / 24);
+                rec->bytes_written / 24);
 
         return 0;
 
@@ -723,58 +642,89 @@ static const char * const record_usage[] = {
         NULL
 };
 
-static bool force, append_file;
+/*
+ * XXX Ideally would be local to cmd_record() and passed to a perf_record__new
+ * because we need to have access to it in perf_record__exit, that is called
+ * after cmd_record() exits, but since record_options need to be accessible to
+ * builtin-script, leave it here.
+ *
+ * At least we don't ouch it in all the other functions here directly.
+ *
+ * Just say no to tons of global variables, sigh.
+ */
+static struct perf_record record = {
+        .opts = {
+                .target_pid          = -1,
+                .target_tid          = -1,
+                .mmap_pages          = UINT_MAX,
+                .user_freq           = UINT_MAX,
+                .user_interval       = ULLONG_MAX,
+                .freq                = 1000,
+                .sample_id_all_avail = true,
+        },
+        .write_mode = WRITE_FORCE,
+        .file_new   = true,
+};
 
+/*
+ * XXX Will stay a global variable till we fix builtin-script.c to stop messing
+ * with it and switch to use the library functions in perf_evlist that came
+ * from builtin-record.c, i.e. use perf_record_opts,
+ * perf_evlist__prepare_workload, etc instead of fork+exec'in 'perf record',
+ * using pipes, etc.
+ */
 const struct option record_options[] = {
-        OPT_CALLBACK('e', "event", &evsel_list, "event",
+        OPT_CALLBACK('e', "event", &record.evlist, "event",
                      "event selector. use 'perf list' to list available events",
                      parse_events_option),
-        OPT_CALLBACK(0, "filter", &evsel_list, "filter",
+        OPT_CALLBACK(0, "filter", &record.evlist, "filter",
                      "event filter", parse_filter),
-        OPT_INTEGER('p', "pid", &target_pid,
+        OPT_INTEGER('p', "pid", &record.opts.target_pid,
                     "record events on existing process id"),
-        OPT_INTEGER('t', "tid", &target_tid,
+        OPT_INTEGER('t', "tid", &record.opts.target_tid,
                     "record events on existing thread id"),
-        OPT_INTEGER('r', "realtime", &realtime_prio,
+        OPT_INTEGER('r', "realtime", &record.realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
-        OPT_BOOLEAN('D', "no-delay", &nodelay,
+        OPT_BOOLEAN('D', "no-delay", &record.opts.no_delay,
                     "collect data without buffering"),
-        OPT_BOOLEAN('R', "raw-samples", &raw_samples,
+        OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
                     "collect raw sample records from all opened counters"),
-        OPT_BOOLEAN('a', "all-cpus", &system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &record.opts.system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_BOOLEAN('A', "append", &append_file,
+        OPT_BOOLEAN('A', "append", &record.append_file,
                             "append to the output file to do incremental profiling"),
-        OPT_STRING('C', "cpu", &cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &record.opts.cpu_list, "cpu",
                     "list of cpus to monitor"),
-        OPT_BOOLEAN('f', "force", &force,
+        OPT_BOOLEAN('f', "force", &record.force,
                         "overwrite existing data file (deprecated)"),
-        OPT_U64('c', "count", &user_interval, "event period to sample"),
-        OPT_STRING('o', "output", &output_name, "file",
+        OPT_U64('c', "count", &record.opts.user_interval, "event period to sample"),
+        OPT_STRING('o', "output", &record.output_name, "file",
                     "output file name"),
-        OPT_BOOLEAN('i', "no-inherit", &no_inherit,
+        OPT_BOOLEAN('i', "no-inherit", &record.opts.no_inherit,
                     "child tasks do not inherit counters"),
-        OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
-        OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
-        OPT_BOOLEAN(0, "group", &group,
+        OPT_UINTEGER('F', "freq", &record.opts.user_freq, "profile at this frequency"),
+        OPT_UINTEGER('m', "mmap-pages", &record.opts.mmap_pages,
+                     "number of mmap data pages"),
+        OPT_BOOLEAN(0, "group", &record.opts.group,
                     "put the counters into a counter group"),
-        OPT_BOOLEAN('g', "call-graph", &call_graph,
+        OPT_BOOLEAN('g', "call-graph", &record.opts.call_graph,
                     "do call-graph (stack chain/backtrace) recording"),
         OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
-        OPT_BOOLEAN('s', "stat", &inherit_stat,
+        OPT_BOOLEAN('s', "stat", &record.opts.inherit_stat,
                     "per thread counts"),
-        OPT_BOOLEAN('d', "data", &sample_address,
+        OPT_BOOLEAN('d', "data", &record.opts.sample_address,
                     "Sample addresses"),
-        OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
-        OPT_BOOLEAN('n', "no-samples", &no_samples,
+        OPT_BOOLEAN('T', "timestamp", &record.opts.sample_time, "Sample timestamps"),
+        OPT_BOOLEAN('P', "period", &record.opts.period, "Sample period"),
+        OPT_BOOLEAN('n', "no-samples", &record.opts.no_samples,
                     "don't sample"),
-        OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
+        OPT_BOOLEAN('N', "no-buildid-cache", &record.no_buildid_cache,
                     "do not update the buildid cache"),
-        OPT_BOOLEAN('B', "no-buildid", &no_buildid,
+        OPT_BOOLEAN('B', "no-buildid", &record.no_buildid,
                     "do not collect buildids in perf.data"),
-        OPT_CALLBACK('G', "cgroup", &evsel_list, "name",
+        OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
                      "monitor event in cgroup name only",
                      parse_cgroups),
         OPT_END()
@@ -784,28 +734,34 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
         int err = -ENOMEM;
         struct perf_evsel *pos;
+        struct perf_evlist *evsel_list;
+        struct perf_record *rec = &record;
+
+        perf_header__set_cmdline(argc, argv);
 
         evsel_list = perf_evlist__new(NULL, NULL);
         if (evsel_list == NULL)
                 return -ENOMEM;
 
+        rec->evlist = evsel_list;
+
         argc = parse_options(argc, argv, record_options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && target_pid == -1 && target_tid == -1 &&
-                !system_wide && !cpu_list)
+        if (!argc && rec->opts.target_pid == -1 && rec->opts.target_tid == -1 &&
+                !rec->opts.system_wide && !rec->opts.cpu_list)
                 usage_with_options(record_usage, record_options);
 
-        if (force && append_file) {
+        if (rec->force && rec->append_file) {
                 fprintf(stderr, "Can't overwrite and append at the same time."
                                 " You need to choose between -f and -A");
                 usage_with_options(record_usage, record_options);
-        } else if (append_file) {
-                write_mode = WRITE_APPEND;
+        } else if (rec->append_file) {
+                rec->write_mode = WRITE_APPEND;
         } else {
-                write_mode = WRITE_FORCE;
+                rec->write_mode = WRITE_FORCE;
         }
 
-        if (nr_cgroups && !system_wide) {
+        if (nr_cgroups && !rec->opts.system_wide) {
                 fprintf(stderr, "cgroup monitoring only available in"
                         " system-wide mode\n");
                 usage_with_options(record_usage, record_options);
@@ -823,7 +779,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 "If some relocation was applied (e.g. kexec) symbols may be misresolved\n"
 "even with a suitable vmlinux or kallsyms file.\n\n");
 
-        if (no_buildid_cache || no_buildid)
+        if (rec->no_buildid_cache || rec->no_buildid)
                 disable_buildid_cache();
 
         if (evsel_list->nr_entries == 0 &&
@@ -832,43 +788,37 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 goto out_symbol_exit;
         }
 
-        if (target_pid != -1)
-                target_tid = target_pid;
+        if (rec->opts.target_pid != -1)
+                rec->opts.target_tid = rec->opts.target_pid;
 
-        if (perf_evlist__create_maps(evsel_list, target_pid,
-                                     target_tid, cpu_list) < 0)
+        if (perf_evlist__create_maps(evsel_list, rec->opts.target_pid,
+                                     rec->opts.target_tid, rec->opts.cpu_list) < 0)
                 usage_with_options(record_usage, record_options);
 
         list_for_each_entry(pos, &evsel_list->entries, node) {
-                if (perf_evsel__alloc_fd(pos, evsel_list->cpus->nr,
-                                         evsel_list->threads->nr) < 0)
-                        goto out_free_fd;
                 if (perf_header__push_event(pos->attr.config, event_name(pos)))
                         goto out_free_fd;
         }
 
-        if (perf_evlist__alloc_pollfd(evsel_list) < 0)
-                goto out_free_fd;
-
-        if (user_interval != ULLONG_MAX)
-                default_interval = user_interval;
-        if (user_freq != UINT_MAX)
-                freq = user_freq;
+        if (rec->opts.user_interval != ULLONG_MAX)
+                rec->opts.default_interval = rec->opts.user_interval;
+        if (rec->opts.user_freq != UINT_MAX)
+                rec->opts.freq = rec->opts.user_freq;
 
         /*
          * User specified count overrides default frequency.
          */
-        if (default_interval)
-                freq = 0;
-        else if (freq) {
-                default_interval = freq;
+        if (rec->opts.default_interval)
+                rec->opts.freq = 0;
+        else if (rec->opts.freq) {
+                rec->opts.default_interval = rec->opts.freq;
         } else {
                 fprintf(stderr, "frequency and count are zero, aborting\n");
                 err = -EINVAL;
                 goto out_free_fd;
         }
 
-        err = __cmd_record(argc, argv);
+        err = __cmd_record(&record, argc, argv);
 out_free_fd:
         perf_evlist__delete_maps(evsel_list);
 out_symbol_exit:
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index d7ff277bdb78..25d34d483e49 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -25,6 +25,7 @@
 #include "util/evsel.h"
 #include "util/header.h"
 #include "util/session.h"
+#include "util/tool.h"
 
 #include "util/parse-options.h"
 #include "util/parse-events.h"
@@ -35,37 +36,35 @@
 
 #include <linux/bitmap.h>
 
-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_threads;
-static struct perf_read_values  show_threads_values;
-
-static const char       default_pretty_printing_style[] = "normal";
-static const char       *pretty_printing_style = default_pretty_printing_style;
-
-static char             callchain_default_opt[] = "fractal,0.5,callee";
-static bool             inverted_callchain;
-static symbol_filter_t  annotate_init;
-
-static const char       *cpu_list;
-static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
+struct perf_report {
+        struct perf_tool        tool;
+        struct perf_session     *session;
+        char const              *input_name;
+        bool                    force, use_tui, use_stdio;
+        bool                    hide_unresolved;
+        bool                    dont_use_callchains;
+        bool                    show_full_info;
+        bool                    show_threads;
+        bool                    inverted_callchain;
+        struct perf_read_values show_threads_values;
+        const char              *pretty_printing_style;
+        symbol_filter_t         annotate_init;
+        const char              *cpu_list;
+        DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
+};
 
-static int perf_session__add_hist_entry(struct perf_session *session,
-                                        struct addr_location *al,
-                                        struct perf_sample *sample,
-                                        struct perf_evsel *evsel)
+static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
+                                      struct addr_location *al,
+                                      struct perf_sample *sample,
+                                      struct machine *machine)
 {
         struct symbol *parent = NULL;
         int err = 0;
         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);
+                err = machine__resolve_callchain(machine, evsel, al->thread,
+                                                 sample->callchain, &parent);
                 if (err)
                         return err;
         }
@@ -75,7 +74,8 @@ static int perf_session__add_hist_entry(struct perf_session *session,
                 return -ENOMEM;
 
         if (symbol_conf.use_callchain) {
-                err = callchain_append(he->callchain, &session->callchain_cursor,
+                err = callchain_append(he->callchain,
+                                       &evsel->hists.callchain_cursor,
                                        sample->period);
                 if (err)
                         return err;
@@ -91,8 +91,7 @@ static int perf_session__add_hist_entry(struct perf_session *session,
                 assert(evsel != NULL);
 
                 err = -ENOMEM;
-                if (notes->src == NULL &&
-                    symbol__alloc_hist(he->ms.sym, session->evlist->nr_entries) < 0)
+                if (notes->src == NULL && symbol__alloc_hist(he->ms.sym) < 0)
                         goto out;
 
                 err = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
@@ -105,30 +104,32 @@ out:
 }
 
 
-static int process_sample_event(union perf_event *event,
+static int process_sample_event(struct perf_tool *tool,
+                                union perf_event *event,
                                 struct perf_sample *sample,