Merge commit 'v2.6.36' into kbuild/misc

Update to be able to fix a recent change to scripts/basic/docproc.c
(commit eda603f).

207 files changed, 21700 insertions, 6396 deletions

diff --git a/tools/firewire/Makefile b/tools/firewire/Makefile
new file mode 100644
index 000000000000..81767adaae7d
--- /dev/null
+++ b/tools/firewire/Makefile
@@ -0,0 +1,19 @@
+prefix = /usr
+nosy-dump-version = 0.4
+
+CC = gcc
+
+all : nosy-dump
+
+nosy-dump : CFLAGS = -Wall -O2 -g
+nosy-dump : CPPFLAGS = -DVERSION=\"$(nosy-dump-version)\" -I../../drivers/firewire
+nosy-dump : LDFLAGS = -g
+nosy-dump : LDLIBS = -lpopt
+
+nosy-dump : nosy-dump.o decode-fcp.o
+
+clean :
+        rm -rf *.o nosy-dump
+
+install :
+        install nosy-dump $(prefix)/bin/nosy-dump
diff --git a/tools/firewire/decode-fcp.c b/tools/firewire/decode-fcp.c
new file mode 100644
index 000000000000..e41223b6a4c8
--- /dev/null
+++ b/tools/firewire/decode-fcp.c
@@ -0,0 +1,213 @@
+#include <linux/firewire-constants.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "list.h"
+#include "nosy-dump.h"
+
+#define CSR_FCP_COMMAND                 0xfffff0000b00ull
+#define CSR_FCP_RESPONSE                0xfffff0000d00ull
+
+static const char * const ctype_names[] = {
+        [0x0] = "control",              [0x8] = "not implemented",
+        [0x1] = "status",               [0x9] = "accepted",
+        [0x2] = "specific inquiry",     [0xa] = "rejected",
+        [0x3] = "notify",               [0xb] = "in transition",
+        [0x4] = "general inquiry",      [0xc] = "stable",
+        [0x5] = "(reserved 0x05)",      [0xd] = "changed",
+        [0x6] = "(reserved 0x06)",      [0xe] = "(reserved 0x0e)",
+        [0x7] = "(reserved 0x07)",      [0xf] = "interim",
+};
+
+static const char * const subunit_type_names[] = {
+        [0x00] = "monitor",             [0x10] = "(reserved 0x10)",
+        [0x01] = "audio",               [0x11] = "(reserved 0x11)",
+        [0x02] = "printer",             [0x12] = "(reserved 0x12)",
+        [0x03] = "disc",                [0x13] = "(reserved 0x13)",
+        [0x04] = "tape recorder/player",[0x14] = "(reserved 0x14)",
+        [0x05] = "tuner",               [0x15] = "(reserved 0x15)",
+        [0x06] = "ca",                  [0x16] = "(reserved 0x16)",
+        [0x07] = "camera",              [0x17] = "(reserved 0x17)",
+        [0x08] = "(reserved 0x08)",     [0x18] = "(reserved 0x18)",
+        [0x09] = "panel",               [0x19] = "(reserved 0x19)",
+        [0x0a] = "bulletin board",      [0x1a] = "(reserved 0x1a)",
+        [0x0b] = "camera storage",      [0x1b] = "(reserved 0x1b)",
+        [0x0c] = "(reserved 0x0c)",     [0x1c] = "vendor unique",
+        [0x0d] = "(reserved 0x0d)",     [0x1d] = "all subunit types",
+        [0x0e] = "(reserved 0x0e)",     [0x1e] = "subunit_type extended to next byte",
+        [0x0f] = "(reserved 0x0f)",     [0x1f] = "unit",
+};
+
+struct avc_enum {
+        int value;
+        const char *name;
+};
+
+struct avc_field {
+        const char *name;       /* Short name for field. */
+        int offset;             /* Location of field, specified in bits; */
+                                /* negative means from end of packet.    */
+        int width;              /* Width of field, 0 means use data_length. */
+        struct avc_enum *names;
+};
+
+struct avc_opcode_info {
+        const char *name;
+        struct avc_field fields[8];
+};
+
+struct avc_enum power_field_names[] = {
+        { 0x70, "on" },
+        { 0x60, "off" },
+        { }
+};
+
+static const struct avc_opcode_info opcode_info[256] = {
+
+        /* TA Document 1999026 */
+        /* AV/C Digital Interface Command Set General Specification 4.0 */
+        [0xb2] = { "power", {
+                        { "state", 0, 8, power_field_names }
+                }
+        },
+        [0x30] = { "unit info", {
+                        { "foo", 0, 8 },
+                        { "unit_type", 8, 5 },
+                        { "unit", 13, 3 },
+                        { "company id", 16, 24 },
+                }
+        },
+        [0x31] = { "subunit info" },
+        [0x01] = { "reserve" },
+        [0xb0] = { "version" },
+        [0x00] = { "vendor dependent" },
+        [0x02] = { "plug info" },
+        [0x12] = { "channel usage" },
+        [0x24] = { "connect" },
+        [0x20] = { "connect av" },
+        [0x22] = { "connections" },
+        [0x11] = { "digital input" },
+        [0x10] = { "digital output" },
+        [0x25] = { "disconnect" },
+        [0x21] = { "disconnect av" },
+        [0x19] = { "input plug signal format" },
+        [0x18] = { "output plug signal format" },
+        [0x1f] = { "general bus setup" },
+
+        /* TA Document 1999025 */
+        /* AV/C Descriptor Mechanism Specification Version 1.0 */
+        [0x0c] = { "create descriptor" },
+        [0x08] = { "open descriptor" },
+        [0x09] = { "read descriptor" },
+        [0x0a] = { "write descriptor" },
+        [0x05] = { "open info block" },
+        [0x06] = { "read info block" },
+        [0x07] = { "write info block" },
+        [0x0b] = { "search descriptor" },
+        [0x0d] = { "object number select" },
+
+        /* TA Document 1999015 */
+        /* AV/C Command Set for Rate Control of Isochronous Data Flow 1.0 */
+        [0xb3] = { "rate", {
+                        { "subfunction", 0, 8 },
+                        { "result", 8, 8 },
+                        { "plug_type", 16, 8 },
+                        { "plug_id", 16, 8 },
+                }
+        },
+
+        /* TA Document 1999008 */
+        /* AV/C Audio Subunit Specification 1.0 */
+        [0xb8] = { "function block" },
+
+        /* TA Document 2001001 */
+        /* AV/C Panel Subunit Specification 1.1 */
+        [0x7d] = { "gui update" },
+        [0x7e] = { "push gui data" },
+        [0x7f] = { "user action" },
+        [0x7c] = { "pass through" },
+
+        /* */
+        [0x26] = { "asynchronous connection" },
+};
+
+struct avc_frame {
+        uint32_t operand0:8;
+        uint32_t opcode:8;
+        uint32_t subunit_id:3;
+        uint32_t subunit_type:5;
+        uint32_t ctype:4;
+        uint32_t cts:4;
+};
+
+static void
+decode_avc(struct link_transaction *t)
+{
+        struct avc_frame *frame =
+            (struct avc_frame *) t->request->packet.write_block.data;
+        const struct avc_opcode_info *info;
+        const char *name;
+        char buffer[32];
+        int i;
+
+        info = &opcode_info[frame->opcode];
+        if (info->name == NULL) {
+                snprintf(buffer, sizeof(buffer),
+                         "(unknown opcode 0x%02x)", frame->opcode);
+                name = buffer;
+        } else {
+                name = info->name;
+        }
+
+        printf("av/c %s, subunit_type=%s, subunit_id=%d, opcode=%s",
+            ctype_names[frame->ctype], subunit_type_names[frame->subunit_type],
+            frame->subunit_id, name);
+
+        for (i = 0; info->fields[i].name != NULL; i++)
+                printf(", %s", info->fields[i].name);
+
+        printf("\n");
+}
+
+int
+decode_fcp(struct link_transaction *t)
+{
+        struct avc_frame *frame =
+            (struct avc_frame *) t->request->packet.write_block.data;
+        unsigned long long offset =
+            ((unsigned long long) t->request->packet.common.offset_high << 32) |
+            t->request->packet.common.offset_low;
+
+        if (t->request->packet.common.tcode != TCODE_WRITE_BLOCK_REQUEST)
+                return 0;
+
+        if (offset == CSR_FCP_COMMAND || offset == CSR_FCP_RESPONSE) {
+                switch (frame->cts) {
+                case 0x00:
+                        decode_avc(t);
+                        break;
+                case 0x01:
+                        printf("cal fcp frame (cts=0x01)\n");
+                        break;
+                case 0x02:
+                        printf("ehs fcp frame (cts=0x02)\n");
+                        break;
+                case 0x03:
+                        printf("havi fcp frame (cts=0x03)\n");
+                        break;
+                case 0x0e:
+                        printf("vendor specific fcp frame (cts=0x0e)\n");
+                        break;
+                case 0x0f:
+                        printf("extended cts\n");
+                        break;
+                default:
+                        printf("reserved fcp frame (ctx=0x%02x)\n", frame->cts);
+                        break;
+                }
+                return 1;
+        }
+
+        return 0;
+}
+
diff --git a/tools/firewire/list.h b/tools/firewire/list.h
new file mode 100644
index 000000000000..41f4bdadf634
--- /dev/null
+++ b/tools/firewire/list.h
@@ -0,0 +1,62 @@
+struct list {
+        struct list *next, *prev;
+};
+
+static inline void
+list_init(struct list *list)
+{
+        list->next = list;
+        list->prev = list;
+}
+
+static inline int
+list_empty(struct list *list)
+{
+        return list->next == list;
+}
+
+static inline void
+list_insert(struct list *link, struct list *new_link)
+{
+        new_link->prev          = link->prev;
+        new_link->next          = link;
+        new_link->prev->next    = new_link;
+        new_link->next->prev    = new_link;
+}
+
+static inline void
+list_append(struct list *list, struct list *new_link)
+{
+        list_insert((struct list *)list, new_link);
+}
+
+static inline void
+list_prepend(struct list *list, struct list *new_link)
+{
+        list_insert(list->next, new_link);
+}
+
+static inline void
+list_remove(struct list *link)
+{
+        link->prev->next = link->next;
+        link->next->prev = link->prev;
+}
+
+#define list_entry(link, type, member) \
+        ((type *)((char *)(link)-(unsigned long)(&((type *)0)->member)))
+
+#define list_head(list, type, member)           \
+        list_entry((list)->next, type, member)
+
+#define list_tail(list, type, member)           \
+        list_entry((list)->prev, type, member)
+
+#define list_next(elm, member)                                  \
+        list_entry((elm)->member.next, typeof(*elm), member)
+
+#define list_for_each_entry(pos, list, member)                  \
+        for (pos = list_head(list, typeof(*pos), member);       \
+             &pos->member != (list);                            \
+             pos = list_next(pos, member))
+
diff --git a/tools/firewire/nosy-dump.c b/tools/firewire/nosy-dump.c
new file mode 100644
index 000000000000..f93b776370b6
--- /dev/null
+++ b/tools/firewire/nosy-dump.c
@@ -0,0 +1,1031 @@
+/*
+ * nosy-dump - Interface to snoop mode driver for TI PCILynx 1394 controllers
+ * Copyright (C) 2002-2006 Kristian Høgsberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <byteswap.h>
+#include <endian.h>
+#include <fcntl.h>
+#include <linux/firewire-constants.h>
+#include <poll.h>
+#include <popt.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <termios.h>
+#include <unistd.h>
+
+#include "list.h"
+#include "nosy-dump.h"
+#include "nosy-user.h"
+
+enum {
+        PACKET_FIELD_DETAIL             = 0x01,
+        PACKET_FIELD_DATA_LENGTH        = 0x02,
+        /* Marks the fields we print in transaction view. */
+        PACKET_FIELD_TRANSACTION        = 0x04,
+};
+
+static void print_packet(uint32_t *data, size_t length);
+static void decode_link_packet(struct link_packet *packet, size_t length,
+                               int include_flags, int exclude_flags);
+static int run = 1;
+sig_t sys_sigint_handler;
+
+static char *option_nosy_device = "/dev/nosy";
+static char *option_view = "packet";
+static char *option_output;
+static char *option_input;
+static int option_hex;
+static int option_iso;
+static int option_cycle_start;
+static int option_version;
+static int option_verbose;
+
+enum {
+        VIEW_TRANSACTION,
+        VIEW_PACKET,
+        VIEW_STATS,
+};
+
+static const struct poptOption options[] = {
+        {
+                .longName       = "device",
+                .shortName      = 'd',
+                .argInfo        = POPT_ARG_STRING,
+                .arg            = &option_nosy_device,
+                .descrip        = "Path to nosy device.",
+                .argDescrip     = "DEVICE"
+        },
+        {
+                .longName       = "view",
+                .argInfo        = POPT_ARG_STRING,
+                .arg            = &option_view,
+                .descrip        = "Specify view of bus traffic: packet, transaction or stats.",
+                .argDescrip     = "VIEW"
+        },
+        {
+                .longName       = "hex",
+                .shortName      = 'x',
+                .argInfo        = POPT_ARG_NONE,
+                .arg            = &option_hex,
+                .descrip        = "Print each packet in hex.",
+        },
+        {
+                .longName       = "iso",
+                .argInfo        = POPT_ARG_NONE,
+                .arg            = &option_iso,
+                .descrip        = "Print iso packets.",
+        },
+        {
+                .longName       = "cycle-start",
+                .argInfo        = POPT_ARG_NONE,
+                .arg            = &option_cycle_start,
+                .descrip        = "Print cycle start packets.",
+        },
+        {
+                .longName       = "verbose",
+                .shortName      = 'v',
+                .argInfo        = POPT_ARG_NONE,
+                .arg            = &option_verbose,
+                .descrip        = "Verbose packet view.",
+        },
+        {
+                .longName       = "output",
+                .shortName      = 'o',
+                .argInfo        = POPT_ARG_STRING,
+                .arg            = &option_output,
+                .descrip        = "Log to output file.",
+                .argDescrip     = "FILENAME"
+        },
+        {
+                .longName       = "input",
+                .shortName      = 'i',
+                .argInfo        = POPT_ARG_STRING,
+                .arg            = &option_input,
+                .descrip        = "Decode log from file.",
+                .argDescrip     = "FILENAME"
+        },
+        {
+                .longName       = "version",
+                .argInfo        = POPT_ARG_NONE,
+                .arg            = &option_version,
+                .descrip        = "Specify print version info.",
+        },
+        POPT_AUTOHELP
+        POPT_TABLEEND
+};
+
+/* Allow all ^C except the first to interrupt the program in the usual way. */
+static void
+sigint_handler(int signal_num)
+{
+        if (run == 1) {
+                run = 0;
+                signal(SIGINT, SIG_DFL);
+        }
+}
+
+static struct subaction *
+subaction_create(uint32_t *data, size_t length)
+{
+        struct subaction *sa;
+
+        /* we put the ack in the subaction struct for easy access. */
+        sa = malloc(sizeof *sa - sizeof sa->packet + length);
+        sa->ack = data[length / 4 - 1];
+        sa->length = length;
+        memcpy(&sa->packet, data, length);
+
+        return sa;
+}
+
+static void
+subaction_destroy(struct subaction *sa)
+{
+        free(sa);
+}
+
+static struct list pending_transaction_list = {
+        &pending_transaction_list, &pending_transaction_list
+};
+
+static struct link_transaction *
+link_transaction_lookup(int request_node, int response_node, int tlabel)
+{
+        struct link_transaction *t;
+
+        list_for_each_entry(t, &pending_transaction_list, link) {
+                if (t->request_node == request_node &&
+                    t->response_node == response_node &&
+                    t->tlabel == tlabel)
+                        return t;
+        }
+
+        t = malloc(sizeof *t);
+        t->request_node = request_node;
+        t->response_node = response_node;
+        t->tlabel = tlabel;
+        list_init(&t->request_list);
+        list_init(&t->response_list);
+
+        list_append(&pending_transaction_list, &t->link);
+
+        return t;
+}
+
+static void
+link_transaction_destroy(struct link_transaction *t)
+{
+        struct subaction *sa;
+
+        while (!list_empty(&t->request_list)) {
+                sa = list_head(&t->request_list, struct subaction, link);
+                list_remove(&sa->link);
+                subaction_destroy(sa);
+        }
+        while (!list_empty(&t->response_list)) {
+                sa = list_head(&t->response_list, struct subaction, link);
+                list_remove(&sa->link);
+                subaction_destroy(sa);
+        }
+        free(t);
+}
+
+struct protocol_decoder {
+        const char *name;
+        int (*decode)(struct link_transaction *t);
+};
+
+static const struct protocol_decoder protocol_decoders[] = {
+        { "FCP", decode_fcp }
+};
+
+static void
+handle_transaction(struct link_transaction *t)
+{
+        struct subaction *sa;
+        int i;
+
+        if (!t->request) {
+                printf("BUG in handle_transaction\n");
+                return;
+        }
+
+        for (i = 0; i < array_length(protocol_decoders); i++)
+                if (protocol_decoders[i].decode(t))
+                        break;
+
+        /* HACK: decode only fcp right now. */
+        return;
+
+        decode_link_packet(&t->request->packet, t->request->length,
+                           PACKET_FIELD_TRANSACTION, 0);
+        if (t->response)
+                decode_link_packet(&t->response->packet, t->request->length,
+                                   PACKET_FIELD_TRANSACTION, 0);
+        else
+                printf("[no response]");
+
+        if (option_verbose) {
+                list_for_each_entry(sa, &t->request_list, link)
+                        print_packet((uint32_t *) &sa->packet, sa->length);
+                list_for_each_entry(sa, &t->response_list, link)
+                        print_packet((uint32_t *) &sa->packet, sa->length);
+        }
+        printf("\r\n");
+
+        link_transaction_destroy(t);
+}
+
+static void
+clear_pending_transaction_list(void)
+{
+        struct link_transaction *t;
+
+        while (!list_empty(&pending_transaction_list)) {
+                t = list_head(&pending_transaction_list,
+                              struct link_transaction, link);
+                list_remove(&t->link);
+                link_transaction_destroy(t);
+                /* print unfinished transactions */
+        }
+}
+
+static const char * const tcode_names[] = {
+        [0x0] = "write_quadlet_request",        [0x6] = "read_quadlet_response",
+        [0x1] = "write_block_request",          [0x7] = "read_block_response",
+        [0x2] = "write_response",               [0x8] = "cycle_start",
+        [0x3] = "reserved",                     [0x9] = "lock_request",
+        [0x4] = "read_quadlet_request",         [0xa] = "iso_data",
+        [0x5] = "read_block_request",           [0xb] = "lock_response",
+};
+
+static const char * const ack_names[] = {
+        [0x0] = "no ack",                       [0x8] = "reserved (0x08)",
+        [0x1] = "ack_complete",                 [0x9] = "reserved (0x09)",
+        [0x2] = "ack_pending",                  [0xa] = "reserved (0x0a)",
+        [0x3] = "reserved (0x03)",              [0xb] = "reserved (0x0b)",
+        [0x4] = "ack_busy_x",                   [0xc] = "reserved (0x0c)",
+        [0x5] = "ack_busy_a",                   [0xd] = "ack_data_error",
+        [0x6] = "ack_busy_b",                   [0xe] = "ack_type_error",
+        [0x7] = "reserved (0x07)",              [0xf] = "reserved (0x0f)",
+};
+
+static const char * const rcode_names[] = {
+        [0x0] = "complete",                     [0x4] = "conflict_error",
+        [0x1] = "reserved (0x01)",              [0x5] = "data_error",
+        [0x2] = "reserved (0x02)",              [0x6] = "type_error",
+        [0x3] = "reserved (0x03)",              [0x7] = "address_error",
+};
+
+static const char * const retry_names[] = {
+        [0x0] = "retry_1",
+        [0x1] = "retry_x",
+        [0x2] = "retry_a",
+        [0x3] = "retry_b",
+};
+
+enum {
+        PACKET_RESERVED,
+        PACKET_REQUEST,
+        PACKET_RESPONSE,
+        PACKET_OTHER,
+};
+
+struct packet_info {
+        const char *name;
+        int type;
+        int response_tcode;
+        const struct packet_field *fields;
+        int field_count;
+};
+
+struct packet_field {
+        const char *name; /* Short name for field. */
+        int offset;     /* Location of field, specified in bits; */
+                        /* negative means from end of packet.    */
+        int width;      /* Width of field, 0 means use data_length. */
+        int flags;      /* Show options. */
+        const char * const *value_names;
+};
+
+#define COMMON_REQUEST_FIELDS                                           \
+        { "dest", 0, 16, PACKET_FIELD_TRANSACTION },                    \
+        { "tl", 16, 6 },                                                \
+        { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names },              \
+        { "tcode", 24, 4, PACKET_FIELD_TRANSACTION, tcode_names },      \
+        { "pri", 28, 4, PACKET_FIELD_DETAIL },                          \
+        { "src", 32, 16, PACKET_FIELD_TRANSACTION },                    \
+        { "offs", 48, 48, PACKET_FIELD_TRANSACTION }
+
+#define COMMON_RESPONSE_FIELDS                                          \
+        { "dest", 0, 16 },                                              \
+        { "tl", 16, 6 },                                                \
+        { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names },              \
+        { "tcode", 24, 4, 0, tcode_names },                             \
+        { "pri", 28, 4, PACKET_FIELD_DETAIL },                          \
+        { "src", 32, 16 },                                              \
+        { "rcode", 48, 4, PACKET_FIELD_TRANSACTION, rcode_names }
+
+static const struct packet_field read_quadlet_request_fields[] = {
+        COMMON_REQUEST_FIELDS,
+        { "crc", 96, 32, PACKET_FIELD_DETAIL },
+        { "ack", 156, 4, 0, ack_names },
+};
+
+static const struct packet_field read_quadlet_response_fields[] = {
+        COMMON_RESPONSE_FIELDS,
+        { "data", 96, 32, PACKET_FIELD_TRANSACTION },
+        { "crc", 128, 32, PACKET_FIELD_DETAIL },
+        { "ack", 188, 4, 0, ack_names },
+};
+
+static const struct packet_field read_block_request_fields[] = {
+        COMMON_REQUEST_FIELDS,
+        { "data_length", 96, 16, PACKET_FIELD_TRANSACTION },
+        { "extended_tcode", 112, 16 },
+        { "crc", 128, 32, PACKET_FIELD_DETAIL },
+        { "ack", 188, 4, 0, ack_names },
+};
+
+static const struct packet_field block_response_fields[] = {
+        COMMON_RESPONSE_FIELDS,
+        { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH },
+        { "extended_tcode", 112, 16 },
+        { "crc", 128, 32, PACKET_FIELD_DETAIL },
+        { "data", 160, 0, PACKET_FIELD_TRANSACTION },
+        { "crc", -64, 32, PACKET_FIELD_DETAIL },
+        { "ack", -4, 4, 0, ack_names },
+};
+
+static const struct packet_field write_quadlet_request_fields[] = {
+        COMMON_REQUEST_FIELDS,
+        { "data", 96, 32, PACKET_FIELD_TRANSACTION },
+        { "ack", -4, 4, 0, ack_names },
+};
+
+static const struct packet_field block_request_fields[] = {
+        COMMON_REQUEST_FIELDS,
+        { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH | PACKET_FIELD_TRANSACTION },
+        { "extended_tcode", 112, 16, PACKET_FIELD_TRANSACTION },
+        { "crc", 128, 32, PACKET_FIELD_DETAIL },
+        { "data", 160, 0, PACKET_FIELD_TRANSACTION },
+        { "crc", -64, 32, PACKET_FIELD_DETAIL },
+        { "ack", -4, 4, 0, ack_names },
+};
+
+static const struct packet_field write_response_fields[] = {
+        COMMON_RESPONSE_FIELDS,
+        { "reserved", 64, 32, PACKET_FIELD_DETAIL },
+        { "ack", -4, 4, 0, ack_names },
+};
+
+static const struct packet_field iso_data_fields[] = {
+        { "data_length", 0, 16, PACKET_FIELD_DATA_LENGTH },
+        { "tag", 16, 2 },
+        { "channel", 18, 6 },
+        { "tcode", 24, 4, 0, tcode_names },
+        { "sy", 28, 4 },
+        { "crc", 32, 32, PACKET_FIELD_DETAIL },
+        { "data", 64, 0 },
+        { "crc", -64, 32, PACKET_FIELD_DETAIL },
+        { "ack", -4, 4, 0, ack_names },
+};
+
+static const struct packet_info packet_info[] = {
+        {
+                .name           = "write_quadlet_request",
+                .type           = PACKET_REQUEST,
+                .response_tcode = TCODE_WRITE_RESPONSE,
+                .fields         = write_quadlet_request_fields,
+                .field_count    = array_length(write_quadlet_request_fields)
+        },
+        {
+                .name           = "write_block_request",
+                .type           = PACKET_REQUEST,
+                .response_tcode = TCODE_WRITE_RESPONSE,
+                .fields         = block_request_fields,
+                .field_count    = array_length(block_request_fields)
+        },
+        {
+                .name           = "write_response",
+                .type           = PACKET_RESPONSE,
+                .fields         = write_response_fields,
+                .field_count    = array_length(write_response_fields)
+        },
+        {
+                .name           = "reserved",
+                .type           = PACKET_RESERVED,
+        },
+        {
+                .name           = "read_quadlet_request",
+                .type           = PACKET_REQUEST,
+                .response_tcode = TCODE_READ_QUADLET_RESPONSE,
+                .fields         = read_quadlet_request_fields,
+                .field_count    = array_length(read_quadlet_request_fields)
+        },
+        {
+                .name           = "read_block_request",
+                .type           = PACKET_REQUEST,
+                .response_tcode = TCODE_READ_BLOCK_RESPONSE,
+                .fields         = read_block_request_fields,
+                .field_count    = array_length(read_block_request_fields)
+        },
+        {
+                .name           = "read_quadlet_response",
+                .type           = PACKET_RESPONSE,
+                .fields         = read_quadlet_response_fields,
+                .field_count    = array_length(read_quadlet_response_fields)
+        },
+        {
+                .name           = "read_block_response",
+                .type           = PACKET_RESPONSE,
+                .fields         = block_response_fields,
+                .field_count    = array_length(block_response_fields)
+        },
+        {
+                .name           = "cycle_start",
+                .type           = PACKET_OTHER,
+                .fields         = write_quadlet_request_fields,
+                .field_count    = array_length(write_quadlet_request_fields)
+        },
+        {
+                .name           = "lock_request",
+                .type           = PACKET_REQUEST,
+                .fields         = block_request_fields,
+                .field_count    = array_length(block_request_fields)
+        },
+        {
+                .name           = "iso_data",
+                .type           = PACKET_OTHER,
+                .fields         = iso_data_fields,
+                .field_count    = array_length(iso_data_fields)
+        },
+        {
+                .name           = "lock_response",
+                .type           = PACKET_RESPONSE,
+                .fields         = block_response_fields,
+                .field_count    = array_length(block_response_fields)
+        },
+};
+
+static int
+handle_request_packet(uint32_t *data, size_t length)
+{
+        struct link_packet *p = (struct link_packet *) data;
+        struct subaction *sa, *prev;
+        struct link_transaction *t;
+
+        t = link_transaction_lookup(p->common.source, p->common.destination,
+                        p->common.tlabel);
+        sa = subaction_create(data, length);
+        t->request = sa;
+
+        if (!list_empty(&t->request_list)) {
+                prev = list_tail(&t->request_list,
+                                 struct subaction, link);
+
+                if (!ACK_BUSY(prev->ack)) {
+                        /*
+                         * error, we should only see ack_busy_* before the
+                         * ack_pending/ack_complete -- this is an ack_pending
+                         * instead (ack_complete would have finished the
+                         * transaction).
+                         */
+                }
+
+                if (prev->packet.common.tcode != sa->packet.common.tcode ||
+                    prev->packet.common.tlabel != sa->packet.common.tlabel) {
+                        /* memcmp() ? */
+                        /* error, these should match for retries. */
+                }
+        }
+
+        list_append(&t->request_list, &sa->link);
+
+        switch (sa->ack) {
+        case ACK_COMPLETE:
+                if (p->common.tcode != TCODE_WRITE_QUADLET_REQUEST &&
+                    p->common.tcode != TCODE_WRITE_BLOCK_REQUEST)
+                        /* error, unified transactions only allowed for write */;
+                list_remove(&t->link);
+                handle_transaction(t);
+                break;
+
+        case ACK_NO_ACK:
+        case ACK_DATA_ERROR:
+        case ACK_TYPE_ERROR:
+                list_remove(&t->link);
+                handle_transaction(t);
+                break;
+
+        case ACK_PENDING:
+                /* request subaction phase over, wait for response. */
+                break;
+
+        case ACK_BUSY_X:
+        case ACK_BUSY_A:
+        case ACK_BUSY_B:
+                /* ok, wait for retry. */
+                /* check that retry protocol is respected. */
+                break;
+        }
+
+        return 1;
+}
+
+static int
+handle_response_packet(uint32_t *data, size_t length)
+{
+        struct link_packet *p = (struct link_packet *) data;
+        struct subaction *sa, *prev;
+        struct link_transaction *t;
+
+        t = link_transaction_lookup(p->common.destination, p->common.source,
+                        p->common.tlabel);
+        if (list_empty(&t->request_list)) {
+                /* unsolicited response */
+        }
+
+        sa = subaction_create(data, length);
+        t->response = sa;
+
+        if (!list_empty(&t->response_list)) {
+                prev = list_tail(&t->response_list, struct subaction, link);
+
+                if (!ACK_BUSY(prev->ack)) {
+                        /*
+                         * error, we should only see ack_busy_* before the
+                         * ack_pending/ack_complete
+                         */
+                }
+
+                if (prev->packet.common.tcode != sa->packet.common.tcode ||
+                    prev->packet.common.tlabel != sa->packet.common.tlabel) {
+                        /* use memcmp() instead? */
+                        /* error, these should match for retries. */
+                }
+        } else {
+                prev = list_tail(&t->request_list, struct subaction, link);
+                if (prev->ack != ACK_PENDING) {
+                        /*
+                         * error, should not get response unless last request got
+                         * ack_pending.
+                         */
+                }
+
+                if (packet_info[prev->packet.common.tcode].response_tcode !=
+                    sa->packet.common.tcode) {
+                        /* error, tcode mismatch */
+                }
+        }
+
+        list_append(&t->response_list, &sa->link);
+
+        switch (sa->ack) {
+        case ACK_COMPLETE:
+        case ACK_NO_ACK:
+        case ACK_DATA_ERROR:
+        case ACK_TYPE_ERROR:
+                list_remove(&t->link);
+                handle_transaction(t);
+                /* transaction complete, remove t from pending list. */
+                break;
+
+        case ACK_PENDING:
+                /* error for responses. */
+                break;
+
+        case ACK_BUSY_X:
+        case ACK_BUSY_A:
+        case ACK_BUSY_B:
+                /* no problem, wait for next retry */
+                break;
+        }
+
+        return 1;
+}
+
+static int
+handle_packet(uint32_t *data, size_t length)
+{
+        if (length == 0) {
+                printf("bus reset\r\n");
+                clear_pending_transaction_list();
+        } else if (length > sizeof(struct phy_packet)) {
+                struct link_packet *p = (struct link_packet *) data;
+
+                switch (packet_info[p->common.tcode].type) {
+                case PACKET_REQUEST:
+                        return handle_request_packet(data, length);
+
+                case PACKET_RESPONSE:
+                        return handle_response_packet(data, length);
+
+                case PACKET_OTHER:
+                case PACKET_RESERVED:
+                        return 0;
+                }
+        }
+
+        return 1;
+}
+
+static unsigned int
+get_bits(struct link_packet *packet, int offset, int width)
+{
+        uint32_t *data = (uint32_t *) packet;
+        uint32_t index, shift, mask;
+
+        index = offset / 32 + 1;
+        shift = 32 - (offset & 31) - width;
+        mask = width == 32 ? ~0 : (1 << width) - 1;
+
+        return (data[index] >> shift) & mask;
+}
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define byte_index(i) ((i) ^ 3)
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define byte_index(i) (i)
+#else
+#error unsupported byte order.
+#endif
+
+static void
+dump_data(unsigned char *data, int length)
+{
+        int i, print_length;
+
+        if (length > 128)
+                print_length = 128;
+        else
+                print_length = length;
+
+        for (i = 0; i < print_length; i++)
+                printf("%s%02hhx",
+                       (i % 4 == 0 && i != 0) ? " " : "",
+                       data[byte_index(i)]);
+
+        if (print_length < length)
+                printf(" (%d more bytes)", length - print_length);
+}
+
+static void
+decode_link_packet(struct link_packet *packet, size_t length,
+                   int include_flags, int exclude_flags)
+{
+        const struct packet_info *pi;
+        int data_length = 0;
+        int i;
+
+        pi = &packet_info[packet->common.tcode];
+
+        for (i = 0; i < pi->field_count; i++) {
+                const struct packet_field *f = &pi->fields[i];
+                int offset;
+
+                if (f->flags & exclude_flags)
+                        continue;
+                if (include_flags && !(f->flags & include_flags))
+                        continue;
+
+                if (f->offset < 0)
+                        offset = length * 8 + f->offset - 32;
+                else
+                        offset = f->offset;
+
+                if (f->value_names != NULL) {
+                        uint32_t bits;
+
+                        bits = get_bits(packet, offset, f->width);
+                        printf("%s", f->value_names[bits]);
+                } else if (f->width == 0) {
+                        printf("%s=[", f->name);
+                        dump_data((unsigned char *) packet + (offset / 8 + 4), data_length);
+                        printf("]");
+                } else {
+                        unsigned long long bits;
+                        int high_width, low_width;
+
+                        if ((offset & ~31) != ((offset + f->width - 1) & ~31)) {
+                                /* Bit field spans quadlet boundary. */
+                                high_width = ((offset + 31) & ~31) - offset;
+                                low_width = f->width - high_width;
+
+                                bits = get_bits(packet, offset, high_width);
+                                bits = (bits << low_width) |
+                                        get_bits(packet, offset + high_width, low_width);
+                        } else {
+                                bits = get_bits(packet, offset, f->width);
+                        }
+
+                        printf("%s=0x%0*llx", f->name, (f->width + 3) / 4, bits);
+
+                        if (f->flags & PACKET_FIELD_DATA_LENGTH)
+                                data_length = bits;
+                }
+
+                if (i < pi->field_count - 1)
+                        printf(", ");
+        }
+}
+
+static void
+print_packet(uint32_t *data, size_t length)
+{
+        int i;
+
+        printf("%6u  ", data[0]);
+
+        if (length == 4) {
+                printf("bus reset");
+        } else if (length < sizeof(struct phy_packet)) {
+                printf("short packet: ");
+                for (i = 1; i < length / 4; i++)
+                        printf("%s%08x", i == 0 ? "[" : " ", data[i]);
+                printf("]");
+
+        } else if (length == sizeof(struct phy_packet) && data[1] == ~data[2]) {
+                struct phy_packet *pp = (struct phy_packet *) data;
+
+                /* phy packet are 3 quadlets: the 1 quadlet payload,
+                 * the bitwise inverse of the payload and the snoop
+                 * mode ack */
+
+                switch (pp->common.identifier) {
+                case PHY_PACKET_CONFIGURATION:
+                        if (!pp->phy_config.set_root && !pp->phy_config.set_gap_count) {
+                                printf("ext phy config: phy_id=%02x", pp->phy_config.root_id);
+                        } else {
+                                printf("phy config:");
+                                if (pp->phy_config.set_root)
+                                        printf(" set_root_id=%02x", pp->phy_config.root_id);
+                                if (pp->phy_config.set_gap_count)
+                                        printf(" set_gap_count=%d", pp->phy_config.gap_count);
+                        }
+                        break;
+
+                case PHY_PACKET_LINK_ON:
+                        printf("link-on packet, phy_id=%02x", pp->link_on.phy_id);
+                        break;
+
+                case PHY_PACKET_SELF_ID:
+                        if (pp->self_id.extended) {
+                                printf("extended self id: phy_id=%02x, seq=%d",
+                                       pp->ext_self_id.phy_id, pp->ext_self_id.sequence);
+                        } else {
+                                static const char * const speed_names[] = {
+                                        "S100", "S200", "S400", "BETA"
+                                };
+                                printf("self id: phy_id=%02x, link %s, gap_count=%d, speed=%s%s%s",
+                                       pp->self_id.phy_id,
+                                       (pp->self_id.link_active ? "active" : "not active"),
+                                       pp->self_id.gap_count,
+                                       speed_names[pp->self_id.phy_speed],
+                                       (pp->self_id.contender ? ", irm contender" : ""),
+                                       (pp->self_id.initiated_reset ? ", initiator" : ""));
+                        }
+                        break;
+                default:
+                        printf("unknown phy packet: ");
+                        for (i = 1; i < length / 4; i++)
+                                printf("%s%08x", i == 0 ? "[" : " ", data[i]);
+                        printf("]");
+                        break;
+                }
+        } else {
+                struct link_packet *packet = (struct link_packet *) data;
+
+                decode_link_packet(packet, length, 0,
+                                   option_verbose ? 0 : PACKET_FIELD_DETAIL);
+        }
+
+        if (option_hex) {
+                printf("  [");
+                dump_data((unsigned char *) data + 4, length - 4);
+                printf("]");
+        }
+
+        printf("\r\n");
+}
+
+#define HIDE_CURSOR     "\033[?25l"
+#define SHOW_CURSOR     "\033[?25h"
+#define CLEAR           "\033[H\033[2J"
+
+static void
+print_stats(uint32_t *data, size_t length)
+{
+        static int bus_reset_count, short_packet_count, phy_packet_count;
+        static int tcode_count[16];
+        static struct timeval last_update;
+        struct timeval now;
+        int i;
+
+        if (length == 0)
+                bus_reset_count++;
+        else if (length < sizeof(struct phy_packet))
+                short_packet_count++;
+        else if (length == sizeof(struct phy_packet) && data[1] == ~data[2])
+                phy_packet_count++;
+        else {
+                struct link_packet *packet = (struct link_packet *) data;
+                tcode_count[packet->common.tcode]++;
+        }
+
+        gettimeofday(&now, NULL);
+        if (now.tv_sec <= last_update.tv_sec &&
+            now.tv_usec < last_update.tv_usec + 500000)
+                return;
+
+        last_update = now;
+        printf(CLEAR HIDE_CURSOR
+               "  bus resets              : %8d\n"
+               "  short packets           : %8d\n"
+               "  phy packets             : %8d\n",
+               bus_reset_count, short_packet_count, phy_packet_count);
+
+        for (i = 0; i < array_length(packet_info); i++)
+                if (packet_info[i].type != PACKET_RESERVED)
+                        printf("  %-24s: %8d\n", packet_info[i].name, tcode_count[i]);
+        printf(SHOW_CURSOR "\n");
+}
+
+static struct termios saved_attributes;
+
+static void
+reset_input_mode(void)
+{
+        tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes);
+}
+
+static void
+set_input_mode(void)
+{
+        struct termios tattr;
+
+        /* Make sure stdin is a terminal. */
+        if (!isatty(STDIN_FILENO)) {
+                fprintf(stderr, "Not a terminal.\n");
+                exit(EXIT_FAILURE);
+        }
+
+        /* Save the terminal attributes so we can restore them later. */
+        tcgetattr(STDIN_FILENO, &saved_attributes);
+        atexit(reset_input_mode);
+
+        /* Set the funny terminal modes. */
+        tcgetattr(STDIN_FILENO, &tattr);
+        tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
+        tattr.c_cc[VMIN] = 1;
+        tattr.c_cc[VTIME] = 0;
+        tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
+}
+
+int main(int argc, const char *argv[])
+{
+        uint32_t buf[128 * 1024];
+        uint32_t filter;
+        int length, retval, view;
+        int fd = -1;
+        FILE *output = NULL, *input = NULL;
+        poptContext con;
+        char c;
+        struct pollfd pollfds[2];
+
+        sys_sigint_handler = signal(SIGINT, sigint_handler);
+
+        con = poptGetContext(NULL, argc, argv, options, 0);
+        retval = poptGetNextOpt(con);
+        if (retval < -1) {
+                poptPrintUsage(con, stdout, 0);
+                return -1;
+        }
+
+        if (option_version) {
+                printf("dump tool for nosy sniffer, version %s\n", VERSION);
+                return 0;
+        }
+
+        if (__BYTE_ORDER != __LITTLE_ENDIAN)
+                fprintf(stderr, "warning: nosy has only been tested on little "
+                        "endian machines\n");
+
+        if (option_input != NULL) {
+                input = fopen(option_input, "r");
+                if (input == NULL) {
+                        fprintf(stderr, "Could not open %s, %m\n", option_input);
+                        return -1;
+                }
+        } else {
+                fd = open(option_nosy_device, O_RDWR);
+                if (fd < 0) {
+                        fprintf(stderr, "Could not open %s, %m\n", option_nosy_device);
+                        return -1;
+                }
+                set_input_mode();
+        }
+
+        if (strcmp(option_view, "transaction") == 0)
+                view = VIEW_TRANSACTION;
+        else if (strcmp(option_view, "stats") == 0)
+                view = VIEW_STATS;
+        else
+                view = VIEW_PACKET;
+
+        if (option_output) {
+                output = fopen(option_output, "w");
+                if (output == NULL) {
+                        fprintf(stderr, "Could not open %s, %m\n", option_output);
+                        return -1;
+                }
+        }
+
+        setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
+
+        filter = ~0;
+        if (!option_iso)
+                filter &= ~(1 << TCODE_STREAM_DATA);
+        if (!option_cycle_start)
+                filter &= ~(1 << TCODE_CYCLE_START);
+        if (view == VIEW_STATS)
+                filter = ~(1 << TCODE_CYCLE_START);
+
+        ioctl(fd, NOSY_IOC_FILTER, filter);
+
+        ioctl(fd, NOSY_IOC_START);
+
+        pollfds[0].fd = fd;
+        pollfds[0].events = POLLIN;
+        pollfds[1].fd = STDIN_FILENO;
+        pollfds[1].events = POLLIN;
+
+        while (run) {
+                if (input != NULL) {
+                        if (fread(&length, sizeof length, 1, input) != 1)
+                                return 0;
+                        fread(buf, 1, length, input);
+                } else {
+                        poll(pollfds, 2, -1);
+                        if (pollfds[1].revents) {
+                                read(STDIN_FILENO, &c, sizeof c);
+                                switch (c) {
+                                case 'q':
+                                        if (output != NULL)
+                                                fclose(output);
+                                        return 0;
+                                }
+                        }
+
+                        if (pollfds[0].revents)
+                                length = read(fd, buf, sizeof buf);
+                        else
+                                continue;
+                }
+
+                if (output != NULL) {
+                        fwrite(&length, sizeof length, 1, output);
+                        fwrite(buf, 1, length, output);
+                }
+
+                switch (view) {
+                case VIEW_TRANSACTION:
+                        handle_packet(buf, length);
+                        break;
+                case VIEW_PACKET:
+                        print_packet(buf, length);
+                        break;
+                case VIEW_STATS:
+                        print_stats(buf, length);
+                        break;
+                }
+        }
+
+        if (output != NULL)
+                fclose(output);
+
+        close(fd);
+
+        poptFreeContext(con);
+
+        return 0;
+}
diff --git a/tools/firewire/nosy-dump.h b/tools/firewire/nosy-dump.h
new file mode 100644
index 000000000000..3a4b5b33ba5d
--- /dev/null
+++ b/tools/firewire/nosy-dump.h
@@ -0,0 +1,173 @@
+#ifndef __nosy_dump_h__
+#define __nosy_dump_h__
+
+#define array_length(array) (sizeof(array) / sizeof(array[0]))
+
+#define ACK_NO_ACK   0x0
+#define ACK_DONE(a)  ((a >> 2) == 0)
+#define ACK_BUSY(a)  ((a >> 2) == 1)
+#define ACK_ERROR(a) ((a >> 2) == 3)
+
+#include <stdint.h>
+
+struct phy_packet {
+        uint32_t timestamp;
+        union {
+                struct {
+                        uint32_t zero:24;
+                        uint32_t phy_id:6;
+                        uint32_t identifier:2;
+                } common, link_on;
+
+                struct {
+                        uint32_t zero:16;
+                        uint32_t gap_count:6;
+                        uint32_t set_gap_count:1;
+                        uint32_t set_root:1;
+                        uint32_t root_id:6;
+                        uint32_t identifier:2;
+                } phy_config;
+
+                struct {
+                        uint32_t more_packets:1;
+                        uint32_t initiated_reset:1;
+                        uint32_t port2:2;
+                        uint32_t port1:2;
+                        uint32_t port0:2;
+                        uint32_t power_class:3;
+                        uint32_t contender:1;
+                        uint32_t phy_delay:2;
+                        uint32_t phy_speed:2;
+                        uint32_t gap_count:6;
+                        uint32_t link_active:1;
+                        uint32_t extended:1;
+                        uint32_t phy_id:6;
+                        uint32_t identifier:2;
+                } self_id;
+
+                struct {
+                        uint32_t more_packets:1;
+                        uint32_t reserved1:1;
+                        uint32_t porth:2;
+                        uint32_t portg:2;
+                        uint32_t portf:2;
+                        uint32_t porte:2;
+                        uint32_t portd:2;
+                        uint32_t portc:2;
+                        uint32_t portb:2;
+                        uint32_t porta:2;
+                        uint32_t reserved0:2;
+                        uint32_t sequence:3;
+                        uint32_t extended:1;
+                        uint32_t phy_id:6;
+                        uint32_t identifier:2;
+                } ext_self_id;
+        };
+        uint32_t inverted;
+        uint32_t ack;
+};
+
+#define TCODE_PHY_PACKET 0x10
+
+#define PHY_PACKET_CONFIGURATION 0x00
+#define PHY_PACKET_LINK_ON 0x01
+#define PHY_PACKET_SELF_ID 0x02
+
+struct link_packet {
+        uint32_t timestamp;
+        union {
+                struct {
+                        uint32_t priority:4;
+                        uint32_t tcode:4;
+                        uint32_t rt:2;
+                        uint32_t tlabel:6;
+                        uint32_t destination:16;
+
+                        uint32_t offset_high:16;
+                        uint32_t source:16;
+
+                        uint32_t offset_low;
+                } common;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t crc;
+                } read_quadlet;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t data;
+                        uint32_t crc;
+                } read_quadlet_response;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t extended_tcode:16;
+                        uint32_t data_length:16;
+                        uint32_t crc;
+                } read_block;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t extended_tcode:16;
+                        uint32_t data_length:16;
+                        uint32_t crc;
+                        uint32_t data[0];
+                        /* crc and ack follows. */
+                } read_block_response;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t data;
+                        uint32_t crc;
+                } write_quadlet;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t extended_tcode:16;
+                        uint32_t data_length:16;
+                        uint32_t crc;
+                        uint32_t data[0];
+                        /* crc and ack follows. */
+                } write_block;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t crc;
+                } write_response;
+
+                struct {
+                        uint32_t common[3];
+                        uint32_t data;
+                        uint32_t crc;
+                } cycle_start;
+
+                struct {
+                        uint32_t sy:4;
+                        uint32_t tcode:4;
+                        uint32_t channel:6;
+                        uint32_t tag:2;
+                        uint32_t data_length:16;
+
+                        uint32_t crc;
+                } iso_data;
+        };
+};
+
+struct subaction {
+        uint32_t ack;
+        size_t length;
+        struct list link;
+        struct link_packet packet;
+};
+
+struct link_transaction {
+        int request_node, response_node, tlabel;
+        struct subaction *request, *response;
+        struct list request_list, response_list;
+        struct list link;
+};
+
+int decode_fcp(struct link_transaction *t);
+
+#endif /* __nosy_dump_h__ */
diff --git a/tools/perf/.gitignore b/tools/perf/.gitignore
index fe08660ce0bd..cb43289e447f 100644
--- a/tools/perf/.gitignore
+++ b/tools/perf/.gitignore
@@ -13,6 +13,10 @@ perf*.xml
 perf*.html
 common-cmds.h
 perf.data
+perf.data.old
+perf-archive
 tags
 TAGS
 cscope*
+config.mak
+config.mak.autogen
diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
index bdd3b7ecad0a..bd498d496952 100644
--- a/tools/perf/Documentation/Makefile
+++ b/tools/perf/Documentation/Makefile
@@ -24,7 +24,10 @@ DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
 DOC_MAN5=$(patsubst %.txt,%.5,$(MAN5_TXT))
 DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
 
+# Make the path relative to DESTDIR, not prefix
+ifndef DESTDIR
 prefix?=$(HOME)
+endif
 bindir?=$(prefix)/bin
 htmldir?=$(prefix)/share/doc/perf-doc
 pdfdir?=$(prefix)/share/doc/perf-doc
@@ -32,7 +35,6 @@ mandir?=$(prefix)/share/man
 man1dir=$(mandir)/man1
 man5dir=$(mandir)/man5
 man7dir=$(mandir)/man7
-# DESTDIR=
 
 ASCIIDOC=asciidoc
 ASCIIDOC_EXTRA = --unsafe
diff --git a/tools/perf/Documentation/perf-annotate.txt b/tools/perf/Documentation/perf-annotate.txt
index c9dcade06831..5164a655c39f 100644
--- a/tools/perf/Documentation/perf-annotate.txt
+++ b/tools/perf/Documentation/perf-annotate.txt
@@ -1,5 +1,5 @@
 perf-annotate(1)
-==============
+================
 
 NAME
 ----
diff --git a/tools/perf/Documentation/perf-archive.txt b/tools/perf/Documentation/perf-archive.txt
new file mode 100644
index 000000000000..fae174dc7d01
--- /dev/null
+++ b/tools/perf/Documentation/perf-archive.txt
@@ -0,0 +1,22 @@
+perf-archive(1)
+===============
+
+NAME
+----
+perf-archive - Create archive with object files with build-ids found in perf.data file
+
+SYNOPSIS
+--------
+[verse]
+'perf archive' [file]
+
+DESCRIPTION
+-----------
+This command runs runs perf-buildid-list --with-hits, and collects the files
+with the buildids found so that analisys of perf.data contents can be possible
+on another machine.
+
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-buildid-list[1], linkperf:perf-report[1]
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index ae525ac5a2ce..a3dbadb26ef5 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -1,5 +1,5 @@
 perf-bench(1)
-============
+=============
 
 NAME
 ----
@@ -19,12 +19,12 @@ COMMON OPTIONS
 -f::
 --format=::
 Specify format style.
-Current available format styles are,
+Current available format styles are:
 
 'default'::
 Default style. This is mainly for human reading.
 ---------------------
-% perf bench sched pipe                      # with no style specify
+% perf bench sched pipe                      # with no style specified
 (executing 1000000 pipe operations between two tasks)
         Total time:5.855 sec
                 5.855061 usecs/op
@@ -79,7 +79,7 @@ options (20 sender and receiver processes per group)
 
       Total time:0.308 sec
 
-% perf bench sched messaging -t -g 20        # be multi-thread,with 20 groups
+% perf bench sched messaging -t -g 20        # be multi-thread, with 20 groups
 (20 sender and receiver threads per group)
 (20 groups == 800 threads run)
 
diff --git a/tools/perf/Documentation/perf-buildid-cache.txt b/tools/perf/Documentation/perf-buildid-cache.txt
new file mode 100644
index 000000000000..c1057701a7dc
--- /dev/null
+++ b/tools/perf/Documentation/perf-buildid-cache.txt
@@ -0,0 +1,33 @@
+perf-buildid-cache(1)
+=====================
+
+NAME
+----
+perf-buildid-cache - Manage build-id cache.
+
+SYNOPSIS
+--------
+[verse]
+'perf buildid-cache <options>'
+
+DESCRIPTION
+-----------
+This command manages the build-id cache. It can add and remove files to/from
+the cache. In the future it should as well purge older entries, set upper
+limits for the space used by the cache, etc.
+
+OPTIONS
+-------
+-a::
+--add=::
+        Add specified file to the cache.
+-r::
+--remove=::
+        Remove specified file from the cache.
+-v::
+--verbose::
+        Be more verbose.
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-report[1], linkperf:perf-buildid-list[1]
diff --git a/tools/perf/Documentation/perf-diff.txt b/tools/perf/Documentation/perf-diff.txt
index 8974e208cba6..20d97d84ea1c 100644
--- a/tools/perf/Documentation/perf-diff.txt
+++ b/tools/perf/Documentation/perf-diff.txt
@@ -1,5 +1,5 @@
 perf-diff(1)
-==============
+============
 
 NAME
 ----
diff --git a/tools/perf/Documentation/perf-inject.txt b/tools/perf/Documentation/perf-inject.txt
new file mode 100644
index 000000000000..025630d43cd2
--- /dev/null
+++ b/tools/perf/Documentation/perf-inject.txt
@@ -0,0 +1,35 @@
+perf-inject(1)
+==============
+
+NAME
+----
+perf-inject - Filter to augment the events stream with additional information
+
+SYNOPSIS
+--------
+[verse]
+'perf inject <options>'
+
+DESCRIPTION
+-----------
+perf-inject reads a perf-record event stream and repipes it to stdout.  At any
+point the processing code can inject other events into the event stream - in
+this case build-ids (-b option) are read and injected as needed into the event
+stream.
+
+Build-ids are just the first user of perf-inject - potentially anything that
+needs userspace processing to augment the events stream with additional
+information could make use of this facility.
+
+OPTIONS
+-------
+-b::
+--build-ids=::
+        Inject build-ids into the output stream
+-v::
+--verbose::
+        Be more verbose.
+
+SEE ALSO
+--------
+linkperf:perf-record[1], linkperf:perf-report[1], linkperf:perf-archive[1]
diff --git a/tools/perf/Documentation/perf-kmem.txt b/tools/perf/Documentation/perf-kmem.txt
index eac4d852e7cd..a52fcde894c7 100644
--- a/tools/perf/Documentation/perf-kmem.txt
+++ b/tools/perf/Documentation/perf-kmem.txt
@@ -1,5 +1,5 @@
 perf-kmem(1)
-==============
+============
 
 NAME
 ----
diff --git a/tools/perf/Documentation/perf-kvm.txt b/tools/perf/Documentation/perf-kvm.txt
new file mode 100644
index 000000000000..d004e19fe6d6
--- /dev/null
+++ b/tools/perf/Documentation/perf-kvm.txt
@@ -0,0 +1,68 @@
+perf-kvm(1)
+===========
+
+NAME
+----
+perf-kvm - Tool to trace/measure kvm guest os
+
+SYNOPSIS
+--------
+[verse]
+'perf kvm' [--host] [--guest] [--guestmount=<path>
+        [--guestkallsyms=<path> --guestmodules=<path> | --guestvmlinux=<path>]]
+        {top|record|report|diff|buildid-list}
+'perf kvm' [--host] [--guest] [--guestkallsyms=<path> --guestmodules=<path>
+        | --guestvmlinux=<path>] {top|record|report|diff|buildid-list}
+
+DESCRIPTION
+-----------
+There are a couple of variants of perf kvm:
+
+  'perf kvm [options] top <command>' to generates and displays
+  a performance counter profile of guest os in realtime
+  of an arbitrary workload.
+
+  'perf kvm record <command>' to record the performance couinter profile
+  of an arbitrary workload and save it into a perf data file. If both
+  --host and --guest are input, the perf data file name is perf.data.kvm.
+  If there is  no --host but --guest, the file name is perf.data.guest.
+  If there is no --guest but --host, the file name is perf.data.host.
+
+  'perf kvm report' to display the performance counter profile information
+  recorded via perf kvm record.
+
+  'perf kvm diff' to displays the performance difference amongst two perf.data
+  files captured via perf record.
+
+  'perf kvm buildid-list' to  display 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.
+
+OPTIONS
+-------
+--host=::
+        Collect host side performance profile.
+--guest=::
+        Collect guest side performance profile.
+--guestmount=<path>::
+        Guest os root file system mount directory. Users mounts guest os
+        root directories under <path> by a specific filesystem access method,
+        typically, sshfs. For example, start 2 guest os. The one's pid is 8888
+        and the other's is 9999.
+        #mkdir ~/guestmount; cd ~/guestmount
+        #sshfs -o allow_other,direct_io -p 5551 localhost:/ 8888/
+        #sshfs -o allow_other,direct_io -p 5552 localhost:/ 9999/
+        #perf kvm --host --guest --guestmount=~/guestmount top
+--guestkallsyms=<path>::
+        Guest os /proc/kallsyms file copy. 'perf' kvm' reads it to get guest
+        kernel symbols. Users copy it out from guest os.
+--guestmodules=<path>::
+        Guest os /proc/modules file copy. 'perf' kvm' reads it to get guest
+        kernel module information. Users copy it out from guest os.
+--guestvmlinux=<path>::
+        Guest os kernel vmlinux.
+
+SEE ALSO
+--------
+linkperf:perf-top[1], linkperf:perf-record[1], linkperf:perf-report[1],
+linkperf:perf-diff[1], linkperf:perf-buildid-list[1]
diff --git a/tools/perf/Documentation/perf-list.txt b/tools/perf/Documentation/perf-list.txt
index 8290b9422668..43e3dd284b90 100644
--- a/tools/perf/Documentation/perf-list.txt
+++ b/tools/perf/Documentation/perf-list.txt
@@ -15,6 +15,35 @@ DESCRIPTION
 This command displays the symbolic event types which can be selected in the
 various perf commands with the -e option.
 
+RAW HARDWARE EVENT DESCRIPTOR
+-----------------------------
+Even when an event is not available in a symbolic form within perf right now,
+it can be encoded in a per processor specific way.
+
+For instance For x86 CPUs NNN represents the raw register encoding with the
+layout of IA32_PERFEVTSELx MSRs (see [Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3B: System Programming Guide] Figure 30-1 Layout
+of IA32_PERFEVTSELx MSRs) or AMD's PerfEvtSeln (see [AMD64 Architecture Programmer’s Manual Volume 2: System Programming], Page 344,
+Figure 13-7 Performance Event-Select Register (PerfEvtSeln)).
+
+Example:
+
+If the Intel docs for a QM720 Core i7 describe an event as:
+
+  Event  Umask  Event Mask
+  Num.   Value  Mnemonic    Description                        Comment
+
+  A8H      01H  LSD.UOPS    Counts the number of micro-ops     Use cmask=1 and
+                            delivered by loop stream detector  invert to count
+                                                               cycles
+
+raw encoding of 0x1A8 can be used:
+
+ perf stat -e r1a8 -a sleep 1
+ perf record -e r1a8 ...
+
+You should refer to the processor specific documentation for getting these
+details. Some of them are referenced in the SEE ALSO section below.
+
 OPTIONS
 -------
 None
@@ -22,4 +51,6 @@ None
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-top[1],
-linkperf:perf-record[1]
+linkperf:perf-record[1],
+http://www.intel.com/Assets/PDF/manual/253669.pdf[Intel® 64 and IA-32 Architectures Software Developer's Manual Volume 3B: System Programming Guide],
+http://support.amd.com/us/Processor_TechDocs/24593.pdf[AMD64 Architecture Programmer’s Manual Volume 2: System Programming]
diff --git a/tools/perf/Documentation/perf-lock.txt b/tools/perf/Documentation/perf-lock.txt
new file mode 100644
index 000000000000..b317102138c8
--- /dev/null
+++ b/tools/perf/Documentation/perf-lock.txt
@@ -0,0 +1,29 @@
+perf-lock(1)
+============
+
+NAME
+----
+perf-lock - Analyze lock events
+
+SYNOPSIS
+--------
+[verse]
+'perf lock' {record|report|trace}
+
+DESCRIPTION
+-----------
+You can analyze various lock behaviours
+and statistics with this 'perf lock' command.
+
+  'perf lock record <command>' records lock events
+  between start and end <command>. And this command
+  produces the file "perf.data" which contains tracing
+  results of lock events.
+
+  'perf lock trace' shows raw lock events.
+
+  'perf lock report' reports statistical data.
+
+SEE ALSO
+--------
+linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 250e391b4bc8..27d52dae5a43 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -15,6 +15,8 @@ or
 'perf probe' [options] --del='[GROUP:]EVENT' [...]
 or
 'perf probe' --list
+or
+'perf probe' --line='FUNC[:RLN[+NUM|:RLN2]]|SRC:ALN[+NUM|:ALN2]'
 
 DESCRIPTION
 -----------
@@ -29,6 +31,10 @@ OPTIONS
 --vmlinux=PATH::
         Specify vmlinux path which has debuginfo (Dwarf binary).
 
+-s::
+--source=PATH::
+        Specify path to kernel source.
+
 -v::
 --verbose::
         Be more verbose (show parsed arguments, etc).
@@ -39,22 +45,105 @@ OPTIONS
 
 -d::
 --del=::
-        Delete a probe event.
+        Delete probe events. This accepts glob wildcards('*', '?') and character
+        classes(e.g. [a-z], [!A-Z]).
 
 -l::
 --list::
         List up current probe events.
 
+-L::
+--line=::
+        Show source code lines which can be probed. This needs an argument
+        which specifies a range of the source code. (see LINE SYNTAX for detail)
+
+-f::
+--force::
+        Forcibly add events with existing name.
+
+-n::
+--dry-run::
+        Dry run. With this option, --add and --del doesn't execute actual
+        adding and removal operations.
+
+--max-probes::
+        Set the maximum number of probe points for an event. Default is 128.
+
 PROBE SYNTAX
 ------------
 Probe points are defined by following syntax.
 
- "[EVENT=]FUNC[+OFFS|:RLN|%return][@SRC]|SRC:ALN [ARG ...]"
+    1) Define event based on function name
+     [EVENT=]FUNC[@SRC][:RLN|+OFFS|%return|;PTN] [ARG ...]
+
+    2) Define event based on source file with line number
+     [EVENT=]SRC:ALN [ARG ...]
+
+    3) Define event based on source file with lazy pattern
+     [EVENT=]SRC;PTN [ARG ...]
+
 
 'EVENT' specifies the name of new event, if omitted, it will be set the name of the probed function. Currently, event group name is set as 'probe'.
-'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, 'RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. In addition, 'SRC' specifies a source file which has that function.
-It is also possible to specify a probe point by the source line number by using 'SRC:ALN' syntax, where 'SRC' is the source file path and 'ALN' is the line number.
-'ARG' specifies the arguments of this probe point. You can use the name of local variable, or kprobe-tracer argument format (e.g. $retval, %ax, etc).
+'FUNC' specifies a probed function name, and it may have one of the following options; '+OFFS' is the offset from function entry address in bytes, ':RLN' is the relative-line number from function entry line, and '%return' means that it probes function return. And ';PTN' means lazy matching pattern (see LAZY MATCHING). Note that ';PTN' must be the end of the probe point definition.  In addition, '@SRC' specifies a source file which has that function.
+It is also possible to specify a probe point by the source line number or lazy matching by using 'SRC:ALN' or 'SRC;PTN' syntax, where 'SRC' is the source file path, ':ALN' is the line number and ';PTN' is the lazy matching pattern.
+'ARG' specifies the arguments of this probe point, (see PROBE ARGUMENT).
+
+PROBE ARGUMENT
+--------------
+Each probe argument follows below syntax.
+
+ [NAME=]LOCALVAR|$retval|%REG|@SYMBOL[:TYPE]
+
+'NAME' specifies the name of this argument (optional). You can use the name of local variable, local data structure member (e.g. var->field, var.field2), local array with fixed index (e.g. array[1], var->array[0], var->pointer[2]), or kprobe-tracer argument format (e.g. $retval, %ax, etc). Note that the name of this argument will be set as the last member name if you specify a local data structure member (e.g. field2 for 'var->field1.field2'.)
+'TYPE' casts the type of this argument (optional). If omitted, perf probe automatically set the type based on debuginfo. You can specify 'string' type only for the local variable or structure member which is an array of or a pointer to 'char' or 'unsigned char' type.
+
+LINE SYNTAX
+-----------
+Line range is descripted by following syntax.
+
+ "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]"
+
+FUNC specifies the function name of showing lines. 'RLN' is the start line
+number from function entry line, and 'RLN2' is the end line number. As same as
+probe syntax, 'SRC' means the source file path, 'ALN' is start line number,
+and 'ALN2' is end line number in the file. It is also possible to specify how
+many lines to show by using 'NUM'.
+So, "source.c:100-120" shows lines between 100th to l20th in source.c file. And "func:10+20" shows 20 lines from 10th line of func function.
+
+LAZY MATCHING
+-------------
+ The lazy line matching is similar to glob matching but ignoring spaces in both of pattern and target. So this accepts wildcards('*', '?') and character classes(e.g. [a-z], [!A-Z]).
+
+e.g.
+ 'a=*' can matches 'a=b', 'a = b', 'a == b' and so on.
+
+This provides some sort of flexibility and robustness to probe point definitions against minor code changes. For example, actual 10th line of schedule() can be moved easily by modifying schedule(), but the same line matching 'rq=cpu_rq*' may still exist in the function.)
+
+
+EXAMPLES
+--------
+Display which lines in schedule() can be probed:
+
+ ./perf probe --line schedule
+
+Add a probe on schedule() function 12th line with recording cpu local variable:
+
+ ./perf probe schedule:12 cpu
+ or
+ ./perf probe --add='schedule:12 cpu'
+
+ this will add one or more probes which has the name start with "schedule".
+
+ Add probes on lines in schedule() function which calls update_rq_clock().
+
+ ./perf probe 'schedule;update_rq_clock*'
+ or
+ ./perf probe --add='schedule;update_rq_clock*'
+
+Delete all probes on schedule().
+
+ ./perf probe --del='schedule*'
+
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index fc46c0b40f6e..3ee27dccfde9 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -58,7 +58,7 @@ OPTIONS
 
 -f::
 --force::
-        Overwrite existing data file.
+        Overwrite existing data file. (deprecated)
 
 -c::
 --count=::
@@ -69,8 +69,8 @@ OPTIONS
         Output file name.
 
 -i::
---inherit::
-        Child tasks inherit counters.
+--no-inherit::
+        Child tasks do not inherit counters.
 -F::
 --freq=::
         Profile at this frequency.
@@ -101,7 +101,20 @@ OPTIONS
 
 -R::
 --raw-samples::
-Collect raw sample records from all opened counters (typically for tracepoint counters).
+Collect raw sample records from all opened counters (default for tracepoint counters).
+
+-C::
+--cpu::
+Collect samples only on the list of cpus provided. Multiple CPUs can be provided as a
+comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+In per-thread mode with inheritance mode on (default), samples are captured only when
+the thread executes on the designated CPUs. Default is to monitor all CPUs.
+
+-N::
+--no-buildid-cache::
+Do not update the builid cache. This saves some overhead in situations
+where the information in the perf.data file (which includes buildids)
+is sufficient.
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-sched.txt b/tools/perf/Documentation/perf-sched.txt
index 1ce79198997b..8417644a6166 100644
--- a/tools/perf/Documentation/perf-sched.txt
+++ b/tools/perf/Documentation/perf-sched.txt
@@ -12,7 +12,7 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-There's four variants of perf sched:
+There are four variants of perf sched:
 
   'perf sched record <command>' to record the scheduling events
   of an arbitrary workload.
@@ -27,7 +27,7 @@ There's four variants of perf sched:
   via perf sched record. (this is done by starting up mockup threads
   that mimic the workload based on the events in the trace. These
   threads can then replay the timings (CPU runtime and sleep patterns)
-  of the workload as it occured when it was recorded - and can repeat
+  of the workload as it occurred when it was recorded - and can repeat
   it a number of times, measuring its performance.)
 
 OPTIONS
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 484080dd5b6f..4b3a2d46b437 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -31,8 +31,8 @@ OPTIONS
          hexadecimal event descriptor.
 
 -i::
---inherit::
-        child tasks inherit counters
+--no-inherit::
+        child tasks do not inherit counters
 -p::
 --pid=<pid>::
         stat events on existing pid
@@ -43,6 +43,16 @@ OPTIONS
 -c::
         scale counter values
 
+-B::
+        print large numbers with thousands' separators according to locale
+
+-C::
+--cpu=::
+Count only on the list of cpus provided. Multiple CPUs can be provided as a
+comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+In per-thread mode, this option is ignored. The -a option is still necessary
+to activate system-wide monitoring. Default is to count on all CPUs.
+
 EXAMPLES
 --------
 
diff --git a/tools/perf/Documentation/perf-test.txt b/tools/perf/Documentation/perf-test.txt
new file mode 100644
index 000000000000..1c4b5f5b7f71
--- /dev/null
+++ b/tools/perf/Documentation/perf-test.txt
@@ -0,0 +1,22 @@
+perf-test(1)
+============
+
+NAME
+----
+perf-test - Runs sanity tests.
+
+SYNOPSIS
+--------
+[verse]
+'perf test <options>'
+
+DESCRIPTION
+-----------
+This command does assorted sanity tests, initially thru linked routines but
+also will look for a directory with more tests in the form of scripts.
+
+OPTIONS
+-------
+-v::
+--verbose::
+        Be more verbose.
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 4a7d558dc309..1f9687663f2a 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -25,9 +25,11 @@ OPTIONS
 --count=<count>::
         Event period to sample.
 
--C <cpu>::
---CPU=<cpu>::
-        CPU to profile.
+-C <cpu-list>::
+--cpu=<cpu>::
+Monitor only on the list of cpus provided. Multiple CPUs can be provided as a
+comma-sperated list with no space: 0,1. Ranges of CPUs are specified with -: 0-2.
+Default is to monitor all CPUS.
 
 -d <seconds>::
 --delay=<seconds>::
@@ -74,7 +76,7 @@ OPTIONS
 
 -s <symbol>::
 --sym-annotate=<symbol>::
-        Annotate this symbol.  Requires -k option.
+        Annotate this symbol.
 
 -v::
 --verbose::
diff --git a/tools/perf/Documentation/perf-trace-perl.txt b/tools/perf/Documentation/perf-trace-perl.txt
index c5f55f439091..ee6525ee6d69 100644
--- a/tools/perf/Documentation/perf-trace-perl.txt
+++ b/tools/perf/Documentation/perf-trace-perl.txt
@@ -8,7 +8,7 @@ perf-trace-perl - Process trace data with a Perl script
 SYNOPSIS
 --------
 [verse]
-'perf trace' [-s [lang]:script[.ext] ]
+'perf trace' [-s [Perl]:script[.pl] ]
 
 DESCRIPTION
 -----------
@@ -49,12 +49,10 @@ available as calls back into the perf executable (see below).
 As an example, the following perf record command can be used to record
 all sched_wakeup events in the system:
 
- # perf record -c 1 -f -a -M -R -e sched:sched_wakeup
+ # perf record -a -e sched:sched_wakeup
 
 Traces meant to be processed using a script should be recorded with
-the above options: -c 1 says to sample every event, -a to enable
-system-wide collection, -M to multiplex the output, and -R to collect
-raw samples.
+the above option: -a to enable system-wide collection.
 
 The format file for the sched_wakep event defines the following fields
 (see /sys/kernel/debug/tracing/events/sched/sched_wakeup/format):
diff --git a/tools/perf/Documentation/perf-trace-python.txt b/tools/perf/Documentation/perf-trace-python.txt
new file mode 100644
index 000000000000..693be804dd3d
--- /dev/null
+++ b/tools/perf/Documentation/perf-trace-python.txt
@@ -0,0 +1,623 @@
+perf-trace-python(1)
+====================
+
+NAME
+----
+perf-trace-python - Process trace data with a Python script
+
+SYNOPSIS
+--------
+[verse]
+'perf trace' [-s [Python]:script[.py] ]
+
+DESCRIPTION
+-----------
+
+This perf trace option is used to process perf trace data using perf's
+built-in Python interpreter.  It reads and processes the input file and
+displays the results of the trace analysis implemented in the given
+Python script, if any.
+
+A QUICK EXAMPLE
+---------------
+
+This section shows the process, start to finish, of creating a working
+Python script that aggregates and extracts useful information from a
+raw perf trace stream.  You can avoid reading the rest of this
+document if an example is enough for you; the rest of the document
+provides more details on each step and lists the library functions
+available to script writers.
+
+This example actually details the steps that were used to create the
+'syscall-counts' script you see when you list the available perf trace
+scripts via 'perf trace -l'.  As such, this script also shows how to
+integrate your script into the list of general-purpose 'perf trace'
+scripts listed by that command.
+
+The syscall-counts script is a simple script, but demonstrates all the
+basic ideas necessary to create a useful script.  Here's an example
+of its output (syscall names are not yet supported, they will appear
+as numbers):
+
+----
+syscall events:
+
+event                                          count
+----------------------------------------  -----------
+sys_write                                     455067
+sys_getdents                                    4072
+sys_close                                       3037
+sys_swapoff                                     1769
+sys_read                                         923
+sys_sched_setparam                               826
+sys_open                                         331
+sys_newfstat                                     326
+sys_mmap                                         217
+sys_munmap                                       216
+sys_futex                                        141
+sys_select                                       102
+sys_poll                                          84
+sys_setitimer                                     12
+sys_writev                                         8
+15                                                 8
+sys_lseek                                          7
+sys_rt_sigprocmask                                 6
+sys_wait4                                          3
+sys_ioctl                                          3
+sys_set_robust_list                                1
+sys_exit                                           1
+56                                                 1
+sys_access                                         1
+----
+
+Basically our task is to keep a per-syscall tally that gets updated
+every time a system call occurs in the system.  Our script will do
+that, but first we need to record the data that will be processed by
+that script.  Theoretically, there are a couple of ways we could do
+that:
+
+- we could enable every event under the tracing/events/syscalls
+  directory, but this is over 600 syscalls, well beyond the number
+  allowable by perf.  These individual syscall events will however be
+  useful if we want to later use the guidance we get from the
+  general-purpose scripts to drill down and get more detail about
+  individual syscalls of interest.
+
+- we can enable the sys_enter and/or sys_exit syscalls found under
+  tracing/events/raw_syscalls.  These are called for all syscalls; the
+  'id' field can be used to distinguish between individual syscall
+  numbers.
+
+For this script, we only need to know that a syscall was entered; we
+don't care how it exited, so we'll use 'perf record' to record only
+the sys_enter events:
+
+----
+# perf record -a -e raw_syscalls:sys_enter
+
+^C[ perf record: Woken up 1 times to write data ]
+[ perf record: Captured and wrote 56.545 MB perf.data (~2470503 samples) ]
+----
+
+The options basically say to collect data for every syscall event
+system-wide and multiplex the per-cpu output into a single stream.
+That single stream will be recorded in a file in the current directory
+called perf.data.
+
+Once we have a perf.data file containing our data, we can use the -g
+'perf trace' option to generate a Python script that will contain a
+callback handler for each event type found in the perf.data trace
+stream (for more details, see the STARTER SCRIPTS section).
+
+----
+# perf trace -g python
+generated Python script: perf-trace.py
+
+The output file created also in the current directory is named
+perf-trace.py.  Here's the file in its entirety:
+
+# perf trace event handlers, generated by perf trace -g python
+# Licensed under the terms of the GNU GPL License version 2
+
+# The common_* event handler fields are the most useful fields common to
+# all events.  They don't necessarily correspond to the 'common_*' fields
+# in the format files.  Those fields not available as handler params can
+# be retrieved using Python functions of the form common_*(context).
+# See the perf-trace-python Documentation for the list of available functions.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+def trace_begin():
+        print "in trace_begin"
+
+def trace_end():
+        print "in trace_end"
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print "id=%d, args=%s\n" % \
+                (id, args),
+
+def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm)
+
+def print_header(event_name, cpu, secs, nsecs, pid, comm):
+        print "%-20s %5u %05u.%09u %8u %-20s " % \
+        (event_name, cpu, secs, nsecs, pid, comm),
+----
+
+At the top is a comment block followed by some import statements and a
+path append which every perf trace script should include.
+
+Following that are a couple generated functions, trace_begin() and
+trace_end(), which are called at the beginning and the end of the
+script respectively (for more details, see the SCRIPT_LAYOUT section
+below).
+
+Following those are the 'event handler' functions generated one for
+every event in the 'perf record' output.  The handler functions take
+the form subsystem__event_name, and contain named parameters, one for
+each field in the event; in this case, there's only one event,
+raw_syscalls__sys_enter().  (see the EVENT HANDLERS section below for
+more info on event handlers).
+
+The final couple of functions are, like the begin and end functions,
+generated for every script.  The first, trace_unhandled(), is called
+every time the script finds an event in the perf.data file that
+doesn't correspond to any event handler in the script.  This could
+mean either that the record step recorded event types that it wasn't
+really interested in, or the script was run against a trace file that
+doesn't correspond to the script.
+
+The script generated by -g option simply prints a line for each
+event found in the trace stream i.e. it basically just dumps the event
+and its parameter values to stdout.  The print_header() function is
+simply a utility function used for that purpose.  Let's rename the
+script and run it to see the default output:
+
+----
+# mv perf-trace.py syscall-counts.py
+# perf trace -s syscall-counts.py
+
+raw_syscalls__sys_enter     1 00840.847582083     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847595764     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847620860     7506 perf                  id=1, args=
+raw_syscalls__sys_enter     1 00840.847710478     6533 npviewer.bin          id=78, args=
+raw_syscalls__sys_enter     1 00840.847719204     6533 npviewer.bin          id=142, args=
+raw_syscalls__sys_enter     1 00840.847755445     6533 npviewer.bin          id=3, args=
+raw_syscalls__sys_enter     1 00840.847775601     6533 npviewer.bin          id=3, args=
+raw_syscalls__sys_enter     1 00840.847781820     6533 npviewer.bin          id=3, args=
+.
+.
+.
+----
+
+Of course, for this script, we're not interested in printing every
+trace event, but rather aggregating it in a useful way.  So we'll get
+rid of everything to do with printing as well as the trace_begin() and
+trace_unhandled() functions, which we won't be using.  That leaves us
+with this minimalistic skeleton:
+
+----
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+def trace_end():
+        print "in trace_end"
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+----
+
+In trace_end(), we'll simply print the results, but first we need to
+generate some results to print.  To do that we need to have our
+sys_enter() handler do the necessary tallying until all events have
+been counted.  A hash table indexed by syscall id is a good way to
+store that information; every time the sys_enter() handler is called,
+we simply increment a count associated with that hash entry indexed by
+that syscall id:
+
+----
+  syscalls = autodict()
+
+  try:
+    syscalls[id] += 1
+  except TypeError:
+    syscalls[id] = 1
+----
+
+The syscalls 'autodict' object is a special kind of Python dictionary
+(implemented in Core.py) that implements Perl's 'autovivifying' hashes
+in Python i.e. with autovivifying hashes, you can assign nested hash
+values without having to go to the trouble of creating intermediate
+levels if they don't exist e.g syscalls[comm][pid][id] = 1 will create
+the intermediate hash levels and finally assign the value 1 to the
+hash entry for 'id' (because the value being assigned isn't a hash
+object itself, the initial value is assigned in the TypeError
+exception.  Well, there may be a better way to do this in Python but
+that's what works for now).
+
+Putting that code into the raw_syscalls__sys_enter() handler, we
+effectively end up with a single-level dictionary keyed on syscall id
+and having the counts we've tallied as values.
+
+The print_syscall_totals() function iterates over the entries in the
+dictionary and displays a line for each entry containing the syscall
+name (the dictonary keys contain the syscall ids, which are passed to
+the Util function syscall_name(), which translates the raw syscall
+numbers to the corresponding syscall name strings).  The output is
+displayed after all the events in the trace have been processed, by
+calling the print_syscall_totals() function from the trace_end()
+handler called at the end of script processing.
+
+The final script producing the output shown above is shown in its
+entirety below (syscall_name() helper is not yet available, you can
+only deal with id's for now):
+
+----
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from Util import *
+
+syscalls = autodict()
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        try:
+                syscalls[id] += 1
+        except TypeError:
+                syscalls[id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
+                                  reverse = True):
+            print "%-40s  %10d\n" % (syscall_name(id), val),
+----
+
+The script can be run just as before:
+
+  # perf trace -s syscall-counts.py
+
+So those are the essential steps in writing and running a script.  The
+process can be generalized to any tracepoint or set of tracepoints
+you're interested in - basically find the tracepoint(s) you're
+interested in by looking at the list of available events shown by
+'perf list' and/or look in /sys/kernel/debug/tracing events for
+detailed event and field info, record the corresponding trace data
+using 'perf record', passing it the list of interesting events,
+generate a skeleton script using 'perf trace -g python' and modify the
+code to aggregate and display it for your particular needs.
+
+After you've done that you may end up with a general-purpose script
+that you want to keep around and have available for future use.  By
+writing a couple of very simple shell scripts and putting them in the
+right place, you can have your script listed alongside the other
+scripts listed by the 'perf trace -l' command e.g.:
+
+----
+root@tropicana:~# perf trace -l
+List of available trace scripts:
+  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
+  wakeup-latency                       system-wide min/max/avg wakeup latency
+  rw-by-file <comm>                    r/w activity for a program, by file
+  rw-by-pid                            system-wide r/w activity
+----
+
+A nice side effect of doing this is that you also then capture the
+probably lengthy 'perf record' command needed to record the events for
+the script.
+
+To have the script appear as a 'built-in' script, you write two simple
+scripts, one for recording and one for 'reporting'.
+
+The 'record' script is a shell script with the same base name as your
+script, but with -record appended.  The shell script should be put
+into the perf/scripts/python/bin directory in the kernel source tree.
+In that script, you write the 'perf record' command-line needed for
+your script:
+
+----
+# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-record
+
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_enter
+----
+
+The 'report' script is also a shell script with the same base name as
+your script, but with -report appended.  It should also be located in
+the perf/scripts/python/bin directory.  In that script, you write the
+'perf trace -s' command-line needed for running your script:
+
+----
+# cat kernel-source/tools/perf/scripts/python/bin/syscall-counts-report
+
+#!/bin/bash
+# description: system-wide syscall counts
+perf trace -s ~/libexec/perf-core/scripts/python/syscall-counts.py
+----
+
+Note that the location of the Python script given in the shell script
+is in the libexec/perf-core/scripts/python directory - this is where
+the script will be copied by 'make install' when you install perf.
+For the installation to install your script there, your script needs
+to be located in the perf/scripts/python directory in the kernel
+source tree:
+
+----
+# ls -al kernel-source/tools/perf/scripts/python
+
+root@tropicana:/home/trz/src/tip# ls -al tools/perf/scripts/python
+total 32
+drwxr-xr-x 4 trz trz 4096 2010-01-26 22:30 .
+drwxr-xr-x 4 trz trz 4096 2010-01-26 22:29 ..
+drwxr-xr-x 2 trz trz 4096 2010-01-26 22:29 bin
+-rw-r--r-- 1 trz trz 2548 2010-01-26 22:29 check-perf-trace.py
+drwxr-xr-x 3 trz trz 4096 2010-01-26 22:49 Perf-Trace-Util
+-rw-r--r-- 1 trz trz 1462 2010-01-26 22:30 syscall-counts.py
+----
+
+Once you've done that (don't forget to do a new 'make install',
+otherwise your script won't show up at run-time), 'perf trace -l'
+should show a new entry for your script:
+
+----
+root@tropicana:~# perf trace -l
+List of available trace scripts:
+  workqueue-stats                      workqueue stats (ins/exe/create/destroy)
+  wakeup-latency                       system-wide min/max/avg wakeup latency
+  rw-by-file <comm>                    r/w activity for a program, by file
+  rw-by-pid                            system-wide r/w activity
+  syscall-counts                       system-wide syscall counts
+----
+
+You can now perform the record step via 'perf trace record':
+
+  # perf trace record syscall-counts
+
+and display the output using 'perf trace report':
+
+  # perf trace report syscall-counts
+
+STARTER SCRIPTS
+---------------
+
+You can quickly get started writing a script for a particular set of
+trace data by generating a skeleton script using 'perf trace -g
+python' in the same directory as an existing perf.data trace file.
+That will generate a starter script containing a handler for each of
+the event types in the trace file; it simply prints every available
+field for each event in the trace file.
+
+You can also look at the existing scripts in
+~/libexec/perf-core/scripts/python for typical examples showing how to
+do basic things like aggregate event data, print results, etc.  Also,
+the check-perf-trace.py script, while not interesting for its results,
+attempts to exercise all of the main scripting features.
+
+EVENT HANDLERS
+--------------
+
+When perf trace is invoked using a trace script, a user-defined
+'handler function' is called for each event in the trace.  If there's
+no handler function defined for a given event type, the event is
+ignored (or passed to a 'trace_handled' function, see below) and the
+next event is processed.
+
+Most of the event's field values are passed as arguments to the
+handler function; some of the less common ones aren't - those are
+available as calls back into the perf executable (see below).
+
+As an example, the following perf record command can be used to record
+all sched_wakeup events in the system:
+
+ # perf record -a -e sched:sched_wakeup
+
+Traces meant to be processed using a script should be recorded with
+the above option: -a to enable system-wide collection.
+
+The format file for the sched_wakep event defines the following fields
+(see /sys/kernel/debug/tracing/events/sched/sched_wakeup/format):
+
+----
+ format:
+        field:unsigned short common_type;
+        field:unsigned char common_flags;
+        field:unsigned char common_preempt_count;
+        field:int common_pid;
+        field:int common_lock_depth;
+
+        field:char comm[TASK_COMM_LEN];
+        field:pid_t pid;
+        field:int prio;
+        field:int success;
+        field:int target_cpu;
+----
+
+The handler function for this event would be defined as:
+
+----
+def sched__sched_wakeup(event_name, context, common_cpu, common_secs,
+       common_nsecs, common_pid, common_comm,
+       comm, pid, prio, success, target_cpu):
+       pass
+----
+
+The handler function takes the form subsystem__event_name.
+
+The common_* arguments in the handler's argument list are the set of
+arguments passed to all event handlers; some of the fields correspond
+to the common_* fields in the format file, but some are synthesized,
+and some of the common_* fields aren't common enough to to be passed
+to every event as arguments but are available as library functions.
+
+Here's a brief description of each of the invariant event args:
+
+ event_name                 the name of the event as text
+ context                    an opaque 'cookie' used in calls back into perf
+ common_cpu                 the cpu the event occurred on
+ common_secs                the secs portion of the event timestamp
+ common_nsecs               the nsecs portion of the event timestamp
+ common_pid                 the pid of the current task
+ common_comm                the name of the current process
+
+All of the remaining fields in the event's format file have
+counterparts as handler function arguments of the same name, as can be
+seen in the example above.
+
+The above provides the basics needed to directly access every field of
+every event in a trace, which covers 90% of what you need to know to
+write a useful trace script.  The sections below cover the rest.
+
+SCRIPT LAYOUT
+-------------
+
+Every perf trace Python script should start by setting up a Python
+module search path and 'import'ing a few support modules (see module
+descriptions below):
+
+----
+ import os
+ import sys
+
+ sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+              '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+ from perf_trace_context import *
+ from Core import *
+----
+
+The rest of the script can contain handler functions and support
+functions in any order.
+
+Aside from the event handler functions discussed above, every script
+can implement a set of optional functions:
+
+*trace_begin*, if defined, is called before any event is processed and
+gives scripts a chance to do setup tasks:
+
+----
+def trace_begin:
+    pass
+----
+
+*trace_end*, if defined, is called after all events have been
+ processed and gives scripts a chance to do end-of-script tasks, such
+ as display results:
+
+----
+def trace_end:
+    pass
+----
+
+*trace_unhandled*, if defined, is called after for any event that
+ doesn't have a handler explicitly defined for it.  The standard set
+ of common arguments are passed into it:
+
+----
+def trace_unhandled(event_name, context, common_cpu, common_secs,
+        common_nsecs, common_pid, common_comm):
+    pass
+----
+
+The remaining sections provide descriptions of each of the available
+built-in perf trace Python modules and their associated functions.
+
+AVAILABLE MODULES AND FUNCTIONS
+-------------------------------
+
+The following sections describe the functions and variables available
+via the various perf trace Python modules.  To use the functions and
+variables from the given module, add the corresponding 'from XXXX
+import' line to your perf trace script.
+
+Core.py Module
+~~~~~~~~~~~~~~
+
+These functions provide some essential functions to user scripts.
+
+The *flag_str* and *symbol_str* functions provide human-readable
+strings for flag and symbolic fields.  These correspond to the strings
+and values parsed from the 'print fmt' fields of the event format
+files:
+
+  flag_str(event_name, field_name, field_value) - returns the string represention corresponding to field_value for the flag field field_name of event event_name
+  symbol_str(event_name, field_name, field_value) - returns the string represention corresponding to field_value for the symbolic field field_name of event event_name
+
+The *autodict* function returns a special kind of Python
+dictionary that implements Perl's 'autovivifying' hashes in Python
+i.e. with autovivifying hashes, you can assign nested hash values
+without having to go to the trouble of creating intermediate levels if
+they don't exist.
+
+  autodict() - returns an autovivifying dictionary instance
+
+
+perf_trace_context Module
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Some of the 'common' fields in the event format file aren't all that
+common, but need to be made accessible to user scripts nonetheless.
+
+perf_trace_context defines a set of functions that can be used to
+access this data in the context of the current event.  Each of these
+functions expects a context variable, which is the same as the
+context variable passed into every event handler as the second
+argument.
+
+ common_pc(context) - returns common_preempt count for the current event
+ common_flags(context) - returns common_flags for the current event
+ common_lock_depth(context) - returns common_lock_depth for the current event
+
+Util.py Module
+~~~~~~~~~~~~~~
+
+Various utility functions for use with perf trace:
+
+  nsecs(secs, nsecs) - returns total nsecs given secs/nsecs pair
+  nsecs_secs(nsecs) - returns whole secs portion given nsecs
+  nsecs_nsecs(nsecs) - returns nsecs remainder given nsecs
+  nsecs_str(nsecs) - returns printable string in the form secs.nsecs
+  avg(total, n) - returns average given a sum and a total number of values
+
+SEE ALSO
+--------
+linkperf:perf-trace[1]
diff --git a/tools/perf/Documentation/perf-trace.txt b/tools/perf/Documentation/perf-trace.txt
index 60e5900da483..122ec9dc4853 100644
--- a/tools/perf/Documentation/perf-trace.txt
+++ b/tools/perf/Documentation/perf-trace.txt
@@ -1,5 +1,5 @@
 perf-trace(1)
-==============
+=============
 
 NAME
 ----
@@ -19,6 +19,11 @@ There are several variants of perf trace:
   'perf trace' to see a detailed trace of the workload that was
   recorded.
 
+  You can also run a set of pre-canned scripts that aggregate and
+  summarize the raw trace data in various ways (the list of scripts is
+  available via 'perf trace -l').  The following variants allow you to
+  record and run those scripts:
+
   'perf trace record <script>' to record the events required for 'perf
   trace report'.  <script> is the name displayed in the output of
   'perf trace --list' i.e. the actual script name minus any language
@@ -31,6 +36,9 @@ There are several variants of perf trace:
   record <script>' is used and should be present for this command to
   succeed.
 
+  See the 'SEE ALSO' section for links to language-specific
+  information on how to write and run your own trace scripts.
+
 OPTIONS
 -------
 -D::
@@ -45,9 +53,11 @@ OPTIONS
 --list=::
         Display a list of available trace scripts.
 
--s::
+-s ['lang']::
 --script=::
         Process trace data with the given script ([lang]:script[.ext]).
+        If the string 'lang' is specified in place of a script name, a
+        list of supported languages will be displayed instead.
 
 -g::
 --gen-script=::
@@ -56,4 +66,5 @@ OPTIONS
 
 SEE ALSO
 --------
-linkperf:perf-record[1], linkperf:perf-trace-perl[1]
+linkperf:perf-record[1], linkperf:perf-trace-perl[1],
+linkperf:perf-trace-python[1]
diff --git a/tools/perf/Documentation/perf.txt b/tools/perf/Documentation/perf.txt
index 69c832557199..0eeb247dc7d2 100644
--- a/tools/perf/Documentation/perf.txt
+++ b/tools/perf/Documentation/perf.txt
@@ -12,7 +12,7 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-Performance counters for Linux are are a new kernel-based subsystem
+Performance counters for Linux are a new kernel-based subsystem
 that provide a framework for all things performance analysis. It
 covers hardware level (CPU/PMU, Performance Monitoring Unit) features
 and software features (software counters, tracepoints) as well.
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
new file mode 100644
index 000000000000..8c7fc0c8f0b8
--- /dev/null
+++ b/tools/perf/MANIFEST
@@ -0,0 +1,12 @@
+tools/perf
+include/linux/perf_event.h
+include/linux/rbtree.h
+include/linux/list.h
+include/linux/hash.h
+include/linux/stringify.h
+lib/rbtree.c
+include/linux/swab.h
+arch/*/include/asm/unistd*.h
+include/linux/poison.h
+include/linux/magic.h
+include/linux/hw_breakpoint.h
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 2e7fa3a06806..1950e19af1cf 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -1,6 +1,16 @@
+ifeq ("$(origin O)", "command line")
+        OUTPUT := $(O)/
+endif
+
 # The default target of this Makefile is...
 all::
 
+ifneq ($(OUTPUT),)
+# check that the output directory actually exists
+OUTDIR := $(shell cd $(OUTPUT) && /bin/pwd)
+$(if $(OUTDIR),, $(error output directory "$(OUTPUT)" does not exist))
+endif
+
 # Define V=1 to have a more verbose compile.
 # Define V=2 to have an even more verbose compile.
 #
@@ -150,10 +160,12 @@ all::
 # Define LDFLAGS=-static to build a static binary.
 #
 # Define EXTRA_CFLAGS=-m64 or EXTRA_CFLAGS=-m32 as appropriate for cross-builds.
+#
+# Define NO_DWARF if you do not want debug-info analysis feature at all.
 
-PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
-        @$(SHELL_PATH) util/PERF-VERSION-GEN
--include PERF-VERSION-FILE
+$(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
+        @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
+-include $(OUTPUT)PERF-VERSION-FILE
 
 uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
 uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
@@ -162,6 +174,20 @@ uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
 uname_P := $(shell sh -c 'uname -p 2>/dev/null || echo not')
 uname_V := $(shell sh -c 'uname -v 2>/dev/null || echo not')
 
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/ -e s/sun4u/sparc64/ \
+                                  -e s/arm.*/arm/ -e s/sa110/arm/ \
+                                  -e s/s390x/s390/ -e s/parisc64/parisc/ \
+                                  -e s/ppc.*/powerpc/ -e s/mips.*/mips/ \
+                                  -e s/sh[234].*/sh/ )
+
+# Additional ARCH settings for x86
+ifeq ($(ARCH),i386)
+        ARCH := x86
+endif
+ifeq ($(ARCH),x86_64)
+        ARCH := x86
+endif
+
 # CFLAGS and LDFLAGS are for the users to override from the command line.
 
 #
@@ -200,7 +226,7 @@ endif
 
 CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
-ALL_CFLAGS = $(CFLAGS)
+ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS = $(LDFLAGS)
 STRIP ?= strip
 
@@ -216,7 +242,10 @@ STRIP ?= strip
 # runtime figures out where they are based on the path to the executable.
 # This can help installing the suite in a relocatable way.
 
+# Make the path relative to DESTDIR, not to prefix
+ifndef DESTDIR
 prefix = $(HOME)
+endif
 bindir_relative = bin
 bindir = $(prefix)/$(bindir_relative)
 mandir = share/man
@@ -233,13 +262,13 @@ sysconfdir = $(prefix)/etc
 ETC_PERFCONFIG = etc/perfconfig
 endif
 lib = lib
-# DESTDIR=
 
 export prefix bindir sharedir sysconfdir
 
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 RM = rm -f
+MKDIR = mkdir
 TAR = tar
 FIND = find
 INSTALL = install
@@ -256,14 +285,10 @@ else
         QUIET_STDERR = ">/dev/null 2>&1"
 endif
 
-BITBUCKET = "/dev/null"
-
-ifneq ($(shell sh -c "(echo '\#include <stdio.h>'; echo 'int main(void) { return puts(\"hi\"); }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) "$(QUIET_STDERR)" && echo y"), y)
-        BITBUCKET = .perf.dev.null
-endif
+-include feature-tests.mak
 
-ifeq ($(shell sh -c "echo 'int foo(void) {char X[2]; return 3;}' | $(CC) -x c -c -Werror -fstack-protector-all - -o $(BITBUCKET) "$(QUIET_STDERR)" && echo y"), y)
-  CFLAGS := $(CFLAGS) -fstack-protector-all
+ifeq ($(call try-cc,$(SOURCE_HELLO),-Werror -fstack-protector-all),y)
+        CFLAGS := $(CFLAGS) -fstack-protector-all
 endif
 
 
@@ -272,7 +297,7 @@ endif
 # Those must not be GNU-specific; they are shared with perl/ which may
 # be built by a different compiler. (Note that this is an artifact now
 # but it still might be nice to keep that distinction.)
-BASIC_CFLAGS = -Iutil/include
+BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include
 BASIC_LDFLAGS =
 
 # Guard against environment variables
@@ -286,11 +311,7 @@ SCRIPT_PERL =
 SCRIPT_SH =
 TEST_PROGRAMS =
 
-#
-# No scripts right now:
-#
-
-# SCRIPT_SH += perf-am.sh
+SCRIPT_SH += perf-archive.sh
 
 #
 # No Perl scripts right now:
@@ -310,20 +331,17 @@ PROGRAMS += $(EXTRA_PROGRAMS)
 #
 # Single 'perf' binary right now:
 #
-PROGRAMS += perf
+PROGRAMS += $(OUTPUT)perf
 
 # List built-in command $C whose implementation cmd_$C() is not in
 # builtin-$C.o but is linked in as part of some other command.
 #
-# None right now:
-#
-# BUILT_INS += perf-init $X
 
 # what 'all' will build and 'install' will install, in perfexecdir
 ALL_PROGRAMS = $(PROGRAMS) $(SCRIPTS)
 
 # what 'all' will build but not install in perfexecdir
-OTHER_PROGRAMS = perf$X
+OTHER_PROGRAMS = $(OUTPUT)perf$X
 
 # Set paths to tools early so that they can be used for version tests.
 ifndef SHELL_PATH
@@ -335,11 +353,12 @@ endif
 
 export PERL_PATH
 
-LIB_FILE=libperf.a
+LIB_FILE=$(OUTPUT)libperf.a
 
 LIB_H += ../../include/linux/perf_event.h
 LIB_H += ../../include/linux/rbtree.h
 LIB_H += ../../include/linux/list.h
+LIB_H += ../../include/linux/hash.h
 LIB_H += ../../include/linux/stringify.h
 LIB_H += util/include/linux/bitmap.h
 LIB_H += util/include/linux/bitops.h
@@ -354,21 +373,24 @@ LIB_H += util/include/linux/rbtree.h
 LIB_H += util/include/linux/string.h
 LIB_H += util/include/linux/types.h
 LIB_H += util/include/asm/asm-offsets.h
-LIB_H += util/include/asm/bitops.h
 LIB_H += util/include/asm/bug.h
 LIB_H += util/include/asm/byteorder.h
+LIB_H += util/include/asm/hweight.h
 LIB_H += util/include/asm/swab.h
 LIB_H += util/include/asm/system.h
 LIB_H += util/include/asm/uaccess.h
+LIB_H += util/include/dwarf-regs.h
 LIB_H += perf.h
 LIB_H += util/cache.h
 LIB_H += util/callchain.h
+LIB_H += util/build-id.h
 LIB_H += util/debug.h
 LIB_H += util/debugfs.h
 LIB_H += util/event.h
 LIB_H += util/exec_cmd.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.h
+LIB_H += util/map.h
 LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
 LIB_H += util/quote.h
@@ -377,7 +399,6 @@ LIB_H += util/header.h
 LIB_H += util/help.h
 LIB_H += util/session.h
 LIB_H += util/strbuf.h
-LIB_H += util/string.h
 LIB_H += util/strlist.h
 LIB_H += util/svghelper.h
 LIB_H += util/run-command.h
@@ -389,77 +410,85 @@ LIB_H += util/sort.h
 LIB_H += util/hist.h
 LIB_H += util/thread.h
 LIB_H += util/trace-event.h
-LIB_H += util/trace-event-perl.h
 LIB_H += util/probe-finder.h
 LIB_H += util/probe-event.h
-
-LIB_OBJS += util/abspath.o
-LIB_OBJS += util/alias.o
-LIB_OBJS += util/config.o
-LIB_OBJS += util/ctype.o
-LIB_OBJS += util/debugfs.o
-LIB_OBJS += util/environment.o
-LIB_OBJS += util/event.o
-LIB_OBJS += util/exec_cmd.o
-LIB_OBJS += util/help.o
-LIB_OBJS += util/levenshtein.o
-LIB_OBJS += util/parse-options.o
-LIB_OBJS += util/parse-events.o
-LIB_OBJS += util/path.o
-LIB_OBJS += util/rbtree.o
-LIB_OBJS += util/bitmap.o
-LIB_OBJS += util/hweight.o
-LIB_OBJS += util/find_next_bit.o
-LIB_OBJS += util/run-command.o
-LIB_OBJS += util/quote.o
-LIB_OBJS += util/strbuf.o
-LIB_OBJS += util/string.o
-LIB_OBJS += util/strlist.o
-LIB_OBJS += util/usage.o
-LIB_OBJS += util/wrapper.o
-LIB_OBJS += util/sigchain.o
-LIB_OBJS += util/symbol.o
-LIB_OBJS += util/color.o
-LIB_OBJS += util/pager.o
-LIB_OBJS += util/header.o
-LIB_OBJS += util/callchain.o
-LIB_OBJS += util/values.o
-LIB_OBJS += util/debug.o
-LIB_OBJS += util/map.o
-LIB_OBJS += util/session.o
-LIB_OBJS += util/thread.o
-LIB_OBJS += util/trace-event-parse.o
-LIB_OBJS += util/trace-event-read.o
-LIB_OBJS += util/trace-event-info.o
-LIB_OBJS += util/trace-event-perl.o
-LIB_OBJS += util/svghelper.o
-LIB_OBJS += util/sort.o
-LIB_OBJS += util/hist.o
-LIB_OBJS += util/data_map.o
-LIB_OBJS += util/probe-event.o
-
-BUILTIN_OBJS += builtin-annotate.o
-
-BUILTIN_OBJS += builtin-bench.o
+LIB_H += util/pstack.h
+LIB_H += util/cpumap.h
+
+LIB_OBJS += $(OUTPUT)util/abspath.o
+LIB_OBJS += $(OUTPUT)util/alias.o
+LIB_OBJS += $(OUTPUT)util/build-id.o
+LIB_OBJS += $(OUTPUT)util/config.o
+LIB_OBJS += $(OUTPUT)util/ctype.o
+LIB_OBJS += $(OUTPUT)util/debugfs.o
+LIB_OBJS += $(OUTPUT)util/environment.o
+LIB_OBJS += $(OUTPUT)util/event.o
+LIB_OBJS += $(OUTPUT)util/exec_cmd.o
+LIB_OBJS += $(OUTPUT)util/help.o
+LIB_OBJS += $(OUTPUT)util/levenshtein.o
+LIB_OBJS += $(OUTPUT)util/parse-options.o
+LIB_OBJS += $(OUTPUT)util/parse-events.o
+LIB_OBJS += $(OUTPUT)util/path.o
+LIB_OBJS += $(OUTPUT)util/rbtree.o
+LIB_OBJS += $(OUTPUT)util/bitmap.o
+LIB_OBJS += $(OUTPUT)util/hweight.o
+LIB_OBJS += $(OUTPUT)util/run-command.o
+LIB_OBJS += $(OUTPUT)util/quote.o
+LIB_OBJS += $(OUTPUT)util/strbuf.o
+LIB_OBJS += $(OUTPUT)util/string.o
+LIB_OBJS += $(OUTPUT)util/strlist.o
+LIB_OBJS += $(OUTPUT)util/usage.o
+LIB_OBJS += $(OUTPUT)util/wrapper.o
+LIB_OBJS += $(OUTPUT)util/sigchain.o
+LIB_OBJS += $(OUTPUT)util/symbol.o
+LIB_OBJS += $(OUTPUT)util/color.o
+LIB_OBJS += $(OUTPUT)util/pager.o
+LIB_OBJS += $(OUTPUT)util/header.o
+LIB_OBJS += $(OUTPUT)util/callchain.o
+LIB_OBJS += $(OUTPUT)util/values.o
+LIB_OBJS += $(OUTPUT)util/debug.o
+LIB_OBJS += $(OUTPUT)util/map.o
+LIB_OBJS += $(OUTPUT)util/pstack.o
+LIB_OBJS += $(OUTPUT)util/session.o
+LIB_OBJS += $(OUTPUT)util/thread.o
+LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
+LIB_OBJS += $(OUTPUT)util/trace-event-read.o
+LIB_OBJS += $(OUTPUT)util/trace-event-info.o
+LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
+LIB_OBJS += $(OUTPUT)util/svghelper.o
+LIB_OBJS += $(OUTPUT)util/sort.o
+LIB_OBJS += $(OUTPUT)util/hist.o
+LIB_OBJS += $(OUTPUT)util/probe-event.o
+LIB_OBJS += $(OUTPUT)util/util.o
+LIB_OBJS += $(OUTPUT)util/cpumap.o
+
+BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
+
+BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
 
 # Benchmark modules
-BUILTIN_OBJS += bench/sched-messaging.o
-BUILTIN_OBJS += bench/sched-pipe.o
-BUILTIN_OBJS += bench/mem-memcpy.o
-
-BUILTIN_OBJS += builtin-diff.o
-BUILTIN_OBJS += builtin-help.o
-BUILTIN_OBJS += builtin-sched.o
-BUILTIN_OBJS += builtin-buildid-list.o
-BUILTIN_OBJS += builtin-list.o
-BUILTIN_OBJS += builtin-record.o
-BUILTIN_OBJS += builtin-report.o
-BUILTIN_OBJS += builtin-stat.o
-BUILTIN_OBJS += builtin-timechart.o
-BUILTIN_OBJS += builtin-top.o
-BUILTIN_OBJS += builtin-trace.o
-BUILTIN_OBJS += builtin-probe.o
-BUILTIN_OBJS += builtin-kmem.o
+BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
+BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
+BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
+
+BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
+BUILTIN_OBJS += $(OUTPUT)builtin-help.o
+BUILTIN_OBJS += $(OUTPUT)builtin-sched.o
+BUILTIN_OBJS += $(OUTPUT)builtin-buildid-list.o
+BUILTIN_OBJS += $(OUTPUT)builtin-buildid-cache.o
+BUILTIN_OBJS += $(OUTPUT)builtin-list.o
+BUILTIN_OBJS += $(OUTPUT)builtin-record.o
+BUILTIN_OBJS += $(OUTPUT)builtin-report.o
+BUILTIN_OBJS += $(OUTPUT)builtin-stat.o
+BUILTIN_OBJS += $(OUTPUT)builtin-timechart.o
+BUILTIN_OBJS += $(OUTPUT)builtin-top.o
+BUILTIN_OBJS += $(OUTPUT)builtin-trace.o
+BUILTIN_OBJS += $(OUTPUT)builtin-probe.o
+BUILTIN_OBJS += $(OUTPUT)builtin-kmem.o
+BUILTIN_OBJS += $(OUTPUT)builtin-lock.o
+BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
+BUILTIN_OBJS += $(OUTPUT)builtin-test.o
+BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 
 PERFLIBS = $(LIB_FILE)
 
@@ -474,6 +503,16 @@ PERFLIBS = $(LIB_FILE)
 -include config.mak.autogen
 -include config.mak
 
+ifndef NO_DWARF
+FLAGS_DWARF=$(ALL_CFLAGS) -I/usr/include/elfutils -ldw -lelf $(ALL_LDFLAGS) $(EXTLIBS)
+ifneq ($(call try-cc,$(SOURCE_DWARF),$(FLAGS_DWARF)),y)
+        msg := $(warning No libdw.h found or old libdw.h found or elfutils is older than 0.138, disables dwarf support. Please install new elfutils-devel/libdw-dev);
+        NO_DWARF := 1
+endif # Dwarf support
+endif # NO_DWARF
+
+-include arch/$(ARCH)/Makefile
+
 ifeq ($(uname_S),Darwin)
         ifndef NO_FINK
                 ifeq ($(shell test -d /sw/lib && echo y),y)
@@ -490,62 +529,124 @@ ifeq ($(uname_S),Darwin)
         PTHREAD_LIBS =
 endif
 
-ifeq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
-ifneq ($(shell sh -c "(echo '\#include <gnu/libc-version.h>'; echo 'int main(void) { const char * version = gnu_get_libc_version(); return (long)version; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
-        msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
+ifneq ($(OUTPUT),)
+        BASIC_CFLAGS += -I$(OUTPUT)
 endif
 
-        ifneq ($(shell sh -c "(echo '\#include <libelf.h>'; echo 'int main(void) { Elf * elf = elf_begin(0, ELF_C_READ_MMAP, 0); return (long)elf; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
-                BASIC_CFLAGS += -DLIBELF_NO_MMAP
+FLAGS_LIBELF=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS)
+ifneq ($(call try-cc,$(SOURCE_LIBELF),$(FLAGS_LIBELF)),y)
+        FLAGS_GLIBC=$(ALL_CFLAGS) $(ALL_LDFLAGS)
+        ifneq ($(call try-cc,$(SOURCE_GLIBC),$(FLAGS_GLIBC)),y)
+                msg := $(error No gnu/libc-version.h found, please install glibc-dev[el]/glibc-static);
+        else
+                msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel);
         endif
-else
-        msg := $(error No libelf.h/libelf found, please install libelf-dev/elfutils-libelf-devel and glibc-dev[el]);
 endif
 
-ifneq ($(shell sh -c "(echo '\#ifndef _MIPS_SZLONG'; echo '\#define _MIPS_SZLONG 0'; echo '\#endif'; echo '\#include <dwarf.h>'; echo '\#include <libdwarf.h>'; echo 'int main(void) { Dwarf_Debug dbg; Dwarf_Error err; Dwarf_Ranges *rng; dwarf_init(0, DW_DLC_READ, 0, 0, &dbg, &err); dwarf_get_ranges(dbg, 0, &rng, 0, 0, &err); return (long)dbg; }') | $(CC) -x c - $(ALL_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -I/usr/include/libdwarf -ldwarf -lelf -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) "$(QUIET_STDERR)" && echo y"), y)
-        msg := $(warning No libdwarf.h found or old libdwarf.h found, disables dwarf support. Please install libdwarf-dev/libdwarf-devel >= 20081231);
-        BASIC_CFLAGS += -DNO_LIBDWARF
-else
-        BASIC_CFLAGS += -I/usr/include/libdwarf
-        EXTLIBS += -lelf -ldwarf
-        LIB_OBJS += util/probe-finder.o
+ifneq ($(call try-cc,$(SOURCE_ELF_MMAP),$(FLAGS_COMMON)),y)
+        BASIC_CFLAGS += -DLIBELF_NO_MMAP
 endif
 
-ifndef NO_LIBPERL
-PERL_EMBED_LDOPTS = `perl -MExtUtils::Embed -e ldopts 2>/dev/null`
-PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
+ifndef NO_DWARF
+ifeq ($(origin PERF_HAVE_DWARF_REGS), undefined)
+        msg := $(warning DWARF register mappings have not been defined for architecture $(ARCH), DWARF support disabled);
+else
+        BASIC_CFLAGS += -I/usr/include/elfutils -DDWARF_SUPPORT
+        EXTLIBS += -lelf -ldw
+        LIB_OBJS += $(OUTPUT)util/probe-finder.o
+endif # PERF_HAVE_DWARF_REGS
+endif # NO_DWARF
+
+ifdef NO_NEWT
+        BASIC_CFLAGS += -DNO_NEWT_SUPPORT
+else
+        FLAGS_NEWT=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lnewt
+        ifneq ($(call try-cc,$(SOURCE_NEWT),$(FLAGS_NEWT)),y)
+                msg := $(warning newt not found, disables TUI support. Please install newt-devel or libnewt-dev);
+                BASIC_CFLAGS += -DNO_NEWT_SUPPORT
+        else
+                # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
+                BASIC_CFLAGS += -I/usr/include/slang
+                EXTLIBS += -lnewt -lslang
+                LIB_OBJS += $(OUTPUT)util/ui/setup.o
+                LIB_OBJS += $(OUTPUT)util/ui/browser.o
+                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/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/libslang.h
+                LIB_H += util/ui/progress.h
+                LIB_H += util/ui/util.h
+        endif
 endif
 
-ifneq ($(shell sh -c "(echo '\#include <EXTERN.h>'; echo '\#include <perl.h>'; echo 'int main(void) { perl_alloc(); return 0; }') | $(CC) -x c - $(PERL_EMBED_CCOPTS) -o $(BITBUCKET) $(PERL_EMBED_LDOPTS) > /dev/null 2>&1 && echo y"), y)
+ifdef NO_LIBPERL
         BASIC_CFLAGS += -DNO_LIBPERL
 else
-        ALL_LDFLAGS += $(PERL_EMBED_LDOPTS)
-        LIB_OBJS += scripts/perl/Perf-Trace-Util/Context.o
+        PERL_EMBED_LDOPTS = `perl -MExtUtils::Embed -e ldopts 2>/dev/null`
+        PERL_EMBED_CCOPTS = `perl -MExtUtils::Embed -e ccopts 2>/dev/null`
+        FLAGS_PERL_EMBED=$(PERL_EMBED_CCOPTS) $(PERL_EMBED_LDOPTS)
+
+        ifneq ($(call try-cc,$(SOURCE_PERL_EMBED),$(FLAGS_PERL_EMBED)),y)
+                BASIC_CFLAGS += -DNO_LIBPERL
+        else
+                ALL_LDFLAGS += $(PERL_EMBED_LDOPTS)
+                LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-perl.o
+                LIB_OBJS += $(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o
+        endif
+endif
+
+ifdef NO_LIBPYTHON
+        BASIC_CFLAGS += -DNO_LIBPYTHON
+else
+        PYTHON_EMBED_LDOPTS = `python-config --ldflags 2>/dev/null`
+        PYTHON_EMBED_CCOPTS = `python-config --cflags 2>/dev/null`
+        FLAGS_PYTHON_EMBED=$(PYTHON_EMBED_CCOPTS) $(PYTHON_EMBED_LDOPTS)
+        ifneq ($(call try-cc,$(SOURCE_PYTHON_EMBED),$(FLAGS_PYTHON_EMBED)),y)
+                BASIC_CFLAGS += -DNO_LIBPYTHON
+        else
+                ALL_LDFLAGS += $(PYTHON_EMBED_LDOPTS)
+                LIB_OBJS += $(OUTPUT)util/scripting-engines/trace-event-python.o
+                LIB_OBJS += $(OUTPUT)scripts/python/Perf-Trace-Util/Context.o
+        endif
 endif
 
 ifdef NO_DEMANGLE
         BASIC_CFLAGS += -DNO_DEMANGLE
 else
-        has_bfd := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd "$(QUIET_STDERR)" && echo y")
-
-        ifeq ($(has_bfd),y)
-                EXTLIBS += -lbfd
-        else
-                has_bfd_iberty := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd -liberty "$(QUIET_STDERR)" && echo y")
-                ifeq ($(has_bfd_iberty),y)
-                        EXTLIBS += -lbfd -liberty
+        ifdef HAVE_CPLUS_DEMANGLE
+                EXTLIBS += -liberty
+                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
+        else
+                FLAGS_BFD=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd
+                has_bfd := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD))
+                ifeq ($(has_bfd),y)
+                        EXTLIBS += -lbfd
                 else
-                        has_bfd_iberty_z := $(shell sh -c "(echo '\#include <bfd.h>'; echo 'int main(void) { bfd_demangle(0, 0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -lbfd -liberty -lz "$(QUIET_STDERR)" && echo y")
-                        ifeq ($(has_bfd_iberty_z),y)
-                                EXTLIBS += -lbfd -liberty -lz
+                        FLAGS_BFD_IBERTY=$(FLAGS_BFD) -liberty
+                        has_bfd_iberty := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY))
+                        ifeq ($(has_bfd_iberty),y)
+                                EXTLIBS += -lbfd -liberty
                         else
-                                has_cplus_demangle := $(shell sh -c "(echo 'extern char *cplus_demangle(const char *, int);'; echo 'int main(void) { cplus_demangle(0, 0); return 0; }') | $(CC) -x c - $(ALL_CFLAGS) -o $(BITBUCKET) $(ALL_LDFLAGS) $(EXTLIBS) -liberty "$(QUIET_STDERR)" && echo y")
-                                ifeq ($(has_cplus_demangle),y)
-                                        EXTLIBS += -liberty
-                                        BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
+                                FLAGS_BFD_IBERTY_Z=$(FLAGS_BFD_IBERTY) -lz
+                                has_bfd_iberty_z := $(call try-cc,$(SOURCE_BFD),$(FLAGS_BFD_IBERTY_Z))
+                                ifeq ($(has_bfd_iberty_z),y)
+                                        EXTLIBS += -lbfd -liberty -lz
                                 else
-                                        msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
-                                        BASIC_CFLAGS += -DNO_DEMANGLE
+                                        FLAGS_CPLUS_DEMANGLE=$(ALL_CFLAGS) $(ALL_LDFLAGS) $(EXTLIBS) -liberty
+                                        has_cplus_demangle := $(call try-cc,$(SOURCE_CPLUS_DEMANGLE),$(FLAGS_CPLUS_DEMANGLE))
+                                        ifeq ($(has_cplus_demangle),y)
+                                                EXTLIBS += -liberty
+                                                BASIC_CFLAGS += -DHAVE_CPLUS_DEMANGLE
+                                        else
+                                                msg := $(warning No bfd.h/libbfd found, install binutils-dev[el]/zlib-static to gain symbol demangling)
+                                                BASIC_CFLAGS += -DNO_DEMANGLE
+                                        endif
                                 endif
                         endif
                 endif
@@ -591,53 +692,53 @@ ifdef NO_C99_FORMAT
 endif
 ifdef SNPRINTF_RETURNS_BOGUS
         COMPAT_CFLAGS += -DSNPRINTF_RETURNS_BOGUS
-        COMPAT_OBJS += compat/snprintf.o
+        COMPAT_OBJS += $(OUTPUT)compat/snprintf.o
 endif
 ifdef FREAD_READS_DIRECTORIES
         COMPAT_CFLAGS += -DFREAD_READS_DIRECTORIES
-        COMPAT_OBJS += compat/fopen.o
+        COMPAT_OBJS += $(OUTPUT)compat/fopen.o
 endif
 ifdef NO_SYMLINK_HEAD
         BASIC_CFLAGS += -DNO_SYMLINK_HEAD
 endif
 ifdef NO_STRCASESTR
         COMPAT_CFLAGS += -DNO_STRCASESTR
-        COMPAT_OBJS += compat/strcasestr.o
+        COMPAT_OBJS += $(OUTPUT)compat/strcasestr.o
 endif
 ifdef NO_STRTOUMAX
         COMPAT_CFLAGS += -DNO_STRTOUMAX
-        COMPAT_OBJS += compat/strtoumax.o
+        COMPAT_OBJS += $(OUTPUT)compat/strtoumax.o
 endif
 ifdef NO_STRTOULL
         COMPAT_CFLAGS += -DNO_STRTOULL
 endif
 ifdef NO_SETENV
         COMPAT_CFLAGS += -DNO_SETENV
-        COMPAT_OBJS += compat/setenv.o
+        COMPAT_OBJS += $(OUTPUT)compat/setenv.o
 endif
 ifdef NO_MKDTEMP
         COMPAT_CFLAGS += -DNO_MKDTEMP
-        COMPAT_OBJS += compat/mkdtemp.o
+        COMPAT_OBJS += $(OUTPUT)compat/mkdtemp.o
 endif
 ifdef NO_UNSETENV
         COMPAT_CFLAGS += -DNO_UNSETENV
-        COMPAT_OBJS += compat/unsetenv.o
+        COMPAT_OBJS += $(OUTPUT)compat/unsetenv.o
 endif
 ifdef NO_SYS_SELECT_H
         BASIC_CFLAGS += -DNO_SYS_SELECT_H
 endif
 ifdef NO_MMAP
         COMPAT_CFLAGS += -DNO_MMAP
-        COMPAT_OBJS += compat/mmap.o
+        COMPAT_OBJS += $(OUTPUT)compat/mmap.o
 else
         ifdef USE_WIN32_MMAP
                 COMPAT_CFLAGS += -DUSE_WIN32_MMAP
-                COMPAT_OBJS += compat/win32mmap.o
+                COMPAT_OBJS += $(OUTPUT)compat/win32mmap.o
         endif
 endif
 ifdef NO_PREAD
         COMPAT_CFLAGS += -DNO_PREAD
-        COMPAT_OBJS += compat/pread.o
+        COMPAT_OBJS += $(OUTPUT)compat/pread.o
 endif
 ifdef NO_FAST_WORKING_DIRECTORY
         BASIC_CFLAGS += -DNO_FAST_WORKING_DIRECTORY
@@ -659,10 +760,10 @@ else
 endif
 endif
 ifdef NO_INET_NTOP
-        LIB_OBJS += compat/inet_ntop.o
+        LIB_OBJS += $(OUTPUT)compat/inet_ntop.o
 endif
 ifdef NO_INET_PTON
-        LIB_OBJS += compat/inet_pton.o
+        LIB_OBJS += $(OUTPUT)compat/inet_pton.o
 endif
 
 ifdef NO_ICONV
@@ -679,15 +780,15 @@ endif
 
 ifdef PPC_SHA1
         SHA1_HEADER = "ppc/sha1.h"
-        LIB_OBJS += ppc/sha1.o ppc/sha1ppc.o
+        LIB_OBJS += $(OUTPUT)ppc/sha1.o ppc/sha1ppc.o
 else
 ifdef ARM_SHA1
         SHA1_HEADER = "arm/sha1.h"
-        LIB_OBJS += arm/sha1.o arm/sha1_arm.o
+        LIB_OBJS += $(OUTPUT)arm/sha1.o $(OUTPUT)arm/sha1_arm.o
 else
 ifdef MOZILLA_SHA1
         SHA1_HEADER = "mozilla-sha1/sha1.h"
-        LIB_OBJS += mozilla-sha1/sha1.o
+        LIB_OBJS += $(OUTPUT)mozilla-sha1/sha1.o
 else
         SHA1_HEADER = <openssl/sha.h>
         EXTLIBS += $(LIB_4_CRYPTO)
@@ -699,15 +800,15 @@ ifdef NO_PERL_MAKEMAKER
 endif
 ifdef NO_HSTRERROR
         COMPAT_CFLAGS += -DNO_HSTRERROR
-        COMPAT_OBJS += compat/hstrerror.o
+        COMPAT_OBJS += $(OUTPUT)compat/hstrerror.o
 endif
 ifdef NO_MEMMEM
         COMPAT_CFLAGS += -DNO_MEMMEM
-        COMPAT_OBJS += compat/memmem.o
+        COMPAT_OBJS += $(OUTPUT)compat/memmem.o
 endif
 ifdef INTERNAL_QSORT
         COMPAT_CFLAGS += -DINTERNAL_QSORT
-        COMPAT_OBJS += compat/qsort.o
+        COMPAT_OBJS += $(OUTPUT)compat/qsort.o
 endif
 ifdef RUNTIME_PREFIX
         COMPAT_CFLAGS += -DRUNTIME_PREFIX
@@ -738,6 +839,7 @@ ifndef V
         QUIET_CC       = @echo '   ' CC $@;
         QUIET_AR       = @echo '   ' AR $@;
         QUIET_LINK     = @echo '   ' LINK $@;
+        QUIET_MKDIR    = @echo '   ' MKDIR $@;
         QUIET_BUILT_IN = @echo '   ' BUILTIN $@;
         QUIET_GEN      = @echo '   ' GEN $@;
         QUIET_SUBDIR0  = +@subdir=
@@ -787,7 +889,7 @@ export TAR INSTALL DESTDIR SHELL_PATH
 
 SHELL = $(SHELL_PATH)
 
-all:: .perf.dev.null shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) PERF-BUILD-OPTIONS
+all:: shell_compatibility_test $(ALL_PROGRAMS) $(BUILT_INS) $(OTHER_PROGRAMS) $(OUTPUT)PERF-BUILD-OPTIONS
 ifneq (,$X)
         $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), test '$p' -ef '$p$X' || $(RM) '$p';)
 endif
@@ -799,51 +901,51 @@ please_set_SHELL_PATH_to_a_more_modern_shell:
 
 shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell
 
-strip: $(PROGRAMS) perf$X
-        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) perf$X
+strip: $(PROGRAMS) $(OUTPUT)perf$X
+        $(STRIP) $(STRIP_OPTS) $(PROGRAMS) $(OUTPUT)perf$X
 
-perf.o: perf.c common-cmds.h PERF-CFLAGS
+$(OUTPUT)perf.o: perf.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -DPERF_VERSION='"$(PERF_VERSION)"' \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
-                $(ALL_CFLAGS) -c $(filter %.c,$^)
+                $(ALL_CFLAGS) -c $(filter %.c,$^) -o $@
 
-perf$X: perf.o $(BUILTIN_OBJS) $(PERFLIBS)
-        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ perf.o \
+$(OUTPUT)perf$X: $(OUTPUT)perf.o $(BUILTIN_OBJS) $(PERFLIBS)
+        $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(OUTPUT)perf.o \
                 $(BUILTIN_OBJS) $(ALL_LDFLAGS) $(LIBS)
 
-builtin-help.o: builtin-help.c common-cmds.h PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
+$(OUTPUT)builtin-help.o: builtin-help.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 
-builtin-timechart.o: builtin-timechart.c common-cmds.h PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
+$(OUTPUT)builtin-timechart.o: builtin-timechart.c $(OUTPUT)common-cmds.h $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
                 '-DPERF_HTML_PATH="$(htmldir_SQ)"' \
                 '-DPERF_MAN_PATH="$(mandir_SQ)"' \
                 '-DPERF_INFO_PATH="$(infodir_SQ)"' $<
 
-$(BUILT_INS): perf$X
+$(BUILT_INS): $(OUTPUT)perf$X
         $(QUIET_BUILT_IN)$(RM) $@ && \
         ln perf$X $@ 2>/dev/null || \
         ln -s perf$X $@ 2>/dev/null || \
         cp perf$X $@
 
-common-cmds.h: util/generate-cmdlist.sh command-list.txt
+$(OUTPUT)common-cmds.h: util/generate-cmdlist.sh command-list.txt
 
-common-cmds.h: $(wildcard Documentation/perf-*.txt)
+$(OUTPUT)common-cmds.h: $(wildcard Documentation/perf-*.txt)
         $(QUIET_GEN). util/generate-cmdlist.sh > $@+ && mv $@+ $@
 
 $(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
-        $(QUIET_GEN)$(RM) $@ $@+ && \
+        $(QUIET_GEN)$(RM) $(OUTPUT)$@ $(OUTPUT)$@+ && \
         sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
             -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \
             -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \
             -e 's/@@PERF_VERSION@@/$(PERF_VERSION)/g' \
             -e 's/@@NO_CURL@@/$(NO_CURL)/g' \
-            $@.sh >$@+ && \
-        chmod +x $@+ && \
-        mv $@+ $@
+            $@.sh > $(OUTPUT)$@+ && \
+        chmod +x $(OUTPUT)$@+ && \
+        mv $(OUTPUT)$@+ $(OUTPUT)$@
 
 configure: configure.ac
         $(QUIET_GEN)$(RM) $@ $<+ && \
@@ -853,60 +955,73 @@ configure: configure.ac
         $(RM) $<+
 
 # These can record PERF_VERSION
-perf.o perf.spec \
+$(OUTPUT)perf.o perf.spec \
         $(patsubst %.sh,%,$(SCRIPT_SH)) \
         $(patsubst %.perl,%,$(SCRIPT_PERL)) \
-        : PERF-VERSION-FILE
+        : $(OUTPUT)PERF-VERSION-FILE
 
-%.o: %.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
-%.s: %.c PERF-CFLAGS
+$(OUTPUT)%.o: %.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+$(OUTPUT)%.s: %.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
-%.o: %.S
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) $<
+$(OUTPUT)%.o: %.S
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
 
-util/exec_cmd.o: util/exec_cmd.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) \
+$(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) \
                 '-DPERF_EXEC_PATH="$(perfexecdir_SQ)"' \
                 '-DBINDIR="$(bindir_relative_SQ)"' \
                 '-DPREFIX="$(prefix_SQ)"' \
                 $<
 
-builtin-init-db.o: builtin-init-db.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DDEFAULT_PERF_TEMPLATE_DIR='"$(template_dir_SQ)"' $<
+$(OUTPUT)builtin-init-db.o: builtin-init-db.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DDEFAULT_PERF_TEMPLATE_DIR='"$(template_dir_SQ)"' $<
+
+$(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
-util/config.o: util/config.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o $*.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/ui/browser.o: util/ui/browser.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-util/rbtree.o: ../../lib/rbtree.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o util/rbtree.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/ui/browsers/annotate.o: util/ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-# some perf warning policies can't fit to lib/bitmap.c, eg: it warns about variable shadowing
-# from <string.h> that comes from kernel headers wrapping.
-KBITMAP_FLAGS=`echo $(ALL_CFLAGS) | sed s/-Wshadow// | sed s/-Wswitch-default// | sed s/-Wextra//`
+$(OUTPUT)util/ui/browsers/hists.o: util/ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-util/bitmap.o: ../../lib/bitmap.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o util/bitmap.o -c $(KBITMAP_FLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-util/hweight.o: ../../lib/hweight.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o util/hweight.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
-util/find_next_bit.o: ../../lib/find_next_bit.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o util/find_next_bit.o -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
+$(OUTPUT)util/scripting-engines/trace-event-perl.o: util/scripting-engines/trace-event-perl.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 
-util/trace-event-perl.o: util/trace-event-perl.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o util/trace-event-perl.o -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
+$(OUTPUT)scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
 
-scripts/perl/Perf-Trace-Util/Context.o: scripts/perl/Perf-Trace-Util/Context.c PERF-CFLAGS
-        $(QUIET_CC)$(CC) -o scripts/perl/Perf-Trace-Util/Context.o -c $(ALL_CFLAGS) $(PERL_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+$(OUTPUT)util/scripting-engines/trace-event-python.o: util/scripting-engines/trace-event-python.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-shadow $<
 
-perf-%$X: %.o $(PERFLIBS)
+$(OUTPUT)scripts/python/Perf-Trace-Util/Context.o: scripts/python/Perf-Trace-Util/Context.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $(PYTHON_EMBED_CCOPTS) -Wno-redundant-decls -Wno-strict-prototypes -Wno-unused-parameter -Wno-nested-externs $<
+
+$(OUTPUT)perf-%$X: %.o $(PERFLIBS)
         $(QUIET_LINK)$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
 
 $(LIB_OBJS) $(BUILTIN_OBJS): $(LIB_H)
 $(patsubst perf-%$X,%.o,$(PROGRAMS)): $(LIB_H) $(wildcard */*.h)
 builtin-revert.o wt-status.o: wt-status.h
 
+# we compile into subdirectories. if the target directory is not the source directory, they might not exists. So
+# we depend the various files onto their directories.
+DIRECTORY_DEPS = $(LIB_OBJS) $(BUILTIN_OBJS) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)common-cmds.h
+$(DIRECTORY_DEPS): | $(sort $(dir $(DIRECTORY_DEPS)))
+# In the second step, we make a rule to actually create these directories
+$(sort $(dir $(DIRECTORY_DEPS))):
+        $(QUIET_MKDIR)$(MKDIR) -p $@ 2>/dev/null
+
 $(LIB_FILE): $(LIB_OBJS)
         $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
 
@@ -941,17 +1056,17 @@ cscope:
 TRACK_CFLAGS = $(subst ','\'',$(ALL_CFLAGS)):\
              $(bindir_SQ):$(perfexecdir_SQ):$(template_dir_SQ):$(prefix_SQ)
 
-PERF-CFLAGS: .FORCE-PERF-CFLAGS
+$(OUTPUT)PERF-CFLAGS: .FORCE-PERF-CFLAGS
         @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat PERF-CFLAGS 2>/dev/null`" ; then \
+            if test x"$$FLAGS" != x"`cat $(OUTPUT)PERF-CFLAGS 2>/dev/null`" ; then \
                 echo 1>&2 "    * new build flags or prefix"; \
-                echo "$$FLAGS" >PERF-CFLAGS; \
+                echo "$$FLAGS" >$(OUTPUT)PERF-CFLAGS; \
             fi
 
 # We need to apply sq twice, once to protect from the shell
-# that runs PERF-BUILD-OPTIONS, and then again to protect it
+# that runs $(OUTPUT)PERF-BUILD-OPTIONS, and then again to protect it
 # and the first level quoting from the shell that runs "echo".
-PERF-BUILD-OPTIONS: .FORCE-PERF-BUILD-OPTIONS
+$(OUTPUT)PERF-BUILD-OPTIONS: .FORCE-PERF-BUILD-OPTIONS
         @echo SHELL_PATH=\''$(subst ','\'',$(SHELL_PATH_SQ))'\' >$@
         @echo TAR=\''$(subst ','\'',$(subst ','\'',$(TAR)))'\' >>$@
         @echo NO_CURL=\''$(subst ','\'',$(subst ','\'',$(NO_CURL)))'\' >>$@
@@ -972,7 +1087,7 @@ all:: $(TEST_PROGRAMS)
 
 export NO_SVN_TESTS
 
-check: common-cmds.h
+check: $(OUTPUT)common-cmds.h
         if sparse; \
         then \
                 for i in *.c */*.c; \
@@ -1006,17 +1121,24 @@ export perfexec_instdir
 
 install: all
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(bindir_SQ)'
-        $(INSTALL) perf$X '$(DESTDIR_SQ)$(bindir_SQ)'
+        $(INSTALL) $(OUTPUT)perf$X '$(DESTDIR_SQ)$(bindir_SQ)'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
+        $(INSTALL) $(OUTPUT)perf-archive -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) scripts/perl/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/Perf-Trace-Util/lib/Perf/Trace'
         $(INSTALL) scripts/perl/*.pl -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl'
         $(INSTALL) scripts/perl/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/perl/bin'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
+        $(INSTALL) scripts/python/Perf-Trace-Util/lib/Perf/Trace/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/Perf-Trace-Util/lib/Perf/Trace'
+        $(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
+        $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
+
 ifdef BUILT_INS
         $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
         $(INSTALL) $(BUILT_INS) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)'
 ifneq (,$X)
-        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) perf$X)), $(RM) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/$p';)
+        $(foreach p,$(patsubst %$X,%,$(filter %$X,$(ALL_PROGRAMS) $(BUILT_INS) $(OUTPUT)perf$X)), $(RM) '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/$p';)
 endif
 endif
 
@@ -1100,25 +1222,20 @@ clean:
         $(RM) *.o */*.o */*/*.o */*/*/*.o $(LIB_FILE)
         $(RM) $(ALL_PROGRAMS) $(BUILT_INS) perf$X
         $(RM) $(TEST_PROGRAMS)
-        $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo common-cmds.h TAGS tags cscope*
+        $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
         $(RM) -r autom4te.cache
         $(RM) config.log config.mak.autogen config.mak.append config.status config.cache
         $(RM) -r $(PERF_TARNAME) .doc-tmp-dir
         $(RM) $(PERF_TARNAME).tar.gz perf-core_$(PERF_VERSION)-*.tar.gz
         $(RM) $(htmldocs).tar.gz $(manpages).tar.gz
         $(MAKE) -C Documentation/ clean
-        $(RM) PERF-VERSION-FILE PERF-CFLAGS PERF-BUILD-OPTIONS
+        $(RM) $(OUTPUT)PERF-VERSION-FILE $(OUTPUT)PERF-CFLAGS $(OUTPUT)PERF-BUILD-OPTIONS
 
 .PHONY: all install clean strip
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
 .PHONY: .FORCE-PERF-BUILD-OPTIONS
 
-.perf.dev.null:
-                touch .perf.dev.null
-
-.INTERMEDIATE:  .perf.dev.null
-
 ### Make sure built-ins do not have dups and listed in perf.c
 #
 check-builtins::
diff --git a/tools/perf/arch/arm/Makefile b/tools/perf/arch/arm/Makefile
new file mode 100644
index 000000000000..15130b50dfe3
--- /dev/null
+++ b/tools/perf/arch/arm/Makefile
@@ -0,0 +1,4 @@
+ifndef NO_DWARF
+PERF_HAVE_DWARF_REGS := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+endif
diff --git a/tools/perf/arch/arm/util/dwarf-regs.c b/tools/perf/arch/arm/util/dwarf-regs.c
new file mode 100644
index 000000000000..fff6450c8c99
--- /dev/null
+++ b/tools/perf/arch/arm/util/dwarf-regs.c
@@ -0,0 +1,64 @@
+/*
+ * Mapping of DWARF debug register numbers into register names.
+ *
+ * Copyright (C) 2010 Will Deacon, ARM Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <libio.h>
+#include <dwarf-regs.h>
+
+struct pt_regs_dwarfnum {
+        const char *name;
+        unsigned int dwarfnum;
+};
+
+#define STR(s) #s
+#define REG_DWARFNUM_NAME(r, num) {.name = r, .dwarfnum = num}
+#define GPR_DWARFNUM_NAME(num) \
+        {.name = STR(%r##num), .dwarfnum = num}
+#define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0}
+
+/*
+ * Reference:
+ * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0040a/IHI0040A_aadwarf.pdf
+ */
+static const struct pt_regs_dwarfnum regdwarfnum_table[] = {
+        GPR_DWARFNUM_NAME(0),
+        GPR_DWARFNUM_NAME(1),
+        GPR_DWARFNUM_NAME(2),
+        GPR_DWARFNUM_NAME(3),
+        GPR_DWARFNUM_NAME(4),
+        GPR_DWARFNUM_NAME(5),
+        GPR_DWARFNUM_NAME(6),
+        GPR_DWARFNUM_NAME(7),
+        GPR_DWARFNUM_NAME(8),
+        GPR_DWARFNUM_NAME(9),
+        GPR_DWARFNUM_NAME(10),
+        REG_DWARFNUM_NAME("%fp", 11),
+        REG_DWARFNUM_NAME("%ip", 12),
+        REG_DWARFNUM_NAME("%sp", 13),
+        REG_DWARFNUM_NAME("%lr", 14),
+        REG_DWARFNUM_NAME("%pc", 15),
+        REG_DWARFNUM_END,
+};
+
+/**
+ * get_arch_regstr() - lookup register name from it's DWARF register number
+ * @n:  the DWARF register number
+ *
+ * get_arch_regstr() returns the name of the register in struct
+ * regdwarfnum_table from it's DWARF register number. If the register is not
+ * found in the table, this returns NULL;
+ */
+const char *get_arch_regstr(unsigned int n)
+{
+        const struct pt_regs_dwarfnum *roff;
+        for (roff = regdwarfnum_table; roff->name != NULL; roff++)
+                if (roff->dwarfnum == n)
+                        return roff->name;
+        return NULL;
+}
diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
new file mode 100644
index 000000000000..15130b50dfe3
--- /dev/null
+++ b/tools/perf/arch/powerpc/Makefile
@@ -0,0 +1,4 @@
+ifndef NO_DWARF
+PERF_HAVE_DWARF_REGS := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+endif
diff --git a/tools/perf/arch/powerpc/util/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
new file mode 100644
index 000000000000..48ae0c5e3f73
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -0,0 +1,88 @@
+/*
+ * Mapping of DWARF debug register numbers into register names.
+ *
+ * Copyright (C) 2010 Ian Munsie, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <libio.h>
+#include <dwarf-regs.h>
+
+
+struct pt_regs_dwarfnum {
+        const char *name;
+        unsigned int dwarfnum;
+};
+
+#define STR(s) #s
+#define REG_DWARFNUM_NAME(r, num) {.name = r, .dwarfnum = num}
+#define GPR_DWARFNUM_NAME(num)  \
+        {.name = STR(%gpr##num), .dwarfnum = num}
+#define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0}
+
+/*
+ * Reference:
+ * http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.html
+ */
+static const struct pt_regs_dwarfnum regdwarfnum_table[] = {
+        GPR_DWARFNUM_NAME(0),
+        GPR_DWARFNUM_NAME(1),
+        GPR_DWARFNUM_NAME(2),
+        GPR_DWARFNUM_NAME(3),
+        GPR_DWARFNUM_NAME(4),
+        GPR_DWARFNUM_NAME(5),
+        GPR_DWARFNUM_NAME(6),
+        GPR_DWARFNUM_NAME(7),
+        GPR_DWARFNUM_NAME(8),
+        GPR_DWARFNUM_NAME(9),
+        GPR_DWARFNUM_NAME(10),
+        GPR_DWARFNUM_NAME(11),
+        GPR_DWARFNUM_NAME(12),
+        GPR_DWARFNUM_NAME(13),
+        GPR_DWARFNUM_NAME(14),
+        GPR_DWARFNUM_NAME(15),
+        GPR_DWARFNUM_NAME(16),
+        GPR_DWARFNUM_NAME(17),
+        GPR_DWARFNUM_NAME(18),
+        GPR_DWARFNUM_NAME(19),
+        GPR_DWARFNUM_NAME(20),
+        GPR_DWARFNUM_NAME(21),
+        GPR_DWARFNUM_NAME(22),
+        GPR_DWARFNUM_NAME(23),
+        GPR_DWARFNUM_NAME(24),
+        GPR_DWARFNUM_NAME(25),
+        GPR_DWARFNUM_NAME(26),
+        GPR_DWARFNUM_NAME(27),
+        GPR_DWARFNUM_NAME(28),
+        GPR_DWARFNUM_NAME(29),
+        GPR_DWARFNUM_NAME(30),
+        GPR_DWARFNUM_NAME(31),
+        REG_DWARFNUM_NAME("%msr",   66),
+        REG_DWARFNUM_NAME("%ctr",   109),
+        REG_DWARFNUM_NAME("%link",  108),
+        REG_DWARFNUM_NAME("%xer",   101),
+        REG_DWARFNUM_NAME("%dar",   119),
+        REG_DWARFNUM_NAME("%dsisr", 118),
+        REG_DWARFNUM_END,
+};
+
+/**
+ * get_arch_regstr() - lookup register name from it's DWARF register number
+ * @n:  the DWARF register number
+ *
+ * get_arch_regstr() returns the name of the register in struct
+ * regdwarfnum_table from it's DWARF register number. If the register is not
+ * found in the table, this returns NULL;
+ */
+const char *get_arch_regstr(unsigned int n)
+{
+        const struct pt_regs_dwarfnum *roff;
+        for (roff = regdwarfnum_table; roff->name != NULL; roff++)
+                if (roff->dwarfnum == n)
+                        return roff->name;
+        return NULL;
+}
diff --git a/tools/perf/arch/sh/Makefile b/tools/perf/arch/sh/Makefile
new file mode 100644
index 000000000000..15130b50dfe3
--- /dev/null
+++ b/tools/perf/arch/sh/Makefile
@@ -0,0 +1,4 @@
+ifndef NO_DWARF
+PERF_HAVE_DWARF_REGS := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+endif
diff --git a/tools/perf/arch/sh/util/dwarf-regs.c b/tools/perf/arch/sh/util/dwarf-regs.c
new file mode 100644
index 000000000000..a11edb007a6c
--- /dev/null
+++ b/tools/perf/arch/sh/util/dwarf-regs.c
@@ -0,0 +1,55 @@
+/*
+ * Mapping of DWARF debug register numbers into register names.
+ *
+ * Copyright (C) 2010 Matt Fleming <matt@console-pimps.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include <libio.h>
+#include <dwarf-regs.h>
+
+/*
+ * Generic dwarf analysis helpers
+ */
+
+#define SH_MAX_REGS 18
+const char *sh_regs_table[SH_MAX_REGS] = {
+        "r0",
+        "r1",
+        "r2",
+        "r3",
+        "r4",
+        "r5",
+        "r6",
+        "r7",
+        "r8",
+        "r9",
+        "r10",
+        "r11",
+        "r12",
+        "r13",
+        "r14",
+        "r15",
+        "pc",
+        "pr",
+};
+
+/* Return architecture dependent register string (for kprobe-tracer) */
+const char *get_arch_regstr(unsigned int n)
+{
+        return (n <= SH_MAX_REGS) ? sh_regs_table[n] : NULL;
+}
diff --git a/tools/perf/arch/sparc/Makefile b/tools/perf/arch/sparc/Makefile
new file mode 100644
index 000000000000..15130b50dfe3
--- /dev/null
+++ b/tools/perf/arch/sparc/Makefile
@@ -0,0 +1,4 @@
+ifndef NO_DWARF
+PERF_HAVE_DWARF_REGS := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+endif
diff --git a/tools/perf/arch/sparc/util/dwarf-regs.c b/tools/perf/arch/sparc/util/dwarf-regs.c
new file mode 100644
index 000000000000..0ab88483720c
--- /dev/null
+++ b/tools/perf/arch/sparc/util/dwarf-regs.c
@@ -0,0 +1,43 @@
+/*
+ * Mapping of DWARF debug register numbers into register names.
+ *
+ * Copyright (C) 2010 David S. Miller <davem@davemloft.net>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <libio.h>
+#include <dwarf-regs.h>
+
+#define SPARC_MAX_REGS  96
+
+const char *sparc_regs_table[SPARC_MAX_REGS] = {
+        "%g0", "%g1", "%g2", "%g3", "%g4", "%g5", "%g6", "%g7",
+        "%o0", "%o1", "%o2", "%o3", "%o4", "%o5", "%sp", "%o7",
+        "%l0", "%l1", "%l2", "%l3", "%l4", "%l5", "%l6", "%l7",
+        "%i0", "%i1", "%i2", "%i3", "%i4", "%i5", "%fp", "%i7",
+        "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
+        "%f8", "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
+        "%f16", "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
+        "%f24", "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
+        "%f32", "%f33", "%f34", "%f35", "%f36", "%f37", "%f38", "%f39",
+        "%f40", "%f41", "%f42", "%f43", "%f44", "%f45", "%f46", "%f47",
+        "%f48", "%f49", "%f50", "%f51", "%f52", "%f53", "%f54", "%f55",
+        "%f56", "%f57", "%f58", "%f59", "%f60", "%f61", "%f62", "%f63",
+};
+
+/**
+ * get_arch_regstr() - lookup register name from it's DWARF register number
+ * @n:  the DWARF register number
+ *
+ * get_arch_regstr() returns the name of the register in struct
+ * regdwarfnum_table from it's DWARF register number. If the register is not
+ * found in the table, this returns NULL;
+ */
+const char *get_arch_regstr(unsigned int n)
+{
+        return (n <= SPARC_MAX_REGS) ? sparc_regs_table[n] : NULL;
+}
diff --git a/tools/perf/arch/x86/Makefile b/tools/perf/arch/x86/Makefile
new file mode 100644
index 000000000000..15130b50dfe3
--- /dev/null
+++ b/tools/perf/arch/x86/Makefile
@@ -0,0 +1,4 @@
+ifndef NO_DWARF
+PERF_HAVE_DWARF_REGS := 1
+LIB_OBJS += $(OUTPUT)arch/$(ARCH)/util/dwarf-regs.o
+endif
diff --git a/tools/perf/arch/x86/util/dwarf-regs.c b/tools/perf/arch/x86/util/dwarf-regs.c
new file mode 100644
index 000000000000..a794d3081928
--- /dev/null
+++ b/tools/perf/arch/x86/util/dwarf-regs.c
@@ -0,0 +1,75 @@
+/*
+ * dwarf-regs.c : Mapping of DWARF debug register numbers into register names.
+ * Extracted from probe-finder.c
+ *
+ * Written by Masami Hiramatsu <mhiramat@redhat.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ *
+ */
+
+#include <libio.h>
+#include <dwarf-regs.h>
+
+/*
+ * Generic dwarf analysis helpers
+ */
+
+#define X86_32_MAX_REGS 8
+const char *x86_32_regs_table[X86_32_MAX_REGS] = {
+        "%ax",
+        "%cx",
+        "%dx",
+        "%bx",
+        "$stack",       /* Stack address instead of %sp */
+        "%bp",
+        "%si",
+        "%di",
+};
+
+#define X86_64_MAX_REGS 16
+const char *x86_64_regs_table[X86_64_MAX_REGS] = {
+        "%ax",
+        "%dx",
+        "%cx",
+        "%bx",
+        "%si",
+        "%di",
+        "%bp",
+        "%sp",
+        "%r8",
+        "%r9",
+        "%r10",
+        "%r11",
+        "%r12",
+        "%r13",
+        "%r14",
+        "%r15",
+};
+
+/* TODO: switching by dwarf address size */
+#ifdef __x86_64__
+#define ARCH_MAX_REGS X86_64_MAX_REGS
+#define arch_regs_table x86_64_regs_table
+#else
+#define ARCH_MAX_REGS X86_32_MAX_REGS
+#define arch_regs_table x86_32_regs_table
+#endif
+
+/* Return architecture dependent register string (for kprobe-tracer) */
+const char *get_arch_regstr(unsigned int n)
+{
+        return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
+}
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 89773178e894..38dae7465142 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -10,7 +10,6 @@
 #include "../perf.h"
 #include "../util/util.h"
 #include "../util/parse-options.h"
-#include "../util/string.h"
 #include "../util/header.h"
 #include "bench.h"
 
@@ -24,7 +23,7 @@
 
 static const char       *length_str     = "1MB";
 static const char       *routine        = "default";
-static int              use_clock       = 0;
+static bool             use_clock       = false;
 static int              clock_fd;
 
 static const struct option options[] = {
diff --git a/tools/perf/bench/sched-messaging.c b/tools/perf/bench/sched-messaging.c
index 81cee78181fa..d1d1b30f99c1 100644
--- a/tools/perf/bench/sched-messaging.c
+++ b/tools/perf/bench/sched-messaging.c
@@ -31,9 +31,9 @@
 
 #define DATASIZE 100
 
-static int use_pipes = 0;
+static bool use_pipes = false;
 static unsigned int loops = 100;
-static unsigned int thread_mode = 0;
+static bool thread_mode = false;
 static unsigned int num_groups = 10;
 
 struct sender_context {
@@ -256,10 +256,8 @@ static const struct option options[] = {
                     "Use pipe() instead of socketpair()"),
         OPT_BOOLEAN('t', "thread", &thread_mode,
                     "Be multi thread instead of multi process"),
-        OPT_INTEGER('g', "group", &num_groups,
-                    "Specify number of groups"),
-        OPT_INTEGER('l', "loop", &loops,
-                    "Specify number of loops"),
+        OPT_UINTEGER('g', "group", &num_groups, "Specify number of groups"),
+        OPT_UINTEGER('l', "loop", &loops, "Specify number of loops"),
         OPT_END()
 };
 
diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
index 4f77c7c27640..d9ab3ce446ac 100644
--- a/tools/perf/bench/sched-pipe.c
+++ b/tools/perf/bench/sched-pipe.c
@@ -93,7 +93,7 @@ int bench_sched_pipe(int argc, const char **argv,
 
         switch (bench_format) {
         case BENCH_FORMAT_DEFAULT:
-                printf("# Extecuted %d pipe operations between two tasks\n\n",
+                printf("# Executed %d pipe operations between two tasks\n\n",
                         loops);
 
                 result_usec = diff.tv_sec * 1000000;
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 593ff25006de..1478dc64bf15 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -14,7 +14,6 @@
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
-#include "util/string.h"
 
 #include "perf.h"
 #include "util/debug.h"
@@ -29,175 +28,65 @@
 
 static char             const *input_name = "perf.data";
 
-static int              force;
+static bool             force;
 
-static int              full_paths;
+static bool             full_paths;
 
-static int              print_line;
-
-struct sym_hist {
-        u64             sum;
-        u64             ip[0];
-};
-
-struct sym_ext {
-        struct rb_node  node;
-        double          percent;
-        char            *path;
-};
-
-struct sym_priv {
-        struct sym_hist *hist;
-        struct sym_ext  *ext;
-};
+static bool             print_line;
 
 static const char *sym_hist_filter;
 
-static int symbol_filter(struct map *map __used, struct symbol *sym)
+static int hists__add_entry(struct hists *self, struct addr_location *al)
 {
-        if (sym_hist_filter == NULL ||
-            strcmp(sym->name, sym_hist_filter) == 0) {
-                struct sym_priv *priv = symbol__priv(sym);
-                const int size = (sizeof(*priv->hist) +
-                                  (sym->end - sym->start) * sizeof(u64));
-
-                priv->hist = malloc(size);
-                if (priv->hist)
-                        memset(priv->hist, 0, size);
+        struct hist_entry *he;
+
+        if (sym_hist_filter != NULL &&
+            (al->sym == NULL || strcmp(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,
+                                 &al->map->dso->symbols[al->map->type]);
+                        symbol__delete(al->sym);
+                }
                 return 0;
         }
-        /*
-         * FIXME: We should really filter it out, as we don't want to go thru symbols
-         * we're not interested, and if a DSO ends up with no symbols, delete it too,
-         * but right now the kernel loading routines in symbol.c bail out if no symbols
-         * are found, fix it later.
-         */
-        return 0;
-}
-
-/*
- * collect histogram counts
- */
-static void hist_hit(struct hist_entry *he, u64 ip)
-{
-        unsigned int sym_size, offset;
-        struct symbol *sym = he->sym;
-        struct sym_priv *priv;
-        struct sym_hist *h;
-
-        he->count++;
-
-        if (!sym || !he->map)
-                return;
 
-        priv = symbol__priv(sym);
-        if (!priv->hist)
-                return;
-
-        sym_size = sym->end - sym->start;
-        offset = ip - sym->start;
-
-        if (verbose)
-                fprintf(stderr, "%s: ip=%Lx\n", __func__,
-                        he->map->unmap_ip(he->map, ip));
-
-        if (offset >= sym_size)
-                return;
-
-        h = priv->hist;
-        h->sum++;
-        h->ip[offset]++;
-
-        if (verbose >= 3)
-                printf("%p %s: count++ [ip: %p, %08Lx] => %Ld\n",
-                        (void *)(unsigned long)he->sym->start,
-                        he->sym->name,
-                        (void *)(unsigned long)ip, ip - he->sym->start,
-                        h->ip[offset]);
-}
-
-static int perf_session__add_hist_entry(struct perf_session *self,
-                                        struct addr_location *al, u64 count)
-{
-        bool hit;
-        struct hist_entry *he = __perf_session__add_hist_entry(self, al, NULL,
-                                                               count, &hit);
+        he = __hists__add_entry(self, al, NULL, 1);
         if (he == NULL)
                 return -ENOMEM;
-        hist_hit(he, al->addr);
-        return 0;
+
+        return hist_entry__inc_addr_samples(he, al->addr);
 }
 
 static int process_sample_event(event_t *event, struct perf_session *session)
 {
         struct addr_location al;
+        struct sample_data data;
 
-        dump_printf("(IP, %d): %d: %p\n", event->header.misc,
-                    event->ip.pid, (void *)(long)event->ip.ip);
-
-        if (event__preprocess_sample(event, session, &al, symbol_filter) < 0) {
-                fprintf(stderr, "problem processing %d event, skipping it.\n",
-                        event->header.type);
+        if (event__preprocess_sample(event, session, &al, &data, NULL) < 0) {
+                pr_warning("problem processing %d event, skipping it.\n",
+                           event->header.type);
                 return -1;
         }
 
-        if (!al.filtered && perf_session__add_hist_entry(session, &al, 1)) {
-                fprintf(stderr, "problem incrementing symbol count, "
-                                "skipping event\n");
+        if (!al.filtered && hists__add_entry(&session->hists, &al)) {
+                pr_warning("problem incrementing symbol count, "
+                           "skipping event\n");
                 return -1;
         }
 
         return 0;
 }
 
-static int parse_line(FILE *file, struct hist_entry *he, u64 len)
+static int objdump_line__print(struct objdump_line *self,
+                               struct list_head *head,
+                               struct hist_entry *he, u64 len)
 {
-        struct symbol *sym = he->sym;
-        char *line = NULL, *tmp, *tmp2;
+        struct symbol *sym = he->ms.sym;
         static const char *prev_line;
         static const char *prev_color;
-        unsigned int offset;
-        size_t line_len;
-        u64 start;
-        s64 line_ip;
-        int ret;
-        char *c;
-
-        if (getline(&line, &line_len, file) < 0)
-                return -1;
-        if (!line)
-                return -1;
-
-        c = strchr(line, '\n');
-        if (c)
-                *c = 0;
-
-        line_ip = -1;
-        offset = 0;
-        ret = -2;
-
-        /*
-         * Strip leading spaces:
-         */
-        tmp = line;
-        while (*tmp) {
-                if (*tmp != ' ')
-                        break;
-                tmp++;
-        }
 
-        if (*tmp) {
-                /*
-                 * Parse hexa addresses followed by ':'
-                 */
-                line_ip = strtoull(tmp, &tmp2, 16);
-                if (*tmp2 != ':')
-                        line_ip = -1;
-        }
-
-        start = he->map->unmap_ip(he->map, sym->start);
-
-        if (line_ip != -1) {
+        if (self->offset != -1) {
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
@@ -205,15 +94,22 @@ static int parse_line(FILE *file, struct hist_entry *he, u64 len)
                 struct sym_priv *priv = symbol__priv(sym);
                 struct sym_ext *sym_ext = priv->ext;
                 struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                if (path == NULL)
+                                        path = sym_ext[offset].path;
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+
+                        ++offset;
+                }
 
-                offset = line_ip - start;
-                if (offset < len)
-                        hits = h->ip[offset];
-
-                if (offset < len && sym_ext) {
-                        path = sym_ext[offset].path;
-                        percent = sym_ext[offset].percent;
-                } else if (h->sum)
+                if (sym_ext == NULL && h->sum)
                         percent = 100.0 * hits / h->sum;
 
                 color = get_percent_color(percent);
@@ -234,12 +130,12 @@ static int parse_line(FILE *file, struct hist_entry *he, u64 len)
 
                 color_fprintf(stdout, color, " %7.2f", percent);
                 printf(" :      ");
-                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
+                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", self->line);
         } else {
-                if (!*line)
+                if (!*self->line)
                         printf("         :\n");
                 else
-                        printf("         :      %s\n", line);
+                        printf("         :      %s\n", self->line);
         }
 
         return 0;
@@ -269,7 +165,7 @@ static void insert_source_line(struct sym_ext *sym_ext)
 
 static void free_source_line(struct hist_entry *he, int len)
 {
-        struct sym_priv *priv = symbol__priv(he->sym);
+        struct sym_priv *priv = symbol__priv(he->ms.sym);
         struct sym_ext *sym_ext = priv->ext;
         int i;
 
@@ -288,7 +184,7 @@ static void free_source_line(struct hist_entry *he, int len)
 static void
 get_source_line(struct hist_entry *he, int len, const char *filename)
 {
-        struct symbol *sym = he->sym;
+        struct symbol *sym = he->ms.sym;
         u64 start;
         int i;
         char cmd[PATH_MAX * 2];
@@ -303,7 +199,7 @@ get_source_line(struct hist_entry *he, int len, const char *filename)
         if (!priv->ext)
                 return;
 
-        start = he->map->unmap_ip(he->map, sym->start);
+        start = he->ms.map->unmap_ip(he->ms.map, sym->start);
 
         for (i = 0; i < len; i++) {
                 char *path = NULL;
@@ -365,24 +261,32 @@ static void print_summary(const char *filename)
         }
 }
 
-static void annotate_sym(struct hist_entry *he)
+static void hist_entry__print_hits(struct hist_entry *self)
 {
-        struct map *map = he->map;
+        struct symbol *sym = self->ms.sym;
+        struct sym_priv *priv = symbol__priv(sym);
+        struct sym_hist *h = priv->hist;
+        u64 len = sym->end - sym->start, offset;
+
+        for (offset = 0; offset < len; ++offset)
+                if (h->ip[offset] != 0)
+                        printf("%*Lx: %Lu\n", BITS_PER_LONG / 2,
+                               sym->start + offset, h->ip[offset]);
+        printf("%*s: %Lu\n", BITS_PER_LONG / 2, "h->sum", h->sum);
+}
+
+static int hist_entry__tty_annotate(struct hist_entry *he)
+{
+        struct map *map = he->ms.map;
         struct dso *dso = map->dso;
-        struct symbol *sym = he->sym;
+        struct symbol *sym = he->ms.sym;
         const char *filename = dso->long_name, *d_filename;
         u64 len;
-        char command[PATH_MAX*2];
-        FILE *file;
-
-        if (!filename)
-                return;
+        LIST_HEAD(head);
+        struct objdump_line *pos, *n;
 
-        if (verbose)
-                fprintf(stderr, "%s: filename=%s, sym=%s, start=%Lx, end=%Lx\n",
-                        __func__, filename, sym->name,
-                        map->unmap_ip(map, sym->start),
-                        map->unmap_ip(map, sym->end));
+        if (hist_entry__annotate(he, &head, 0) < 0)
+                return -1;
 
         if (full_paths)
                 d_filename = filename;
@@ -400,61 +304,78 @@ static void annotate_sym(struct hist_entry *he)
         printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
         printf("------------------------------------------------\n");
 
-        if (verbose >= 2)
-                printf("annotating [%p] %30s : [%p] %30s\n",
-                       dso, dso->long_name, sym, sym->name);
-
-        sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
-                map->unmap_ip(map, sym->start), map->unmap_ip(map, sym->end),
-                filename, filename);
-
-        if (verbose >= 3)
-                printf("doing: %s\n", command);
-
-        file = popen(command, "r");
-        if (!file)
-                return;
+        if (verbose)
+                hist_entry__print_hits(he);
 
-        while (!feof(file)) {
-                if (parse_line(file, he, len) < 0)
-                        break;
+        list_for_each_entry_safe(pos, n, &head, node) {
+                objdump_line__print(pos, &head, he, len);
+                list_del(&pos->node);
+                objdump_line__free(pos);
         }
 
-        pclose(file);
         if (print_line)
                 free_source_line(he, len);
+
+        return 0;
 }
 
-static void perf_session__find_annotations(struct perf_session *self)
+static void hists__find_annotations(struct hists *self)
 {
-        struct rb_node *nd;
+        struct rb_node *first = rb_first(&self->entries), *nd = first;
+        int key = KEY_RIGHT;
 
-        for (nd = rb_first(&self->hists); nd; nd = rb_next(nd)) {
+        while (nd) {
                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
                 struct sym_priv *priv;
 
-                if (he->sym == NULL)
-                        continue;
+                if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
+                        goto find_next;
 
-                priv = symbol__priv(he->sym);
-                if (priv->hist == NULL)
+                priv = symbol__priv(he->ms.sym);
+                if (priv->hist == NULL) {
+find_next:
+                        if (key == KEY_LEFT)
+                                nd = rb_prev(nd);
+                        else
+                                nd = rb_next(nd);
                         continue;
+                }
 
-                annotate_sym(he);
-                /*
-                 * Since we have a hist_entry per IP for the same symbol, free
-                 * he->sym->hist to signal we already processed this symbol.
-                 */
-                free(priv->hist);
-                priv->hist = NULL;
+                if (use_browser > 0) {
+                        key = hist_entry__tui_annotate(he);
+                        if (is_exit_key(key))
+                                break;
+                        switch (key) {
+                        case KEY_RIGHT:
+                        case '\t':
+                                nd = rb_next(nd);
+                                break;
+                        case KEY_LEFT:
+                                if (nd == first)
+                                        continue;
+                                nd = rb_prev(nd);
+                        default:
+                                break;
+                        }
+                } else {
+                        hist_entry__tty_annotate(he);
+                        nd = rb_next(nd);
+                        /*
+                         * Since we have a hist_entry per IP for the same
+                         * symbol, free he->ms.sym->hist to signal we already
+                         * processed this symbol.
+                         */
+                        free(priv->hist);
+                        priv->hist = NULL;
+                }
         }
 }
 
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_mmap_event     = event__process_mmap,
-        .process_comm_event     = event__process_comm,
-        .process_fork_event     = event__process_task,
+        .sample = process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .fork   = event__process_task,
 };
 
 static int __cmd_annotate(void)
@@ -462,7 +383,7 @@ static int __cmd_annotate(void)
         int ret;
         struct perf_session *session;
 
-        session = perf_session__new(input_name, O_RDONLY, force);
+        session = perf_session__new(input_name, O_RDONLY, force, false);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -471,7 +392,7 @@ static int __cmd_annotate(void)
                 goto out_delete;
 
         if (dump_trace) {
-                event__print_totals();
+                perf_session__fprintf_nr_events(session, stdout);
                 goto out_delete;
         }
 
@@ -479,11 +400,11 @@ static int __cmd_annotate(void)
                 perf_session__fprintf(session, stdout);
 
         if (verbose > 2)
-                dsos__fprintf(stdout);
+                perf_session__fprintf_dsos(session, stdout);
 
-        perf_session__collapse_resort(session);
-        perf_session__output_resort(session, session->event_total[0]);
-        perf_session__find_annotations(session);
+        hists__collapse_resort(&session->hists);
+        hists__output_resort(&session->hists);
+        hists__find_annotations(&session->hists);
 out_delete:
         perf_session__delete(session);
 
@@ -498,10 +419,12 @@ static const char * const annotate_usage[] = {
 static const struct option options[] = {
         OPT_STRING('i', "input", &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",
                     "symbol to annotate"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        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"),
@@ -520,6 +443,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 {
         argc = parse_options(argc, argv, options, annotate_usage, 0);
 
+        setup_browser();
+
         symbol_conf.priv_size = sizeof(struct sym_priv);
         symbol_conf.try_vmlinux_path = true;
 
@@ -539,12 +464,9 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 sym_hist_filter = argv[0];
         }
 
-        setup_pager();
-
         if (field_sep && *field_sep == '.') {
-                fputs("'.' is the only non valid --field-separator argument\n",
-                                stderr);
-                exit(129);
+                pr_err("'.' is the only non valid --field-separator argument\n");
+                return -1;
         }
 
         return __cmd_annotate();
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index 46996774e559..fcb96269852a 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -95,7 +95,7 @@ static void dump_suites(int subsys_index)
         return;
 }
 
-static char *bench_format_str;
+static const char *bench_format_str;
 int bench_format = BENCH_FORMAT_DEFAULT;
 
 static const struct option bench_options[] = {
@@ -126,7 +126,7 @@ static void print_usage(void)
         printf("\n");
 }
 
-static int bench_str2int(char *str)
+static int bench_str2int(const char *str)
 {
         if (!str)
                 return BENCH_FORMAT_DEFAULT;
diff --git a/tools/perf/builtin-buildid-cache.c b/tools/perf/builtin-buildid-cache.c
new file mode 100644
index 000000000000..29ad20e67919
--- /dev/null
+++ b/tools/perf/builtin-buildid-cache.c
@@ -0,0 +1,132 @@
+/*
+ * builtin-buildid-cache.c
+ *
+ * Builtin buildid-cache command: Manages build-id cache
+ *
+ * Copyright (C) 2010, Red Hat Inc.
+ * Copyright (C) 2010, Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "builtin.h"
+#include "perf.h"
+#include "util/cache.h"
+#include "util/debug.h"
+#include "util/header.h"
+#include "util/parse-options.h"
+#include "util/strlist.h"
+#include "util/symbol.h"
+
+static char const *add_name_list_str, *remove_name_list_str;
+
+static const char * const buildid_cache_usage[] = {
+        "perf buildid-cache [<options>]",
+        NULL
+};
+
+static const struct option buildid_cache_options[] = {
+        OPT_STRING('a', "add", &add_name_list_str,
+                   "file list", "file(s) to add"),
+        OPT_STRING('r', "remove", &remove_name_list_str, "file list",
+                    "file(s) to remove"),
+        OPT_INCR('v', "verbose", &verbose, "be more verbose"),
+        OPT_END()
+};
+
+static int build_id_cache__add_file(const char *filename, const char *debugdir)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+        u8 build_id[BUILD_ID_SIZE];
+        int err;
+
+        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
+                pr_debug("Couldn't read a build-id in %s\n", filename);
+                return -1;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__add_s(sbuild_id, debugdir, filename, false);
+        if (verbose)
+                pr_info("Adding %s %s: %s\n", sbuild_id, filename,
+                        err ? "FAIL" : "Ok");
+        return err;
+}
+
+static int build_id_cache__remove_file(const char *filename __used,
+                                       const char *debugdir __used)
+{
+        u8 build_id[BUILD_ID_SIZE];
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        int err;
+
+        if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
+                pr_debug("Couldn't read a build-id in %s\n", filename);
+                return -1;
+        }
+
+        build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
+        err = build_id_cache__remove_s(sbuild_id, debugdir);
+        if (verbose)
+                pr_info("Removing %s %s: %s\n", sbuild_id, filename,
+                        err ? "FAIL" : "Ok");
+
+        return err;
+}
+
+static int __cmd_buildid_cache(void)
+{
+        struct strlist *list;
+        struct str_node *pos;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
+
+        if (add_name_list_str) {
+                list = strlist__new(true, add_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__add_file(pos->s, debugdir)) {
+                                        if (errno == EEXIST) {
+                                                pr_debug("%s already in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't add %s: %s\n",
+                                                   pos->s, strerror(errno));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        if (remove_name_list_str) {
+                list = strlist__new(true, remove_name_list_str);
+                if (list) {
+                        strlist__for_each(pos, list)
+                                if (build_id_cache__remove_file(pos->s, debugdir)) {
+                                        if (errno == ENOENT) {
+                                                pr_debug("%s wasn't in the cache\n",
+                                                         pos->s);
+                                                continue;
+                                        }
+                                        pr_warning("Couldn't remove %s: %s\n",
+                                                   pos->s, strerror(errno));
+                                }
+
+                        strlist__delete(list);
+                }
+        }
+
+        return 0;
+}
+
+int cmd_buildid_cache(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, buildid_cache_options,
+                             buildid_cache_usage, 0);
+
+        if (symbol__init() < 0)
+                return -1;
+
+        setup_pager();
+        return __cmd_buildid_cache();
+}
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 1e99ac806913..44a47e13bd67 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -8,6 +8,7 @@
  */
 #include "builtin.h"
 #include "perf.h"
+#include "util/build-id.h"
 #include "util/cache.h"
 #include "util/debug.h"
 #include "util/parse-options.h"
@@ -15,7 +16,8 @@
 #include "util/symbol.h"
 
 static char const *input_name = "perf.data";
-static int force;
+static bool force;
+static bool with_hits;
 
 static const char * const buildid_list_usage[] = {
         "perf buildid-list [<options>]",
@@ -23,47 +25,28 @@ static const char * const buildid_list_usage[] = {
 };
 
 static const struct option options[] = {
+        OPT_BOOLEAN('H', "with-hits", &with_hits, "Show only DSOs with hits"),
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose"),
         OPT_END()
 };
 
-static int perf_file_section__process_buildids(struct perf_file_section *self,
-                                               int feat, int fd)
-{
-        if (feat != HEADER_BUILD_ID)
-                return 0;
-
-        if (lseek(fd, self->offset, SEEK_SET) < 0) {
-                pr_warning("Failed to lseek to %Ld offset for buildids!\n",
-                           self->offset);
-                return -1;
-        }
-
-        if (perf_header__read_build_ids(fd, self->offset, self->size)) {
-                pr_warning("Failed to read buildids!\n");
-                return -1;
-        }
-
-        return 0;
-}
-
 static int __cmd_buildid_list(void)
 {
         int err = -1;
         struct perf_session *session;
 
-        session = perf_session__new(input_name, O_RDONLY, force);
+        session = perf_session__new(input_name, O_RDONLY, force, false);
         if (session == NULL)
                 return -1;
 
-        err = perf_header__process_sections(&session->header, session->fd,
-                                         perf_file_section__process_buildids);
-        if (err >= 0)
-                dsos__fprintf_buildid(stdout);
+        if (with_hits)
+                perf_session__process_events(session, &build_id__mark_dso_hit_ops);
+
+        perf_session__fprintf_dsos_buildid(session, stdout, with_hits);
 
         perf_session__delete(session);
         return err;
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index bd71b8ceafb7..fca1d4402910 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -19,22 +19,15 @@
 static char const *input_old = "perf.data.old",
                   *input_new = "perf.data";
 static char       diff__default_sort_order[] = "dso,symbol";
-static int  force;
+static bool  force;
 static bool show_displacement;
 
-static int perf_session__add_hist_entry(struct perf_session *self,
-                                        struct addr_location *al, u64 count)
+static int hists__add_entry(struct hists *self,
+                            struct addr_location *al, u64 period)
 {
-        bool hit;
-        struct hist_entry *he = __perf_session__add_hist_entry(self, al, NULL,
-                                                               count, &hit);
-        if (he == NULL)
-                return -ENOMEM;
-
-        if (hit)
-                he->count += count;
-
-        return 0;
+        if (__hists__add_entry(self, al, NULL, period) != NULL)
+                return 0;
+        return -ENOMEM;
 }
 
 static int diff__process_sample_event(event_t *event, struct perf_session *session)
@@ -42,36 +35,31 @@ static int diff__process_sample_event(event_t *event, struct perf_session *sessi
         struct addr_location al;
         struct sample_data data = { .period = 1, };
 
-        dump_printf("(IP, %d): %d: %p\n", event->header.misc,
-                    event->ip.pid, (void *)(long)event->ip.ip);
-
-        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+        if (event__preprocess_sample(event, session, &al, &data, NULL) < 0) {
                 pr_warning("problem processing %d event, skipping it.\n",
                            event->header.type);
                 return -1;
         }
 
-        if (al.filtered)
+        if (al.filtered || al.sym == NULL)
                 return 0;
 
-        event__parse_sample(event, session->sample_type, &data);
-
-        if (al.sym && perf_session__add_hist_entry(session, &al, data.period)) {
-                pr_warning("problem incrementing symbol count, skipping event\n");
+        if (hists__add_entry(&session->hists, &al, data.period)) {
+                pr_warning("problem incrementing symbol period, skipping event\n");
                 return -1;
         }
 
-        session->events_stats.total += data.period;
+        session->hists.stats.total_period += data.period;
         return 0;
 }
 
 static struct perf_event_ops event_ops = {
-        .process_sample_event = diff__process_sample_event,
-        .process_mmap_event   = event__process_mmap,
-        .process_comm_event   = event__process_comm,
-        .process_exit_event   = event__process_task,
-        .process_fork_event   = event__process_task,
-        .process_lost_event   = event__process_lost,
+        .sample = diff__process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .exit   = event__process_task,
+        .fork   = event__process_task,
+        .lost   = event__process_lost,
 };
 
 static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
@@ -82,84 +70,69 @@ static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
         struct hist_entry *iter;
 
         while (*p != NULL) {
-                int cmp;
                 parent = *p;
                 iter = rb_entry(parent, struct hist_entry, rb_node);
-
-                cmp = strcmp(he->map->dso->name, iter->map->dso->name);
-                if (cmp > 0)
+                if (hist_entry__cmp(he, iter) < 0)
                         p = &(*p)->rb_left;
-                else if (cmp < 0)
+                else
                         p = &(*p)->rb_right;
-                else {
-                        cmp = strcmp(he->sym->name, iter->sym->name);
-                        if (cmp > 0)
-                                p = &(*p)->rb_left;
-                        else
-                                p = &(*p)->rb_right;
-                }
         }
 
         rb_link_node(&he->rb_node, parent, p);
         rb_insert_color(&he->rb_node, root);
 }
 
-static void perf_session__resort_by_name(struct perf_session *self)
+static void hists__resort_entries(struct hists *self)
 {
         unsigned long position = 1;
         struct rb_root tmp = RB_ROOT;
-        struct rb_node *next = rb_first(&self->hists);
+        struct rb_node *next = rb_first(&self->entries);
 
         while (next != NULL) {
                 struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
 
                 next = rb_next(&n->rb_node);
-                rb_erase(&n->rb_node, &self->hists);
+                rb_erase(&n->rb_node, &self->entries);
                 n->position = position++;
                 perf_session__insert_hist_entry_by_name(&tmp, n);
         }
 
-        self->hists = tmp;
+        self->entries = tmp;
+}
+
+static void hists__set_positions(struct hists *self)
+{
+        hists__output_resort(self);
+        hists__resort_entries(self);
 }
 
-static struct hist_entry *
-perf_session__find_hist_entry_by_name(struct perf_session *self,
-                                      struct hist_entry *he)
+static struct hist_entry *hists__find_entry(struct hists *self,
+                                            struct hist_entry *he)
 {
-        struct rb_node *n = self->hists.rb_node;
+        struct rb_node *n = self->entries.rb_node;
 
         while (n) {
                 struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
-                int cmp = strcmp(he->map->dso->name, iter->map->dso->name);
+                int64_t cmp = hist_entry__cmp(he, iter);
 
-                if (cmp > 0)
+                if (cmp < 0)
                         n = n->rb_left;
-                else if (cmp < 0)
+                else if (cmp > 0)
                         n = n->rb_right;
-                else {
-                        cmp = strcmp(he->sym->name, iter->sym->name);
-                        if (cmp > 0)
-                                n = n->rb_left;
-                        else if (cmp < 0)
-                                n = n->rb_right;
-                        else
-                                return iter;
-                }
+                else 
+                        return iter;
         }
 
         return NULL;
 }
 
-static void perf_session__match_hists(struct perf_session *old_session,
-                                      struct perf_session *new_session)
+static void hists__match(struct hists *older, struct hists *newer)
 {
         struct rb_node *nd;
 
-        perf_session__resort_by_name(old_session);
-
-        for (nd = rb_first(&new_session->hists); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
-                pos->pair = perf_session__find_hist_entry_by_name(old_session, pos);
+                pos->pair = hists__find_entry(older, pos);
         }
 }
 
@@ -168,8 +141,8 @@ static int __cmd_diff(void)
         int ret, i;
         struct perf_session *session[2];
 
-        session[0] = perf_session__new(input_old, O_RDONLY, force);
-        session[1] = perf_session__new(input_new, O_RDONLY, force);
+        session[0] = perf_session__new(input_old, O_RDONLY, force, false);
+        session[1] = perf_session__new(input_new, O_RDONLY, force, false);
         if (session[0] == NULL || session[1] == NULL)
                 return -ENOMEM;
 
@@ -177,12 +150,15 @@ static int __cmd_diff(void)
                 ret = perf_session__process_events(session[i], &event_ops);
                 if (ret)
                         goto out_delete;
-                perf_session__output_resort(session[i], session[i]->events_stats.total);
         }
 
-        perf_session__match_hists(session[0], session[1]);
-        perf_session__fprintf_hists(session[1], session[0],
-                                    show_displacement, stdout);
+        hists__output_resort(&session[1]->hists);
+        if (show_displacement)
+                hists__set_positions(&session[0]->hists);
+
+        hists__match(&session[0]->hists, &session[1]->hists);
+        hists__fprintf(&session[1]->hists, &session[0]->hists,
+                       show_displacement, stdout);
 out_delete:
         for (i = 0; i < 2; ++i)
                 perf_session__delete(session[i]);
@@ -195,7 +171,7 @@ static const char * const diff_usage[] = {
 };
 
 static const struct option options[] = {
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('m', "displacement", &show_displacement,
                     "Show position displacement relative to baseline"),
@@ -204,8 +180,6 @@ static const struct option options[] = {
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
         OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
                     "load module symbols - WARNING: use only with -k and LIVE kernel"),
-        OPT_BOOLEAN('P', "full-paths", &event_ops.full_paths,
-                    "Don't shorten the pathnames taking into account the cwd"),
         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                    "only consider symbols in these dsos"),
         OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
@@ -232,6 +206,10 @@ int cmd_diff(int argc, const char **argv, const char *prefix __used)
                         input_new = argv[1];
                 } else
                         input_new = argv[0];
+        } else if (symbol_conf.default_guest_vmlinux_name ||
+                   symbol_conf.default_guest_kallsyms) {
+                input_old = "perf.data.host";
+                input_new = "perf.data.guest";
         }
 
         symbol_conf.exclude_other = false;
diff --git a/tools/perf/builtin-help.c b/tools/perf/builtin-help.c
index 9f810b17c25c..6d5a8a7faf48 100644
--- a/tools/perf/builtin-help.c
+++ b/tools/perf/builtin-help.c
@@ -29,14 +29,14 @@ enum help_format {
         HELP_FORMAT_WEB,
 };
 
-static int show_all = 0;
+static bool show_all = false;
 static enum help_format help_format = HELP_FORMAT_MAN;
 static struct option builtin_help_options[] = {
         OPT_BOOLEAN('a', "all", &show_all, "print all available commands"),
-        OPT_SET_INT('m', "man", &help_format, "show man page", HELP_FORMAT_MAN),
-        OPT_SET_INT('w', "web", &help_format, "show manual in web browser",
+        OPT_SET_UINT('m', "man", &help_format, "show man page", HELP_FORMAT_MAN),
+        OPT_SET_UINT('w', "web", &help_format, "show manual in web browser",
                         HELP_FORMAT_WEB),
-        OPT_SET_INT('i', "info", &help_format, "show info page",
+        OPT_SET_UINT('i', "info", &help_format, "show info page",
                         HELP_FORMAT_INFO),
         OPT_END(),
 };
@@ -286,8 +286,7 @@ void list_common_cmds_help(void)
 
         puts(" The most commonly used perf commands are:");
         for (i = 0; i < ARRAY_SIZE(common_cmds); i++) {
-                printf("   %s   ", common_cmds[i].name);
-                mput_char(' ', longest - strlen(common_cmds[i].name));
+                printf("   %-*s   ", longest, common_cmds[i].name);
                 puts(common_cmds[i].help);
         }
 }
@@ -314,8 +313,6 @@ static const char *cmd_to_page(const char *perf_cmd)
                 return "perf";
         else if (!prefixcmp(perf_cmd, "perf"))
                 return perf_cmd;
-        else if (is_perf_command(perf_cmd))
-                return prepend("perf-", perf_cmd);
         else
                 return prepend("perf-", perf_cmd);
 }
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
new file mode 100644
index 000000000000..8e3e47b064ce
--- /dev/null
+++ b/tools/perf/builtin-inject.c
@@ -0,0 +1,228 @@
+/*
+ * builtin-inject.c
+ *
+ * Builtin inject command: Examine the live mode (stdin) event stream
+ * and repipe it to stdout while optionally injecting additional
+ * events into it.
+ */
+#include "builtin.h"
+
+#include "perf.h"
+#include "util/session.h"
+#include "util/debug.h"
+
+#include "util/parse-options.h"
+
+static char             const *input_name = "-";
+static bool             inject_build_ids;
+
+static int event__repipe(event_t *event __used,
+                         struct perf_session *session __used)
+{
+        uint32_t size;
+        void *buf = event;
+
+        size = event->header.size;
+
+        while (size) {
+                int ret = write(STDOUT_FILENO, buf, size);
+                if (ret < 0)
+                        return -errno;
+
+                size -= ret;
+                buf += ret;
+        }
+
+        return 0;
+}
+
+static int event__repipe_mmap(event_t *self, struct perf_session *session)
+{
+        int err;
+
+        err = event__process_mmap(self, session);
+        event__repipe(self, session);
+
+        return err;
+}
+
+static int event__repipe_task(event_t *self, struct perf_session *session)
+{
+        int err;
+
+        err = event__process_task(self, session);
+        event__repipe(self, session);
+
+        return err;
+}
+
+static int event__repipe_tracing_data(event_t *self,
+                                      struct perf_session *session)
+{
+        int err;
+
+        event__repipe(self, session);
+        err = event__process_tracing_data(self, session);
+
+        return err;
+}
+
+static int dso__read_build_id(struct dso *self)
+{
+        if (self->has_build_id)
+                return 0;
+
+        if (filename__read_build_id(self->long_name, self->build_id,
+                                    sizeof(self->build_id)) > 0) {
+                self->has_build_id = true;
+                return 0;
+        }
+
+        return -1;
+}
+
+static int dso__inject_build_id(struct dso *self, struct perf_session *session)
+{
+        u16 misc = PERF_RECORD_MISC_USER;
+        struct machine *machine;
+        int err;
+
+        if (dso__read_build_id(self) < 0) {
+                pr_debug("no build_id found for %s\n", self->long_name);
+                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 = event__synthesize_build_id(self, misc, event__repipe,
+                                         machine, session);
+        if (err) {
+                pr_err("Can't synthesize build_id event for %s\n", self->long_name);
+                return -1;
+        }
+
+        return 0;
+}
+
+static int event__inject_buildid(event_t *event, struct perf_session *session)
+{
+        struct addr_location al;
+        struct thread *thread;
+        u8 cpumode;
+
+        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        thread = perf_session__findnew(session, 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);
+
+        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);
+                                /*
+                                 * If this fails, too bad, let the other side
+                                 * account this as unresolved.
+                                 */
+                        } else
+                                pr_warning("no symbols found in %s, maybe "
+                                           "install a debug package?\n",
+                                           al.map->dso->long_name);
+                }
+        }
+
+repipe:
+        event__repipe(event, session);
+        return 0;
+}
+
+struct perf_event_ops inject_ops = {
+        .sample         = event__repipe,
+        .mmap           = event__repipe,
+        .comm           = event__repipe,
+        .fork           = event__repipe,
+        .exit           = event__repipe,
+        .lost           = event__repipe,
+        .read           = event__repipe,
+        .throttle       = event__repipe,
+        .unthrottle     = event__repipe,
+        .attr           = event__repipe,
+        .event_type     = event__repipe,
+        .tracing_data   = event__repipe,
+        .build_id       = event__repipe,
+};
+
+extern volatile int session_done;
+
+static void sig_handler(int sig __attribute__((__unused__)))
+{
+        session_done = 1;
+}
+
+static int __cmd_inject(void)
+{
+        struct perf_session *session;
+        int ret = -EINVAL;
+
+        signal(SIGINT, sig_handler);
+
+        if (inject_build_ids) {
+                inject_ops.sample       = event__inject_buildid;
+                inject_ops.mmap         = event__repipe_mmap;
+                inject_ops.fork         = event__repipe_task;
+                inject_ops.tracing_data = event__repipe_tracing_data;
+        }
+
+        session = perf_session__new(input_name, O_RDONLY, false, true);
+        if (session == NULL)
+                return -ENOMEM;
+
+        ret = perf_session__process_events(session, &inject_ops);
+
+        perf_session__delete(session);
+
+        return ret;
+}
+
+static const char * const report_usage[] = {
+        "perf inject [<options>]",
+        NULL
+};
+
+static const struct option options[] = {
+        OPT_BOOLEAN('b', "build-ids", &inject_build_ids,
+                    "Inject build-ids into the output stream"),
+        OPT_INCR('v', "verbose", &verbose,
+                 "be more verbose (show build ids, etc)"),
+        OPT_END()
+};
+
+int cmd_inject(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, options, report_usage, 0);
+
+        /*
+         * Any (unrecognized) arguments left?
+         */
+        if (argc)
+                usage_with_options(report_usage, options);
+
+        if (symbol__init() < 0)
+                return -1;
+
+        return __cmd_inject();
+}
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 93c67bf53d2c..31f60a2535e0 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -92,23 +92,18 @@ static void setup_cpunode_map(void)
         if (!dir1)
                 return;
 
-        while (true) {
-                dent1 = readdir(dir1);
-                if (!dent1)
-                        break;
-
-                if (sscanf(dent1->d_name, "node%u", &mem) < 1)
+        while ((dent1 = readdir(dir1)) != NULL) {
+                if (dent1->d_type != DT_DIR ||
+                    sscanf(dent1->d_name, "node%u", &mem) < 1)
                         continue;
 
                 snprintf(buf, PATH_MAX, "%s/%s", PATH_SYS_NODE, dent1->d_name);
                 dir2 = opendir(buf);
                 if (!dir2)
                         continue;
-                while (true) {
-                        dent2 = readdir(dir2);
-                        if (!dent2)
-                                break;
-                        if (sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
+                while ((dent2 = readdir(dir2)) != NULL) {
+                        if (dent2->d_type != DT_LNK ||
+                            sscanf(dent2->d_name, "cpu%u", &cpu) < 1)
                                 continue;
                         cpunode_map[cpu] = mem;
                 }
@@ -321,11 +316,8 @@ static int process_sample_event(event_t *event, struct perf_session *session)
 
         event__parse_sample(event, session->sample_type, &data);
 
-        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
-                event->header.misc,
-                data.pid, data.tid,
-                (void *)(long)data.ip,
-                (long long)data.period);
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
 
         thread = perf_session__findnew(session, event->ip.pid);
         if (thread == NULL) {
@@ -342,22 +334,10 @@ static int process_sample_event(event_t *event, struct perf_session *session)
         return 0;
 }
 
-static int sample_type_check(struct perf_session *session)
-{
-        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
-                fprintf(stderr,
-                        "No trace sample to read. Did you call perf record "
-                        "without -R?");
-                return -1;
-        }
-
-        return 0;
-}
-
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_comm_event     = event__process_comm,
-        .sample_type_check      = sample_type_check,
+        .sample                 = process_sample_event,
+        .comm                   = event__process_comm,
+        .ordered_samples        = true,
 };
 
 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
@@ -372,6 +352,7 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
                            int n_lines, int is_caller)
 {
         struct rb_node *next;
+        struct machine *machine;
 
         printf("%.102s\n", graph_dotted_line);
         printf(" %-34s |",  is_caller ? "Callsite": "Alloc Ptr");
@@ -380,23 +361,29 @@ static void __print_result(struct rb_root *root, struct perf_session *session,
 
         next = rb_first(root);
 
+        machine = perf_session__find_host_machine(session);
+        if (!machine) {
+                pr_err("__print_result: couldn't find kernel information\n");
+                return;
+        }
         while (next && n_lines--) {
                 struct alloc_stat *data = rb_entry(next, struct alloc_stat,
                                                    node);
                 struct symbol *sym = NULL;
+                struct map *map;
                 char buf[BUFSIZ];
                 u64 addr;
 
                 if (is_caller) {
                         addr = data->call_site;
                         if (!raw_ip)
-                                sym = map_groups__find_function(&session->kmaps, session, addr, NULL);
+                                sym = machine__find_kernel_function(machine, addr, &map, NULL);
                 } else
                         addr = data->ptr;
 
                 if (sym != NULL)
                         snprintf(buf, sizeof(buf), "%s+%Lx", sym->name,
-                                 addr - sym->start);
+                                 addr - map->unmap_ip(map, sym->start));
                 else
                         snprintf(buf, sizeof(buf), "%#Lx", addr);
                 printf(" %-34s |", buf);
@@ -504,11 +491,17 @@ static void sort_result(void)
 
 static int __cmd_kmem(void)
 {
-        int err;
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        int err = -EINVAL;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0, false);
         if (session == NULL)
                 return -ENOMEM;
 
+        if (perf_session__create_kernel_maps(session) < 0)
+                goto out_delete;
+
+        if (!perf_session__has_traces(session, "kmem record"))
+                goto out_delete;
+
         setup_pager();
         err = perf_session__process_events(session, &event_ops);
         if (err != 0)
@@ -736,7 +729,6 @@ static const char *record_args[] = {
         "record",
         "-a",
         "-R",
-        "-M",
         "-f",
         "-c", "1",
         "-e", "kmem:kmalloc",
diff --git a/tools/perf/builtin-kvm.c b/tools/perf/builtin-kvm.c
new file mode 100644
index 000000000000..34d1e853829d
--- /dev/null
+++ b/tools/perf/builtin-kvm.c
@@ -0,0 +1,144 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+#include "util/session.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+
+#include "util/debug.h"
+
+#include <sys/prctl.h>
+
+#include <semaphore.h>
+#include <pthread.h>
+#include <math.h>
+
+static const char               *file_name;
+static char                     name_buffer[256];
+
+bool                            perf_host = 1;
+bool                            perf_guest;
+
+static const char * const kvm_usage[] = {
+        "perf kvm [<options>] {top|record|report|diff|buildid-list}",
+        NULL
+};
+
+static const struct option kvm_options[] = {
+        OPT_STRING('i', "input", &file_name, "file",
+                   "Input file name"),
+        OPT_STRING('o', "output", &file_name, "file",
+                   "Output file name"),
+        OPT_BOOLEAN(0, "guest", &perf_guest,
+                    "Collect guest os data"),
+        OPT_BOOLEAN(0, "host", &perf_host,
+                    "Collect guest os data"),
+        OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
+                   "guest mount directory under which every guest os"
+                   " instance has a subdir"),
+        OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
+                   "file", "file saving guest os vmlinux"),
+        OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
+                   "file", "file saving guest os /proc/kallsyms"),
+        OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
+                   "file", "file saving guest os /proc/modules"),
+        OPT_END()
+};
+
+static int __cmd_record(int argc, const char **argv)
+{
+        int rec_argc, i = 0, j;
+        const char **rec_argv;
+
+        rec_argc = argc + 2;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+        rec_argv[i++] = strdup("record");
+        rec_argv[i++] = strdup("-o");
+        rec_argv[i++] = strdup(file_name);
+        for (j = 1; j < argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        BUG_ON(i != rec_argc);
+
+        return cmd_record(i, rec_argv, NULL);
+}
+
+static int __cmd_report(int argc, const char **argv)
+{
+        int rec_argc, i = 0, j;
+        const char **rec_argv;
+
+        rec_argc = argc + 2;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+        rec_argv[i++] = strdup("report");
+        rec_argv[i++] = strdup("-i");
+        rec_argv[i++] = strdup(file_name);
+        for (j = 1; j < argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        BUG_ON(i != rec_argc);
+
+        return cmd_report(i, rec_argv, NULL);
+}
+
+static int __cmd_buildid_list(int argc, const char **argv)
+{
+        int rec_argc, i = 0, j;
+        const char **rec_argv;
+
+        rec_argc = argc + 2;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+        rec_argv[i++] = strdup("buildid-list");
+        rec_argv[i++] = strdup("-i");
+        rec_argv[i++] = strdup(file_name);
+        for (j = 1; j < argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        BUG_ON(i != rec_argc);
+
+        return cmd_buildid_list(i, rec_argv, NULL);
+}
+
+int cmd_kvm(int argc, const char **argv, const char *prefix __used)
+{
+        perf_host = perf_guest = 0;
+
+        argc = parse_options(argc, argv, kvm_options, kvm_usage,
+                        PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc)
+                usage_with_options(kvm_usage, kvm_options);
+
+        if (!perf_host)
+                perf_guest = 1;
+
+        if (!file_name) {
+                if (perf_host && !perf_guest)
+                        sprintf(name_buffer, "perf.data.host");
+                else if (!perf_host && perf_guest)
+                        sprintf(name_buffer, "perf.data.guest");
+                else
+                        sprintf(name_buffer, "perf.data.kvm");
+                file_name = name_buffer;
+        }
+
+        if (!strncmp(argv[0], "rec", 3))
+                return __cmd_record(argc, argv);
+        else if (!strncmp(argv[0], "rep", 3))
+                return __cmd_report(argc, argv);
+        else if (!strncmp(argv[0], "diff", 4))
+                return cmd_diff(argc, argv, NULL);
+        else if (!strncmp(argv[0], "top", 3))
+                return cmd_top(argc, argv, NULL);
+        else if (!strncmp(argv[0], "buildid-list", 12))
+                return __cmd_buildid_list(argc, argv);
+        else
+                usage_with_options(kvm_usage, kvm_options);
+
+        return 0;
+}
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
new file mode 100644
index 000000000000..821c1586a22b
--- /dev/null
+++ b/tools/perf/builtin-lock.c
@@ -0,0 +1,1005 @@
+#include "builtin.h"
+#include "perf.h"
+
+#include "util/util.h"
+#include "util/cache.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+#include "util/header.h"
+
+#include "util/parse-options.h"
+#include "util/trace-event.h"
+
+#include "util/debug.h"
+#include "util/session.h"
+
+#include <sys/types.h>
+#include <sys/prctl.h>
+#include <semaphore.h>
+#include <pthread.h>
+#include <math.h>
+#include <limits.h>
+
+#include <linux/list.h>
+#include <linux/hash.h>
+
+static struct perf_session *session;
+
+/* based on kernel/lockdep.c */
+#define LOCKHASH_BITS           12
+#define LOCKHASH_SIZE           (1UL << LOCKHASH_BITS)
+
+static struct list_head lockhash_table[LOCKHASH_SIZE];
+
+#define __lockhashfn(key)       hash_long((unsigned long)key, LOCKHASH_BITS)
+#define lockhashentry(key)      (lockhash_table + __lockhashfn((key)))
+
+struct lock_stat {
+        struct list_head        hash_entry;
+        struct rb_node          rb;             /* used for sorting */
+
+        /*
+         * FIXME: raw_field_value() returns unsigned long long,
+         * so address of lockdep_map should be dealed as 64bit.
+         * Is there more better solution?
+         */
+        void                    *addr;          /* address of lockdep_map, used as ID */
+        char                    *name;          /* for strcpy(), we cannot use const */
+
+        unsigned int            nr_acquire;
+        unsigned int            nr_acquired;
+        unsigned int            nr_contended;
+        unsigned int            nr_release;
+
+        unsigned int            nr_readlock;
+        unsigned int            nr_trylock;
+        /* these times are in nano sec. */
+        u64                     wait_time_total;
+        u64                     wait_time_min;
+        u64                     wait_time_max;
+
+        int                     discard; /* flag of blacklist */
+};
+
+/*
+ * States of lock_seq_stat
+ *
+ * UNINITIALIZED is required for detecting first event of acquire.
+ * As the nature of lock events, there is no guarantee
+ * that the first event for the locks are acquire,
+ * it can be acquired, contended or release.
+ */
+#define SEQ_STATE_UNINITIALIZED      0         /* initial state */
+#define SEQ_STATE_RELEASED      1
+#define SEQ_STATE_ACQUIRING     2
+#define SEQ_STATE_ACQUIRED      3
+#define SEQ_STATE_READ_ACQUIRED 4
+#define SEQ_STATE_CONTENDED     5
+
+/*
+ * MAX_LOCK_DEPTH
+ * Imported from include/linux/sched.h.
+ * Should this be synchronized?
+ */
+#define MAX_LOCK_DEPTH 48
+
+/*
+ * struct lock_seq_stat:
+ * Place to put on state of one lock sequence
+ * 1) acquire -> acquired -> release
+ * 2) acquire -> contended -> acquired -> release
+ * 3) acquire (with read or try) -> release
+ * 4) Are there other patterns?
+ */
+struct lock_seq_stat {
+        struct list_head        list;
+        int                     state;
+        u64                     prev_event_time;
+        void                    *addr;
+
+        int                     read_count;
+};
+
+struct thread_stat {
+        struct rb_node          rb;
+
+        u32                     tid;
+        struct list_head        seq_list;
+};
+
+static struct rb_root           thread_stats;
+
+static struct thread_stat *thread_stat_find(u32 tid)
+{
+        struct rb_node *node;
+        struct thread_stat *st;
+
+        node = thread_stats.rb_node;
+        while (node) {
+                st = container_of(node, struct thread_stat, rb);
+                if (st->tid == tid)
+                        return st;
+                else if (tid < st->tid)
+                        node = node->rb_left;
+                else
+                        node = node->rb_right;
+        }
+
+        return NULL;
+}
+
+static void thread_stat_insert(struct thread_stat *new)
+{
+        struct rb_node **rb = &thread_stats.rb_node;
+        struct rb_node *parent = NULL;
+        struct thread_stat *p;
+
+        while (*rb) {
+                p = container_of(*rb, struct thread_stat, rb);
+                parent = *rb;
+
+                if (new->tid < p->tid)
+                        rb = &(*rb)->rb_left;
+                else if (new->tid > p->tid)
+                        rb = &(*rb)->rb_right;
+                else
+                        BUG_ON("inserting invalid thread_stat\n");
+        }
+
+        rb_link_node(&new->rb, parent, rb);
+        rb_insert_color(&new->rb, &thread_stats);
+}
+
+static struct thread_stat *thread_stat_findnew_after_first(u32 tid)
+{
+        struct thread_stat *st;
+
+        st = thread_stat_find(tid);
+        if (st)
+                return st;
+
+        st = zalloc(sizeof(struct thread_stat));
+        if (!st)
+                die("memory allocation failed\n");
+
+        st->tid = tid;
+        INIT_LIST_HEAD(&st->seq_list);
+
+        thread_stat_insert(st);
+
+        return st;
+}
+
+static struct thread_stat *thread_stat_findnew_first(u32 tid);
+static struct thread_stat *(*thread_stat_findnew)(u32 tid) =
+        thread_stat_findnew_first;
+
+static struct thread_stat *thread_stat_findnew_first(u32 tid)
+{
+        struct thread_stat *st;
+
+        st = zalloc(sizeof(struct thread_stat));
+        if (!st)
+                die("memory allocation failed\n");
+        st->tid = tid;
+        INIT_LIST_HEAD(&st->seq_list);
+
+        rb_link_node(&st->rb, NULL, &thread_stats.rb_node);
+        rb_insert_color(&st->rb, &thread_stats);
+
+        thread_stat_findnew = thread_stat_findnew_after_first;
+        return st;
+}
+
+/* build simple key function one is bigger than two */
+#define SINGLE_KEY(member)                                              \
+        static int lock_stat_key_ ## member(struct lock_stat *one,      \
+                                         struct lock_stat *two)         \
+        {                                                               \
+                return one->member > two->member;                       \
+        }
+
+SINGLE_KEY(nr_acquired)
+SINGLE_KEY(nr_contended)
+SINGLE_KEY(wait_time_total)
+SINGLE_KEY(wait_time_min)
+SINGLE_KEY(wait_time_max)
+
+struct lock_key {
+        /*
+         * name: the value for specify by user
+         * this should be simpler than raw name of member
+         * e.g. nr_acquired -> acquired, wait_time_total -> wait_total
+         */
+        const char              *name;
+        int                     (*key)(struct lock_stat*, struct lock_stat*);
+};
+
+static const char               *sort_key = "acquired";
+
+static int                      (*compare)(struct lock_stat *, struct lock_stat *);
+
+static struct rb_root           result; /* place to store sorted data */
+
+#define DEF_KEY_LOCK(name, fn_suffix)   \
+        { #name, lock_stat_key_ ## fn_suffix }
+struct lock_key keys[] = {
+        DEF_KEY_LOCK(acquired, nr_acquired),
+        DEF_KEY_LOCK(contended, nr_contended),
+        DEF_KEY_LOCK(wait_total, wait_time_total),
+        DEF_KEY_LOCK(wait_min, wait_time_min),
+        DEF_KEY_LOCK(wait_max, wait_time_max),
+
+        /* extra comparisons much complicated should be here */
+
+        { NULL, NULL }
+};
+
+static void select_key(void)
+{
+        int i;
+
+        for (i = 0; keys[i].name; i++) {
+                if (!strcmp(keys[i].name, sort_key)) {
+                        compare = keys[i].key;
+                        return;
+                }
+        }
+
+        die("Unknown compare key:%s\n", sort_key);
+}
+
+static void insert_to_result(struct lock_stat *st,
+                             int (*bigger)(struct lock_stat *, struct lock_stat *))
+{
+        struct rb_node **rb = &result.rb_node;
+        struct rb_node *parent = NULL;
+        struct lock_stat *p;
+
+        while (*rb) {
+                p = container_of(*rb, struct lock_stat, rb);
+                parent = *rb;
+
+                if (bigger(st, p))
+                        rb = &(*rb)->rb_left;
+                else
+                        rb = &(*rb)->rb_right;
+        }
+
+        rb_link_node(&st->rb, parent, rb);
+        rb_insert_color(&st->rb, &result);
+}
+
+/* returns left most element of result, and erase it */
+static struct lock_stat *pop_from_result(void)
+{
+        struct rb_node *node = result.rb_node;
+
+        if (!node)
+                return NULL;
+
+        while (node->rb_left)
+                node = node->rb_left;
+
+        rb_erase(node, &result);
+        return container_of(node, struct lock_stat, rb);
+}
+
+static struct lock_stat *lock_stat_findnew(void *addr, const char *name)
+{
+        struct list_head *entry = lockhashentry(addr);
+        struct lock_stat *ret, *new;
+
+        list_for_each_entry(ret, entry, hash_entry) {
+                if (ret->addr == addr)
+                        return ret;
+        }
+
+        new = zalloc(sizeof(struct lock_stat));
+        if (!new)
+                goto alloc_failed;
+
+        new->addr = addr;
+        new->name = zalloc(sizeof(char) * strlen(name) + 1);
+        if (!new->name)
+                goto alloc_failed;
+        strcpy(new->name, name);
+
+        new->wait_time_min = ULLONG_MAX;
+
+        list_add(&new->hash_entry, entry);
+        return new;
+
+alloc_failed:
+        die("memory allocation failed\n");
+}
+
+static char                     const *input_name = "perf.data";
+
+struct raw_event_sample {
+        u32                     size;
+        char                    data[0];
+};
+
+struct trace_acquire_event {
+        void                    *addr;
+        const char              *name;
+        int                     flag;
+};
+
+struct trace_acquired_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_contended_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_release_event {
+        void                    *addr;
+        const char              *name;
+};
+
+struct trace_lock_handler {
+        void (*acquire_event)(struct trace_acquire_event *,
+                              struct event *,
+                              int cpu,
+                              u64 timestamp,
+                              struct thread *thread);
+
+        void (*acquired_event)(struct trace_acquired_event *,
+                               struct event *,
+                               int cpu,
+                               u64 timestamp,
+                               struct thread *thread);
+
+        void (*contended_event)(struct trace_contended_event *,
+                                struct event *,
+                                int cpu,
+                                u64 timestamp,
+                                struct thread *thread);
+
+        void (*release_event)(struct trace_release_event *,
+                              struct event *,
+                              int cpu,
+                              u64 timestamp,
+                              struct thread *thread);
+};
+
+static struct lock_seq_stat *get_seq(struct thread_stat *ts, void *addr)
+{
+        struct lock_seq_stat *seq;
+
+        list_for_each_entry(seq, &ts->seq_list, list) {
+                if (seq->addr == addr)
+                        return seq;
+        }
+
+        seq = zalloc(sizeof(struct lock_seq_stat));
+        if (!seq)
+                die("Not enough memory\n");
+        seq->state = SEQ_STATE_UNINITIALIZED;
+        seq->addr = addr;
+
+        list_add(&seq->list, &ts->seq_list);
+        return seq;
+}
+
+enum broken_state {
+        BROKEN_ACQUIRE,
+        BROKEN_ACQUIRED,
+        BROKEN_CONTENDED,
+        BROKEN_RELEASE,
+        BROKEN_MAX,
+};
+
+static int bad_hist[BROKEN_MAX];
+
+enum acquire_flags {
+        TRY_LOCK = 1,
+        READ_LOCK = 2,
+};
+
+static void
+report_lock_acquire_event(struct trace_acquire_event *acquire_event,
+                        struct event *__event __used,
+                        int cpu __used,
+                        u64 timestamp __used,
+                        struct thread *thread __used)
+{
+        struct lock_stat *ls;
+        struct thread_stat *ts;
+        struct lock_seq_stat *seq;
+
+        ls = lock_stat_findnew(acquire_event->addr, acquire_event->name);
+        if (ls->discard)
+                return;
+
+        ts = thread_stat_findnew(thread->pid);
+        seq = get_seq(ts, acquire_event->addr);
+
+        switch (seq->state) {
+        case SEQ_STATE_UNINITIALIZED:
+        case SEQ_STATE_RELEASED:
+                if (!acquire_event->flag) {
+                        seq->state = SEQ_STATE_ACQUIRING;
+                } else {
+                        if (acquire_event->flag & TRY_LOCK)
+                                ls->nr_trylock++;
+                        if (acquire_event->flag & READ_LOCK)
+                                ls->nr_readlock++;
+                        seq->state = SEQ_STATE_READ_ACQUIRED;
+                        seq->read_count = 1;
+                        ls->nr_acquired++;
+                }
+                break;
+        case SEQ_STATE_READ_ACQUIRED:
+                if (acquire_event->flag & READ_LOCK) {
+                        seq->read_count++;
+                        ls->nr_acquired++;
+                        goto end;
+                } else {
+                        goto broken;
+                }
+                break;
+        case SEQ_STATE_ACQUIRED:
+        case SEQ_STATE_ACQUIRING:
+        case SEQ_STATE_CONTENDED:
+broken:
+                /* broken lock sequence, discard it */
+                ls->discard = 1;
+                bad_hist[BROKEN_ACQUIRE]++;
+                list_del(&seq->list);
+                free(seq);
+                goto end;
+                break;
+        default:
+                BUG_ON("Unknown state of lock sequence found!\n");
+                break;
+        }
+
+        ls->nr_acquire++;
+        seq->prev_event_time = timestamp;
+end:
+        return;
+}
+
+static void
+report_lock_acquired_event(struct trace_acquired_event *acquired_event,
+                         struct event *__event __used,
+                         int cpu __used,
+                         u64 timestamp __used,
+                         struct thread *thread __used)
+{
+        struct lock_stat *ls;
+        struct thread_stat *ts;
+        struct lock_seq_stat *seq;
+        u64 contended_term;
+
+        ls = lock_stat_findnew(acquired_event->addr, acquired_event->name);
+        if (ls->discard)
+                return;
+
+        ts = thread_stat_findnew(thread->pid);
+        seq = get_seq(ts, acquired_event->addr);
+
+        switch (seq->state) {
+        case SEQ_STATE_UNINITIALIZED:
+                /* orphan event, do nothing */
+                return;
+        case SEQ_STATE_ACQUIRING:
+                break;
+        case SEQ_STATE_CONTENDED:
+                contended_term = timestamp - seq->prev_event_time;
+                ls->wait_time_total += contended_term;
+                if (contended_term < ls->wait_time_min)
+                        ls->wait_time_min = contended_term;
+                if (ls->wait_time_max < contended_term)
+                        ls->wait_time_max = contended_term;
+                break;
+        case SEQ_STATE_RELEASED:
+        case SEQ_STATE_ACQUIRED:
+        case SEQ_STATE_READ_ACQUIRED:
+                /* broken lock sequence, discard it */
+                ls->discard = 1;
+                bad_hist[BROKEN_ACQUIRED]++;
+                list_del(&seq->list);
+                free(seq);
+                goto end;
+                break;
+
+        default:
+                BUG_ON("Unknown state of lock sequence found!\n");
+                break;
+        }
+
+        seq->state = SEQ_STATE_ACQUIRED;
+        ls->nr_acquired++;
+        seq->prev_event_time = timestamp;
+end:
+        return;
+}
+
+static void
+report_lock_contended_event(struct trace_contended_event *contended_event,
+                          struct event *__event __used,
+                          int cpu __used,
+                          u64 timestamp __used,
+                          struct thread *thread __used)
+{
+        struct lock_stat *ls;
+        struct thread_stat *ts;
+        struct lock_seq_stat *seq;
+
+        ls = lock_stat_findnew(contended_event->addr, contended_event->name);
+        if (ls->discard)
+                return;
+
+        ts = thread_stat_findnew(thread->pid);
+        seq = get_seq(ts, contended_event->addr);
+
+        switch (seq->state) {
+        case SEQ_STATE_UNINITIALIZED:
+                /* orphan event, do nothing */
+                return;
+        case SEQ_STATE_ACQUIRING:
+                break;
+        case SEQ_STATE_RELEASED:
+        case SEQ_STATE_ACQUIRED:
+        case SEQ_STATE_READ_ACQUIRED:
+        case SEQ_STATE_CONTENDED:
+                /* broken lock sequence, discard it */
+                ls->discard = 1;
+                bad_hist[BROKEN_CONTENDED]++;
+                list_del(&seq->list);
+                free(seq);
+                goto end;
+                break;
+        default:
+                BUG_ON("Unknown state of lock sequence found!\n");
+                break;
+        }
+
+        seq->state = SEQ_STATE_CONTENDED;
+        ls->nr_contended++;
+        seq->prev_event_time = timestamp;
+end:
+        return;
+}
+
+static void
+report_lock_release_event(struct trace_release_event *release_event,
+                        struct event *__event __used,
+                        int cpu __used,
+                        u64 timestamp __used,
+                        struct thread *thread __used)
+{
+        struct lock_stat *ls;
+        struct thread_stat *ts;
+        struct lock_seq_stat *seq;
+
+        ls = lock_stat_findnew(release_event->addr, release_event->name);
+        if (ls->discard)
+                return;
+
+        ts = thread_stat_findnew(thread->pid);
+        seq = get_seq(ts, release_event->addr);
+
+        switch (seq->state) {
+        case SEQ_STATE_UNINITIALIZED:
+                goto end;
+                break;
+        case SEQ_STATE_ACQUIRED:
+                break;
+        case SEQ_STATE_READ_ACQUIRED:
+                seq->read_count--;
+                BUG_ON(seq->read_count < 0);
+                if (!seq->read_count) {
+                        ls->nr_release++;
+                        goto end;
+                }
+                break;
+        case SEQ_STATE_ACQUIRING:
+        case SEQ_STATE_CONTENDED:
+        case SEQ_STATE_RELEASED:
+                /* broken lock sequence, discard it */
+                ls->discard = 1;
+                bad_hist[BROKEN_RELEASE]++;
+                goto free_seq;
+                break;
+        default:
+                BUG_ON("Unknown state of lock sequence found!\n");
+                break;
+        }
+
+        ls->nr_release++;
+free_seq:
+        list_del(&seq->list);
+        free(seq);
+end:
+        return;
+}
+
+/* lock oriented handlers */
+/* TODO: handlers for CPU oriented, thread oriented */
+static struct trace_lock_handler report_lock_ops  = {
+        .acquire_event          = report_lock_acquire_event,
+        .acquired_event         = report_lock_acquired_event,
+        .contended_event        = report_lock_contended_event,
+        .release_event          = report_lock_release_event,
+};
+
+static struct trace_lock_handler *trace_handler;
+
+static void
+process_lock_acquire_event(void *data,
+                           struct event *event __used,
+                           int cpu __used,
+                           u64 timestamp __used,
+                           struct thread *thread __used)
+{
+        struct trace_acquire_event acquire_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&acquire_event.addr, &tmp, sizeof(void *));
+        acquire_event.name = (char *)raw_field_ptr(event, "name", data);
+        acquire_event.flag = (int)raw_field_value(event, "flag", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->acquire_event(&acquire_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_acquired_event(void *data,
+                            struct event *event __used,
+                            int cpu __used,
+                            u64 timestamp __used,
+                            struct thread *thread __used)
+{
+        struct trace_acquired_event acquired_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&acquired_event.addr, &tmp, sizeof(void *));
+        acquired_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->acquired_event(&acquired_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_contended_event(void *data,
+                             struct event *event __used,
+                             int cpu __used,
+                             u64 timestamp __used,
+                             struct thread *thread __used)
+{
+        struct trace_contended_event contended_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&contended_event.addr, &tmp, sizeof(void *));
+        contended_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->contended_event(&contended_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_lock_release_event(void *data,
+                           struct event *event __used,
+                           int cpu __used,
+                           u64 timestamp __used,
+                           struct thread *thread __used)
+{
+        struct trace_release_event release_event;
+        u64 tmp;                /* this is required for casting... */
+
+        tmp = raw_field_value(event, "lockdep_addr", data);
+        memcpy(&release_event.addr, &tmp, sizeof(void *));
+        release_event.name = (char *)raw_field_ptr(event, "name", data);
+
+        if (trace_handler->acquire_event)
+                trace_handler->release_event(&release_event, event, cpu, timestamp, thread);
+}
+
+static void
+process_raw_event(void *data, int cpu, u64 timestamp, struct thread *thread)
+{
+        struct event *event;
+        int type;
+
+        type = trace_parse_common_type(data);
+        event = trace_find_event(type);
+
+        if (!strcmp(event->name, "lock_acquire"))
+                process_lock_acquire_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_acquired"))
+                process_lock_acquired_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_contended"))
+                process_lock_contended_event(data, event, cpu, timestamp, thread);
+        if (!strcmp(event->name, "lock_release"))
+                process_lock_release_event(data, event, cpu, timestamp, thread);
+}
+
+static void print_bad_events(int bad, int total)
+{
+        /* Output for debug, this have to be removed */
+        int i;
+        const char *name[4] =
+                { "acquire", "acquired", "contended", "release" };
+
+        pr_info("\n=== output for debug===\n\n");
+        pr_info("bad: %d, total: %d\n", bad, total);
+        pr_info("bad rate: %f %%\n", (double)bad / (double)total * 100);
+        pr_info("histogram of events caused bad sequence\n");
+        for (i = 0; i < BROKEN_MAX; i++)
+                pr_info(" %10s: %d\n", name[i], bad_hist[i]);
+}
+
+/* TODO: various way to print, coloring, nano or milli sec */
+static void print_result(void)
+{
+        struct lock_stat *st;
+        char cut_name[20];
+        int bad, total;
+
+        pr_info("%20s ", "Name");
+        pr_info("%10s ", "acquired");
+        pr_info("%10s ", "contended");
+
+        pr_info("%15s ", "total wait (ns)");
+        pr_info("%15s ", "max wait (ns)");
+        pr_info("%15s ", "min wait (ns)");
+
+        pr_info("\n\n");
+
+        bad = total = 0;
+        while ((st = pop_from_result())) {
+                total++;
+                if (st->discard) {
+                        bad++;
+                        continue;
+                }
+                bzero(cut_name, 20);
+
+                if (strlen(st->name) < 16) {
+                        /* output raw name */
+                        pr_info("%20s ", st->name);
+                } else {
+                        strncpy(cut_name, st->name, 16);
+                        cut_name[16] = '.';
+                        cut_name[17] = '.';
+                        cut_name[18] = '.';
+                        cut_name[19] = '\0';
+                        /* cut off name for saving output style */
+                        pr_info("%20s ", cut_name);
+                }
+
+                pr_info("%10u ", st->nr_acquired);
+                pr_info("%10u ", st->nr_contended);
+
+                pr_info("%15llu ", st->wait_time_total);
+                pr_info("%15llu ", st->wait_time_max);
+                pr_info("%15llu ", st->wait_time_min == ULLONG_MAX ?
+                       0 : st->wait_time_min);
+                pr_info("\n");
+        }
+
+        print_bad_events(bad, total);
+}
+
+static bool info_threads, info_map;
+
+static void dump_threads(void)
+{
+        struct thread_stat *st;
+        struct rb_node *node;
+        struct thread *t;
+
+        pr_info("%10s: comm\n", "Thread ID");
+
+        node = rb_first(&thread_stats);
+        while (node) {
+                st = container_of(node, struct thread_stat, rb);
+                t = perf_session__findnew(session, st->tid);
+                pr_info("%10d: %s\n", st->tid, t->comm);
+                node = rb_next(node);
+        };
+}
+
+static void dump_map(void)
+{
+        unsigned int i;
+        struct lock_stat *st;
+
+        pr_info("Address of instance: name of class\n");
+        for (i = 0; i < LOCKHASH_SIZE; i++) {
+                list_for_each_entry(st, &lockhash_table[i], hash_entry) {
+                        pr_info(" %p: %s\n", st->addr, st->name);
+                }
+        }
+}
+
+static void dump_info(void)
+{
+        if (info_threads)
+                dump_threads();
+        else if (info_map)
+                dump_map();
+        else
+                die("Unknown type of information\n");
+}
+
+static int process_sample_event(event_t *self, struct perf_session *s)
+{
+        struct sample_data data;
+        struct thread *thread;
+
+        bzero(&data, sizeof(data));
+        event__parse_sample(self, s->sample_type, &data);
+
+        thread = perf_session__findnew(s, data.tid);
+        if (thread == NULL) {
+                pr_debug("problem processing %d event, skipping it.\n",
+                        self->header.type);
+                return -1;
+        }
+
+        process_raw_event(data.raw_data, data.cpu, data.time, thread);
+
+        return 0;
+}
+
+static struct perf_event_ops eops = {
+        .sample                 = process_sample_event,
+        .comm                   = event__process_comm,
+        .ordered_samples        = true,
+};
+
+static int read_events(void)
+{
+        session = perf_session__new(input_name, O_RDONLY, 0, false);
+        if (!session)
+                die("Initializing perf session failed\n");
+
+        return perf_session__process_events(session, &eops);
+}
+
+static void sort_result(void)
+{
+        unsigned int i;
+        struct lock_stat *st;
+
+        for (i = 0; i < LOCKHASH_SIZE; i++) {
+                list_for_each_entry(st, &lockhash_table[i], hash_entry) {
+                        insert_to_result(st, compare);
+                }
+        }
+}
+
+static void __cmd_report(void)
+{
+        setup_pager();
+        select_key();
+        read_events();
+        sort_result();
+        print_result();
+}
+
+static const char * const report_usage[] = {
+        "perf lock report [<options>]",
+        NULL
+};
+
+static const struct option report_options[] = {
+        OPT_STRING('k', "key", &sort_key, "acquired",
+                    "key for sorting"),
+        /* TODO: type */
+        OPT_END()
+};
+
+static const char * const info_usage[] = {
+        "perf lock info [<options>]",
+        NULL
+};
+
+static const struct option info_options[] = {
+        OPT_BOOLEAN('t', "threads", &info_threads,
+                    "dump thread list in perf.data"),
+        OPT_BOOLEAN('m', "map", &info_map,
+                    "map of lock instances (name:address table)"),
+        OPT_END()
+};
+
+static const char * const lock_usage[] = {
+        "perf lock [<options>] {record|trace|report}",
+        NULL
+};
+
+static const struct option lock_options[] = {
+        OPT_STRING('i', "input", &input_name, "file", "input file name"),
+        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_END()
+};
+
+static const char *record_args[] = {
+        "record",
+        "-R",
+        "-f",
+        "-m", "1024",
+        "-c", "1",
+        "-e", "lock:lock_acquire:r",
+        "-e", "lock:lock_acquired:r",
+        "-e", "lock:lock_contended:r",
+        "-e", "lock:lock_release:r",
+};
+
+static int __cmd_record(int argc, const char **argv)
+{
+        unsigned int rec_argc, i, j;
+        const char **rec_argv;
+
+        rec_argc = ARRAY_SIZE(record_args) + argc - 1;
+        rec_argv = calloc(rec_argc + 1, sizeof(char *));
+
+        for (i = 0; i < ARRAY_SIZE(record_args); i++)
+                rec_argv[i] = strdup(record_args[i]);
+
+        for (j = 1; j < (unsigned int)argc; j++, i++)
+                rec_argv[i] = argv[j];
+
+        BUG_ON(i != rec_argc);
+
+        return cmd_record(i, rec_argv, NULL);
+}
+
+int cmd_lock(int argc, const char **argv, const char *prefix __used)
+{
+        unsigned int i;
+
+        symbol__init();
+        for (i = 0; i < LOCKHASH_SIZE; i++)
+                INIT_LIST_HEAD(lockhash_table + i);
+
+        argc = parse_options(argc, argv, lock_options, lock_usage,
+                             PARSE_OPT_STOP_AT_NON_OPTION);
+        if (!argc)
+                usage_with_options(lock_usage, lock_options);
+
+        if (!strncmp(argv[0], "rec", 3)) {
+                return __cmd_record(argc, argv);
+        } else if (!strncmp(argv[0], "report", 6)) {
+                trace_handler = &report_lock_ops;
+                if (argc) {
+                        argc = parse_options(argc, argv,
+                                             report_options, report_usage, 0);
+                        if (argc)
+                                usage_with_options(report_usage, report_options);
+                }
+                __cmd_report();
+        } else if (!strcmp(argv[0], "trace")) {
+                /* Aliased to 'perf trace' */
+                return cmd_trace(argc, argv, prefix);
+        } else if (!strcmp(argv[0], "info")) {
+                if (argc) {
+                        argc = parse_options(argc, argv,
+                                             info_options, info_usage, 0);
+                        if (argc)
+                                usage_with_options(info_usage, info_options);
+                }
+                /* recycling report_lock_ops */
+                trace_handler = &report_lock_ops;
+                setup_pager();
+                read_events();
+                dump_info();
+        } else {
+                usage_with_options(lock_usage, lock_options);
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index c1e6774fd3ed..199d5e19554f 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -36,51 +36,50 @@
 #include "builtin.h"
 #include "util/util.h"
 #include "util/strlist.h"
-#include "util/event.h"
+#include "util/symbol.h"
 #include "util/debug.h"
 #include "util/debugfs.h"
-#include "util/symbol.h"
-#include "util/thread.h"
-#include "util/session.h"
 #include "util/parse-options.h"
-#include "util/parse-events.h"  /* For debugfs_path */
 #include "util/probe-finder.h"
 #include "util/probe-event.h"
 
 #define MAX_PATH_LEN 256
-#define MAX_PROBES 128
 
 /* Session management structure */
 static struct {
-        bool need_dwarf;
         bool list_events;
         bool force_add;
-        int nr_probe;
-        struct probe_point probes[MAX_PROBES];
+        bool show_lines;
+        int nevents;
+        struct perf_probe_event events[MAX_PROBES];
         struct strlist *dellist;
-        struct perf_session *psession;
-        struct map *kmap;
-} session;
+        struct line_range line_range;
+        int max_probe_points;
+} params;
 
 
 /* Parse an event definition. Note that any error must die. */
-static void parse_probe_event(const char *str)
+static int parse_probe_event(const char *str)
 {
-        struct probe_point *pp = &session.probes[session.nr_probe];
+        struct perf_probe_event *pev = &params.events[params.nevents];
+        int ret;
 
-        pr_debug("probe-definition(%d): %s\n", session.nr_probe, str);
-        if (++session.nr_probe == MAX_PROBES)
-                die("Too many probes (> %d) are specified.", MAX_PROBES);
+        pr_debug("probe-definition(%d): %s\n", params.nevents, str);
+        if (++params.nevents == MAX_PROBES) {
+                pr_err("Too many probes (> %d) were specified.", MAX_PROBES);
+                return -1;
+        }
 
-        /* Parse perf-probe event into probe_point */
-        parse_perf_probe_event(str, pp, &session.need_dwarf);
+        /* Parse a perf-probe command into event */
+        ret = parse_perf_probe_command(str, pev);
+        pr_debug("%d arguments\n", pev->nargs);
 
-        pr_debug("%d arguments\n", pp->nr_args);
+        return ret;
 }
 
-static void parse_probe_event_argv(int argc, const char **argv)
+static int parse_probe_event_argv(int argc, const char **argv)
 {
-        int i, len;
+        int i, len, ret;
         char *buf;
 
         /* Bind up rest arguments */
@@ -88,54 +87,48 @@ static void parse_probe_event_argv(int argc, const char **argv)
         for (i = 0; i < argc; i++)
                 len += strlen(argv[i]) + 1;
         buf = zalloc(len + 1);
-        if (!buf)
-                die("Failed to allocate memory for binding arguments.");
+        if (buf == NULL)
+                return -ENOMEM;
         len = 0;
         for (i = 0; i < argc; i++)
                 len += sprintf(&buf[len], "%s ", argv[i]);
-        parse_probe_event(buf);
+        ret = parse_probe_event(buf);
         free(buf);
+        return ret;
 }
 
 static int opt_add_probe_event(const struct option *opt __used,
                               const char *str, int unset __used)
 {
         if (str)
-                parse_probe_event(str);
-        return 0;
+                return parse_probe_event(str);
+        else
+                return 0;
 }
 
 static int opt_del_probe_event(const struct option *opt __used,
                                const char *str, int unset __used)
 {
         if (str) {
-                if (!session.dellist)
-                        session.dellist = strlist__new(true, NULL);
-                strlist__add(session.dellist, str);
+                if (!params.dellist)
+                        params.dellist = strlist__new(true, NULL);
+                strlist__add(params.dellist, str);
         }
         return 0;
 }
 
-/* Currently just checking function name from symbol map */
-static void evaluate_probe_point(struct probe_point *pp)
+#ifdef DWARF_SUPPORT
+static int opt_show_lines(const struct option *opt __used,
+                          const char *str, int unset __used)
 {
-        struct symbol *sym;
-        sym = map__find_symbol_by_name(session.kmap, pp->function,
-                                       session.psession, NULL);
-        if (!sym)
-                die("Kernel symbol \'%s\' not found - probe not added.",
-                    pp->function);
-}
+        int ret = 0;
 
-#ifndef NO_LIBDWARF
-static int open_vmlinux(void)
-{
-        if (map__load(session.kmap, session.psession, NULL) < 0) {
-                pr_debug("Failed to load kernel map.\n");
-                return -EINVAL;
-        }
-        pr_debug("Try to open %s\n", session.kmap->dso->long_name);
-        return open(session.kmap->dso->long_name, O_RDONLY);
+        if (str)
+                ret = parse_line_range_desc(str, &params.line_range);
+        INIT_LIST_HEAD(&params.line_range.line_list);
+        params.show_lines = true;
+
+        return ret;
 }
 #endif
 
@@ -144,54 +137,63 @@ static const char * const probe_usage[] = {
         "perf probe [<options>] --add 'PROBEDEF' [--add 'PROBEDEF' ...]",
         "perf probe [<options>] --del '[GROUP:]EVENT' ...",
         "perf probe --list",
+#ifdef DWARF_SUPPORT
+        "perf probe --line 'LINEDESC'",
+#endif
         NULL
 };
 
 static const struct option options[] = {
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show parsed arguments, etc)"),
-#ifndef NO_LIBDWARF
-        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
-                   "file", "vmlinux pathname"),
-#endif
-        OPT_BOOLEAN('l', "list", &session.list_events,
+        OPT_BOOLEAN('l', "list", &params.list_events,
                     "list up current probe events"),
         OPT_CALLBACK('d', "del", NULL, "[GROUP:]EVENT", "delete a probe event.",
                 opt_del_probe_event),
         OPT_CALLBACK('a', "add", NULL,
-#ifdef NO_LIBDWARF
-                "[EVENT=]FUNC[+OFFS|%return] [ARG ...]",
+#ifdef DWARF_SUPPORT
+                "[EVENT=]FUNC[@SRC][+OFF|%return|:RL|;PT]|SRC:AL|SRC;PT"
+                " [[NAME=]ARG ...]",
 #else
-                "[EVENT=]FUNC[+OFFS|%return|:RLN][@SRC]|SRC:ALN [ARG ...]",
+                "[EVENT=]FUNC[+OFF|%return] [[NAME=]ARG ...]",
 #endif
                 "probe point definition, where\n"
                 "\t\tGROUP:\tGroup name (optional)\n"
                 "\t\tEVENT:\tEvent name\n"
                 "\t\tFUNC:\tFunction name\n"
-                "\t\tOFFS:\tOffset from function entry (in byte)\n"
+                "\t\tOFF:\tOffset from function entry (in byte)\n"
                 "\t\t%return:\tPut the probe at function return\n"
-#ifdef NO_LIBDWARF
-                "\t\tARG:\tProbe argument (only \n"
-#else
+#ifdef DWARF_SUPPORT
                 "\t\tSRC:\tSource code path\n"
-                "\t\tRLN:\tRelative line number from function entry.\n"
-                "\t\tALN:\tAbsolute line number in file.\n"
+                "\t\tRL:\tRelative line number from function entry.\n"
+                "\t\tAL:\tAbsolute line number in file.\n"
+                "\t\tPT:\tLazy expression of line code.\n"
                 "\t\tARG:\tProbe argument (local variable name or\n"
-#endif
                 "\t\t\tkprobe-tracer argument format.)\n",
+#else
+                "\t\tARG:\tProbe argument (kprobe-tracer argument format.)\n",
+#endif
                 opt_add_probe_event),
-        OPT_BOOLEAN('f', "force", &session.force_add, "forcibly add events"
+        OPT_BOOLEAN('f', "force", &params.force_add, "forcibly add events"
                     " with existing name"),
+#ifdef DWARF_SUPPORT
+        OPT_CALLBACK('L', "line", NULL,
+                     "FUNC[:RLN[+NUM|-RLN2]]|SRC:ALN[+NUM|-ALN2]",
+                     "Show source code lines.", opt_show_lines),
+        OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
+                   "file", "vmlinux pathname"),
+        OPT_STRING('s', "source", &symbol_conf.source_prefix,
+                   "directory", "path to kernel source"),
+#endif
+        OPT__DRY_RUN(&probe_event_dry_run),
+        OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
+                 "Set how many probe points can be found for a probe."),
         OPT_END()
 };
 
 int cmd_probe(int argc, const char **argv, const char *prefix __used)
 {
-        int i, ret;
-#ifndef NO_LIBDWARF
-        int fd;
-#endif
-        struct probe_point *pp;
+        int ret;
 
         argc = parse_options(argc, argv, options, probe_usage,
                              PARSE_OPT_STOP_AT_NON_OPTION);
@@ -200,110 +202,68 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
                         pr_warning("  Error: '-' is not supported.\n");
                         usage_with_options(probe_usage, options);
                 }
-                parse_probe_event_argv(argc, argv);
+                ret = parse_probe_event_argv(argc, argv);
+                if (ret < 0) {
+                        pr_err("  Error: Parse Error.  (%d)\n", ret);
+                        return ret;
+                }
         }
 
-        if ((!session.nr_probe && !session.dellist && !session.list_events))
-                usage_with_options(probe_usage, options);
+        if (params.max_probe_points == 0)
+                params.max_probe_points = MAX_PROBES;
 
-        if (debugfs_valid_mountpoint(debugfs_path) < 0)
-                die("Failed to find debugfs path.");
+        if ((!params.nevents && !params.dellist && !params.list_events &&
+             !params.show_lines))
+                usage_with_options(probe_usage, options);
 
-        if (session.list_events) {
-                if (session.nr_probe != 0 || session.dellist) {
-                        pr_warning("  Error: Don't use --list with"
-                                   " --add/--del.\n");
+        if (params.list_events) {
+                if (params.nevents != 0 || params.dellist) {
+                        pr_err("  Error: Don't use --list with --add/--del.\n");
                         usage_with_options(probe_usage, options);
                 }
-                show_perf_probe_events();
-                return 0;
-        }
-
-        if (session.dellist) {
-                del_trace_kprobe_events(session.dellist);
-                strlist__delete(session.dellist);
-                if (session.nr_probe == 0)
-                        return 0;
+                if (params.show_lines) {
+                        pr_err("  Error: Don't use --list with --line.\n");
+                        usage_with_options(probe_usage, options);
+                }
+                ret = show_perf_probe_events();
+                if (ret < 0)
+                        pr_err("  Error: Failed to show event list. (%d)\n",
+                               ret);
+                return ret;
         }
 
-        /* Initialize symbol maps for vmlinux */
-        symbol_conf.sort_by_name = true;
-        if (symbol_conf.vmlinux_name == NULL)
-                symbol_conf.try_vmlinux_path = true;
-        if (symbol__init() < 0)
-                die("Failed to init symbol map.");
-        session.psession = perf_session__new(NULL, O_WRONLY, false);
-        if (session.psession == NULL)
-                die("Failed to init perf_session.");
-        session.kmap = map_groups__find_by_name(&session.psession->kmaps,
-                                                MAP__FUNCTION,
-                                                "[kernel.kallsyms]");
-        if (!session.kmap)
-                die("Could not find kernel map.\n");
-
-        if (session.need_dwarf)
-#ifdef NO_LIBDWARF
-                die("Debuginfo-analysis is not supported");
-#else   /* !NO_LIBDWARF */
-                pr_debug("Some probes require debuginfo.\n");
-
-        fd = open_vmlinux();
-        if (fd < 0) {
-                if (session.need_dwarf)
-                        die("Could not open debuginfo file.");
+#ifdef DWARF_SUPPORT
+        if (params.show_lines) {
+                if (params.nevents != 0 || params.dellist) {
+                        pr_warning("  Error: Don't use --line with"
+                                   " --add/--del.\n");
+                        usage_with_options(probe_usage, options);
+                }
 
-                pr_debug("Could not open vmlinux/module file."
-                         " Try to use symbols.\n");
-                goto end_dwarf;
+                ret = show_line_range(&params.line_range);
+                if (ret < 0)
+                        pr_err("  Error: Failed to show lines. (%d)\n", ret);
+                return ret;
         }
+#endif
 
-        /* Searching probe points */
-        for (i = 0; i < session.nr_probe; i++) {
-                pp = &session.probes[i];
-                if (pp->found)
-                        continue;
-
-                lseek(fd, SEEK_SET, 0);
-                ret = find_probepoint(fd, pp);
-                if (ret > 0)
-                        continue;
-                if (ret == 0) { /* No error but failed to find probe point. */
-                        synthesize_perf_probe_point(pp);
-                        die("Probe point '%s' not found. - probe not added.",
-                            pp->probes[0]);
-                }
-                /* Error path */
-                if (session.need_dwarf) {
-                        if (ret == -ENOENT)
-                                pr_warning("No dwarf info found in the vmlinux - please rebuild with CONFIG_DEBUG_INFO=y.\n");
-                        die("Could not analyze debuginfo.");
+        if (params.dellist) {
+                ret = del_perf_probe_events(params.dellist);
+                strlist__delete(params.dellist);
+                if (ret < 0) {
+                        pr_err("  Error: Failed to delete events. (%d)\n", ret);
+                        return ret;
                 }
-                pr_debug("An error occurred in debuginfo analysis."
-                         " Try to use symbols.\n");
-                break;
         }
-        close(fd);
 
-end_dwarf:
-#endif /* !NO_LIBDWARF */
-
-        /* Synthesize probes without dwarf */
-        for (i = 0; i < session.nr_probe; i++) {
-                pp = &session.probes[i];
-                if (pp->found)  /* This probe is already found. */
-                        continue;
-
-                evaluate_probe_point(pp);
-                ret = synthesize_trace_kprobe_event(pp);
-                if (ret == -E2BIG)
-                        die("probe point definition becomes too long.");
-                else if (ret < 0)
-                        die("Failed to synthesize a probe point.");
+        if (params.nevents) {
+                ret = add_perf_probe_events(params.events, params.nevents,
+                                            params.force_add,
+                                            params.max_probe_points);
+                if (ret < 0) {
+                        pr_err("  Error: Failed to add events. (%d)\n", ret);
+                        return ret;
+                }
         }
-
-        /* Settng up probe points */
-        add_trace_kprobe_events(session.probes, session.nr_probe,
-                                session.force_add);
         return 0;
 }
-
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 265425322734..ff77b805de71 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -5,65 +5,76 @@
  * (or a CPU, or a PID) into the perf.data output file - for
  * later analysis via perf report.
  */
+#define _FILE_OFFSET_BITS 64
+
 #include "builtin.h"
 
 #include "perf.h"
 
+#include "util/build-id.h"
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
-#include "util/string.h"
 
 #include "util/header.h"
 #include "util/event.h"
 #include "util/debug.h"
 #include "util/session.h"
 #include "util/symbol.h"
+#include "util/cpumap.h"
 
 #include <unistd.h>
 #include <sched.h>
+#include <sys/mman.h>
+
+enum write_mode_t {
+        WRITE_FORCE,
+        WRITE_APPEND
+};
 
-static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
 
-static long                     default_interval                =      0;
+static u64                      user_interval                   = ULLONG_MAX;
+static u64                      default_interval                =      0;
 
 static int                      nr_cpus                         =      0;
 static unsigned int             page_size;
 static unsigned int             mmap_pages                      =    128;
+static unsigned int             user_freq                       = UINT_MAX;
 static int                      freq                            =   1000;
 static int                      output;
+static int                      pipe_output                     =      0;
 static const char               *output_name                    = "perf.data";
 static int                      group                           =      0;
-static unsigned int             realtime_prio                   =      0;
-static int                      raw_samples                     =      0;
-static int                      system_wide                     =      0;
-static int                      profile_cpu                     =     -1;
+static int                      realtime_prio                   =      0;
+static bool                     raw_samples                     =  false;
+static bool                     system_wide                     =  false;
 static pid_t                    target_pid                      =     -1;
+static pid_t                    target_tid                      =     -1;
+static pid_t                    *all_tids                       =      NULL;
+static int                      thread_num                      =      0;
 static pid_t                    child_pid                       =     -1;
-static int                      inherit                         =      1;
-static int                      force                           =      0;
-static int                      append_file                     =      0;
-static int                      call_graph                      =      0;
-static int                      inherit_stat                    =      0;
-static int                      no_samples                      =      0;
-static int                      sample_address                  =      0;
-static int                      multiplex                       =      0;
-static int                      multiplex_fd                    =     -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                     no_buildid                      =  false;
 
 static long                     samples                         =      0;
-static struct timeval           last_read;
-static struct timeval           this_read;
-
 static u64                      bytes_written                   =      0;
 
-static struct pollfd            event_array[MAX_NR_CPUS * MAX_COUNTERS];
+static struct pollfd            *event_array;
 
 static int                      nr_poll                         =      0;
 static int                      nr_cpu                          =      0;
 
 static int                      file_new                        =      1;
+static off_t                    post_processing_offset;
 
 static struct perf_session      *session;
+static const char               *cpu_list;
 
 struct mmap_data {
         int                     counter;
@@ -72,7 +83,7 @@ struct mmap_data {
         unsigned int            prev;
 };
 
-static struct mmap_data         mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
+static struct mmap_data         mmap_array[MAX_NR_CPUS];
 
 static unsigned long mmap_read_head(struct mmap_data *md)
 {
@@ -96,6 +107,11 @@ static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
         pc->data_tail = tail;
 }
 
+static void advance_output(size_t size)
+{
+        bytes_written += size;
+}
+
 static void write_output(void *buf, size_t size)
 {
         while (size) {
@@ -111,22 +127,10 @@ static void write_output(void *buf, size_t size)
         }
 }
 
-static void write_event(event_t *buf, size_t size)
-{
-        /*
-        * Add it to the list of DSOs, so that when we finish this
-         * record session we can pick the available build-ids.
-         */
-        if (buf->header.type == PERF_RECORD_MMAP)
-                dsos__findnew(buf->mmap.filename);
-
-        write_output(buf, size);
-}
-
 static int process_synthesized_event(event_t *event,
                                      struct perf_session *self __used)
 {
-        write_event(event, event->header.size);
+        write_output(event, event->header.size);
         return 0;
 }
 
@@ -139,8 +143,6 @@ static void mmap_read(struct mmap_data *md)
         void *buf;
         int diff;
 
-        gettimeofday(&this_read, NULL);
-
         /*
          * If we're further behind than half the buffer, there's a chance
          * the writer will bite our tail and mess up the samples under us.
@@ -151,23 +153,13 @@ static void mmap_read(struct mmap_data *md)
          */
         diff = head - old;
         if (diff < 0) {
-                struct timeval iv;
-                unsigned long msecs;
-
-                timersub(&this_read, &last_read, &iv);
-                msecs = iv.tv_sec*1000 + iv.tv_usec/1000;
-
-                fprintf(stderr, "WARNING: failed to keep up with mmap data."
-                                "  Last read %lu msecs ago.\n", msecs);
-
+                fprintf(stderr, "WARNING: failed to keep up with mmap data\n");
                 /*
                  * head points to a known good entry, start there.
                  */
                 old = head;
         }
 
-        last_read = this_read;
-
         if (old != head)
                 samples++;
 
@@ -178,14 +170,14 @@ static void mmap_read(struct mmap_data *md)
                 size = md->mask + 1 - (old & md->mask);
                 old += size;
 
-                write_event(buf, size);
+                write_output(buf, size);
         }
 
         buf = &data[old & md->mask];
         size = head - old;
         old += size;
 
-        write_event(buf, size);
+        write_output(buf, size);
 
         md->prev = old;
         mmap_write_tail(md, old);
@@ -202,7 +194,7 @@ static void sig_handler(int sig)
 
 static void sig_atexit(void)
 {
-        if (child_pid != -1)
+        if (child_pid > 0)
                 kill(child_pid, SIGTERM);
 
         if (signr == -1)
@@ -232,12 +224,13 @@ static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int n
         return h_attr;
 }
 
-static void create_counter(int counter, int cpu, pid_t pid)
+static void create_counter(int counter, int cpu)
 {
         char *filter = filters[counter];
         struct perf_event_attr *attr = attrs + counter;
         struct perf_header_attr *h_attr;
         int track = !counter; /* only the first counter needs these */
+        int thread_index;
         int ret;
         struct {
                 u64 count;
@@ -252,10 +245,22 @@ static void create_counter(int counter, int cpu, pid_t pid)
 
         attr->sample_type       |= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 
-        if (freq) {
-                attr->sample_type       |= PERF_SAMPLE_PERIOD;
-                attr->freq              = 1;
-                attr->sample_freq       = freq;
+        if (nr_counters > 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)
@@ -264,12 +269,17 @@ static void create_counter(int counter, int cpu, pid_t pid)
         if (inherit_stat)
                 attr->inherit_stat = 1;
 
-        if (sample_address)
+        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 (raw_samples) {
                 attr->sample_type       |= PERF_SAMPLE_TIME;
                 attr->sample_type       |= PERF_SAMPLE_RAW;
@@ -278,146 +288,229 @@ static void create_counter(int counter, int cpu, pid_t pid)
 
         attr->mmap              = track;
         attr->comm              = track;
-        attr->inherit           = inherit;
-        attr->disabled          = 1;
+        attr->inherit           = !no_inherit;
+        if (target_pid == -1 && target_tid == -1 && !system_wide) {
+                attr->disabled = 1;
+                attr->enable_on_exec = 1;
+        }
 
+        for (thread_index = 0; thread_index < thread_num; thread_index++) {
 try_again:
-        fd[nr_cpu][counter] = sys_perf_event_open(attr, pid, cpu, group_fd, 0);
-
-        if (fd[nr_cpu][counter] < 0) {
-                int err = errno;
-
-                if (err == EPERM || err == EACCES)
-                        die("Permission error - are you root?\n");
-                else if (err ==  ENODEV && profile_cpu != -1)
-                        die("No such device - did you specify an out-of-range profile CPU?\n");
+                fd[nr_cpu][counter][thread_index] = sys_perf_event_open(attr,
+                                all_tids[thread_index], cpu, group_fd, 0);
+
+                if (fd[nr_cpu][counter][thread_index] < 0) {
+                        int err = errno;
+
+                        if (err == EPERM || err == EACCES)
+                                die("Permission error - are you root?\n"
+                                        "\t Consider tweaking"
+                                        " /proc/sys/kernel/perf_event_paranoid.\n");
+                        else if (err ==  ENODEV && cpu_list) {
+                                die("No such device - did you specify"
+                                        " an out-of-range profile CPU?\n");
+                        }
 
-                /*
-                 * If it's cycles then fall back to hrtimer
-                 * based cpu-clock-tick sw counter, which
-                 * is always available even if no PMU support:
-                 */
-                if (attr->type == PERF_TYPE_HARDWARE
-                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
-
-                        if (verbose)
-                                warning(" ... trying to fall back to cpu-clock-ticks\n");
-                        attr->type = PERF_TYPE_SOFTWARE;
-                        attr->config = PERF_COUNT_SW_CPU_CLOCK;
-                        goto try_again;
-                }
-                printf("\n");
-                error("perfcounter syscall returned with %d (%s)\n",
-                        fd[nr_cpu][counter], strerror(err));
+                        /*
+                         * If it's cycles then fall back to hrtimer
+                         * based cpu-clock-tick sw counter, which
+                         * is always available even if no PMU support:
+                         */
+                        if (attr->type == PERF_TYPE_HARDWARE
+                                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
+
+                                if (verbose)
+                                        warning(" ... trying to fall back to cpu-clock-ticks\n");
+                                attr->type = PERF_TYPE_SOFTWARE;
+                                attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                                goto try_again;
+                        }
+                        printf("\n");
+                        error("perfcounter syscall returned with %d (%s)\n",
+                                        fd[nr_cpu][counter][thread_index], strerror(err));
 
 #if defined(__i386__) || defined(__x86_64__)
-                if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
-                        die("No hardware sampling interrupt available. No APIC? If so then you can boot the kernel with the \"lapic\" boot parameter to force-enable it.\n");
+                        if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
+                                die("No hardware sampling interrupt available."
+                                    " No APIC? If so then you can boot the kernel"
+                                    " with the \"lapic\" boot parameter to"
+                                    " force-enable it.\n");
 #endif
 
-                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
-                exit(-1);
-        }
-
-        h_attr = get_header_attr(attr, counter);
-        if (h_attr == NULL)
-                die("nomem\n");
-
-        if (!file_new) {
-                if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
-                        fprintf(stderr, "incompatible append\n");
+                        die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
                         exit(-1);
                 }
-        }
 
-        if (read(fd[nr_cpu][counter], &read_data, sizeof(read_data)) == -1) {
-                perror("Unable to read perf file descriptor\n");
-                exit(-1);
-        }
+                h_attr = get_header_attr(attr, counter);
+                if (h_attr == NULL)
+                        die("nomem\n");
 
-        if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
-                pr_warning("Not enough memory to add id\n");
-                exit(-1);
-        }
+                if (!file_new) {
+                        if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
+                                fprintf(stderr, "incompatible append\n");
+                                exit(-1);
+                        }
+                }
 
-        assert(fd[nr_cpu][counter] >= 0);
-        fcntl(fd[nr_cpu][counter], F_SETFL, O_NONBLOCK);
+                if (read(fd[nr_cpu][counter][thread_index], &read_data, sizeof(read_data)) == -1) {
+                        perror("Unable to read perf file descriptor\n");
+                        exit(-1);
+                }
 
-        /*
-         * First counter acts as the group leader:
-         */
-        if (group && group_fd == -1)
-                group_fd = fd[nr_cpu][counter];
-        if (multiplex && multiplex_fd == -1)
-                multiplex_fd = fd[nr_cpu][counter];
+                if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
+                        pr_warning("Not enough memory to add id\n");
+                        exit(-1);
+                }
 
-        if (multiplex && fd[nr_cpu][counter] != multiplex_fd) {
+                assert(fd[nr_cpu][counter][thread_index] >= 0);
+                fcntl(fd[nr_cpu][counter][thread_index], F_SETFL, O_NONBLOCK);
 
-                ret = ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_SET_OUTPUT, multiplex_fd);
-                assert(ret != -1);
-        } else {
-                event_array[nr_poll].fd = fd[nr_cpu][counter];
-                event_array[nr_poll].events = POLLIN;
-                nr_poll++;
-
-                mmap_array[nr_cpu][counter].counter = counter;
-                mmap_array[nr_cpu][counter].prev = 0;
-                mmap_array[nr_cpu][counter].mask = mmap_pages*page_size - 1;
-                mmap_array[nr_cpu][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
-                                PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter], 0);
-                if (mmap_array[nr_cpu][counter].base == MAP_FAILED) {
-                        error("failed to mmap with %d (%s)\n", errno, strerror(errno));
-                        exit(-1);
+                /*
+                 * First counter acts as the group leader:
+                 */
+                if (group && group_fd == -1)
+                        group_fd = fd[nr_cpu][counter][thread_index];
+
+                if (counter || thread_index) {
+                        ret = ioctl(fd[nr_cpu][counter][thread_index],
+                                        PERF_EVENT_IOC_SET_OUTPUT,
+                                        fd[nr_cpu][0][0]);
+                        if (ret) {
+                                error("failed to set output: %d (%s)\n", errno,
+                                                strerror(errno));
+                                exit(-1);
+                        }
+                } else {
+                        mmap_array[nr_cpu].counter = counter;
+                        mmap_array[nr_cpu].prev = 0;
+                        mmap_array[nr_cpu].mask = mmap_pages*page_size - 1;
+                        mmap_array[nr_cpu].base = mmap(NULL, (mmap_pages+1)*page_size,
+                                PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter][thread_index], 0);
+                        if (mmap_array[nr_cpu].base == MAP_FAILED) {
+                                error("failed to mmap with %d (%s)\n", errno, strerror(errno));
+                                exit(-1);
+                        }
+
+                        event_array[nr_poll].fd = fd[nr_cpu][counter][thread_index];
+                        event_array[nr_poll].events = POLLIN;
+                        nr_poll++;
                 }
-        }
 
-        if (filter != NULL) {
-                ret = ioctl(fd[nr_cpu][counter],
-                            PERF_EVENT_IOC_SET_FILTER, filter);
-                if (ret) {
-                        error("failed to set filter with %d (%s)\n", errno,
-                              strerror(errno));
-                        exit(-1);
+                if (filter != NULL) {
+                        ret = ioctl(fd[nr_cpu][counter][thread_index],
+                                        PERF_EVENT_IOC_SET_FILTER, filter);
+                        if (ret) {
+                                error("failed to set filter with %d (%s)\n", errno,
+                                                strerror(errno));
+                                exit(-1);
+                        }
                 }
         }
-
-        ioctl(fd[nr_cpu][counter], PERF_EVENT_IOC_ENABLE);
 }
 
-static void open_counters(int cpu, pid_t pid)
+static void open_counters(int cpu)
 {
         int counter;
 
         group_fd = -1;
         for (counter = 0; counter < nr_counters; counter++)
-                create_counter(counter, cpu, pid);
+                create_counter(counter, cpu);
 
         nr_cpu++;
 }
 
+static int process_buildids(void)
+{
+        u64 size = lseek(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,
+                                              size, &build_id__mark_dso_hit_ops);
+}
+
 static void atexit_header(void)
 {
-        session->header.data_size += bytes_written;
+        if (!pipe_output) {
+                session->header.data_size += bytes_written;
+
+                process_buildids();
+                perf_header__write(&session->header, output, true);
+                perf_session__delete(session);
+                symbol__exit();
+        }
+}
+
+static void event__synthesize_guest_os(struct machine *machine, void *data)
+{
+        int err;
+        struct perf_session *psession = data;
+
+        if (machine__is_host(machine))
+                return;
+
+        /*
+         *As for guest kernel when processing subcommand record&report,
+         *we arrange module mmap prior to guest kernel mmap and trigger
+         *a preload dso because default guest module symbols are loaded
+         *from guest kallsyms instead of /lib/modules/XXX/XXX. This
+         *method is used to avoid symbol missing when the first addr is
+         *in module instead of in guest kernel.
+         */
+        err = event__synthesize_modules(process_synthesized_event,
+                                        psession, machine);
+        if (err < 0)
+                pr_err("Couldn't record guest kernel [%d]'s reference"
+                       " relocation symbol.\n", machine->pid);
+
+        /*
+         * We use _stext for guest kernel because guest kernel's /proc/kallsyms
+         * have no _text sometimes.
+         */
+        err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                            psession, machine, "_text");
+        if (err < 0)
+                err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                                    psession, machine, "_stext");
+        if (err < 0)
+                pr_err("Couldn't record guest kernel [%d]'s reference"
+                       " relocation symbol.\n", machine->pid);
+}
+
+static struct perf_event_header finished_round_event = {
+        .size = sizeof(struct perf_event_header),
+        .type = PERF_RECORD_FINISHED_ROUND,
+};
+
+static void mmap_read_all(void)
+{
+        int i;
+
+        for (i = 0; i < nr_cpu; i++) {
+                if (mmap_array[i].base)
+                        mmap_read(&mmap_array[i]);
+        }
 
-        perf_header__write(&session->header, output, true);
+        if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
+                write_output(&finished_round_event, sizeof(finished_round_event));
 }
 
 static int __cmd_record(int argc, const char **argv)
 {
         int i, counter;
         struct stat st;
-        pid_t pid = 0;
         int flags;
         int err;
         unsigned long waking = 0;
         int child_ready_pipe[2], go_pipe[2];
-        const bool forks = target_pid == -1 && argc > 0;
+        const bool forks = argc > 0;
         char buf;
+        struct machine *machine;
 
         page_size = sysconf(_SC_PAGE_SIZE);
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert(nr_cpus >= 0);
 
         atexit(sig_atexit);
         signal(SIGCHLD, sig_handler);
@@ -428,70 +521,66 @@ static int __cmd_record(int argc, const char **argv)
                 exit(-1);
         }
 
-        if (!stat(output_name, &st) && st.st_size) {
-                if (!force) {
-                        if (!append_file) {
-                                pr_err("Error, output file %s exists, use -A "
-                                       "to append or -f to overwrite.\n",
-                                       output_name);
-                                exit(-1);
-                        }
-                } else {
+        if (!strcmp(output_name, "-"))
+                pipe_output = 1;
+        else if (!stat(output_name, &st) && st.st_size) {
+                if (write_mode == WRITE_FORCE) {
                         char oldname[PATH_MAX];
                         snprintf(oldname, sizeof(oldname), "%s.old",
                                  output_name);
                         unlink(oldname);
                         rename(output_name, oldname);
                 }
-        } else {
-                append_file = 0;
+        } else if (write_mode == WRITE_APPEND) {
+                write_mode = WRITE_FORCE;
         }
 
         flags = O_CREAT|O_RDWR;
-        if (append_file)
+        if (write_mode == WRITE_APPEND)
                 file_new = 0;
         else
                 flags |= O_TRUNC;
 
-        output = open(output_name, flags, S_IRUSR|S_IWUSR);
+        if (pipe_output)
+                output = STDOUT_FILENO;
+        else
+                output = open(output_name, flags, S_IRUSR | S_IWUSR);
         if (output < 0) {
                 perror("failed to create output file");
                 exit(-1);
         }
 
-        session = perf_session__new(output_name, O_WRONLY, force);
+        session = perf_session__new(output_name, O_WRONLY,
+                                    write_mode == WRITE_FORCE, false);
         if (session == NULL) {
                 pr_err("Not enough memory for reading perf file header\n");
                 return -1;
         }
 
         if (!file_new) {
-                err = perf_header__read(&session->header, output);
+                err = perf_header__read(session, output);
                 if (err < 0)
-                        return err;
+                        goto out_delete_session;
         }
 
-        if (raw_samples) {
+        if (have_tracepoints(attrs, nr_counters))
                 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
-        } else {
-                for (i = 0; i < nr_counters; i++) {
-                        if (attrs[i].sample_type & PERF_SAMPLE_RAW) {
-                                perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
-                                break;
-                        }
-                }
-        }
 
+        /*
+         * perf_session__delete(session) will be called at atexit_header()
+         */
         atexit(atexit_header);
 
         if (forks) {
-                pid = fork();
-                if (pid < 0) {
+                child_pid = fork();
+                if (child_pid < 0) {
                         perror("failed to fork");
                         exit(-1);
                 }
 
-                if (!pid) {
+                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);
@@ -520,10 +609,8 @@ static int __cmd_record(int argc, const char **argv)
                         exit(-1);
                 }
 
-                child_pid = pid;
-
-                if (!system_wide)
-                        target_pid = pid;
+                if (!system_wide && target_tid == -1 && target_pid == -1)
+                        all_tids[0] = child_pid;
 
                 close(child_ready_pipe[1]);
                 close(go_pipe[0]);
@@ -537,22 +624,95 @@ static int __cmd_record(int argc, const char **argv)
                 close(child_ready_pipe[0]);
         }
 
+        nr_cpus = read_cpu_map(cpu_list);
+        if (nr_cpus < 1) {
+                perror("failed to collect number of CPUs\n");
+                return -1;
+        }
 
-        if ((!system_wide && !inherit) || profile_cpu != -1) {
-                open_counters(profile_cpu, target_pid);
+        if (!system_wide && no_inherit && !cpu_list) {
+                open_counters(-1);
         } else {
                 for (i = 0; i < nr_cpus; i++)
-                        open_counters(i, target_pid);
+                        open_counters(cpumap[i]);
         }
 
-        if (file_new) {
+        if (pipe_output) {
+                err = perf_header__write_pipe(output);
+                if (err < 0)
+                        return err;
+        } else if (file_new) {
                 err = perf_header__write(&session->header, output, false);
                 if (err < 0)
                         return err;
         }
 
-        if (!system_wide && profile_cpu == -1)
-                event__synthesize_thread(pid, process_synthesized_event,
+        post_processing_offset = lseek(output, 0, SEEK_CUR);
+
+        if (pipe_output) {
+                err = event__synthesize_attrs(&session->header,
+                                              process_synthesized_event,
+                                              session);
+                if (err < 0) {
+                        pr_err("Couldn't synthesize attrs.\n");
+                        return err;
+                }
+
+                err = event__synthesize_event_types(process_synthesized_event,
+                                                    session);
+                if (err < 0) {
+                        pr_err("Couldn't synthesize event_types.\n");
+                        return err;
+                }
+
+                if (have_tracepoints(attrs, nr_counters)) {
+                        /*
+                         * FIXME err <= 0 here actually means that
+                         * there were no tracepoints so its not really
+                         * an error, just that we don't need to
+                         * synthesize anything.  We really have to
+                         * return this more properly and also
+                         * propagate errors that now are calling die()
+                         */
+                        err = event__synthesize_tracing_data(output, attrs,
+                                                             nr_counters,
+                                                             process_synthesized_event,
+                                                             session);
+                        if (err <= 0) {
+                                pr_err("Couldn't record tracing data.\n");
+                                return err;
+                        }
+                        advance_output(err);
+                }
+        }
+
+        machine = perf_session__find_host_machine(session);
+        if (!machine) {
+                pr_err("Couldn't find native kernel information.\n");
+                return -1;
+        }
+
+        err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                            session, machine, "_text");
+        if (err < 0)
+                err = event__synthesize_kernel_mmap(process_synthesized_event,
+                                                    session, machine, "_stext");
+        if (err < 0) {
+                pr_err("Couldn't record kernel reference relocation symbol.\n");
+                return err;
+        }
+
+        err = event__synthesize_modules(process_synthesized_event,
+                                        session, machine);
+        if (err < 0) {
+                pr_err("Couldn't record kernel reference relocation symbol.\n");
+                return err;
+        }
+        if (perf_guest)
+                perf_session__process_machines(session, event__synthesize_guest_os);
+
+        if (!system_wide)
+                event__synthesize_thread(target_tid, process_synthesized_event,
                                          session);
         else
                 event__synthesize_threads(process_synthesized_event, session);
@@ -575,13 +735,9 @@ static int __cmd_record(int argc, const char **argv)
 
         for (;;) {
                 int hits = samples;
+                int thread;
 
-                for (i = 0; i < nr_cpu; i++) {
-                        for (counter = 0; counter < nr_counters; counter++) {
-                                if (mmap_array[i][counter].base)
-                                        mmap_read(&mmap_array[i][counter]);
-                        }
-                }
+                mmap_read_all();
 
                 if (hits == samples) {
                         if (done)
@@ -592,8 +748,15 @@ static int __cmd_record(int argc, const char **argv)
 
                 if (done) {
                         for (i = 0; i < nr_cpu; i++) {
-                                for (counter = 0; counter < nr_counters; counter++)
-                                        ioctl(fd[i][counter], PERF_EVENT_IOC_DISABLE);
+                                for (counter = 0;
+                                        counter < nr_counters;
+                                        counter++) {
+                                        for (thread = 0;
+                                                thread < thread_num;
+                                                thread++)
+                                                ioctl(fd[i][counter][thread],
+                                                        PERF_EVENT_IOC_DISABLE);
+                                }
                         }
                 }
         }
@@ -610,6 +773,10 @@ static int __cmd_record(int argc, const char **argv)
                 bytes_written / 24);
 
         return 0;
+
+out_delete_session:
+        perf_session__delete(session);
+        return err;
 }
 
 static const char * const record_usage[] = {
@@ -618,6 +785,8 @@ static const char * const record_usage[] = {
         NULL
 };
 
+static bool force, append_file;
+
 static const struct option options[] = {
         OPT_CALLBACK('e', "event", NULL, "event",
                      "event selector. use 'perf list' to list available events",
@@ -625,7 +794,9 @@ static const struct option options[] = {
         OPT_CALLBACK(0, "filter", NULL, "filter",
                      "event filter", parse_filter),
         OPT_INTEGER('p', "pid", &target_pid,
-                    "record events on existing pid"),
+                    "record events on existing process id"),
+        OPT_INTEGER('t', "tid", &target_tid,
+                    "record events on existing thread id"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
         OPT_BOOLEAN('R', "raw-samples", &raw_samples,
@@ -634,23 +805,20 @@ static const struct option options[] = {
                             "system-wide collection from all CPUs"),
         OPT_BOOLEAN('A', "append", &append_file,
                             "append to the output file to do incremental profiling"),
-        OPT_INTEGER('C', "profile_cpu", &profile_cpu,
-                            "CPU to profile on"),
+        OPT_STRING('C', "cpu", &cpu_list, "cpu",
+                    "list of cpus to monitor"),
         OPT_BOOLEAN('f', "force", &force,
-                        "overwrite existing data file"),
-        OPT_LONG('c', "count", &default_interval,
-                    "event period to sample"),
+                        "overwrite existing data file (deprecated)"),
+        OPT_U64('c', "count", &user_interval, "event period to sample"),
         OPT_STRING('o', "output", &output_name, "file",
                     "output file name"),
-        OPT_BOOLEAN('i', "inherit", &inherit,
-                    "child tasks inherit counters"),
-        OPT_INTEGER('F', "freq", &freq,
-                    "profile at this frequency"),
-        OPT_INTEGER('m', "mmap-pages", &mmap_pages,
-                    "number of mmap data pages"),
+        OPT_BOOLEAN('i', "no-inherit", &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('g', "call-graph", &call_graph,
                     "do call-graph (stack chain/backtrace) recording"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_BOOLEAN('s', "stat", &inherit_stat,
                     "per thread counts"),
@@ -658,21 +826,34 @@ static const struct option options[] = {
                     "Sample addresses"),
         OPT_BOOLEAN('n', "no-samples", &no_samples,
                     "don't sample"),
-        OPT_BOOLEAN('M', "multiplex", &multiplex,
-                    "multiplex counter output in a single channel"),
+        OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid,
+                    "do not update the buildid cache"),
         OPT_END()
 };
 
 int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
-        int counter;
+        int i, j, err = -ENOMEM;
 
         argc = parse_options(argc, argv, options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && target_pid == -1 && !system_wide && profile_cpu == -1)
+        if (!argc && target_pid == -1 && target_tid == -1 &&
+                !system_wide && !cpu_list)
                 usage_with_options(record_usage, options);
 
+        if (force && 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, options);
+        } else if (append_file) {
+                write_mode = WRITE_APPEND;
+        } else {
+                write_mode = WRITE_FORCE;
+        }
+
         symbol__init();
+        if (no_buildid)
+                disable_buildid_cache();
 
         if (!nr_counters) {
                 nr_counters     = 1;
@@ -680,6 +861,40 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
         }
 
+        if (target_pid != -1) {
+                target_tid = target_pid;
+                thread_num = find_all_tid(target_pid, &all_tids);
+                if (thread_num <= 0) {
+                        fprintf(stderr, "Can't find all threads of pid %d\n",
+                                        target_pid);
+                        usage_with_options(record_usage, options);
+                }
+        } else {
+                all_tids=malloc(sizeof(pid_t));
+                if (!all_tids)
+                        goto out_symbol_exit;
+
+                all_tids[0] = target_tid;
+                thread_num = 1;
+        }
+
+        for (i = 0; i < MAX_NR_CPUS; i++) {
+                for (j = 0; j < MAX_COUNTERS; j++) {
+                        fd[i][j] = malloc(sizeof(int)*thread_num);
+                        if (!fd[i][j])
+                                goto out_free_fd;
+                }
+        }
+        event_array = malloc(
+                sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num);
+        if (!event_array)
+                goto out_free_fd;
+
+        if (user_interval != ULLONG_MAX)
+                default_interval = user_interval;
+        if (user_freq != UINT_MAX)
+                freq = user_freq;
+
         /*
          * User specified count overrides default frequency.
          */
@@ -689,15 +904,22 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 default_interval = freq;
         } else {
                 fprintf(stderr, "frequency and count are zero, aborting\n");
-                exit(EXIT_FAILURE);
+                err = -EINVAL;
+                goto out_free_event_array;
         }
 
-        for (counter = 0; counter < nr_counters; counter++) {
-                if (attrs[counter].sample_period)
-                        continue;
+        err = __cmd_record(argc, argv);
 
-                attrs[counter].sample_period = default_interval;
+out_free_event_array:
+        free(event_array);
+out_free_fd:
+        for (i = 0; i < MAX_NR_CPUS; i++) {
+                for (j = 0; j < MAX_COUNTERS; j++)
+                        free(fd[i][j]);
         }
-
-        return __cmd_record(argc, argv);
+        free(all_tids);
+        all_tids = NULL;
+out_symbol_exit:
+        symbol__exit();
+        return err;
 }
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index db10c0e8ecae..55fc1f46892a 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -14,7 +14,6 @@
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
-#include "util/string.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
 #include "util/values.h"
@@ -33,54 +32,120 @@
 
 static char             const *input_name = "perf.data";
 
-static int              force;
+static bool             force;
+static bool             hide_unresolved;
+static bool             dont_use_callchains;
 
-static int              show_threads;
+static bool             show_threads;
 static struct perf_read_values  show_threads_values;
 
-static char             default_pretty_printing_style[] = "normal";
-static char             *pretty_printing_style = default_pretty_printing_style;
+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";
 
+static struct hists *perf_session__hists_findnew(struct perf_session *self,
+                                                 u64 event_stream, u32 type,
+                                                 u64 config)
+{
+        struct rb_node **p = &self->hists_tree.rb_node;
+        struct rb_node *parent = NULL;
+        struct hists *iter, *new;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct hists, rb_node);
+                if (iter->config == config)
+                        return iter;
+
+
+                if (config > iter->config)
+                        p = &(*p)->rb_right;
+                else
+                        p = &(*p)->rb_left;
+        }
+
+        new = malloc(sizeof(struct hists));
+        if (new == NULL)
+                return NULL;
+        memset(new, 0, sizeof(struct hists));
+        new->event_stream = event_stream;
+        new->config = config;
+        new->type = type;
+        rb_link_node(&new->rb_node, parent, p);
+        rb_insert_color(&new->rb_node, &self->hists_tree);
+        return new;
+}
+
 static int perf_session__add_hist_entry(struct perf_session *self,
                                         struct addr_location *al,
-                                        struct ip_callchain *chain, u64 count)
+                                        struct sample_data *data)
 {
-        struct symbol **syms = NULL, *parent = NULL;
-        bool hit;
+        struct map_symbol *syms = NULL;
+        struct symbol *parent = NULL;
+        int err = -ENOMEM;
         struct hist_entry *he;
+        struct hists *hists;
+        struct perf_event_attr *attr;
 
-        if ((sort__has_parent || symbol_conf.use_callchain) && chain)
+        if ((sort__has_parent || symbol_conf.use_callchain) && data->callchain) {
                 syms = perf_session__resolve_callchain(self, al->thread,
-                                                       chain, &parent);
-        he = __perf_session__add_hist_entry(self, al, parent, count, &hit);
-        if (he == NULL)
-                return -ENOMEM;
-
-        if (hit)
-                he->count += count;
+                                                       data->callchain, &parent);
+                if (syms == NULL)
+                        return -ENOMEM;
+        }
 
+        attr = perf_header__find_attr(data->id, &self->header);
+        if (attr)
+                hists = perf_session__hists_findnew(self, data->id, attr->type, attr->config);
+        else
+                hists = perf_session__hists_findnew(self, data->id, 0, 0);
+        if (hists == NULL)
+                goto out_free_syms;
+        he = __hists__add_entry(hists, al, parent, data->period);
+        if (he == NULL)
+                goto out_free_syms;
+        err = 0;
         if (symbol_conf.use_callchain) {
-                if (!hit)
-                        callchain_init(&he->callchain);
-                append_chain(&he->callchain, chain, syms);
-                free(syms);
+                err = append_chain(he->callchain, data->callchain, syms, data->period);
+                if (err)
+                        goto out_free_syms;
         }
-
-        return 0;
+        /*
+         * Only in the newt browser we are doing integrated annotation,
+         * so we don't allocated the extra space needed because the stdio
+         * code will not use it.
+         */
+        if (use_browser > 0)
+                err = hist_entry__inc_addr_samples(he, al->addr);
+out_free_syms:
+        free(syms);
+        return err;
 }
 
-static int validate_chain(struct ip_callchain *chain, event_t *event)
+static int add_event_total(struct perf_session *session,
+                           struct sample_data *data,
+                           struct perf_event_attr *attr)
 {
-        unsigned int chain_size;
+        struct hists *hists;
 
-        chain_size = event->header.size;
-        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
+        if (attr)
+                hists = perf_session__hists_findnew(session, data->id,
+                                                    attr->type, attr->config);
+        else
+                hists = perf_session__hists_findnew(session, data->id, 0, 0);
 
-        if (chain->nr*sizeof(u64) > chain_size)
-                return -1;
+        if (!hists)
+                return -ENOMEM;
 
+        hists->stats.total_period += data->period;
+        /*
+         * FIXME: add_event_total should be moved from here to
+         * perf_session__process_event so that the proper hist is passed to
+         * the event_op methods.
+         */
+        hists__inc_nr_events(hists, PERF_RECORD_SAMPLE);
+        session->hists.stats.total_period += data->period;
         return 0;
 }
 
@@ -88,48 +153,29 @@ static int process_sample_event(event_t *event, struct perf_session *session)
 {
         struct sample_data data = { .period = 1, };
         struct addr_location al;
+        struct perf_event_attr *attr;
 
-        event__parse_sample(event, session->sample_type, &data);
-
-        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
-                event->header.misc,
-                data.pid, data.tid,
-                (void *)(long)data.ip,
-                (long long)data.period);
-
-        if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
-                unsigned int i;
-
-                dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
-
-                if (validate_chain(data.callchain, event) < 0) {
-                        pr_debug("call-chain problem with event, "
-                                 "skipping it.\n");
-                        return 0;
-                }
-
-                if (dump_trace) {
-                        for (i = 0; i < data.callchain->nr; i++)
-                                dump_printf("..... %2d: %016Lx\n",
-                                            i, data.callchain->ips[i]);
-                }
-        }
-
-        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+        if (event__preprocess_sample(event, session, &al, &data, NULL) < 0) {
                 fprintf(stderr, "problem processing %d event, skipping it.\n",
                         event->header.type);
                 return -1;
         }
 
-        if (al.filtered)
+        if (al.filtered || (hide_unresolved && al.sym == NULL))
                 return 0;
 
-        if (perf_session__add_hist_entry(session, &al, data.callchain, data.period)) {
-                pr_debug("problem incrementing symbol count, skipping event\n");
+        if (perf_session__add_hist_entry(session, &al, &data)) {
+                pr_debug("problem incrementing symbol period, skipping event\n");
+                return -1;
+        }
+
+        attr = perf_header__find_attr(data.id, &session->header);
+
+        if (add_event_total(session, &data, attr)) {
+                pr_debug("problem adding event period\n");
                 return -1;
         }
 
-        session->events_stats.total += data.period;
         return 0;
 }
 
@@ -156,14 +202,14 @@ static int process_read_event(event_t *event, struct perf_session *session __use
         return 0;
 }
 
-static int sample_type_check(struct perf_session *session)
+static int perf_session__setup_sample_type(struct perf_session *self)
 {
-        if (!(session->sample_type & PERF_SAMPLE_CALLCHAIN)) {
+        if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
                         fprintf(stderr, "selected --sort parent, but no"
                                         " callchain data. Did you call"
                                         " perf record without -g?\n");
-                        return -1;
+                        return -EINVAL;
                 }
                 if (symbol_conf.use_callchain) {
                         fprintf(stderr, "selected -g but no callchain data."
@@ -171,12 +217,13 @@ static int sample_type_check(struct perf_session *session)
                                         " -g?\n");
                         return -1;
                 }
-        } else if (callchain_param.mode != CHAIN_NONE && !symbol_conf.use_callchain) {
+        } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
+                   !symbol_conf.use_callchain) {
                         symbol_conf.use_callchain = true;
                         if (register_callchain_param(&callchain_param) < 0) {
                                 fprintf(stderr, "Can't register callchain"
                                                 " params\n");
-                                return -1;
+                                return -EINVAL;
                         }
         }
 
@@ -184,35 +231,98 @@ static int sample_type_check(struct perf_session *session)
 }
 
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_mmap_event     = event__process_mmap,
-        .process_comm_event     = event__process_comm,
-        .process_exit_event     = event__process_task,
-        .process_fork_event     = event__process_task,
-        .process_lost_event     = event__process_lost,
-        .process_read_event     = process_read_event,
-        .sample_type_check      = sample_type_check,
+        .sample = process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .exit   = event__process_task,
+        .fork   = event__process_task,
+        .lost   = event__process_lost,
+        .read   = process_read_event,
+        .attr   = event__process_attr,
+        .event_type = event__process_event_type,
+        .tracing_data = event__process_tracing_data,
+        .build_id = event__process_build_id,
 };
 
+extern volatile int session_done;
+
+static void sig_handler(int sig __used)
+{
+        session_done = 1;
+}
+
+static size_t hists__fprintf_nr_sample_events(struct hists *self,
+                                              const char *evname, FILE *fp)
+{
+        size_t ret;
+        char unit;
+        unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
+
+        nr_events = convert_unit(nr_events, &unit);
+        ret = fprintf(fp, "# Events: %lu%c", nr_events, unit);
+        if (evname != NULL)
+                ret += fprintf(fp, " %s", evname);
+        return ret + fprintf(fp, "\n#\n");
+}
+
+static int hists__tty_browse_tree(struct rb_root *tree, const char *help)
+{
+        struct rb_node *next = rb_first(tree);
+
+        while (next) {
+                struct hists *hists = rb_entry(next, struct hists, rb_node);
+                const char *evname = NULL;
+
+                if (rb_first(&hists->entries) != rb_last(&hists->entries))
+                        evname = __event_name(hists->type, hists->config);
+
+                hists__fprintf_nr_sample_events(hists, evname, stdout);
+                hists__fprintf(hists, NULL, false, stdout);
+                fprintf(stdout, "\n\n");
+                next = rb_next(&hists->rb_node);
+        }
+
+        if (sort_order == default_sort_order &&
+            parent_pattern == default_parent_pattern) {
+                fprintf(stdout, "#\n# (%s)\n#\n", help);
+
+                if (show_threads) {
+                        bool style = !strcmp(pretty_printing_style, "raw");
+                        perf_read_values_display(stdout, &show_threads_values,
+                                                 style);
+                        perf_read_values_destroy(&show_threads_values);
+                }
+        }
+
+        return 0;
+}
 
 static int __cmd_report(void)
 {
-        int ret;
+        int ret = -EINVAL;
         struct perf_session *session;
+        struct rb_node *next;
+        const char *help = "For a higher level overview, try: perf report --sort comm,dso";
+
+        signal(SIGINT, sig_handler);
 
-        session = perf_session__new(input_name, O_RDONLY, force);
+        session = perf_session__new(input_name, O_RDONLY, force, false);
         if (session == NULL)
                 return -ENOMEM;
 
         if (show_threads)
                 perf_read_values_init(&show_threads_values);
 
+        ret = perf_session__setup_sample_type(session);
+        if (ret)
+                goto out_delete;
+
         ret = perf_session__process_events(session, &event_ops);
         if (ret)
                 goto out_delete;
 
         if (dump_trace) {
-                event__print_totals();
+                perf_session__fprintf_nr_events(session, stdout);
                 goto out_delete;
         }
 
@@ -220,34 +330,54 @@ static int __cmd_report(void)
                 perf_session__fprintf(session, stdout);
 
         if (verbose > 2)
-                dsos__fprintf(stdout);
+                perf_session__fprintf_dsos(session, stdout);
 
-        perf_session__collapse_resort(session);
-        perf_session__output_resort(session, session->events_stats.total);
-        fprintf(stdout, "# Samples: %Ld\n#\n", session->events_stats.total);
-        perf_session__fprintf_hists(session, NULL, false, stdout);
-        if (sort_order == default_sort_order &&
-            parent_pattern == default_parent_pattern)
-                fprintf(stdout, "#\n# (For a higher level overview, try: perf report --sort comm,dso)\n#\n");
+        next = rb_first(&session->hists_tree);
+        while (next) {
+                struct hists *hists;
 
-        if (show_threads) {
-                bool raw_printing_style = !strcmp(pretty_printing_style, "raw");
-                perf_read_values_display(stdout, &show_threads_values,
-                                         raw_printing_style);
-                perf_read_values_destroy(&show_threads_values);
+                hists = rb_entry(next, struct hists, rb_node);
+                hists__collapse_resort(hists);
+                hists__output_resort(hists);
+                next = rb_next(&hists->rb_node);
         }
+
+        if (use_browser > 0)
+                hists__tui_browse_tree(&session->hists_tree, help);
+        else
+                hists__tty_browse_tree(&session->hists_tree, help);
+
 out_delete:
-        perf_session__delete(session);
+        /*
+         * Speed up the exit process, for large files this can
+         * take quite a while.
+         *
+         * XXX Enable this when using valgrind or if we ever
+         * librarize this command.
+         *
+         * Also experiment with obstacks to see how much speed
+         * up we'll get here.
+         *
+         * perf_session__delete(session);
+         */
         return ret;
 }
 
 static int
 parse_callchain_opt(const struct option *opt __used, const char *arg,
-                    int unset __used)
+                    int unset)
 {
-        char *tok;
+        char *tok, *tok2;
         char *endptr;
 
+        /*
+         * --no-call-graph
+         */
+        if (unset) {
+                dont_use_callchains = true;
+                return 0;
+        }
+
         symbol_conf.use_callchain = true;
 
         if (!arg)
@@ -269,7 +399,7 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
 
         else if (!strncmp(tok, "none", strlen(arg))) {
                 callchain_param.mode = CHAIN_NONE;
-                symbol_conf.use_callchain = true;
+                symbol_conf.use_callchain = false;
 
                 return 0;
         }
@@ -282,10 +412,13 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
         if (!tok)
                 goto setup;
 
+        tok2 = strtok(NULL, ",");
         callchain_param.min_percent = strtod(tok, &endptr);
         if (tok == endptr)
                 return -1;
 
+        if (tok2)
+                callchain_param.print_limit = strtod(tok2, &endptr);
 setup:
         if (register_callchain_param(&callchain_param) < 0) {
                 fprintf(stderr, "Can't register callchain params\n");
@@ -302,7 +435,7 @@ static const char * const report_usage[] = {
 static const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        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"),
@@ -319,14 +452,14 @@ static const struct option options[] = {
                    "pretty printing style key: normal raw"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                    "sort by key(s): pid, comm, dso, symbol, parent"),
-        OPT_BOOLEAN('P', "full-paths", &event_ops.full_paths,
-                    "Don't shorten the pathnames taking into account the cwd"),
+        OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
+                    "Show sample percentage for different cpu modes"),
         OPT_STRING('p', "parent", &parent_pattern, "regex",
                    "regex filter to identify parent, see: '--sort parent'"),
         OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
                     "Only display entries with parent-match"),
         OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
-                     "Display callchains using output_type and min percent threshold. "
+                     "Display callchains using output_type (graph, flat, fractal, or none) and min percent threshold. "
                      "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
         OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
                    "only consider symbols in these dsos"),
@@ -340,6 +473,8 @@ static const struct option options[] = {
         OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
                    "separator for columns, no spaces will be added between "
                    "columns '.' is reserved."),
+        OPT_BOOLEAN('U', "hide-unresolved", &hide_unresolved,
+                    "Only display entries resolved to a symbol"),
         OPT_END()
 };
 
@@ -347,7 +482,31 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
         argc = parse_options(argc, argv, options, report_usage, 0);
 
-        setup_pager();
+        if (strcmp(input_name, "-") != 0)
+                setup_browser();
+        /*
+         * Only in the newt browser we are doing integrated annotation,
+         * so don't allocate extra space that won't be used in the stdio
+         * implementation.
+         */
+        if (use_browser > 0) {
+                symbol_conf.priv_size = sizeof(struct sym_priv);
+                /*
+                 * For searching by name on the "Browse map details".
+                 * providing it only in verbose mode not to bloat too
+                 * much struct symbol.
+                 */
+                if (verbose) {
+                        /*
+                         * XXX: Need to provide a less kludgy way to ask for
+                         * more space per symbol, the u32 is for the index on
+                         * the ui browser.
+                         * See symbol__browser_index.
+                         */
+                        symbol_conf.priv_size += sizeof(u32);
+                        symbol_conf.sort_by_name = true;
+                }
+        }
 
         if (symbol__init() < 0)
                 return -1;
@@ -355,7 +514,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         setup_sorting(report_usage, options);
 
         if (parent_pattern != default_parent_pattern) {
-                sort_dimension__add("parent");
+                if (sort_dimension__add("parent") < 0)
+                        return -1;
                 sort_parent.elide = 1;
         } else
                 symbol_conf.exclude_other = false;
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 80209df6cfe8..55f3b5dcc731 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -22,7 +22,7 @@
 static char                     const *input_name = "perf.data";
 
 static char                     default_sort_order[] = "avg, max, switch, runtime";
-static char                     *sort_order = default_sort_order;
+static const char               *sort_order = default_sort_order;
 
 static int                      profile_cpu = -1;
 
@@ -68,10 +68,10 @@ enum sched_event_type {
 
 struct sched_atom {
         enum sched_event_type   type;
+        int                     specific_wait;
         u64                     timestamp;
         u64                     duration;
         unsigned long           nr;
-        int                     specific_wait;
         sem_t                   *wait_sem;
         struct task_desc        *wakee;
 };
@@ -105,7 +105,7 @@ static u64			sum_runtime;
 static u64                      sum_fluct;
 static u64                      run_avg;
 
-static unsigned long            replay_repeat = 10;
+static unsigned int             replay_repeat = 10;
 static unsigned long            nr_timestamps;
 static unsigned long            nr_unordered_timestamps;
 static unsigned long            nr_state_machine_bugs;
@@ -1621,11 +1621,8 @@ static int process_sample_event(event_t *event, struct perf_session *session)
 
         event__parse_sample(event, session->sample_type, &data);
 
-        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
-                event->header.misc,
-                data.pid, data.tid,
-                (void *)(long)data.ip,
-                (long long)data.period);
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
 
         thread = perf_session__findnew(session, data.pid);
         if (thread == NULL) {
@@ -1644,42 +1641,28 @@ static int process_sample_event(event_t *event, struct perf_session *session)
         return 0;
 }
 
-static int process_lost_event(event_t *event __used,
-                              struct perf_session *session __used)
-{
-        nr_lost_chunks++;
-        nr_lost_events += event->lost.lost;
-
-        return 0;
-}
-
-static int sample_type_check(struct perf_session *session __used)
-{
-        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
-                fprintf(stderr,
-                        "No trace sample to read. Did you call perf record "
-                        "without -R?");
-                return -1;
-        }
-
-        return 0;
-}
-
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_comm_event     = event__process_comm,
-        .process_lost_event     = process_lost_event,
-        .sample_type_check      = sample_type_check,
+        .sample                 = process_sample_event,
+        .comm                   = event__process_comm,
+        .lost                   = event__process_lost,
+        .fork                   = event__process_task,
+        .ordered_samples        = true,
 };
 
 static int read_events(void)
 {
-        int err;
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
+        int err = -EINVAL;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0, false);
         if (session == NULL)
                 return -ENOMEM;
 
-        err = perf_session__process_events(session, &event_ops);
+        if (perf_session__has_traces(session, "record -R")) {
+                err = perf_session__process_events(session, &event_ops);
+                nr_events      = session->hists.stats.nr_events[0];
+                nr_lost_events = session->hists.stats.total_lost;
+                nr_lost_chunks = session->hists.stats.nr_events[PERF_RECORD_LOST];
+        }
+
         perf_session__delete(session);
         return err;
 }
@@ -1804,7 +1787,7 @@ static const char * const sched_usage[] = {
 static const struct option sched_options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        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"),
@@ -1819,7 +1802,7 @@ static const char * const latency_usage[] = {
 static const struct option latency_options[] = {
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
                    "sort by key(s): runtime, switch, avg, max"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_INTEGER('C', "CPU", &profile_cpu,
                     "CPU to profile on"),
@@ -1834,9 +1817,9 @@ static const char * const replay_usage[] = {
 };
 
 static const struct option replay_options[] = {
-        OPT_INTEGER('r', "repeat", &replay_repeat,
-                    "repeat the workload replay N times (-1: infinite)"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_UINTEGER('r', "repeat", &replay_repeat,
+                     "repeat the workload replay N times (-1: infinite)"),
+        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"),
@@ -1864,7 +1847,6 @@ static const char *record_args[] = {
         "record",
         "-a",
         "-R",
-        "-M",
         "-f",
         "-m", "1024",
         "-c", "1",
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index c70d72003557..a6b4d44f9502 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -44,9 +44,13 @@
 #include "util/parse-events.h"
 #include "util/event.h"
 #include "util/debug.h"
+#include "util/header.h"
+#include "util/cpumap.h"
+#include "util/thread.h"
 
 #include <sys/prctl.h>
 #include <math.h>
+#include <locale.h>
 
 static struct perf_event_attr default_attrs[] = {
 
@@ -64,21 +68,29 @@ static struct perf_event_attr default_attrs[] = {
 
 };
 
-static int                      system_wide                     =  0;
-static unsigned int             nr_cpus                         =  0;
+static bool                     system_wide                     =  false;
+static int                      nr_cpus                         =  0;
 static int                      run_idx                         =  0;
 
 static int                      run_count                       =  1;
-static int                      inherit                         =  1;
-static int                      scale                           =  1;
+static bool                     no_inherit                      = false;
+static bool                     scale                           =  true;
 static pid_t                    target_pid                      = -1;
+static pid_t                    target_tid                      = -1;
+static pid_t                    *all_tids                       =  NULL;
+static int                      thread_num                      =  0;
 static pid_t                    child_pid                       = -1;
-static int                      null_run                        =  0;
+static bool                     null_run                        =  false;
+static bool                     big_num                         =  false;
+static const char               *cpu_list;
 
-static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+
+static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
 
 static int                      event_scaled[MAX_COUNTERS];
 
+static volatile int done = 0;
+
 struct stats
 {
         double n, mean, M2;
@@ -136,33 +148,47 @@ struct stats			runtime_branches_stats;
 #define ERR_PERF_OPEN \
 "Error: counter %d, sys_perf_event_open() syscall returned with %d (%s)\n"
 
-static void create_perf_stat_counter(int counter, int pid)
+static int create_perf_stat_counter(int counter)
 {
         struct perf_event_attr *attr = attrs + counter;
+        int thread;
+        int ncreated = 0;
 
         if (scale)
                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 
         if (system_wide) {
-                unsigned int cpu;
+                int cpu;
 
                 for (cpu = 0; cpu < nr_cpus; cpu++) {
-                        fd[cpu][counter] = sys_perf_event_open(attr, -1, cpu, -1, 0);
-                        if (fd[cpu][counter] < 0 && verbose)
-                                fprintf(stderr, ERR_PERF_OPEN, counter,
-                                        fd[cpu][counter], strerror(errno));
+                        fd[cpu][counter][0] = sys_perf_event_open(attr,
+                                        -1, cpumap[cpu], -1, 0);
+                        if (fd[cpu][counter][0] < 0)
+                                pr_debug(ERR_PERF_OPEN, counter,
+                                         fd[cpu][counter][0], strerror(errno));
+                        else
+                                ++ncreated;
                 }
         } else {
-                attr->inherit        = inherit;
-                attr->disabled       = 1;
-                attr->enable_on_exec = 1;
-
-                fd[0][counter] = sys_perf_event_open(attr, pid, -1, -1, 0);
-                if (fd[0][counter] < 0 && verbose)
-                        fprintf(stderr, ERR_PERF_OPEN, counter,
-                                fd[0][counter], strerror(errno));
+                attr->inherit = !no_inherit;
+                if (target_pid == -1 && target_tid == -1) {
+                        attr->disabled = 1;
+                        attr->enable_on_exec = 1;
+                }
+                for (thread = 0; thread < thread_num; thread++) {
+                        fd[0][counter][thread] = sys_perf_event_open(attr,
+                                all_tids[thread], -1, -1, 0);
+                        if (fd[0][counter][thread] < 0)
+                                pr_debug(ERR_PERF_OPEN, counter,
+                                         fd[0][counter][thread],
+                                         strerror(errno));
+                        else
+                                ++ncreated;
+                }
         }
+
+        return ncreated;
 }
 
 /*
@@ -183,28 +209,31 @@ static inline int nsec_counter(int counter)
 static void read_counter(int counter)
 {
         u64 count[3], single_count[3];
-        unsigned int cpu;
+        int cpu;
         size_t res, nv;
         int scaled;
-        int i;
+        int i, thread;
 
         count[0] = count[1] = count[2] = 0;
 
         nv = scale ? 3 : 1;
         for (cpu = 0; cpu < nr_cpus; cpu++) {
-                if (fd[cpu][counter] < 0)
-                        continue;
-
-                res = read(fd[cpu][counter], single_count, nv * sizeof(u64));
-                assert(res == nv * sizeof(u64));
-
-                close(fd[cpu][counter]);
-                fd[cpu][counter] = -1;
-
-                count[0] += single_count[0];
-                if (scale) {
-                        count[1] += single_count[1];
-                        count[2] += single_count[2];
+                for (thread = 0; thread < thread_num; thread++) {
+                        if (fd[cpu][counter][thread] < 0)
+                                continue;
+
+                        res = read(fd[cpu][counter][thread],
+                                        single_count, nv * sizeof(u64));
+                        assert(res == nv * sizeof(u64));
+
+                        close(fd[cpu][counter][thread]);
+                        fd[cpu][counter][thread] = -1;
+
+                        count[0] += single_count[0];
+                        if (scale) {
+                                count[1] += single_count[1];
+                                count[2] += single_count[2];
+                        }
                 }
         }
 
@@ -246,72 +275,88 @@ static int run_perf_stat(int argc __used, const char **argv)
 {
         unsigned long long t0, t1;
         int status = 0;
-        int counter;
-        int pid;
+        int counter, ncreated = 0;
         int child_ready_pipe[2], go_pipe[2];
+        const bool forks = (argc > 0);
         char buf;
 
         if (!system_wide)
                 nr_cpus = 1;
 
-        if (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0) {
+        if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
                 perror("failed to create pipes");
                 exit(1);
         }
 
-        if ((pid = fork()) < 0)
-                perror("failed to fork");
+        if (forks) {
+                if ((child_pid = fork()) < 0)
+                        perror("failed to fork");
+
+                if (!child_pid) {
+                        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]);
+                        exit(-1);
+                }
 
-        if (!pid) {
-                close(child_ready_pipe[0]);
-                close(go_pipe[1]);
-                fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
+                if (target_tid == -1 && target_pid == -1 && !system_wide)
+                        all_tids[0] = child_pid;
 
                 /*
-                 * 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
+                 * Wait for the child to be ready to exec.
                  */
                 close(child_ready_pipe[1]);
-
-                /*
-                 * Wait until the parent tells us to go.
-                 */
-                if (read(go_pipe[0], &buf, 1) == -1)
+                close(go_pipe[0]);
+                if (read(child_ready_pipe[0], &buf, 1) == -1)
                         perror("unable to read pipe");
-
-                execvp(argv[0], (char **)argv);
-
-                perror(argv[0]);
-                exit(-1);
+                close(child_ready_pipe[0]);
         }
 
-        child_pid = pid;
-
-        /*
-         * Wait for the child to be ready to exec.
-         */
-        close(child_ready_pipe[1]);
-        close(go_pipe[0]);
-        if (read(child_ready_pipe[0], &buf, 1) == -1)
-                perror("unable to read pipe");
-        close(child_ready_pipe[0]);
-
         for (counter = 0; counter < nr_counters; counter++)
-                create_perf_stat_counter(counter, pid);
+                ncreated += create_perf_stat_counter(counter);
+
+        if (ncreated == 0) {
+                pr_err("No permission to collect %sstats.\n"
+                       "Consider tweaking /proc/sys/kernel/perf_event_paranoid.\n",
+                       system_wide ? "system-wide " : "");
+                if (child_pid != -1)
+                        kill(child_pid, SIGTERM);
+                return -1;
+        }
 
         /*
          * Enable counters and exec the command:
          */
         t0 = rdclock();
 
-        close(go_pipe[1]);
-        wait(&status);
+        if (forks) {
+                close(go_pipe[1]);
+                wait(&status);
+        } else {
+                while(!done) sleep(1);
+        }
 
         t1 = rdclock();
 
@@ -336,7 +381,7 @@ static void nsec_printout(int counter, double avg)
 {
         double msecs = avg / 1e6;
 
-        fprintf(stderr, " %14.6f  %-24s", msecs, event_name(counter));
+        fprintf(stderr, " %18.6f  %-24s", msecs, event_name(counter));
 
         if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
                 fprintf(stderr, " # %10.3f CPUs ",
@@ -348,7 +393,10 @@ static void abs_printout(int counter, double avg)
 {
         double total, ratio = 0.0;
 
-        fprintf(stderr, " %14.0f  %-24s", avg, event_name(counter));
+        if (big_num)
+                fprintf(stderr, " %'18.0f  %-24s", avg, event_name(counter));
+        else
+                fprintf(stderr, " %18.0f  %-24s", avg, event_name(counter));
 
         if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
                 total = avg_stats(&runtime_cycles_stats);
@@ -385,7 +433,7 @@ static void print_counter(int counter)
         int scaled = event_scaled[counter];
 
         if (scaled == -1) {
-                fprintf(stderr, " %14s  %-24s\n",
+                fprintf(stderr, " %18s  %-24s\n",
                         "<not counted>", event_name(counter));
                 return;
         }
@@ -417,10 +465,15 @@ static void print_stat(int argc, const char **argv)
         fflush(stdout);
 
         fprintf(stderr, "\n");
-        fprintf(stderr, " Performance counter stats for \'%s", argv[0]);
-
-        for (i = 1; i < argc; i++)
-                fprintf(stderr, " %s", argv[i]);
+        fprintf(stderr, " Performance counter stats for ");
+        if(target_pid == -1 && target_tid == -1) {
+                fprintf(stderr, "\'%s", argv[0]);
+                for (i = 1; i < argc; i++)
+                        fprintf(stderr, " %s", argv[i]);
+        } else if (target_pid != -1)
+                fprintf(stderr, "process id \'%d", target_pid);
+        else
+                fprintf(stderr, "thread id \'%d", target_tid);
 
         fprintf(stderr, "\'");
         if (run_count > 1)
@@ -431,7 +484,7 @@ static void print_stat(int argc, const char **argv)
                 print_counter(counter);
 
         fprintf(stderr, "\n");
-        fprintf(stderr, " %14.9f  seconds time elapsed",
+        fprintf(stderr, " %18.9f  seconds time elapsed",
                         avg_stats(&walltime_nsecs_stats)/1e9);
         if (run_count > 1) {
                 fprintf(stderr, "   ( +- %7.3f%% )",
@@ -445,6 +498,9 @@ static volatile int signr = -1;
 
 static void skip_signal(int signo)
 {
+        if(child_pid == -1)
+                done = 1;
+
         signr = signo;
 }
 
@@ -461,7 +517,7 @@ static void sig_atexit(void)
 }
 
 static const char * const stat_usage[] = {
-        "perf stat [<options>] <command>",
+        "perf stat [<options>] [<command>]",
         NULL
 };
 
@@ -469,30 +525,39 @@ static const struct option options[] = {
         OPT_CALLBACK('e', "event", NULL, "event",
                      "event selector. use 'perf list' to list available events",
                      parse_events),
-        OPT_BOOLEAN('i', "inherit", &inherit,
-                    "child tasks inherit counters"),
+        OPT_BOOLEAN('i', "no-inherit", &no_inherit,
+                    "child tasks do not inherit counters"),
         OPT_INTEGER('p', "pid", &target_pid,
-                    "stat events on existing pid"),
+                    "stat events on existing process id"),
+        OPT_INTEGER('t', "tid", &target_tid,
+                    "stat events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
         OPT_BOOLEAN('c', "scale", &scale,
                     "scale/normalize counters"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_INTEGER('r', "repeat", &run_count,
                     "repeat command and print average + stddev (max: 100)"),
         OPT_BOOLEAN('n', "null", &null_run,
                     "null run - dont start any counters"),
+        OPT_BOOLEAN('B', "big-num", &big_num,
+                    "print large numbers with thousands\' separators"),
+        OPT_STRING('C', "cpu", &cpu_list, "cpu",
+                    "list of cpus to monitor in system-wide"),
         OPT_END()
 };
 
 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 {
         int status;
+        int i,j;
+
+        setlocale(LC_ALL, "");
 
         argc = parse_options(argc, argv, options, stat_usage,
                 PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc)
+        if (!argc && target_pid == -1 && target_tid == -1)
                 usage_with_options(stat_usage, options);
         if (run_count <= 0)
                 usage_with_options(stat_usage, options);
@@ -503,9 +568,38 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 nr_counters = ARRAY_SIZE(default_attrs);
         }
 
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert((int)nr_cpus >= 0);
+        if (system_wide)
+                nr_cpus = read_cpu_map(cpu_list);
+        else
+                nr_cpus = 1;
+
+        if (nr_cpus < 1)
+                usage_with_options(stat_usage, options);
+
+        if (target_pid != -1) {
+                target_tid = target_pid;
+                thread_num = find_all_tid(target_pid, &all_tids);
+                if (thread_num <= 0) {
+                        fprintf(stderr, "Can't find all threads of pid %d\n",
+                                        target_pid);
+                        usage_with_options(stat_usage, options);
+                }
+        } else {
+                all_tids=malloc(sizeof(pid_t));
+                if (!all_tids)
+                        return -ENOMEM;
+
+                all_tids[0] = target_tid;
+                thread_num = 1;
+        }
+
+        for (i = 0; i < MAX_NR_CPUS; i++) {
+                for (j = 0; j < MAX_COUNTERS; j++) {
+                        fd[i][j] = malloc(sizeof(int)*thread_num);
+                        if (!fd[i][j])
+                                return -ENOMEM;
+                }
+        }
 
         /*
          * We dont want to block the signals - that would cause
@@ -525,7 +619,8 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 status = run_perf_stat(argc, argv);
         }
 
-        print_stat(argc, argv);
+        if (status != -1)
+                print_stat(argc, argv);
 
         return status;
 }
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
new file mode 100644
index 000000000000..035b9fa063a9
--- /dev/null
+++ b/tools/perf/builtin-test.c
@@ -0,0 +1,281 @@
+/*
+ * builtin-test.c
+ *
+ * Builtin regression testing command: ever growing number of sanity tests
+ */
+#include "builtin.h"
+
+#include "util/cache.h"
+#include "util/debug.h"
+#include "util/parse-options.h"
+#include "util/session.h"
+#include "util/symbol.h"
+#include "util/thread.h"
+
+static long page_size;
+
+static int vmlinux_matches_kallsyms_filter(struct map *map __used, struct symbol *sym)
+{
+        bool *visited = symbol__priv(sym);
+        *visited = true;
+        return 0;
+}
+
+static int test__vmlinux_matches_kallsyms(void)
+{
+        int err = -1;
+        struct rb_node *nd;
+        struct symbol *sym;
+        struct map *kallsyms_map, *vmlinux_map;
+        struct machine kallsyms, vmlinux;
+        enum map_type type = MAP__FUNCTION;
+        struct ref_reloc_sym ref_reloc_sym = { .name = "_stext", };
+
+        /*
+         * Step 1:
+         *
+         * Init the machines that will hold kernel, modules obtained from
+         * both vmlinux + .ko files and from /proc/kallsyms split by modules.
+         */
+        machine__init(&kallsyms, "", HOST_KERNEL_ID);
+        machine__init(&vmlinux, "", HOST_KERNEL_ID);
+
+        /*
+         * Step 2:
+         *
+         * Create the kernel maps for kallsyms and the DSO where we will then
+         * load /proc/kallsyms. Also create the modules maps from /proc/modules
+         * and find the .ko files that match them in /lib/modules/`uname -r`/.
+         */
+        if (machine__create_kernel_maps(&kallsyms) < 0) {
+                pr_debug("machine__create_kernel_maps ");
+                return -1;
+        }
+
+        /*
+         * Step 3:
+         *
+         * Load and split /proc/kallsyms into multiple maps, one per module.
+         */
+        if (machine__load_kallsyms(&kallsyms, "/proc/kallsyms", type, NULL) <= 0) {
+                pr_debug("dso__load_kallsyms ");
+                goto out;
+        }
+
+        /*
+         * Step 4:
+         *
+         * kallsyms will be internally on demand sorted by name so that we can
+         * find the reference relocation * symbol, i.e. the symbol we will use
+         * to see if the running kernel was relocated by checking if it has the
+         * same value in the vmlinux file we load.
+         */
+        kallsyms_map = machine__kernel_map(&kallsyms, type);
+
+        sym = map__find_symbol_by_name(kallsyms_map, ref_reloc_sym.name, NULL);
+        if (sym == NULL) {
+                pr_debug("dso__find_symbol_by_name ");
+                goto out;
+        }
+
+        ref_reloc_sym.addr = sym->start;
+
+        /*
+         * Step 5:
+         *
+         * Now repeat step 2, this time for the vmlinux file we'll auto-locate.
+         */
+        if (machine__create_kernel_maps(&vmlinux) < 0) {
+                pr_debug("machine__create_kernel_maps ");
+                goto out;
+        }
+
+        vmlinux_map = machine__kernel_map(&vmlinux, type);
+        map__kmap(vmlinux_map)->ref_reloc_sym = &ref_reloc_sym;
+
+        /*
+         * Step 6:
+         *
+         * Locate a vmlinux file in the vmlinux path that has a buildid that
+         * matches the one of the running kernel.
+         *
+         * While doing that look if we find the ref reloc symbol, if we find it
+         * we'll have its ref_reloc_symbol.unrelocated_addr and then
+         * maps__reloc_vmlinux will notice and set proper ->[un]map_ip routines
+         * to fixup the symbols.
+         */
+        if (machine__load_vmlinux_path(&vmlinux, type,
+                                       vmlinux_matches_kallsyms_filter) <= 0) {
+                pr_debug("machine__load_vmlinux_path ");
+                goto out;
+        }
+
+        err = 0;
+        /*
+         * Step 7:
+         *
+         * Now look at the symbols in the vmlinux DSO and check if we find all of them
+         * in the kallsyms dso. For the ones that are in both, check its names and
+         * end addresses too.
+         */
+        for (nd = rb_first(&vmlinux_map->dso->symbols[type]); nd; nd = rb_next(nd)) {
+                struct symbol *pair;
+
+                sym  = rb_entry(nd, struct symbol, rb_node);
+                pair = machine__find_kernel_symbol(&kallsyms, type, sym->start, NULL, NULL);
+
+                if (pair && pair->start == sym->start) {
+next_pair:
+                        if (strcmp(sym->name, pair->name) == 0) {
+                                /*
+                                 * kallsyms don't have the symbol end, so we
+                                 * set that by using the next symbol start - 1,
+                                 * in some cases we get this up to a page
+                                 * wrong, trace_kmalloc when I was developing
+                                 * this code was one such example, 2106 bytes
+                                 * off the real size. More than that and we
+                                 * _really_ have a problem.
+                                 */
+                                s64 skew = sym->end - pair->end;
+                                if (llabs(skew) < page_size)
+                                        continue;
+
+                                pr_debug("%#Lx: diff end addr for %s v: %#Lx k: %#Lx\n",
+                                         sym->start, sym->name, sym->end, pair->end);
+                        } else {
+                                struct rb_node *nnd = rb_prev(&pair->rb_node);
+
+                                if (nnd) {
+                                        struct symbol *next = rb_entry(nnd, struct symbol, rb_node);
+
+                                        if (next->start == sym->start) {
+                                                pair = next;
+                                                goto next_pair;
+                                        }
+                                }
+                                pr_debug("%#Lx: diff name v: %s k: %s\n",
+                                         sym->start, sym->name, pair->name);
+                        }
+                } else
+                        pr_debug("%#Lx: %s not on kallsyms\n", sym->start, sym->name);
+
+                err = -1;
+        }
+
+        if (!verbose)
+                goto out;
+
+        pr_info("Maps only in vmlinux:\n");
+
+        for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
+                /*
+                 * If it is the kernel, kallsyms is always "[kernel.kallsyms]", while
+                 * the kernel will have the path for the vmlinux file being used,
+                 * so use the short name, less descriptive but the same ("[kernel]" in
+                 * both cases.
+                 */
+                pair = map_groups__find_by_name(&kallsyms.kmaps, type,
+                                                (pos->dso->kernel ?
+                                                        pos->dso->short_name :
+                                                        pos->dso->name));
+                if (pair)
+                        pair->priv = 1;
+                else
+                        map__fprintf(pos, stderr);
+        }
+
+        pr_info("Maps in vmlinux with a different name in kallsyms:\n");
+
+        for (nd = rb_first(&vmlinux.kmaps.maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node), *pair;
+
+                pair = map_groups__find(&kallsyms.kmaps, type, pos->start);
+                if (pair == NULL || pair->priv)
+                        continue;
+
+                if (pair->start == pos->start) {
+                        pair->priv = 1;
+                        pr_info(" %Lx-%Lx %Lx %s in kallsyms as",
+                                pos->start, pos->end, pos->pgoff, pos->dso->name);
+                        if (pos->pgoff != pair->pgoff || pos->end != pair->end)
+                                pr_info(": \n*%Lx-%Lx %Lx",
+                                        pair->start, pair->end, pair->pgoff);
+                        pr_info(" %s\n", pair->dso->name);
+                        pair->priv = 1;
+                }
+        }
+
+        pr_info("Maps only in kallsyms:\n");
+
+        for (nd = rb_first(&kallsyms.kmaps.maps[type]);
+             nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+
+                if (!pos->priv)
+                        map__fprintf(pos, stderr);
+        }
+out:
+        return err;
+}
+
+static struct test {
+        const char *desc;
+        int (*func)(void);
+} tests[] = {
+        {
+                .desc = "vmlinux symtab matches kallsyms",
+                .func = test__vmlinux_matches_kallsyms,
+        },
+        {
+                .func = NULL,
+        },
+};
+
+static int __cmd_test(void)
+{
+        int i = 0;
+
+        page_size = sysconf(_SC_PAGE_SIZE);
+
+        while (tests[i].func) {
+                int err;
+                pr_info("%2d: %s:", i + 1, tests[i].desc);
+                pr_debug("\n--- start ---\n");
+                err = tests[i].func();
+                pr_debug("---- end ----\n%s:", tests[i].desc);
+                pr_info(" %s\n", err ? "FAILED!\n" : "Ok");
+                ++i;
+        }
+
+        return 0;
+}
+
+static const char * const test_usage[] = {
+        "perf test [<options>]",
+        NULL,
+};
+
+static const struct option test_options[] = {
+        OPT_INTEGER('v', "verbose", &verbose,
+                    "be more verbose (show symbol address, etc)"),
+        OPT_END()
+};
+
+int cmd_test(int argc, const char **argv, const char *prefix __used)
+{
+        argc = parse_options(argc, argv, test_options, test_usage, 0);
+        if (argc)
+                usage_with_options(test_usage, test_options);
+
+        symbol_conf.priv_size = sizeof(int);
+        symbol_conf.sort_by_name = true;
+        symbol_conf.try_vmlinux_path = true;
+
+        if (symbol__init() < 0)
+                return -1;
+
+        setup_pager();
+
+        return __cmd_test();
+}
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 3f8bbcfb1e9b..9bcc38f0b706 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -21,7 +21,6 @@
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
-#include "util/string.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
 
@@ -43,7 +42,7 @@ static u64		turbo_frequency;
 
 static u64              first_time, last_time;
 
-static int              power_only;
+static bool             power_only;
 
 
 struct per_pid;
@@ -78,8 +77,6 @@ struct per_pid {
 
         struct per_pidcomm *all;
         struct per_pidcomm *current;
-
-        int painted;
 };
 
 
@@ -146,9 +143,6 @@ struct wake_event {
 static struct power_event    *power_events;
 static struct wake_event     *wake_events;
 
-struct sample_wrapper *all_samples;
-
-
 struct process_filter;
 struct process_filter {
         char                    *name;
@@ -306,8 +300,9 @@ struct trace_entry {
 
 struct power_entry {
         struct trace_entry te;
-        s64     type;
-        s64     value;
+        u64     type;
+        u64     value;
+        u64     cpu_id;
 };
 
 #define TASK_COMM_LEN 16
@@ -460,8 +455,8 @@ static void sched_switch(int cpu, u64 timestamp, struct trace_entry *te)
                 if (p->current->state != TYPE_NONE)
                         pid_put_sample(sw->next_pid, p->current->state, cpu, p->current->state_since, timestamp);
 
-                        p->current->state_since = timestamp;
-                        p->current->state = TYPE_RUNNING;
+                p->current->state_since = timestamp;
+                p->current->state = TYPE_RUNNING;
         }
 
         if (prev_p->current) {
@@ -504,13 +499,13 @@ static int process_sample_event(event_t *event, struct perf_session *session)
                         return 0;
 
                 if (strcmp(event_str, "power:power_start") == 0)
-                        c_state_start(data.cpu, data.time, pe->value);
+                        c_state_start(pe->cpu_id, data.time, pe->value);
 
                 if (strcmp(event_str, "power:power_end") == 0)
-                        c_state_end(data.cpu, data.time);
+                        c_state_end(pe->cpu_id, data.time);
 
                 if (strcmp(event_str, "power:power_frequency") == 0)
-                        p_state_change(data.cpu, data.time, pe->value);
+                        p_state_change(pe->cpu_id, data.time, pe->value);
 
                 if (strcmp(event_str, "sched:sched_wakeup") == 0)
                         sched_wakeup(data.cpu, data.time, data.pid, te);
@@ -569,88 +564,6 @@ static void end_sample_processing(void)
         }
 }
 
-static u64 sample_time(event_t *event, const struct perf_session *session)
-{
-        int cursor;
-
-        cursor = 0;
-        if (session->sample_type & PERF_SAMPLE_IP)
-                cursor++;
-        if (session->sample_type & PERF_SAMPLE_TID)
-                cursor++;
-        if (session->sample_type & PERF_SAMPLE_TIME)
-                return event->sample.array[cursor];
-        return 0;
-}
-
-
-/*
- * We first queue all events, sorted backwards by insertion.
- * The order will get flipped later.
- */
-static int queue_sample_event(event_t *event, struct perf_session *session)
-{
-        struct sample_wrapper *copy, *prev;
-        int size;
-
-        size = event->sample.header.size + sizeof(struct sample_wrapper) + 8;
-
-        copy = malloc(size);
-        if (!copy)
-                return 1;
-
-        memset(copy, 0, size);
-
-        copy->next = NULL;
-        copy->timestamp = sample_time(event, session);
-
-        memcpy(&copy->data, event, event->sample.header.size);
-
-        /* insert in the right place in the list */
-
-        if (!all_samples) {
-                /* first sample ever */
-                all_samples = copy;
-                return 0;
-        }
-
-        if (all_samples->timestamp < copy->timestamp) {
-                /* insert at the head of the list */
-                copy->next = all_samples;
-                all_samples = copy;
-                return 0;
-        }
-
-        prev = all_samples;
-        while (prev->next) {
-                if (prev->next->timestamp < copy->timestamp) {
-                        copy->next = prev->next;
-                        prev->next = copy;
-                        return 0;
-                }
-                prev = prev->next;
-        }
-        /* insert at the end of the list */
-        prev->next = copy;
-
-        return 0;
-}
-
-static void sort_queued_samples(void)
-{
-        struct sample_wrapper *cursor, *next;
-
-        cursor = all_samples;
-        all_samples = NULL;
-
-        while (cursor) {
-                next = cursor->next;
-                cursor->next = all_samples;
-                all_samples = cursor;
-                cursor = next;
-        }
-}
-
 /*
  * Sort the pid datastructure
  */
@@ -1014,54 +927,29 @@ static void write_svg_file(const char *filename)
         svg_close();
 }
 
-static void process_samples(struct perf_session *session)
-{
-        struct sample_wrapper *cursor;
-        event_t *event;
-
-        sort_queued_samples();
-
-        cursor = all_samples;
-        while (cursor) {
-                event = (void *)&cursor->data;
-                cursor = cursor->next;
-                process_sample_event(event, session);
-        }
-}
-
-static int sample_type_check(struct perf_session *session)
-{
-        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
-                fprintf(stderr, "No trace samples found in the file.\n"
-                                "Have you used 'perf timechart record' to record it?\n");
-                return -1;
-        }
-
-        return 0;
-}
-
 static struct perf_event_ops event_ops = {
-        .process_comm_event     = process_comm_event,
-        .process_fork_event     = process_fork_event,
-        .process_exit_event     = process_exit_event,
-        .process_sample_event   = queue_sample_event,
-        .sample_type_check      = sample_type_check,
+        .comm                   = process_comm_event,
+        .fork                   = process_fork_event,
+        .exit                   = process_exit_event,
+        .sample                 = process_sample_event,
+        .ordered_samples        = true,
 };
 
 static int __cmd_timechart(void)
 {
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0);
-        int ret;
+        struct perf_session *session = perf_session__new(input_name, O_RDONLY, 0, false);
+        int ret = -EINVAL;
 
         if (session == NULL)
                 return -ENOMEM;
 
+        if (!perf_session__has_traces(session, "timechart record"))
+                goto out_delete;
+
         ret = perf_session__process_events(session, &event_ops);
         if (ret)
                 goto out_delete;
 
-        process_samples(session);
-
         end_sample_processing();
 
         sort_pids();
@@ -1084,7 +972,6 @@ static const char *record_args[] = {
         "record",
         "-a",
         "-R",
-        "-M",
         "-f",
         "-c", "1",
         "-e", "power:power_start",
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index ddc584b64871..b513e40974f4 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -28,6 +28,7 @@
 #include <linux/rbtree.h>
 #include "util/parse-options.h"
 #include "util/parse-events.h"
+#include "util/cpumap.h"
 
 #include "util/debug.h"
 
@@ -54,9 +55,9 @@
 #include <linux/unistd.h>
 #include <linux/types.h>
 
-static int                      fd[MAX_NR_CPUS][MAX_COUNTERS];
+static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
 
-static int                      system_wide                     =      0;
+static bool                     system_wide                     =  false;
 
 static int                      default_interval                =      0;
 
@@ -64,18 +65,21 @@ static int			count_filter			=      5;
 static int                      print_entries;
 
 static int                      target_pid                      =     -1;
-static int                      inherit                         =      0;
+static int                      target_tid                      =     -1;
+static pid_t                    *all_tids                       =      NULL;
+static int                      thread_num                      =      0;
+static bool                     inherit                         =  false;
 static int                      profile_cpu                     =     -1;
 static int                      nr_cpus                         =      0;
-static unsigned int             realtime_prio                   =      0;
-static int                      group                           =      0;
+static int                      realtime_prio                   =      0;
+static bool                     group                           =  false;
 static unsigned int             page_size;
 static unsigned int             mmap_pages                      =     16;
 static int                      freq                            =   1000; /* 1 KHz */
 
 static int                      delay_secs                      =      2;
-static int                      zero                            =      0;
-static int                      dump_symtab                     =      0;
+static bool                     zero                            =  false;
+static bool                     dump_symtab                     =  false;
 
 static bool                     hide_kernel_symbols             =  false;
 static bool                     hide_user_symbols               =  false;
@@ -92,11 +96,13 @@ struct source_line {
         struct source_line      *next;
 };
 
-static char                     *sym_filter                     =   NULL;
+static const char               *sym_filter                     =   NULL;
 struct sym_entry                *sym_filter_entry               =   NULL;
+struct sym_entry                *sym_filter_entry_sched         =   NULL;
 static int                      sym_pcnt_filter                 =      5;
 static int                      sym_counter                     =      0;
 static int                      display_weighted                =     -1;
+static const char               *cpu_list;
 
 /*
  * Symbols
@@ -131,7 +137,7 @@ static inline struct symbol *sym_entry__symbol(struct sym_entry *self)
        return ((void *)self) + symbol_conf.priv_size;
 }
 
-static void get_term_dimensions(struct winsize *ws)
+void get_term_dimensions(struct winsize *ws)
 {
         char *s = getenv("LINES");
 
@@ -167,7 +173,7 @@ static void sig_winch_handler(int sig __used)
         update_print_entries(&winsize);
 }
 
-static void parse_source(struct sym_entry *syme)
+static int parse_source(struct sym_entry *syme)
 {
         struct symbol *sym;
         struct sym_entry_source *source;
@@ -178,12 +184,21 @@ static void parse_source(struct sym_entry *syme)
         u64 len;
 
         if (!syme)
-                return;
+                return -1;
+
+        sym = sym_entry__symbol(syme);
+        map = syme->map;
+
+        /*
+         * We can't annotate with just /proc/kallsyms
+         */
+        if (map->dso->origin == DSO__ORIG_KERNEL)
+                return -1;
 
         if (syme->src == NULL) {
                 syme->src = zalloc(sizeof(*source));
                 if (syme->src == NULL)
-                        return;
+                        return -1;
                 pthread_mutex_init(&syme->src->lock, NULL);
         }
 
@@ -193,29 +208,25 @@ static void parse_source(struct sym_entry *syme)
                 pthread_mutex_lock(&source->lock);
                 goto out_assign;
         }
-
-        sym = sym_entry__symbol(syme);
-        map = syme->map;
         path = map->dso->long_name;
 
         len = sym->end - sym->start;
 
         sprintf(command,
-                "objdump --start-address=0x%016Lx "
-                         "--stop-address=0x%016Lx -dS %s",
-                map->unmap_ip(map, sym->start),
-                map->unmap_ip(map, sym->end), path);
+                "objdump --start-address=%#0*Lx --stop-address=%#0*Lx -dS %s",
+                BITS_PER_LONG / 4, map__rip_2objdump(map, sym->start),
+                BITS_PER_LONG / 4, map__rip_2objdump(map, sym->end), path);
 
         file = popen(command, "r");
         if (!file)
-                return;
+                return -1;
 
         pthread_mutex_lock(&source->lock);
         source->lines_tail = &source->lines;
         while (!feof(file)) {
                 struct source_line *src;
                 size_t dummy = 0;
-                char *c;
+                char *c, *sep;
 
                 src = malloc(sizeof(struct source_line));
                 assert(src != NULL);
@@ -234,19 +245,17 @@ static void parse_source(struct sym_entry *syme)
                 *source->lines_tail = src;
                 source->lines_tail = &src->next;
 
-                if (strlen(src->line)>8 && src->line[8] == ':') {
-                        src->eip = strtoull(src->line, NULL, 16);
-                        src->eip = map->unmap_ip(map, src->eip);
-                }
-                if (strlen(src->line)>8 && src->line[16] == ':') {
-                        src->eip = strtoull(src->line, NULL, 16);
-                        src->eip = map->unmap_ip(map, src->eip);
-                }
+                src->eip = strtoull(src->line, &sep, 16);
+                if (*sep == ':')
+                        src->eip = map__objdump_2ip(map, src->eip);
+                else /* this line has no ip info (e.g. source line) */
+                        src->eip = 0;
         }
         pclose(file);
 out_assign:
         sym_filter_entry = syme;
         pthread_mutex_unlock(&source->lock);
+        return 0;
 }
 
 static void __zero_source_counters(struct sym_entry *syme)
@@ -276,6 +285,9 @@ static void record_precise_ip(struct sym_entry *syme, int counter, u64 ip)
                 goto out_unlock;
 
         for (line = syme->src->lines; line; line = line->next) {
+                /* skip lines without IP info */
+                if (line->eip == 0)
+                        continue;
                 if (line->eip == ip) {
                         line->count[counter]++;
                         break;
@@ -287,17 +299,20 @@ out_unlock:
         pthread_mutex_unlock(&syme->src->lock);
 }
 
+#define PATTERN_LEN             (BITS_PER_LONG / 4 + 2)
+
 static void lookup_sym_source(struct sym_entry *syme)
 {
         struct symbol *symbol = sym_entry__symbol(syme);
         struct source_line *line;
-        char pattern[PATH_MAX];
+        char pattern[PATTERN_LEN + 1];
 
-        sprintf(pattern, "<%s>:", symbol->name);
+        sprintf(pattern, "%0*Lx <", BITS_PER_LONG / 4,
+                map__rip_2objdump(syme->map, symbol->start));
 
         pthread_mutex_lock(&syme->src->lock);
         for (line = syme->src->lines; line; line = line->next) {
-                if (strstr(line->line, pattern)) {
+                if (memcmp(line->line, pattern, PATTERN_LEN) == 0) {
                         syme->src->source = line;
                         break;
                 }
@@ -406,7 +421,9 @@ static double sym_weight(const struct sym_entry *sym)
 }
 
 static long                     samples;
-static long                     userspace_samples;
+static long                     kernel_samples, us_samples;
+static long                     exact_samples;
+static long                     guest_us_samples, guest_kernel_samples;
 static const char               CONSOLE_CLEAR[] = "";
 
 static void __list_insert_active_sym(struct sym_entry *syme)
@@ -446,15 +463,20 @@ static void print_sym_table(void)
         int printed = 0, j;
         int counter, snap = !display_weighted ? sym_counter : 0;
         float samples_per_sec = samples/delay_secs;
-        float ksamples_per_sec = (samples-userspace_samples)/delay_secs;
+        float ksamples_per_sec = kernel_samples/delay_secs;
+        float us_samples_per_sec = (us_samples)/delay_secs;
+        float guest_kernel_samples_per_sec = (guest_kernel_samples)/delay_secs;
+        float guest_us_samples_per_sec = (guest_us_samples)/delay_secs;
+        float esamples_percent = (100.0*exact_samples)/samples;
         float sum_ksamples = 0.0;
         struct sym_entry *syme, *n;
         struct rb_root tmp = RB_ROOT;
         struct rb_node *nd;
-        int sym_width = 0, dso_width = 0, max_dso_width;
+        int sym_width = 0, dso_width = 0, dso_short_width = 0;
         const int win_width = winsize.ws_col - 1;
 
-        samples = userspace_samples = 0;
+        samples = us_samples = kernel_samples = exact_samples = 0;
+        guest_kernel_samples = guest_us_samples = 0;
 
         /* Sort the active symbols */
         pthread_mutex_lock(&active_symbols_lock);
@@ -485,9 +507,30 @@ static void print_sym_table(void)
         puts(CONSOLE_CLEAR);
 
         printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
-        printf( "   PerfTop:%8.0f irqs/sec  kernel:%4.1f%% [",
-                samples_per_sec,
-                100.0 - (100.0*((samples_per_sec-ksamples_per_sec)/samples_per_sec)));
+        if (!perf_guest) {
+                printf("   PerfTop:%8.0f irqs/sec  kernel:%4.1f%%"
+                        "  exact: %4.1f%% [",
+                        samples_per_sec,
+                        100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) /
+                                         samples_per_sec)),
+                        esamples_percent);
+        } else {
+                printf("   PerfTop:%8.0f irqs/sec  kernel:%4.1f%% us:%4.1f%%"
+                        " guest kernel:%4.1f%% guest us:%4.1f%%"
+                        " exact: %4.1f%% [",
+                        samples_per_sec,
+                        100.0 - (100.0 * ((samples_per_sec-ksamples_per_sec) /
+                                          samples_per_sec)),
+                        100.0 - (100.0 * ((samples_per_sec-us_samples_per_sec) /
+                                          samples_per_sec)),
+                        100.0 - (100.0 * ((samples_per_sec -
+                                                guest_kernel_samples_per_sec) /
+                                          samples_per_sec)),
+                        100.0 - (100.0 * ((samples_per_sec -
+                                           guest_us_samples_per_sec) /
+                                          samples_per_sec)),
+                        esamples_percent);
+        }
 
         if (nr_counters == 1 || !display_weighted) {
                 printf("%Ld", (u64)attrs[0].sample_period);
@@ -510,13 +553,15 @@ static void print_sym_table(void)
 
         if (target_pid != -1)
                 printf(" (target_pid: %d", target_pid);
+        else if (target_tid != -1)
+                printf(" (target_tid: %d", target_tid);
         else
                 printf(" (all");
 
         if (profile_cpu != -1)
                 printf(", cpu: %d)\n", profile_cpu);
         else {
-                if (target_pid != -1)
+                if (target_tid != -1)
                         printf(")\n");
                 else
                         printf(", %d CPUs)\n", nr_cpus);
@@ -541,15 +586,20 @@ static void print_sym_table(void)
                 if (syme->map->dso->long_name_len > dso_width)
                         dso_width = syme->map->dso->long_name_len;
 
+                if (syme->map->dso->short_name_len > dso_short_width)
+                        dso_short_width = syme->map->dso->short_name_len;
+
                 if (syme->name_len > sym_width)
                         sym_width = syme->name_len;
         }
 
         printed = 0;
 
-        max_dso_width = winsize.ws_col - sym_width - 29;
-        if (dso_width > max_dso_width)
-                dso_width = max_dso_width;
+        if (sym_width + dso_width > winsize.ws_col - 29) {
+                dso_width = dso_short_width;
+                if (sym_width + dso_width > winsize.ws_col - 29)
+                        sym_width = winsize.ws_col - dso_width - 29;
+        }
         putchar('\n');
         if (nr_counters == 1)
                 printf("             samples  pcnt");
@@ -573,7 +623,6 @@ static void print_sym_table(void)
 
                 syme = rb_entry(nd, struct sym_entry, rb_node);
                 sym = sym_entry__symbol(syme);
-
                 if (++printed > print_entries || (int)syme->snap_count < count_filter)
                         continue;
 
@@ -667,7 +716,7 @@ static void prompt_symbol(struct sym_entry **target, const char *msg)
         }
 
         if (!found) {
-                fprintf(stderr, "Sorry, %s is not active.\n", sym_filter);
+                fprintf(stderr, "Sorry, %s is not active.\n", buf);
                 sleep(1);
                 return;
         } else
@@ -695,17 +744,15 @@ static void print_mapped_keys(void)
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
 
-        if (symbol_conf.vmlinux_name) {
-                fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
-                fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
-                fprintf(stdout, "\t[S]     stop annotation.\n");
-        }
+        fprintf(stdout, "\t[F]     annotate display filter (percent). \t(%d%%)\n", sym_pcnt_filter);
+        fprintf(stdout, "\t[s]     annotate symbol.                   \t(%s)\n", name?: "NULL");
+        fprintf(stdout, "\t[S]     stop annotation.\n");
 
         if (nr_counters > 1)
                 fprintf(stdout, "\t[w]     toggle display weighted/count[E]r. \t(%d)\n", display_weighted ? 1 : 0);
 
         fprintf(stdout,
-                "\t[K]     hide kernel_symbols symbols.             \t(%s)\n",
+                "\t[K]     hide kernel_symbols symbols.     \t(%s)\n",
                 hide_kernel_symbols ? "yes" : "no");
         fprintf(stdout,
                 "\t[U]     hide user symbols.               \t(%s)\n",
@@ -725,14 +772,13 @@ static int key_mapped(int c)
                 case 'Q':
                 case 'K':
                 case 'U':
+                case 'F':
+                case 's':
+                case 'S':
                         return 1;
                 case 'E':
                 case 'w':
                         return nr_counters > 1 ? 1 : 0;
-                case 'F':
-                case 's':
-                case 'S':
-                        return symbol_conf.vmlinux_name ? 1 : 0;
                 default:
                         break;
         }
@@ -740,7 +786,7 @@ static int key_mapped(int c)
         return 0;
 }
 
-static void handle_keypress(int c)
+static void handle_keypress(struct perf_session *session, int c)
 {
         if (!key_mapped(c)) {
                 struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
@@ -809,7 +855,7 @@ static void handle_keypress(int c)
                 case 'Q':
                         printf("exiting.\n");
                         if (dump_symtab)
-                                dsos__fprintf(stderr);
+                                perf_session__fprintf_dsos(session, stderr);
                         exit(0);
                 case 's':
                         prompt_symbol(&sym_filter_entry, "Enter details symbol");
@@ -833,7 +879,7 @@ static void handle_keypress(int c)
                         display_weighted = ~display_weighted;
                         break;
                 case 'z':
-                        zero = ~zero;
+                        zero = !zero;
                         break;
                 default:
                         break;
@@ -845,6 +891,7 @@ static void *display_thread(void *arg __used)
         struct pollfd stdin_poll = { .fd = 0, .events = POLLIN };
         struct termios tc, save;
         int delay_msecs, c;
+        struct perf_session *session = (struct perf_session *) arg;
 
         tcgetattr(0, &save);
         tc = save;
@@ -865,7 +912,7 @@ repeat:
         c = getc(stdin);
         tcsetattr(0, TCSAFLUSH, &save);
 
-        handle_keypress(c);
+        handle_keypress(session, c);
         goto repeat;
 
         return NULL;
@@ -910,8 +957,12 @@ static int symbol_filter(struct map *map, struct symbol *sym)
         syme = symbol__priv(sym);
         syme->map = map;
         syme->src = NULL;
-        if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter))
-                sym_filter_entry = syme;
+
+        if (!sym_filter_entry && sym_filter && !strcmp(name, sym_filter)) {
+                /* schedule initial sym_filter_entry setup */
+                sym_filter_entry_sched = syme;
+                sym_filter = NULL;
+        }
 
         for (i = 0; skip_symbols[i]; i++) {
                 if (!strcmp(skip_symbols[i], name)) {
@@ -932,24 +983,92 @@ static void event__process_sample(const event_t *self,
         u64 ip = self->ip.ip;
         struct sym_entry *syme;
         struct addr_location al;
+        struct sample_data data;
+        struct machine *machine;
         u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
+        ++samples;
+
         switch (origin) {
         case PERF_RECORD_MISC_USER:
+                ++us_samples;
                 if (hide_user_symbols)
                         return;
+                machine = perf_session__find_host_machine(session);
                 break;
         case PERF_RECORD_MISC_KERNEL:
+                ++kernel_samples;
                 if (hide_kernel_symbols)
                         return;
+                machine = perf_session__find_host_machine(session);
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                ++guest_kernel_samples;
+                machine = perf_session__find_machine(session, self->ip.pid);
                 break;
+        case PERF_RECORD_MISC_GUEST_USER:
+                ++guest_us_samples;
+                /*
+                 * TODO: we don't process guest user from host side
+                 * except simple counting.
+                 */
+                return;
         default:
                 return;
         }
 
-        if (event__preprocess_sample(self, session, &al, symbol_filter) < 0 ||
-            al.sym == NULL || al.filtered)
+        if (!machine && perf_guest) {
+                pr_err("Can't find guest [%d]'s kernel information\n",
+                        self->ip.pid);
                 return;
+        }
+
+        if (self->header.misc & PERF_RECORD_MISC_EXACT_IP)
+                exact_samples++;
+
+        if (event__preprocess_sample(self, session, &al, &data,
+                                     symbol_filter) < 0 ||
+            al.filtered)
+                return;
+
+        if (al.sym == NULL) {
+                /*
+                 * As we do lazy loading of symtabs we only will know if the
+                 * specified vmlinux file is invalid when we actually have a
+                 * hit in kernel space and then try to load it. So if we get
+                 * here and there are _no_ symbols in the DSO backing the
+                 * kernel map, bail out.
+                 *
+                 * We may never get here, for instance, if we use -K/
+                 * --hide-kernel-symbols, even if the user specifies an
+                 * invalid --vmlinux ;-)
+                 */
+                if (al.map == machine->vmlinux_maps[MAP__FUNCTION] &&
+                    RB_EMPTY_ROOT(&al.map->dso->symbols[MAP__FUNCTION])) {
+                        pr_err("The %s file can't be used\n",
+                               symbol_conf.vmlinux_name);
+                        exit(1);
+                }
+
+                return;
+        }
+
+        /* let's see, whether we need to install initial sym_filter_entry */
+        if (sym_filter_entry_sched) {
+                sym_filter_entry = sym_filter_entry_sched;
+                sym_filter_entry_sched = NULL;
+                if (parse_source(sym_filter_entry) < 0) {
+                        struct symbol *sym = sym_entry__symbol(sym_filter_entry);
+
+                        pr_err("Can't annotate %s", sym->name);
+                        if (sym_filter_entry->map->dso->origin == DSO__ORIG_KERNEL) {
+                                pr_err(": No vmlinux file was found in the path:\n");
+                                machine__fprintf_vmlinux_path(machine, stderr);
+                        } else
+                                pr_err(".\n");
+                        exit(1);
+                }
+        }
 
         syme = symbol__priv(al.sym);
         if (!syme->skip) {
@@ -960,28 +1079,9 @@ static void event__process_sample(const event_t *self,
                 if (list_empty(&syme->node) || !syme->node.next)
                         __list_insert_active_sym(syme);
                 pthread_mutex_unlock(&active_symbols_lock);
-                if (origin == PERF_RECORD_MISC_USER)
-                        ++userspace_samples;
-                ++samples;
         }
 }
 
-static int event__process(event_t *event, struct perf_session *session)
-{
-        switch (event->header.type) {
-        case PERF_RECORD_COMM:
-                event__process_comm(event, session);
-                break;
-        case PERF_RECORD_MMAP:
-                event__process_mmap(event, session);
-                break;
-        default:
-                break;
-        }
-
-        return 0;
-}
-
 struct mmap_data {
         int                     counter;
         void                    *base;
@@ -1063,16 +1163,21 @@ static void perf_session__mmap_read_counter(struct perf_session *self,
         md->prev = old;
 }
 
-static struct pollfd event_array[MAX_NR_CPUS * MAX_COUNTERS];
-static struct mmap_data mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
+static struct pollfd *event_array;
+static struct mmap_data *mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
 
 static void perf_session__mmap_read(struct perf_session *self)
 {
-        int i, counter;
+        int i, counter, thread_index;
 
         for (i = 0; i < nr_cpus; i++) {
                 for (counter = 0; counter < nr_counters; counter++)
-                        perf_session__mmap_read_counter(self, &mmap_array[i][counter]);
+                        for (thread_index = 0;
+                                thread_index < thread_num;
+                                thread_index++) {
+                                perf_session__mmap_read_counter(self,
+                                        &mmap_array[i][counter][thread_index]);
+                        }
         }
 }
 
@@ -1083,10 +1188,11 @@ static void start_counter(int i, int counter)
 {
         struct perf_event_attr *attr;
         int cpu;
+        int thread_index;
 
         cpu = profile_cpu;
-        if (target_pid == -1 && profile_cpu == -1)
-                cpu = i;
+        if (target_tid == -1 && profile_cpu == -1)
+                cpu = cpumap[i];
 
         attr = attrs + counter;
 
@@ -1101,55 +1207,58 @@ static void start_counter(int i, int counter)
         attr->inherit           = (cpu < 0) && inherit;
         attr->mmap              = 1;
 
+        for (thread_index = 0; thread_index < thread_num; thread_index++) {
 try_again:
-        fd[i][counter] = sys_perf_event_open(attr, target_pid, cpu, group_fd, 0);
-
-        if (fd[i][counter] < 0) {
-                int err = errno;
+                fd[i][counter][thread_index] = sys_perf_event_open(attr,
+                                all_tids[thread_index], cpu, group_fd, 0);
+
+                if (fd[i][counter][thread_index] < 0) {
+                        int err = errno;
+
+                        if (err == EPERM || err == EACCES)
+                                die("No permission - are you root?\n");
+                        /*
+                         * If it's cycles then fall back to hrtimer
+                         * based cpu-clock-tick sw counter, which
+                         * is always available even if no PMU support:
+                         */
+                        if (attr->type == PERF_TYPE_HARDWARE
+                                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
+
+                                if (verbose)
+                                        warning(" ... trying to fall back to cpu-clock-ticks\n");
+
+                                attr->type = PERF_TYPE_SOFTWARE;
+                                attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                                goto try_again;
+                        }
+                        printf("\n");
+                        error("perfcounter syscall returned with %d (%s)\n",
+                                        fd[i][counter][thread_index], strerror(err));
+                        die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
+                        exit(-1);
+                }
+                assert(fd[i][counter][thread_index] >= 0);
+                fcntl(fd[i][counter][thread_index], F_SETFL, O_NONBLOCK);
 
-                if (err == EPERM || err == EACCES)
-                        die("No permission - are you root?\n");
                 /*
-                 * If it's cycles then fall back to hrtimer
-                 * based cpu-clock-tick sw counter, which
-                 * is always available even if no PMU support:
+                 * First counter acts as the group leader:
                  */
-                if (attr->type == PERF_TYPE_HARDWARE
-                        && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
-
-                        if (verbose)
-                                warning(" ... trying to fall back to cpu-clock-ticks\n");
-
-                        attr->type = PERF_TYPE_SOFTWARE;
-                        attr->config = PERF_COUNT_SW_CPU_CLOCK;
-                        goto try_again;
-                }
-                printf("\n");
-                error("perfcounter syscall returned with %d (%s)\n",
-                        fd[i][counter], strerror(err));
-                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
-                exit(-1);
+                if (group && group_fd == -1)
+                        group_fd = fd[i][counter][thread_index];
+
+                event_array[nr_poll].fd = fd[i][counter][thread_index];
+                event_array[nr_poll].events = POLLIN;
+                nr_poll++;
+
+                mmap_array[i][counter][thread_index].counter = counter;
+                mmap_array[i][counter][thread_index].prev = 0;
+                mmap_array[i][counter][thread_index].mask = mmap_pages*page_size - 1;
+                mmap_array[i][counter][thread_index].base = mmap(NULL, (mmap_pages+1)*page_size,
+                                PROT_READ, MAP_SHARED, fd[i][counter][thread_index], 0);
+                if (mmap_array[i][counter][thread_index].base == MAP_FAILED)
+                        die("failed to mmap with %d (%s)\n", errno, strerror(errno));
         }
-        assert(fd[i][counter] >= 0);
-        fcntl(fd[i][counter], F_SETFL, O_NONBLOCK);
-
-        /*
-         * First counter acts as the group leader:
-         */
-        if (group && group_fd == -1)
-                group_fd = fd[i][counter];
-
-        event_array[nr_poll].fd = fd[i][counter];
-        event_array[nr_poll].events = POLLIN;
-        nr_poll++;
-
-        mmap_array[i][counter].counter = counter;
-        mmap_array[i][counter].prev = 0;
-        mmap_array[i][counter].mask = mmap_pages*page_size - 1;
-        mmap_array[i][counter].base = mmap(NULL, (mmap_pages+1)*page_size,
-                        PROT_READ, MAP_SHARED, fd[i][counter], 0);
-        if (mmap_array[i][counter].base == MAP_FAILED)
-                die("failed to mmap with %d (%s)\n", errno, strerror(errno));
 }
 
 static int __cmd_top(void)
@@ -1161,12 +1270,12 @@ static int __cmd_top(void)
          * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
          * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
          */
-        struct perf_session *session = perf_session__new(NULL, O_WRONLY, false);
+        struct perf_session *session = perf_session__new(NULL, O_WRONLY, false, false);
         if (session == NULL)
                 return -ENOMEM;
 
-        if (target_pid != -1)
-                event__synthesize_thread(target_pid, event__process, session);
+        if (target_tid != -1)
+                event__synthesize_thread(target_tid, event__process, session);
         else
                 event__synthesize_threads(event__process, session);
 
@@ -1177,11 +1286,11 @@ static int __cmd_top(void)
         }
 
         /* Wait for a minimal set of events before starting the snapshot */
-        poll(event_array, nr_poll, 100);
+        poll(&event_array[0], nr_poll, 100);
 
         perf_session__mmap_read(session);
 
-        if (pthread_create(&thread, NULL, display_thread, NULL)) {
+        if (pthread_create(&thread, NULL, display_thread, session)) {
                 printf("Could not create display thread.\n");
                 exit(-1);
         }
@@ -1220,17 +1329,18 @@ static const struct option options[] = {
         OPT_INTEGER('c', "count", &default_interval,
                     "event period to sample"),
         OPT_INTEGER('p', "pid", &target_pid,
-                    "profile events on existing pid"),
+                    "profile events on existing process id"),
+        OPT_INTEGER('t', "tid", &target_tid,
+                    "profile events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_INTEGER('C', "CPU", &profile_cpu,
-                    "CPU to profile on"),
+        OPT_STRING('C', "cpu", &cpu_list, "cpu",
+                    "list of cpus to monitor"),
         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
                    "file", "vmlinux pathname"),
         OPT_BOOLEAN('K', "hide_kernel_symbols", &hide_kernel_symbols,
                     "hide kernel symbols"),
-        OPT_INTEGER('m', "mmap-pages", &mmap_pages,
-                    "number of mmap data pages"),
+        OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
         OPT_INTEGER('r', "realtime", &realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
         OPT_INTEGER('d', "delay", &delay_secs,
@@ -1244,7 +1354,7 @@ static const struct option options[] = {
         OPT_BOOLEAN('i', "inherit", &inherit,
                     "child tasks inherit counters"),
         OPT_STRING('s', "sym-annotate", &sym_filter, "symbol name",
-                    "symbol to annotate - requires -k option"),
+                    "symbol to annotate"),
         OPT_BOOLEAN('z', "zero", &zero,
                     "zero history across updates"),
         OPT_INTEGER('F', "freq", &freq,
@@ -1253,7 +1363,7 @@ static const struct option options[] = {
                     "display this many functions"),
         OPT_BOOLEAN('U', "hide_user_symbols", &hide_user_symbols,
                     "hide user symbols"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show counter open errors, etc)"),
         OPT_END()
 };
@@ -1261,6 +1371,7 @@ static const struct option options[] = {
 int cmd_top(int argc, const char **argv, const char *prefix __used)
 {
         int counter;
+        int i,j;
 
         page_size = sysconf(_SC_PAGE_SIZE);
 
@@ -1268,11 +1379,42 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         if (argc)
                 usage_with_options(top_usage, options);
 
+        if (target_pid != -1) {
+                target_tid = target_pid;
+                thread_num = find_all_tid(target_pid, &all_tids);
+                if (thread_num <= 0) {
+                        fprintf(stderr, "Can't find all threads of pid %d\n",
+                                target_pid);
+                        usage_with_options(top_usage, options);
+                }
+        } else {
+                all_tids=malloc(sizeof(pid_t));
+                if (!all_tids)
+                        return -ENOMEM;
+
+                all_tids[0] = target_tid;
+                thread_num = 1;
+        }
+
+        for (i = 0; i < MAX_NR_CPUS; i++) {
+                for (j = 0; j < MAX_COUNTERS; j++) {
+                        fd[i][j] = malloc(sizeof(int)*thread_num);
+                        mmap_array[i][j] = zalloc(
+                                sizeof(struct mmap_data)*thread_num);
+                        if (!fd[i][j] || !mmap_array[i][j])
+                                return -ENOMEM;
+                }
+        }
+        event_array = malloc(
+                sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num);
+        if (!event_array)
+                return -ENOMEM;
+
         /* CPU and PID are mutually exclusive */
-        if (target_pid != -1 && profile_cpu != -1) {
+        if (target_tid > 0 && cpu_list) {
                 printf("WARNING: PID switch overriding CPU\n");
                 sleep(1);
-                profile_cpu = -1;
+                cpu_list = NULL;
         }
 
         if (!nr_counters)
@@ -1280,16 +1422,14 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 
         symbol_conf.priv_size = (sizeof(struct sym_entry) +
                                  (nr_counters + 1) * sizeof(unsigned long));
-        if (symbol_conf.vmlinux_name == NULL)
-                symbol_conf.try_vmlinux_path = true;
+
+        symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
         if (symbol__init() < 0)
                 return -1;
 
         if (delay_secs < 1)
                 delay_secs = 1;
 
-        parse_source(sym_filter_entry);
-
         /*
          * User specified count overrides default frequency.
          */
@@ -1312,12 +1452,13 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 attrs[counter].sample_period = default_interval;
         }
 
-        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert(nr_cpus >= 0);
-
-        if (target_pid != -1 || profile_cpu != -1)
+        if (target_tid != -1)
                 nr_cpus = 1;
+        else
+                nr_cpus = read_cpu_map(cpu_list);
+
+        if (nr_cpus < 1)
+                usage_with_options(top_usage, options);
 
         get_term_dimensions(&winsize);
         if (print_entries == 0) {
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 574a215e800b..40a6a2992d15 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -1,16 +1,22 @@
 #include "builtin.h"
 
-#include "util/util.h"
+#include "perf.h"
 #include "util/cache.h"
+#include "util/debug.h"
+#include "util/exec_cmd.h"
+#include "util/header.h"
+#include "util/parse-options.h"
+#include "util/session.h"
 #include "util/symbol.h"
 #include "util/thread.h"
-#include "util/header.h"
-#include "util/exec_cmd.h"
 #include "util/trace-event.h"
-#include "util/session.h"
+#include "util/util.h"
 
 static char const               *script_name;
 static char const               *generate_script_lang;
+static bool                     debug_mode;
+static u64                      last_timestamp;
+static u64                      nr_unordered;
 
 static int default_start_script(const char *script __unused,
                                 int argc __unused,
@@ -44,23 +50,18 @@ static void setup_scripting(void)
         perf_set_argv_exec_path(perf_exec_path());
 
         setup_perl_scripting();
+        setup_python_scripting();
 
         scripting_ops = &default_scripting_ops;
 }
 
 static int cleanup_scripting(void)
 {
+        pr_debug("\nperf trace script stopped\n");
+
         return scripting_ops->stop_script();
 }
 
-#include "util/parse-options.h"
-
-#include "perf.h"
-#include "util/debug.h"
-
-#include "util/trace-event.h"
-#include "util/exec_cmd.h"
-
 static char const               *input_name = "perf.data";
 
 static int process_sample_event(event_t *event, struct perf_session *session)
@@ -75,11 +76,8 @@ static int process_sample_event(event_t *event, struct perf_session *session)
 
         event__parse_sample(event, session->sample_type, &data);
 
-        dump_printf("(IP, %d): %d/%d: %p period: %Ld\n",
-                event->header.misc,
-                data.pid, data.tid,
-                (void *)(long)data.ip,
-                (long long)data.period);
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld\n", event->header.misc,
+                    data.pid, data.tid, data.ip, data.period);
 
         thread = perf_session__findnew(session, event->ip.pid);
         if (thread == NULL) {
@@ -89,6 +87,16 @@ static int process_sample_event(event_t *event, struct perf_session *session)
         }
 
         if (session->sample_type & PERF_SAMPLE_RAW) {
+                if (debug_mode) {
+                        if (data.time < last_timestamp) {
+                                pr_err("Samples misordered, previous: %llu "
+                                        "this: %llu\n", last_timestamp,
+                                        data.time);
+                                nr_unordered++;
+                        }
+                        last_timestamp = data.time;
+                        return 0;
+                }
                 /*
                  * FIXME: better resolve from pid from the struct trace_entry
                  * field, although it should be the same than this perf
@@ -99,31 +107,51 @@ static int process_sample_event(event_t *event, struct perf_session *session)
                                              data.time, thread->comm);
         }
 
-        session->events_stats.total += data.period;
+        session->hists.stats.total_period += data.period;
         return 0;
 }
 
-static int sample_type_check(struct perf_session *session)
+static u64 nr_lost;
+
+static int process_lost_event(event_t *event, struct perf_session *session __used)
 {
-        if (!(session->sample_type & PERF_SAMPLE_RAW)) {
-                fprintf(stderr,
-                        "No trace sample to read. Did you call perf record "
-                        "without -R?");
-                return -1;
-        }
+        nr_lost += event->lost.lost;
 
         return 0;
 }
 
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_comm_event     = event__process_comm,
-        .sample_type_check      = sample_type_check,
+        .sample = process_sample_event,
+        .comm   = event__process_comm,
+        .attr   = event__process_attr,
+        .event_type = event__process_event_type,
+        .tracing_data = event__process_tracing_data,
+        .build_id = event__process_build_id,
+        .lost = process_lost_event,
+        .ordered_samples = true,
 };
 
+extern volatile int session_done;
+
+static void sig_handler(int sig __unused)
+{
+        session_done = 1;
+}
+
 static int __cmd_trace(struct perf_session *session)
 {
-        return perf_session__process_events(session, &event_ops);
+        int ret;
+
+        signal(SIGINT, sig_handler);
+
+        ret = perf_session__process_events(session, &event_ops);
+
+        if (debug_mode) {
+                pr_err("Misordered timestamps: %llu\n", nr_unordered);
+                pr_err("Lost events: %llu\n", nr_lost);
+        }
+
+        return ret;
 }
 
 struct script_spec {
@@ -235,9 +263,9 @@ static int parse_scriptname(const struct option *opt __used,
         const char *script, *ext;
         int len;
 
-        if (strcmp(str, "list") == 0) {
+        if (strcmp(str, "lang") == 0) {
                 list_available_languages();
-                return 0;
+                exit(0);
         }
 
         script = strchr(str, ':');
@@ -520,7 +548,7 @@ static const char * const trace_usage[] = {
 static const struct option options[] = {
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('L', "Latency", &latency_format,
                     "show latency attributes (irqs/preemption disabled, etc)"),
@@ -531,6 +559,10 @@ static const struct option options[] = {
                      parse_scriptname),
         OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
                    "generate perf-trace.xx script in specified language"),
+        OPT_STRING('i', "input", &input_name, "file",
+                    "input file name"),
+        OPT_BOOLEAN('d', "debug-mode", &debug_mode,
+                   "do various checks like samples ordering and lost events"),
 
         OPT_END()
 };
@@ -561,6 +593,65 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
                 suffix = REPORT_SUFFIX;
         }
 
+        if (!suffix && argc >= 2 && strncmp(argv[1], "-", strlen("-")) != 0) {
+                char *record_script_path, *report_script_path;
+                int live_pipe[2];
+                pid_t pid;
+
+                record_script_path = get_script_path(argv[1], RECORD_SUFFIX);
+                if (!record_script_path) {
+                        fprintf(stderr, "record script not found\n");
+                        return -1;
+                }
+
+                report_script_path = get_script_path(argv[1], REPORT_SUFFIX);
+                if (!report_script_path) {
+                        fprintf(stderr, "report script not found\n");
+                        return -1;
+                }
+
+                if (pipe(live_pipe) < 0) {
+                        perror("failed to create pipe");
+                        exit(-1);
+                }
+
+                pid = fork();
+                if (pid < 0) {
+                        perror("failed to fork");
+                        exit(-1);
+                }
+
+                if (!pid) {
+                        dup2(live_pipe[1], 1);
+                        close(live_pipe[0]);
+
+                        __argv = malloc(5 * sizeof(const char *));
+                        __argv[0] = "/bin/sh";
+                        __argv[1] = record_script_path;
+                        __argv[2] = "-o";
+                        __argv[3] = "-";
+                        __argv[4] = NULL;
+
+                        execvp("/bin/sh", (char **)__argv);
+                        exit(-1);
+                }
+
+                dup2(live_pipe[0], 0);
+                close(live_pipe[1]);
+
+                __argv = malloc((argc + 3) * sizeof(const char *));
+                __argv[0] = "/bin/sh";
+                __argv[1] = report_script_path;
+                for (i = 2; i < argc; i++)
+                        __argv[i] = argv[i];
+                __argv[i++] = "-i";
+                __argv[i++] = "-";
+                __argv[i++] = NULL;
+
+                execvp("/bin/sh", (char **)__argv);
+                exit(-1);
+        }
+
         if (suffix) {
                 script_path = get_script_path(argv[2], suffix);
                 if (!script_path) {
@@ -586,12 +677,17 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
 
         if (symbol__init() < 0)
                 return -1;
-        setup_pager();
+        if (!script_name)
+                setup_pager();
 
-        session = perf_session__new(input_name, O_RDONLY, 0);
+        session = perf_session__new(input_name, O_RDONLY, 0, false);
         if (session == NULL)
                 return -ENOMEM;
 
+        if (strcmp(input_name, "-") &&
+            !perf_session__has_traces(session, "record -R"))
+                return -EINVAL;
+
         if (generate_script_lang) {
                 struct stat perf_stat;
 
@@ -618,7 +714,6 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
                         return -1;
                 }
 
-                perf_header__read(&session->header, input);
                 err = scripting_ops->generate_script("perf-trace");
                 goto out;
         }
@@ -627,6 +722,7 @@ int cmd_trace(int argc, const char **argv, const char *prefix __used)
                 err = scripting_ops->start_script(script_name, argc, argv);
                 if (err)
                         goto out;
+                pr_debug("perf trace started with script %s\n\n", script_name);
         }
 
         err = __cmd_trace(session);
diff --git a/tools/perf/builtin.h b/tools/perf/builtin.h
index 18035b1f16c7..921245b28583 100644
--- a/tools/perf/builtin.h
+++ b/tools/perf/builtin.h
@@ -16,6 +16,7 @@ extern int check_pager_config(const char *cmd);
 
 extern int cmd_annotate(int argc, const char **argv, const char *prefix);
 extern int cmd_bench(int argc, const char **argv, const char *prefix);
+extern int cmd_buildid_cache(int argc, const char **argv, const char *prefix);
 extern int cmd_buildid_list(int argc, const char **argv, const char *prefix);
 extern int cmd_diff(int argc, const char **argv, const char *prefix);
 extern int cmd_help(int argc, const char **argv, const char *prefix);
@@ -30,5 +31,9 @@ extern int cmd_trace(int argc, const char **argv, const char *prefix);
 extern int cmd_version(int argc, const char **argv, const char *prefix);
 extern int cmd_probe(int argc, const char **argv, const char *prefix);
 extern int cmd_kmem(int argc, const char **argv, const char *prefix);
+extern int cmd_lock(int argc, const char **argv, const char *prefix);
+extern int cmd_kvm(int argc, const char **argv, const char *prefix);
+extern int cmd_test(int argc, const char **argv, const char *prefix);
+extern int cmd_inject(int argc, const char **argv, const char *prefix);
 
 #endif
diff --git a/tools/perf/command-list.txt b/tools/perf/command-list.txt
index 71dc7c3fe7b2..949d77fc0b97 100644
--- a/tools/perf/command-list.txt
+++ b/tools/perf/command-list.txt
@@ -3,9 +3,12 @@
 # command name                  category [deprecated] [common]
 #
 perf-annotate                   mainporcelain common
+perf-archive                    mainporcelain common
 perf-bench                      mainporcelain common
+perf-buildid-cache              mainporcelain common
 perf-buildid-list               mainporcelain common
 perf-diff                       mainporcelain common
+perf-inject                     mainporcelain common
 perf-list                       mainporcelain common
 perf-sched                      mainporcelain common
 perf-record                     mainporcelain common
@@ -16,3 +19,6 @@ perf-top			mainporcelain common
 perf-trace                      mainporcelain common
 perf-probe                      mainporcelain common
 perf-kmem                       mainporcelain common
+perf-lock                       mainporcelain common
+perf-kvm                        mainporcelain common
+perf-test                       mainporcelain common
diff --git a/tools/perf/design.txt b/tools/perf/design.txt
index 8d0de5130db3..bd0bb1b1279b 100644
--- a/tools/perf/design.txt
+++ b/tools/perf/design.txt
@@ -101,10 +101,10 @@ enum hw_event_ids {
          */
         PERF_COUNT_HW_CPU_CYCLES                = 0,
         PERF_COUNT_HW_INSTRUCTIONS              = 1,
-        PERF_COUNT_HW_CACHE_REFERENCES  = 2,
+        PERF_COUNT_HW_CACHE_REFERENCES          = 2,
         PERF_COUNT_HW_CACHE_MISSES              = 3,
         PERF_COUNT_HW_BRANCH_INSTRUCTIONS       = 4,
-        PERF_COUNT_HW_BRANCH_MISSES     = 5,
+        PERF_COUNT_HW_BRANCH_MISSES             = 5,
         PERF_COUNT_HW_BUS_CYCLES                = 6,
 };
 
@@ -131,8 +131,8 @@ software events, selected by 'event_id':
  */
 enum sw_event_ids {
         PERF_COUNT_SW_CPU_CLOCK         = 0,
-        PERF_COUNT_SW_TASK_CLOCK                = 1,
-        PERF_COUNT_SW_PAGE_FAULTS               = 2,
+        PERF_COUNT_SW_TASK_CLOCK        = 1,
+        PERF_COUNT_SW_PAGE_FAULTS       = 2,
         PERF_COUNT_SW_CONTEXT_SWITCHES  = 3,
         PERF_COUNT_SW_CPU_MIGRATIONS    = 4,
         PERF_COUNT_SW_PAGE_FAULTS_MIN   = 5,
diff --git a/tools/perf/feature-tests.mak b/tools/perf/feature-tests.mak
new file mode 100644
index 000000000000..7a7b60859053
--- /dev/null
+++ b/tools/perf/feature-tests.mak
@@ -0,0 +1,119 @@
+define SOURCE_HELLO
+#include <stdio.h>
+int main(void)
+{
+        return puts(\"hi\");
+}
+endef
+
+ifndef NO_DWARF
+define SOURCE_DWARF
+#include <dwarf.h>
+#include <libdw.h>
+#include <version.h>
+#ifndef _ELFUTILS_PREREQ
+#error
+#endif
+
+int main(void)
+{
+        Dwarf *dbg = dwarf_begin(0, DWARF_C_READ);
+        return (long)dbg;
+}
+endef
+endif
+
+define SOURCE_LIBELF
+#include <libelf.h>
+
+int main(void)
+{
+        Elf *elf = elf_begin(0, ELF_C_READ, 0);
+        return (long)elf;
+}
+endef
+
+define SOURCE_GLIBC
+#include <gnu/libc-version.h>
+
+int main(void)
+{
+        const char *version = gnu_get_libc_version();
+        return (long)version;
+}
+endef
+
+define SOURCE_ELF_MMAP
+#include <libelf.h>
+int main(void)
+{
+        Elf *elf = elf_begin(0, ELF_C_READ_MMAP, 0);
+        return (long)elf;
+}
+endef
+
+ifndef NO_NEWT
+define SOURCE_NEWT
+#include <newt.h>
+
+int main(void)
+{
+        newtInit();
+        newtCls();
+        return newtFinished();
+}
+endef
+endif
+
+ifndef NO_LIBPERL
+define SOURCE_PERL_EMBED
+#include <EXTERN.h>
+#include <perl.h>
+
+int main(void)
+{
+perl_alloc();
+return 0;
+}
+endef
+endif
+
+ifndef NO_LIBPYTHON
+define SOURCE_PYTHON_EMBED
+#include <Python.h>
+
+int main(void)
+{
+        Py_Initialize();
+        return 0;
+}
+endef
+endif
+
+define SOURCE_BFD
+#include <bfd.h>
+
+int main(void)
+{
+        bfd_demangle(0, 0, 0);
+        return 0;
+}
+endef
+
+define SOURCE_CPLUS_DEMANGLE
+extern char *cplus_demangle(const char *, int);
+
+int main(void)
+{
+        cplus_demangle(0, 0);
+        return 0;
+}
+endef
+
+# try-cc
+# Usage: option = $(call try-cc, source-to-build, cc-options)
+try-cc = $(shell sh -c                                            \
+        'TMP="$(OUTPUT)$(TMPOUT).$$$$";                           \
+         echo "$(1)" |                                            \
+         $(CC) -x c - $(2) -o "$$TMP" > /dev/null 2>&1 && echo y; \
+         rm -f "$$TMP"')
diff --git a/tools/perf/perf-archive.sh b/tools/perf/perf-archive.sh
new file mode 100644
index 000000000000..677e59d62a8d
--- /dev/null
+++ b/tools/perf/perf-archive.sh
@@ -0,0 +1,46 @@
+#!/bin/bash
+# perf archive
+# Arnaldo Carvalho de Melo <acme@redhat.com>
+
+PERF_DATA=perf.data
+if [ $# -ne 0 ] ; then
+        PERF_DATA=$1
+fi
+
+#
+# PERF_BUILDID_DIR environment variable set by perf
+# path to buildid directory, default to $HOME/.debug
+#
+if [ -z $PERF_BUILDID_DIR ]; then
+        PERF_BUILDID_DIR=~/.debug/
+else
+        # append / to make substitutions work
+        PERF_BUILDID_DIR=$PERF_BUILDID_DIR/
+fi
+
+BUILDIDS=$(mktemp /tmp/perf-archive-buildids.XXXXXX)
+NOBUILDID=0000000000000000000000000000000000000000
+
+perf buildid-list -i $PERF_DATA --with-hits | grep -v "^$NOBUILDID " > $BUILDIDS
+if [ ! -s $BUILDIDS ] ; then
+        echo "perf archive: no build-ids found"
+        rm -f $BUILDIDS
+        exit 1
+fi
+
+MANIFEST=$(mktemp /tmp/perf-archive-manifest.XXXXXX)
+
+cut -d ' ' -f 1 $BUILDIDS | \
+while read build_id ; do
+        linkname=$PERF_BUILDID_DIR.build-id/${build_id:0:2}/${build_id:2}
+        filename=$(readlink -f $linkname)
+        echo ${linkname#$PERF_BUILDID_DIR} >> $MANIFEST
+        echo ${filename#$PERF_BUILDID_DIR} >> $MANIFEST
+done
+
+tar cfj $PERF_DATA.tar.bz2 -C $PERF_BUILDID_DIR -T $MANIFEST
+rm -f $MANIFEST $BUILDIDS
+echo -e "Now please run:\n"
+echo -e "$ tar xvf $PERF_DATA.tar.bz2 -C ~/.debug\n"
+echo "wherever you need to run 'perf report' on."
+exit 0
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 873e55fab375..cdd6c03f1e14 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -13,7 +13,6 @@
 #include "util/quote.h"
 #include "util/run-command.h"
 #include "util/parse-events.h"
-#include "util/string.h"
 #include "util/debugfs.h"
 
 const char perf_usage_string[] =
@@ -22,7 +21,9 @@ const char perf_usage_string[] =
 const char perf_more_info_string[] =
         "See 'perf help COMMAND' for more information on a specific command.";
 
+int use_browser = -1;
 static int use_pager = -1;
+
 struct pager_config {
         const char *cmd;
         int val;
@@ -48,7 +49,26 @@ int check_pager_config(const char *cmd)
         return c.val;
 }
 
-static void commit_pager_choice(void) {
+static int tui_command_config(const char *var, const char *value, void *data)
+{
+        struct pager_config *c = data;
+        if (!prefixcmp(var, "tui.") && !strcmp(var + 4, c->cmd))
+                c->val = perf_config_bool(var, value);
+        return 0;
+}
+
+/* returns 0 for "no tui", 1 for "use tui", and -1 for "not specified" */
+static int check_tui_config(const char *cmd)
+{
+        struct pager_config c;
+        c.cmd = cmd;
+        c.val = -1;
+        perf_config(tui_command_config, &c);
+        return c.val;
+}
+
+static void commit_pager_choice(void)
+{
         switch (use_pager) {
         case 0:
                 setenv("PERF_PAGER", "cat", 1);
@@ -70,7 +90,7 @@ static void set_debugfs_path(void)
                  "tracing/events");
 }
 
-static int handle_options(const char*** argv, int* argc, int* envchanged)
+static int handle_options(const char ***argv, int *argc, int *envchanged)
 {
         int handled = 0;
 
@@ -109,7 +129,7 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                                 *envchanged = 1;
                 } else if (!strcmp(cmd, "--perf-dir")) {
                         if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --perf-dir.\n" );
+                                fprintf(stderr, "No directory given for --perf-dir.\n");
                                 usage(perf_usage_string);
                         }
                         setenv(PERF_DIR_ENVIRONMENT, (*argv)[1], 1);
@@ -124,7 +144,7 @@ static int handle_options(const char*** argv, int* argc, int* envchanged)
                                 *envchanged = 1;
                 } else if (!strcmp(cmd, "--work-tree")) {
                         if (*argc < 2) {
-                                fprintf(stderr, "No directory given for --work-tree.\n" );
+                                fprintf(stderr, "No directory given for --work-tree.\n");
                                 usage(perf_usage_string);
                         }
                         setenv(PERF_WORK_TREE_ENVIRONMENT, (*argv)[1], 1);
@@ -168,7 +188,7 @@ static int handle_alias(int *argcp, const char ***argv)
 {
         int envchanged = 0, ret = 0, saved_errno = errno;
         int count, option_count;
-        const char** new_argv;
+        const char **new_argv;
         const char *alias_command;
         char *alias_string;
 
@@ -210,11 +230,11 @@ static int handle_alias(int *argcp, const char ***argv)
                 if (!strcmp(alias_command, new_argv[0]))
                         die("recursive alias: %s", alias_command);
 
-                new_argv = realloc(new_argv, sizeof(char*) *
+                new_argv = realloc(new_argv, sizeof(char *) *
                                     (count + *argcp + 1));
                 /* insert after command name */
-                memcpy(new_argv + count, *argv + 1, sizeof(char*) * *argcp);
-                new_argv[count+*argcp] = NULL;
+                memcpy(new_argv + count, *argv + 1, sizeof(char *) * *argcp);
+                new_argv[count + *argcp] = NULL;
 
                 *argv = new_argv;
                 *argcp += count - 1;
@@ -253,6 +273,9 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         if (p->option & RUN_SETUP)
                 prefix = NULL; /* setup_perf_directory(); */
 
+        if (use_browser == -1)
+                use_browser = check_tui_config(p->cmd);
+
         if (use_pager == -1 && p->option & RUN_SETUP)
                 use_pager = check_pager_config(p->cmd);
         if (use_pager == -1 && p->option & USE_PAGER)
@@ -261,6 +284,8 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         set_debugfs_path();
 
         status = p->fn(argc, argv, prefix);
+        exit_browser(status);
+
         if (status)
                 return status & 0xff;
 
@@ -285,6 +310,7 @@ static void handle_internal_command(int argc, const char **argv)
 {
         const char *cmd = argv[0];
         static struct cmd_struct commands[] = {
+                { "buildid-cache", cmd_buildid_cache, 0 },
                 { "buildid-list", cmd_buildid_list, 0 },
                 { "diff",       cmd_diff,       0 },
                 { "help",       cmd_help,       0 },
@@ -301,6 +327,10 @@ static void handle_internal_command(int argc, const char **argv)
                 { "sched",      cmd_sched,      0 },
                 { "probe",      cmd_probe,      0 },
                 { "kmem",       cmd_kmem,       0 },
+                { "lock",       cmd_lock,       0 },
+                { "kvm",        cmd_kvm,        0 },
+                { "test",       cmd_test,       0 },
+                { "inject",     cmd_inject,     0 },
         };
         unsigned int i;
         static const char ext[] = STRIP_EXTENSION;
@@ -388,7 +418,7 @@ static int run_argv(int *argcp, const char ***argv)
 /* mini /proc/mounts parser: searching for "^blah /mount/point debugfs" */
 static void get_debugfs_mntpt(void)
 {
-        const char *path = debugfs_find_mountpoint();
+        const char *path = debugfs_mount(NULL);
 
         if (path)
                 strncpy(debugfs_mntpt, path, sizeof(debugfs_mntpt));
@@ -428,6 +458,8 @@ int main(int argc, const char **argv)
         handle_options(&argv, &argc, NULL);
         commit_pager_choice();
         set_debugfs_path();
+        set_buildid_dir();
+
         if (argc > 0) {
                 if (!prefixcmp(argv[0], "--"))
                         argv[0] += 2;
@@ -442,15 +474,15 @@ int main(int argc, const char **argv)
 
         /*
          * We use PATH to find perf commands, but we prepend some higher
-         * precidence paths: the "--exec-path" option, the PERF_EXEC_PATH
+         * precedence paths: the "--exec-path" option, the PERF_EXEC_PATH
          * environment, and the $(perfexecdir) from the Makefile at build
          * time.
          */
         setup_path();
 
         while (1) {
-                static int done_help = 0;
-                static int was_alias = 0;
+                static int done_help;
+                static int was_alias;
 
                 was_alias = run_argv(&argc, &argv);
                 if (errno != ENOENT)
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 75f941bfba9e..95aaf565c704 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -1,6 +1,10 @@
 #ifndef _PERF_PERF_H
 #define _PERF_PERF_H
 
+struct winsize;
+
+void get_term_dimensions(struct winsize *ws);
+
 #if defined(__i386__)
 #include "../../arch/x86/include/asm/unistd.h"
 #define rmb()           asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
@@ -65,12 +69,22 @@
  * Use the __kuser_memory_barrier helper in the CPU helper page. See
  * arch/arm/kernel/entry-armv.S in the kernel source for details.
  */
-#define rmb()           asm volatile("mov r0, #0xffff0fff; mov lr, pc;" \
-                                     "sub pc, r0, #95" ::: "r0", "lr", "cc", \
-                                     "memory")
+#define rmb()           ((void(*)(void))0xffff0fa0)()
 #define cpu_relax()     asm volatile("":::"memory")
 #endif
 
+#ifdef __mips__
+#include "../../arch/mips/include/asm/unistd.h"
+#define rmb()           asm volatile(                                   \
+                                ".set   mips2\n\t"                      \
+                                "sync\n\t"                              \
+                                ".set   mips0"                          \
+                                : /* no output */                       \
+                                : /* no input */                        \
+                                : "memory")
+#define cpu_relax()     asm volatile("" ::: "memory")
+#endif
+
 #include <time.h>
 #include <unistd.h>
 #include <sys/types.h>
@@ -78,6 +92,7 @@
 
 #include "../../include/linux/perf_event.h"
 #include "util/types.h"
+#include <stdbool.h>
 
 /*
  * prctl(PR_TASK_PERF_EVENTS_DISABLE) will (cheaply) disable all
@@ -104,8 +119,6 @@ static inline unsigned long long rdclock(void)
 #define __user
 #define asmlinkage
 
-#define __used          __attribute__((__unused__))
-
 #define unlikely(x)     __builtin_expect(!!(x), 0)
 #define min(x, y) ({                            \
         typeof(x) _min1 = (x);                  \
@@ -131,4 +144,6 @@ struct ip_callchain {
         u64 ips[0];
 };
 
+extern bool perf_host, perf_guest;
+
 #endif
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.c b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
index af78d9a52a7d..01a64ad693f2 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.c
@@ -31,13 +31,14 @@
 #include "EXTERN.h"
 #include "perl.h"
 #include "XSUB.h"
-#include "../../../util/trace-event-perl.h"
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
 
 #ifndef PERL_UNUSED_VAR
 #  define PERL_UNUSED_VAR(var) if (0) var = var
 #endif
 
-#line 41 "Context.c"
+#line 42 "Context.c"
 
 XS(XS_Perf__Trace__Context_common_pc); /* prototype to pass -Wmissing-prototypes */
 XS(XS_Perf__Trace__Context_common_pc)
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
index fb78006c165e..549cf0467d30 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/Context.xs
@@ -22,7 +22,8 @@
 #include "EXTERN.h"
 #include "perl.h"
 #include "XSUB.h"
-#include "../../../util/trace-event-perl.h"
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
 
 MODULE = Perf::Trace::Context           PACKAGE = Perf::Trace::Context
 PROTOTYPES: ENABLE
diff --git a/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm
index 052f132ced24..d94b40c8ac85 100644
--- a/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm
+++ b/tools/perf/scripts/perl/Perf-Trace-Util/lib/Perf/Trace/Util.pm
@@ -15,6 +15,7 @@ our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
 
 our @EXPORT = qw(
 avg nsecs nsecs_secs nsecs_nsecs nsecs_usecs print_nsecs
+clear_term
 );
 
 our $VERSION = '0.01';
@@ -44,7 +45,7 @@ sub nsecs_secs {
 sub nsecs_nsecs {
     my ($nsecs) = @_;
 
-    return $nsecs - nsecs_secs($nsecs);
+    return $nsecs % $NSECS_PER_SEC;
 }
 
 sub nsecs_str {
@@ -55,6 +56,11 @@ sub nsecs_str {
     return $str;
 }
 
+sub clear_term
+{
+    print "\x1b[H\x1b[2J";
+}
+
 1;
 __END__
 =head1 NAME
diff --git a/tools/perf/scripts/perl/bin/check-perf-trace-record b/tools/perf/scripts/perl/bin/check-perf-trace-record
index c7ec5de2f535..423ad6aed056 100644
--- a/tools/perf/scripts/perl/bin/check-perf-trace-record
+++ b/tools/perf/scripts/perl/bin/check-perf-trace-record
@@ -1,7 +1,2 @@
 #!/bin/bash
-perf record -c 1 -f -a -M -R -e kmem:kmalloc -e irq:softirq_entry
-
-
-
-
-
+perf record -a -e kmem:kmalloc -e irq:softirq_entry -e kmem:kfree
diff --git a/tools/perf/scripts/perl/bin/check-perf-trace-report b/tools/perf/scripts/perl/bin/check-perf-trace-report
deleted file mode 100644
index 7fc4a033dd49..000000000000
--- a/tools/perf/scripts/perl/bin/check-perf-trace-report
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash
-# description: useless but exhaustive test script
-perf trace -s ~/libexec/perf-core/scripts/perl/check-perf-trace.pl
-
-
-
diff --git a/tools/perf/scripts/perl/bin/failed-syscalls-record b/tools/perf/scripts/perl/bin/failed-syscalls-record
new file mode 100644
index 000000000000..eb5846bcb565
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/failed-syscalls-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_exit $@
diff --git a/tools/perf/scripts/perl/bin/failed-syscalls-report b/tools/perf/scripts/perl/bin/failed-syscalls-report
new file mode 100644
index 000000000000..e3a5e55d54ff
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/failed-syscalls-report
@@ -0,0 +1,10 @@
+#!/bin/bash
+# description: system-wide failed syscalls
+# args: [comm]
+if [ $# -gt 0 ] ; then
+    if ! expr match "$1" "-" > /dev/null ; then
+        comm=$1
+        shift
+    fi
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/failed-syscalls.pl $comm
diff --git a/tools/perf/scripts/perl/bin/rw-by-file-record b/tools/perf/scripts/perl/bin/rw-by-file-record
index b25056ebf963..5bfaae5a6cba 100644
--- a/tools/perf/scripts/perl/bin/rw-by-file-record
+++ b/tools/perf/scripts/perl/bin/rw-by-file-record
@@ -1,2 +1,3 @@
 #!/bin/bash
-perf record -c 1 -f -a -M -R -e syscalls:sys_enter_read -e syscalls:sys_enter_write
+perf record -a -e syscalls:sys_enter_read -e syscalls:sys_enter_write $@
+
diff --git a/tools/perf/scripts/perl/bin/rw-by-file-report b/tools/perf/scripts/perl/bin/rw-by-file-report
index eddb9ccce6a5..d83070b7eeb5 100644
--- a/tools/perf/scripts/perl/bin/rw-by-file-report
+++ b/tools/perf/scripts/perl/bin/rw-by-file-report
@@ -1,7 +1,13 @@
 #!/bin/bash
 # description: r/w activity for a program, by file
 # args: <comm>
-perf trace -s ~/libexec/perf-core/scripts/perl/rw-by-file.pl $1
+if [ $# -lt 1 ] ; then
+    echo "usage: rw-by-file <comm>"
+    exit
+fi
+comm=$1
+shift
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/rw-by-file.pl $comm
 
 
 
diff --git a/tools/perf/scripts/perl/bin/rw-by-pid-record b/tools/perf/scripts/perl/bin/rw-by-pid-record
index 8903979c5b6c..6e0b2f7755ac 100644
--- a/tools/perf/scripts/perl/bin/rw-by-pid-record
+++ b/tools/perf/scripts/perl/bin/rw-by-pid-record
@@ -1,2 +1,2 @@
 #!/bin/bash
-perf record -c 1 -f -a -M -R -e syscalls:sys_enter_read -e syscalls:sys_exit_read -e syscalls:sys_enter_write -e syscalls:sys_exit_write
+perf record -a -e syscalls:sys_enter_read -e syscalls:sys_exit_read -e syscalls:sys_enter_write -e syscalls:sys_exit_write $@
diff --git a/tools/perf/scripts/perl/bin/rw-by-pid-report b/tools/perf/scripts/perl/bin/rw-by-pid-report
index 7f44c25cc857..7ef46983f62f 100644
--- a/tools/perf/scripts/perl/bin/rw-by-pid-report
+++ b/tools/perf/scripts/perl/bin/rw-by-pid-report
@@ -1,6 +1,6 @@
 #!/bin/bash
 # description: system-wide r/w activity
-perf trace -s ~/libexec/perf-core/scripts/perl/rw-by-pid.pl
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/rw-by-pid.pl
 
 
 
diff --git a/tools/perf/scripts/perl/bin/rwtop-record b/tools/perf/scripts/perl/bin/rwtop-record
new file mode 100644
index 000000000000..6e0b2f7755ac
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rwtop-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e syscalls:sys_enter_read -e syscalls:sys_exit_read -e syscalls:sys_enter_write -e syscalls:sys_exit_write $@
diff --git a/tools/perf/scripts/perl/bin/rwtop-report b/tools/perf/scripts/perl/bin/rwtop-report
new file mode 100644
index 000000000000..93e698cd3f38
--- /dev/null
+++ b/tools/perf/scripts/perl/bin/rwtop-report
@@ -0,0 +1,23 @@
+#!/bin/bash
+# description: system-wide r/w top
+# args: [interval]
+n_args=0
+for i in "$@"
+do
+    if expr match "$i" "-" > /dev/null ; then
+        break
+    fi
+    n_args=$(( $n_args + 1 ))
+done
+if [ "$n_args" -gt 1 ] ; then
+    echo "usage: rwtop-report [interval]"
+    exit
+fi
+if [ "$n_args" -gt 0 ] ; then
+    interval=$1
+    shift
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/rwtop.pl $interval
+
+
+
diff --git a/tools/perf/scripts/perl/bin/wakeup-latency-record b/tools/perf/scripts/perl/bin/wakeup-latency-record
index 6abedda911a4..9f2acaaae9f0 100644
--- a/tools/perf/scripts/perl/bin/wakeup-latency-record
+++ b/tools/perf/scripts/perl/bin/wakeup-latency-record
@@ -1,5 +1,5 @@
 #!/bin/bash
-perf record -c 1 -f -a -M -R -e sched:sched_switch -e sched:sched_wakeup
+perf record -a -e sched:sched_switch -e sched:sched_wakeup $@
 
 
 
diff --git a/tools/perf/scripts/perl/bin/wakeup-latency-report b/tools/perf/scripts/perl/bin/wakeup-latency-report
index fce3adcb3249..a0d898f9ca1d 100644
--- a/tools/perf/scripts/perl/bin/wakeup-latency-report
+++ b/tools/perf/scripts/perl/bin/wakeup-latency-report
@@ -1,6 +1,6 @@
 #!/bin/bash
 # description: system-wide min/max/avg wakeup latency
-perf trace -s ~/libexec/perf-core/scripts/perl/wakeup-latency.pl
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/wakeup-latency.pl
 
 
 
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-record b/tools/perf/scripts/perl/bin/workqueue-stats-record
index fce6637b19ba..85301f2471ff 100644
--- a/tools/perf/scripts/perl/bin/workqueue-stats-record
+++ b/tools/perf/scripts/perl/bin/workqueue-stats-record
@@ -1,2 +1,2 @@
 #!/bin/bash
-perf record -c 1 -f -a -M -R -e workqueue:workqueue_creation -e workqueue:workqueue_destruction -e workqueue:workqueue_execution -e workqueue:workqueue_insertion
+perf record -a -e workqueue:workqueue_creation -e workqueue:workqueue_destruction -e workqueue:workqueue_execution -e workqueue:workqueue_insertion $@
diff --git a/tools/perf/scripts/perl/bin/workqueue-stats-report b/tools/perf/scripts/perl/bin/workqueue-stats-report
index 71cfbd182fb9..35081132ef97 100644
--- a/tools/perf/scripts/perl/bin/workqueue-stats-report
+++ b/tools/perf/scripts/perl/bin/workqueue-stats-report
@@ -1,6 +1,6 @@
 #!/bin/bash
 # description: workqueue stats (ins/exe/create/destroy)
-perf trace -s ~/libexec/perf-core/scripts/perl/workqueue-stats.pl
+perf trace $@ -s ~/libexec/perf-core/scripts/perl/workqueue-stats.pl
 
 
 
diff --git a/tools/perf/scripts/perl/failed-syscalls.pl b/tools/perf/scripts/perl/failed-syscalls.pl
new file mode 100644
index 000000000000..94bc25a347eb
--- /dev/null
+++ b/tools/perf/scripts/perl/failed-syscalls.pl
@@ -0,0 +1,42 @@
+# failed system call counts
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide failed system call totals
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Context;
+use Perf::Trace::Util;
+
+my $for_comm = shift;
+
+my %failed_syscalls;
+
+sub raw_syscalls::sys_exit
+{
+        my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+            $common_pid, $common_comm,
+            $id, $ret) = @_;
+
+        if ($ret < 0) {
+            $failed_syscalls{$common_comm}++;
+        }
+}
+
+sub trace_end
+{
+    printf("\nfailed syscalls by comm:\n\n");
+
+    printf("%-20s  %10s\n", "comm", "# errors");
+    printf("%-20s  %6s  %10s\n", "--------------------", "----------");
+
+    foreach my $comm (sort {$failed_syscalls{$b} <=> $failed_syscalls{$a}}
+                      keys %failed_syscalls) {
+        next if ($for_comm && $comm ne $for_comm);
+
+        printf("%-20s  %10s\n", $comm, $failed_syscalls{$comm});
+    }
+}
diff --git a/tools/perf/scripts/perl/rw-by-pid.pl b/tools/perf/scripts/perl/rw-by-pid.pl
index da601fae1a00..9db23c9daf55 100644
--- a/tools/perf/scripts/perl/rw-by-pid.pl
+++ b/tools/perf/scripts/perl/rw-by-pid.pl
@@ -79,12 +79,12 @@ sub trace_end
     printf("%6s  %-20s  %10s  %10s  %10s\n", "------", "--------------------",
            "-----------", "----------", "----------");
 
-    foreach my $pid (sort {$reads{$b}{bytes_read} <=>
-                               $reads{$a}{bytes_read}} keys %reads) {
-        my $comm = $reads{$pid}{comm};
-        my $total_reads = $reads{$pid}{total_reads};
-        my $bytes_requested = $reads{$pid}{bytes_requested};
-        my $bytes_read = $reads{$pid}{bytes_read};
+    foreach my $pid (sort { ($reads{$b}{bytes_read} || 0) <=>
+                                ($reads{$a}{bytes_read} || 0) } keys %reads) {
+        my $comm = $reads{$pid}{comm} || "";
+        my $total_reads = $reads{$pid}{total_reads} || 0;
+        my $bytes_requested = $reads{$pid}{bytes_requested} || 0;
+        my $bytes_read = $reads{$pid}{bytes_read} || 0;
 
         printf("%6s  %-20s  %10s  %10s  %10s\n", $pid, $comm,
                $total_reads, $bytes_requested, $bytes_read);
@@ -96,16 +96,23 @@ sub trace_end
     printf("%6s  %20s  %6s  %10s\n", "------", "--------------------",
            "------", "----------");
 
-    foreach my $pid (keys %reads) {
-        my $comm = $reads{$pid}{comm};
-        foreach my $err (sort {$reads{$b}{comm} cmp $reads{$a}{comm}}
-                         keys %{$reads{$pid}{errors}}) {
-            my $errors = $reads{$pid}{errors}{$err};
+    my @errcounts = ();
 
-            printf("%6d  %-20s  %6d  %10s\n", $pid, $comm, $err, $errors);
+    foreach my $pid (keys %reads) {
+        foreach my $error (keys %{$reads{$pid}{errors}}) {
+            my $comm = $reads{$pid}{comm} || "";
+            my $errcount = $reads{$pid}{errors}{$error} || 0;
+            push @errcounts, [$pid, $comm, $error, $errcount];
         }
     }
 
+    @errcounts = sort { $b->[3] <=> $a->[3] } @errcounts;
+
+    for my $i (0 .. $#errcounts) {
+        printf("%6d  %-20s  %6d  %10s\n", $errcounts[$i][0],
+               $errcounts[$i][1], $errcounts[$i][2], $errcounts[$i][3]);
+    }
+
     printf("\nwrite counts by pid:\n\n");
 
     printf("%6s  %20s  %10s  %10s\n", "pid", "comm",
@@ -113,11 +120,11 @@ sub trace_end
     printf("%6s  %-20s  %10s  %10s\n", "------", "--------------------",
            "-----------", "----------");
 
-    foreach my $pid (sort {$writes{$b}{bytes_written} <=>
-                               $writes{$a}{bytes_written}} keys %writes) {
-        my $comm = $writes{$pid}{comm};
-        my $total_writes = $writes{$pid}{total_writes};
-        my $bytes_written = $writes{$pid}{bytes_written};
+    foreach my $pid (sort { ($writes{$b}{bytes_written} || 0) <=>
+                        ($writes{$a}{bytes_written} || 0)} keys %writes) {
+        my $comm = $writes{$pid}{comm} || "";
+        my $total_writes = $writes{$pid}{total_writes} || 0;
+        my $bytes_written = $writes{$pid}{bytes_written} || 0;
 
         printf("%6s  %-20s  %10s  %10s\n", $pid, $comm,
                $total_writes, $bytes_written);
@@ -129,16 +136,23 @@ sub trace_end
     printf("%6s  %20s  %6s  %10s\n", "------", "--------------------",
            "------", "----------");
 
-    foreach my $pid (keys %writes) {
-        my $comm = $writes{$pid}{comm};
-        foreach my $err (sort {$writes{$b}{comm} cmp $writes{$a}{comm}}
-                         keys %{$writes{$pid}{errors}}) {
-            my $errors = $writes{$pid}{errors}{$err};
+    @errcounts = ();
 
-            printf("%6d  %-20s  %6d  %10s\n", $pid, $comm, $err, $errors);
+    foreach my $pid (keys %writes) {
+        foreach my $error (keys %{$writes{$pid}{errors}}) {
+            my $comm = $writes{$pid}{comm} || "";
+            my $errcount = $writes{$pid}{errors}{$error} || 0;
+            push @errcounts, [$pid, $comm, $error, $errcount];
         }
     }
 
+    @errcounts = sort { $b->[3] <=> $a->[3] } @errcounts;
+
+    for my $i (0 .. $#errcounts) {
+        printf("%6d  %-20s  %6d  %10s\n", $errcounts[$i][0],
+               $errcounts[$i][1], $errcounts[$i][2], $errcounts[$i][3]);
+    }
+
     print_unhandled();
 }
 
diff --git a/tools/perf/scripts/perl/rwtop.pl b/tools/perf/scripts/perl/rwtop.pl
new file mode 100644
index 000000000000..4bb3ecd33472
--- /dev/null
+++ b/tools/perf/scripts/perl/rwtop.pl
@@ -0,0 +1,199 @@
+#!/usr/bin/perl -w
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+
+# read/write top
+#
+# Periodically displays system-wide r/w call activity, broken down by
+# pid.  If an [interval] arg is specified, the display will be
+# refreshed every [interval] seconds.  The default interval is 3
+# seconds.
+
+use 5.010000;
+use strict;
+use warnings;
+
+use lib "$ENV{'PERF_EXEC_PATH'}/scripts/perl/Perf-Trace-Util/lib";
+use lib "./Perf-Trace-Util/lib";
+use Perf::Trace::Core;
+use Perf::Trace::Util;
+
+my $default_interval = 3;
+my $nlines = 20;
+my $print_thread;
+my $print_pending = 0;
+
+my %reads;
+my %writes;
+
+my $interval = shift;
+if (!$interval) {
+    $interval = $default_interval;
+}
+
+sub syscalls::sys_exit_read
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $ret) = @_;
+
+    print_check();
+
+    if ($ret > 0) {
+        $reads{$common_pid}{bytes_read} += $ret;
+    } else {
+        if (!defined ($reads{$common_pid}{bytes_read})) {
+            $reads{$common_pid}{bytes_read} = 0;
+        }
+        $reads{$common_pid}{errors}{$ret}++;
+    }
+}
+
+sub syscalls::sys_enter_read
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $fd, $buf, $count) = @_;
+
+    print_check();
+
+    $reads{$common_pid}{bytes_requested} += $count;
+    $reads{$common_pid}{total_reads}++;
+    $reads{$common_pid}{comm} = $common_comm;
+}
+
+sub syscalls::sys_exit_write
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $ret) = @_;
+
+    print_check();
+
+    if ($ret <= 0) {
+        $writes{$common_pid}{errors}{$ret}++;
+    }
+}
+
+sub syscalls::sys_enter_write
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm,
+        $nr, $fd, $buf, $count) = @_;
+
+    print_check();
+
+    $writes{$common_pid}{bytes_written} += $count;
+    $writes{$common_pid}{total_writes}++;
+    $writes{$common_pid}{comm} = $common_comm;
+}
+
+sub trace_begin
+{
+    $SIG{ALRM} = \&set_print_pending;
+    alarm 1;
+}
+
+sub trace_end
+{
+    print_unhandled();
+    print_totals();
+}
+
+sub print_check()
+{
+    if ($print_pending == 1) {
+        $print_pending = 0;
+        print_totals();
+    }
+}
+
+sub set_print_pending()
+{
+    $print_pending = 1;
+    alarm $interval;
+}
+
+sub print_totals
+{
+    my $count;
+
+    $count = 0;
+
+    clear_term();
+
+    printf("\nread counts by pid:\n\n");
+
+    printf("%6s  %20s  %10s  %10s  %10s\n", "pid", "comm",
+           "# reads", "bytes_req", "bytes_read");
+    printf("%6s  %-20s  %10s  %10s  %10s\n", "------", "--------------------",
+           "----------", "----------", "----------");
+
+    foreach my $pid (sort { ($reads{$b}{bytes_read} || 0) <=>
+                               ($reads{$a}{bytes_read} || 0) } keys %reads) {
+        my $comm = $reads{$pid}{comm} || "";
+        my $total_reads = $reads{$pid}{total_reads} || 0;
+        my $bytes_requested = $reads{$pid}{bytes_requested} || 0;
+        my $bytes_read = $reads{$pid}{bytes_read} || 0;
+
+        printf("%6s  %-20s  %10s  %10s  %10s\n", $pid, $comm,
+               $total_reads, $bytes_requested, $bytes_read);
+
+        if (++$count == $nlines) {
+            last;
+        }
+    }
+
+    $count = 0;
+
+    printf("\nwrite counts by pid:\n\n");
+
+    printf("%6s  %20s  %10s  %13s\n", "pid", "comm",
+           "# writes", "bytes_written");
+    printf("%6s  %-20s  %10s  %13s\n", "------", "--------------------",
+           "----------", "-------------");
+
+    foreach my $pid (sort { ($writes{$b}{bytes_written} || 0) <=>
+                        ($writes{$a}{bytes_written} || 0)} keys %writes) {
+        my $comm = $writes{$pid}{comm} || "";
+        my $total_writes = $writes{$pid}{total_writes} || 0;
+        my $bytes_written = $writes{$pid}{bytes_written} || 0;
+
+        printf("%6s  %-20s  %10s  %13s\n", $pid, $comm,
+               $total_writes, $bytes_written);
+
+        if (++$count == $nlines) {
+            last;
+        }
+    }
+
+    %reads = ();
+    %writes = ();
+}
+
+my %unhandled;
+
+sub print_unhandled
+{
+    if ((scalar keys %unhandled) == 0) {
+        return;
+    }
+
+    print "\nunhandled events:\n\n";
+
+    printf("%-40s  %10s\n", "event", "count");
+    printf("%-40s  %10s\n", "----------------------------------------",
+           "-----------");
+
+    foreach my $event_name (keys %unhandled) {
+        printf("%-40s  %10d\n", $event_name, $unhandled{$event_name});
+    }
+}
+
+sub trace_unhandled
+{
+    my ($event_name, $context, $common_cpu, $common_secs, $common_nsecs,
+        $common_pid, $common_comm) = @_;
+
+    $unhandled{$event_name}++;
+}
diff --git a/tools/perf/scripts/perl/wakeup-latency.pl b/tools/perf/scripts/perl/wakeup-latency.pl
index ed58ef284e23..d9143dcec6c6 100644
--- a/tools/perf/scripts/perl/wakeup-latency.pl
+++ b/tools/perf/scripts/perl/wakeup-latency.pl
@@ -22,8 +22,8 @@ my %last_wakeup;
 
 my $max_wakeup_latency;
 my $min_wakeup_latency;
-my $total_wakeup_latency;
-my $total_wakeups;
+my $total_wakeup_latency = 0;
+my $total_wakeups = 0;
 
 sub sched::sched_switch
 {
@@ -67,8 +67,12 @@ sub trace_end
 {
     printf("wakeup_latency stats:\n\n");
     print "total_wakeups: $total_wakeups\n";
-    printf("avg_wakeup_latency (ns): %u\n",
-           avg($total_wakeup_latency, $total_wakeups));
+    if ($total_wakeups) {
+        printf("avg_wakeup_latency (ns): %u\n",
+               avg($total_wakeup_latency, $total_wakeups));
+    } else {
+        printf("avg_wakeup_latency (ns): N/A\n");
+    }
     printf("min_wakeup_latency (ns): %u\n", $min_wakeup_latency);
     printf("max_wakeup_latency (ns): %u\n", $max_wakeup_latency);
 
diff --git a/tools/perf/scripts/perl/workqueue-stats.pl b/tools/perf/scripts/perl/workqueue-stats.pl
index 511302c8a494..b84b12699b70 100644
--- a/tools/perf/scripts/perl/workqueue-stats.pl
+++ b/tools/perf/scripts/perl/workqueue-stats.pl
@@ -71,9 +71,9 @@ sub trace_end
     printf("%3s %6s %6s\t%-20s\n", "---", "---", "----", "----");
     foreach my $pidhash (@cpus) {
         while ((my $pid, my $wqhash) = each %$pidhash) {
-            my $ins = $$wqhash{'inserted'};
-            my $exe = $$wqhash{'executed'};
-            my $comm = $$wqhash{'comm'};
+            my $ins = $$wqhash{'inserted'} || 0;
+            my $exe = $$wqhash{'executed'} || 0;
+            my $comm = $$wqhash{'comm'} || "";
             if ($ins || $exe) {
                 printf("%3u %6u %6u\t%-20s\n", $cpu, $ins, $exe, $comm);
             }
@@ -87,9 +87,9 @@ sub trace_end
     printf("%3s %6s %6s\t%-20s\n", "---", "-------", "---------", "----");
     foreach my $pidhash (@cpus) {
         while ((my $pid, my $wqhash) = each %$pidhash) {
-            my $created = $$wqhash{'created'};
-            my $destroyed = $$wqhash{'destroyed'};
-            my $comm = $$wqhash{'comm'};
+            my $created = $$wqhash{'created'} || 0;
+            my $destroyed = $$wqhash{'destroyed'} || 0;
+            my $comm = $$wqhash{'comm'} || "";
             if ($created || $destroyed) {
                 printf("%3u %6u %6u\t%-20s\n", $cpu, $created, $destroyed,
                        $comm);
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/Context.c b/tools/perf/scripts/python/Perf-Trace-Util/Context.c
new file mode 100644
index 000000000000..957085dd5d8d
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/Context.c
@@ -0,0 +1,88 @@
+/*
+ * Context.c.  Python interfaces for perf trace.
+ *
+ * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <Python.h>
+#include "../../../perf.h"
+#include "../../../util/trace-event.h"
+
+PyMODINIT_FUNC initperf_trace_context(void);
+
+static PyObject *perf_trace_context_common_pc(PyObject *self, PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_pc(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyObject *perf_trace_context_common_flags(PyObject *self,
+                                                 PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_flags(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyObject *perf_trace_context_common_lock_depth(PyObject *self,
+                                                      PyObject *args)
+{
+        static struct scripting_context *scripting_context;
+        PyObject *context;
+        int retval;
+
+        if (!PyArg_ParseTuple(args, "O", &context))
+                return NULL;
+
+        scripting_context = PyCObject_AsVoidPtr(context);
+        retval = common_lock_depth(scripting_context);
+
+        return Py_BuildValue("i", retval);
+}
+
+static PyMethodDef ContextMethods[] = {
+        { "common_pc", perf_trace_context_common_pc, METH_VARARGS,
+          "Get the common preempt count event field value."},
+        { "common_flags", perf_trace_context_common_flags, METH_VARARGS,
+          "Get the common flags event field value."},
+        { "common_lock_depth", perf_trace_context_common_lock_depth,
+          METH_VARARGS, "Get the common lock depth event field value."},
+        { NULL, NULL, 0, NULL}
+};
+
+PyMODINIT_FUNC initperf_trace_context(void)
+{
+        (void) Py_InitModule("perf_trace_context", ContextMethods);
+}
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
new file mode 100644
index 000000000000..aad7525bca1d
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Core.py
@@ -0,0 +1,121 @@
+# Core.py - Python extension for perf trace, core functions
+#
+# Copyright (C) 2010 by Tom Zanussi <tzanussi@gmail.com>
+#
+# This software may be distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+from collections import defaultdict
+
+def autodict():
+    return defaultdict(autodict)
+
+flag_fields = autodict()
+symbolic_fields = autodict()
+
+def define_flag_field(event_name, field_name, delim):
+    flag_fields[event_name][field_name]['delim'] = delim
+
+def define_flag_value(event_name, field_name, value, field_str):
+    flag_fields[event_name][field_name]['values'][value] = field_str
+
+def define_symbolic_field(event_name, field_name):
+    # nothing to do, really
+    pass
+
+def define_symbolic_value(event_name, field_name, value, field_str):
+    symbolic_fields[event_name][field_name]['values'][value] = field_str
+
+def flag_str(event_name, field_name, value):
+    string = ""
+
+    if flag_fields[event_name][field_name]:
+        print_delim = 0
+        keys = flag_fields[event_name][field_name]['values'].keys()
+        keys.sort()
+        for idx in keys:
+            if not value and not idx:
+                string += flag_fields[event_name][field_name]['values'][idx]
+                break
+            if idx and (value & idx) == idx:
+                if print_delim and flag_fields[event_name][field_name]['delim']:
+                    string += " " + flag_fields[event_name][field_name]['delim'] + " "
+                string += flag_fields[event_name][field_name]['values'][idx]
+                print_delim = 1
+                value &= ~idx
+
+    return string
+
+def symbol_str(event_name, field_name, value):
+    string = ""
+
+    if symbolic_fields[event_name][field_name]:
+        keys = symbolic_fields[event_name][field_name]['values'].keys()
+        keys.sort()
+        for idx in keys:
+            if not value and not idx:
+                string = symbolic_fields[event_name][field_name]['values'][idx]
+                break
+            if (value == idx):
+                string = symbolic_fields[event_name][field_name]['values'][idx]
+                break
+
+    return string
+
+trace_flags = { 0x00: "NONE", \
+                    0x01: "IRQS_OFF", \
+                    0x02: "IRQS_NOSUPPORT", \
+                    0x04: "NEED_RESCHED", \
+                    0x08: "HARDIRQ", \
+                    0x10: "SOFTIRQ" }
+
+def trace_flag_str(value):
+    string = ""
+    print_delim = 0
+
+    keys = trace_flags.keys()
+
+    for idx in keys:
+        if not value and not idx:
+            string += "NONE"
+            break
+
+        if idx and (value & idx) == idx:
+            if print_delim:
+                string += " | ";
+            string += trace_flags[idx]
+            print_delim = 1
+            value &= ~idx
+
+    return string
+
+
+def taskState(state):
+        states = {
+                0 : "R",
+                1 : "S",
+                2 : "D",
+                64: "DEAD"
+        }
+
+        if state not in states:
+                return "Unknown"
+
+        return states[state]
+
+
+class EventHeaders:
+        def __init__(self, common_cpu, common_secs, common_nsecs,
+                     common_pid, common_comm):
+                self.cpu = common_cpu
+                self.secs = common_secs
+                self.nsecs = common_nsecs
+                self.pid = common_pid
+                self.comm = common_comm
+
+        def ts(self):
+                return (self.secs * (10 ** 9)) + self.nsecs
+
+        def ts_format(self):
+                return "%d.%d" % (self.secs, int(self.nsecs / 1000))
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py
new file mode 100644
index 000000000000..ae9a56e43e05
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/SchedGui.py
@@ -0,0 +1,184 @@
+# SchedGui.py - Python extension for perf trace, basic GUI code for
+#               traces drawing and overview.
+#
+# Copyright (C) 2010 by Frederic Weisbecker <fweisbec@gmail.com>
+#
+# This software is distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+
+try:
+        import wx
+except ImportError:
+        raise ImportError, "You need to install the wxpython lib for this script"
+
+
+class RootFrame(wx.Frame):
+        Y_OFFSET = 100
+        RECT_HEIGHT = 100
+        RECT_SPACE = 50
+        EVENT_MARKING_WIDTH = 5
+
+        def __init__(self, sched_tracer, title, parent = None, id = -1):
+                wx.Frame.__init__(self, parent, id, title)
+
+                (self.screen_width, self.screen_height) = wx.GetDisplaySize()
+                self.screen_width -= 10
+                self.screen_height -= 10
+                self.zoom = 0.5
+                self.scroll_scale = 20
+                self.sched_tracer = sched_tracer
+                self.sched_tracer.set_root_win(self)
+                (self.ts_start, self.ts_end) = sched_tracer.interval()
+                self.update_width_virtual()
+                self.nr_rects = sched_tracer.nr_rectangles() + 1
+                self.height_virtual = RootFrame.Y_OFFSET + (self.nr_rects * (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE))
+
+                # whole window panel
+                self.panel = wx.Panel(self, size=(self.screen_width, self.screen_height))
+
+                # scrollable container
+                self.scroll = wx.ScrolledWindow(self.panel)
+                self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale)
+                self.scroll.EnableScrolling(True, True)
+                self.scroll.SetFocus()
+
+                # scrollable drawing area
+                self.scroll_panel = wx.Panel(self.scroll, size=(self.screen_width - 15, self.screen_height / 2))
+                self.scroll_panel.Bind(wx.EVT_PAINT, self.on_paint)
+                self.scroll_panel.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
+                self.scroll_panel.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
+                self.scroll.Bind(wx.EVT_PAINT, self.on_paint)
+                self.scroll.Bind(wx.EVT_KEY_DOWN, self.on_key_press)
+                self.scroll.Bind(wx.EVT_LEFT_DOWN, self.on_mouse_down)
+
+                self.scroll.Fit()
+                self.Fit()
+
+                self.scroll_panel.SetDimensions(-1, -1, self.width_virtual, self.height_virtual, wx.SIZE_USE_EXISTING)
+
+                self.txt = None
+
+                self.Show(True)
+
+        def us_to_px(self, val):
+                return val / (10 ** 3) * self.zoom
+
+        def px_to_us(self, val):
+                return (val / self.zoom) * (10 ** 3)
+
+        def scroll_start(self):
+                (x, y) = self.scroll.GetViewStart()
+                return (x * self.scroll_scale, y * self.scroll_scale)
+
+        def scroll_start_us(self):
+                (x, y) = self.scroll_start()
+                return self.px_to_us(x)
+
+        def paint_rectangle_zone(self, nr, color, top_color, start, end):
+                offset_px = self.us_to_px(start - self.ts_start)
+                width_px = self.us_to_px(end - self.ts_start)
+
+                offset_py = RootFrame.Y_OFFSET + (nr * (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE))
+                width_py = RootFrame.RECT_HEIGHT
+
+                dc = self.dc
+
+                if top_color is not None:
+                        (r, g, b) = top_color
+                        top_color = wx.Colour(r, g, b)
+                        brush = wx.Brush(top_color, wx.SOLID)
+                        dc.SetBrush(brush)
+                        dc.DrawRectangle(offset_px, offset_py, width_px, RootFrame.EVENT_MARKING_WIDTH)
+                        width_py -= RootFrame.EVENT_MARKING_WIDTH
+                        offset_py += RootFrame.EVENT_MARKING_WIDTH
+
+                (r ,g, b) = color
+                color = wx.Colour(r, g, b)
+                brush = wx.Brush(color, wx.SOLID)
+                dc.SetBrush(brush)
+                dc.DrawRectangle(offset_px, offset_py, width_px, width_py)
+
+        def update_rectangles(self, dc, start, end):
+                start += self.ts_start
+                end += self.ts_start
+                self.sched_tracer.fill_zone(start, end)
+
+        def on_paint(self, event):
+                dc = wx.PaintDC(self.scroll_panel)
+                self.dc = dc
+
+                width = min(self.width_virtual, self.screen_width)
+                (x, y) = self.scroll_start()
+                start = self.px_to_us(x)
+                end = self.px_to_us(x + width)
+                self.update_rectangles(dc, start, end)
+
+        def rect_from_ypixel(self, y):
+                y -= RootFrame.Y_OFFSET
+                rect = y / (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE)
+                height = y % (RootFrame.RECT_HEIGHT + RootFrame.RECT_SPACE)
+
+                if rect < 0 or rect > self.nr_rects - 1 or height > RootFrame.RECT_HEIGHT:
+                        return -1
+
+                return rect
+
+        def update_summary(self, txt):
+                if self.txt:
+                        self.txt.Destroy()
+                self.txt = wx.StaticText(self.panel, -1, txt, (0, (self.screen_height / 2) + 50))
+
+
+        def on_mouse_down(self, event):
+                (x, y) = event.GetPositionTuple()
+                rect = self.rect_from_ypixel(y)
+                if rect == -1:
+                        return
+
+                t = self.px_to_us(x) + self.ts_start
+
+                self.sched_tracer.mouse_down(rect, t)
+
+
+        def update_width_virtual(self):
+                self.width_virtual = self.us_to_px(self.ts_end - self.ts_start)
+
+        def __zoom(self, x):
+                self.update_width_virtual()
+                (xpos, ypos) = self.scroll.GetViewStart()
+                xpos = self.us_to_px(x) / self.scroll_scale
+                self.scroll.SetScrollbars(self.scroll_scale, self.scroll_scale, self.width_virtual / self.scroll_scale, self.height_virtual / self.scroll_scale, xpos, ypos)
+                self.Refresh()
+
+        def zoom_in(self):
+                x = self.scroll_start_us()
+                self.zoom *= 2
+                self.__zoom(x)
+
+        def zoom_out(self):
+                x = self.scroll_start_us()
+                self.zoom /= 2
+                self.__zoom(x)
+
+
+        def on_key_press(self, event):
+                key = event.GetRawKeyCode()
+                if key == ord("+"):
+                        self.zoom_in()
+                        return
+                if key == ord("-"):
+                        self.zoom_out()
+                        return
+
+                key = event.GetKeyCode()
+                (x, y) = self.scroll.GetViewStart()
+                if key == wx.WXK_RIGHT:
+                        self.scroll.Scroll(x + 1, y)
+                elif key == wx.WXK_LEFT:
+                        self.scroll.Scroll(x - 1, y)
+                elif key == wx.WXK_DOWN:
+                        self.scroll.Scroll(x, y + 1)
+                elif key == wx.WXK_UP:
+                        self.scroll.Scroll(x, y - 1)
diff --git a/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py
new file mode 100644
index 000000000000..9689bc0acd9f
--- /dev/null
+++ b/tools/perf/scripts/python/Perf-Trace-Util/lib/Perf/Trace/Util.py
@@ -0,0 +1,28 @@
+# Util.py - Python extension for perf trace, miscellaneous utility code
+#
+# Copyright (C) 2010 by Tom Zanussi <tzanussi@gmail.com>
+#
+# This software may be distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+NSECS_PER_SEC    = 1000000000
+
+def avg(total, n):
+    return total / n
+
+def nsecs(secs, nsecs):
+    return secs * NSECS_PER_SEC + nsecs
+
+def nsecs_secs(nsecs):
+    return nsecs / NSECS_PER_SEC
+
+def nsecs_nsecs(nsecs):
+    return nsecs % NSECS_PER_SEC
+
+def nsecs_str(nsecs):
+    str = "%5u.%09u" % (nsecs_secs(nsecs), nsecs_nsecs(nsecs)),
+    return str
+
+def clear_term():
+    print("\x1b[H\x1b[2J")
diff --git a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
new file mode 100644
index 000000000000..eb5846bcb565
--- /dev/null
+++ b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_exit $@
diff --git a/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report
new file mode 100644
index 000000000000..30293545fcc2
--- /dev/null
+++ b/tools/perf/scripts/python/bin/failed-syscalls-by-pid-report
@@ -0,0 +1,10 @@
+#!/bin/bash
+# description: system-wide failed syscalls, by pid
+# args: [comm]
+if [ $# -gt 0 ] ; then
+    if ! expr match "$1" "-" > /dev/null ; then
+        comm=$1
+        shift
+    fi
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/python/failed-syscalls-by-pid.py $comm
diff --git a/tools/perf/scripts/python/bin/sched-migration-record b/tools/perf/scripts/python/bin/sched-migration-record
new file mode 100644
index 000000000000..17a3e9bd9e8f
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sched-migration-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -m 16384 -a -e sched:sched_wakeup -e sched:sched_wakeup_new -e sched:sched_switch -e sched:sched_migrate_task $@
diff --git a/tools/perf/scripts/python/bin/sched-migration-report b/tools/perf/scripts/python/bin/sched-migration-report
new file mode 100644
index 000000000000..61d05f72e443
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sched-migration-report
@@ -0,0 +1,3 @@
+#!/bin/bash
+# description: sched migration overview
+perf trace $@ -s ~/libexec/perf-core/scripts/python/sched-migration.py
diff --git a/tools/perf/scripts/python/bin/sctop-record b/tools/perf/scripts/python/bin/sctop-record
new file mode 100644
index 000000000000..1fc5998b721d
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sctop-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_enter $@
diff --git a/tools/perf/scripts/python/bin/sctop-report b/tools/perf/scripts/python/bin/sctop-report
new file mode 100644
index 000000000000..b01c842ae7b4
--- /dev/null
+++ b/tools/perf/scripts/python/bin/sctop-report
@@ -0,0 +1,24 @@
+#!/bin/bash
+# description: syscall top
+# args: [comm] [interval]
+n_args=0
+for i in "$@"
+do
+    if expr match "$i" "-" > /dev/null ; then
+        break
+    fi
+    n_args=$(( $n_args + 1 ))
+done
+if [ "$n_args" -gt 2 ] ; then
+    echo "usage: sctop-report [comm] [interval]"
+    exit
+fi
+if [ "$n_args" -gt 1 ] ; then
+    comm=$1
+    interval=$2
+    shift 2
+elif [ "$n_args" -gt 0 ] ; then
+    interval=$1
+    shift
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/python/sctop.py $comm $interval
diff --git a/tools/perf/scripts/python/bin/syscall-counts-by-pid-record b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
new file mode 100644
index 000000000000..1fc5998b721d
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-by-pid-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_enter $@
diff --git a/tools/perf/scripts/python/bin/syscall-counts-by-pid-report b/tools/perf/scripts/python/bin/syscall-counts-by-pid-report
new file mode 100644
index 000000000000..9e9d8ddd72ce
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-by-pid-report
@@ -0,0 +1,10 @@
+#!/bin/bash
+# description: system-wide syscall counts, by pid
+# args: [comm]
+if [ $# -gt 0 ] ; then
+    if ! expr match "$1" "-" > /dev/null ; then
+        comm=$1
+        shift
+    fi
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/python/syscall-counts-by-pid.py $comm
diff --git a/tools/perf/scripts/python/bin/syscall-counts-record b/tools/perf/scripts/python/bin/syscall-counts-record
new file mode 100644
index 000000000000..1fc5998b721d
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-record
@@ -0,0 +1,2 @@
+#!/bin/bash
+perf record -a -e raw_syscalls:sys_enter $@
diff --git a/tools/perf/scripts/python/bin/syscall-counts-report b/tools/perf/scripts/python/bin/syscall-counts-report
new file mode 100644
index 000000000000..dc076b618796
--- /dev/null
+++ b/tools/perf/scripts/python/bin/syscall-counts-report
@@ -0,0 +1,10 @@
+#!/bin/bash
+# description: system-wide syscall counts
+# args: [comm]
+if [ $# -gt 0 ] ; then
+    if ! expr match "$1" "-" > /dev/null ; then
+        comm=$1
+        shift
+    fi
+fi
+perf trace $@ -s ~/libexec/perf-core/scripts/python/syscall-counts.py $comm
diff --git a/tools/perf/scripts/python/check-perf-trace.py b/tools/perf/scripts/python/check-perf-trace.py
new file mode 100644
index 000000000000..d9f7893e315c
--- /dev/null
+++ b/tools/perf/scripts/python/check-perf-trace.py
@@ -0,0 +1,82 @@
+# perf trace event handlers, generated by perf trace -g python
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# This script tests basic functionality such as flag and symbol
+# strings, common_xxx() calls back into perf, begin, end, unhandled
+# events, etc.  Basically, if this script runs successfully and
+# displays expected results, Python scripting support should be ok.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from Core import *
+from perf_trace_context import *
+
+unhandled = autodict()
+
+def trace_begin():
+        print "trace_begin"
+        pass
+
+def trace_end():
+        print_unhandled()
+
+def irq__softirq_entry(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        vec):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print_uncommon(context)
+
+                print "vec=%s\n" % \
+                (symbol_str("irq__softirq_entry", "vec", vec)),
+
+def kmem__kmalloc(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        call_site, ptr, bytes_req, bytes_alloc,
+        gfp_flags):
+                print_header(event_name, common_cpu, common_secs, common_nsecs,
+                        common_pid, common_comm)
+
+                print_uncommon(context)
+
+                print "call_site=%u, ptr=%u, bytes_req=%u, " \
+                "bytes_alloc=%u, gfp_flags=%s\n" % \
+                (call_site, ptr, bytes_req, bytes_alloc,
+
+                flag_str("kmem__kmalloc", "gfp_flags", gfp_flags)),
+
+def trace_unhandled(event_name, context, event_fields_dict):
+    try:
+        unhandled[event_name] += 1
+    except TypeError:
+        unhandled[event_name] = 1
+
+def print_header(event_name, cpu, secs, nsecs, pid, comm):
+        print "%-20s %5u %05u.%09u %8u %-20s " % \
+        (event_name, cpu, secs, nsecs, pid, comm),
+
+# print trace fields not included in handler args
+def print_uncommon(context):
+    print "common_preempt_count=%d, common_flags=%s, common_lock_depth=%d, " \
+        % (common_pc(context), trace_flag_str(common_flags(context)), \
+               common_lock_depth(context))
+
+def print_unhandled():
+    keys = unhandled.keys()
+    if not keys:
+        return
+
+    print "\nunhandled events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for event_name in keys:
+        print "%-40s  %10d\n" % (event_name, unhandled[event_name])
diff --git a/tools/perf/scripts/python/failed-syscalls-by-pid.py b/tools/perf/scripts/python/failed-syscalls-by-pid.py
new file mode 100644
index 000000000000..0ca02278fe69
--- /dev/null
+++ b/tools/perf/scripts/python/failed-syscalls-by-pid.py
@@ -0,0 +1,68 @@
+# failed system call counts, by pid
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide failed system call totals, broken down by pid.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts-by-pid.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_error_totals()
+
+def raw_syscalls__sys_exit(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, ret):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+
+        if ret < 0:
+                try:
+                        syscalls[common_comm][common_pid][id][ret] += 1
+                except TypeError:
+                        syscalls[common_comm][common_pid][id][ret] = 1
+
+def print_error_totals():
+    if for_comm is not None:
+            print "\nsyscall errors for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall errors:\n\n",
+
+    print "%-30s  %10s\n" % ("comm [pid]", "count"),
+    print "%-30s  %10s\n" % ("------------------------------", \
+                                 "----------"),
+
+    comm_keys = syscalls.keys()
+    for comm in comm_keys:
+            pid_keys = syscalls[comm].keys()
+            for pid in pid_keys:
+                    print "\n%s [%d]\n" % (comm, pid),
+                    id_keys = syscalls[comm][pid].keys()
+                    for id in id_keys:
+                            print "  syscall: %-16d\n" % (id),
+                            ret_keys = syscalls[comm][pid][id].keys()
+                            for ret, val in sorted(syscalls[comm][pid][id].iteritems(), key = lambda(k, v): (v, k),  reverse = True):
+                                    print "    err = %-20d  %10d\n" % (ret, val),
diff --git a/tools/perf/scripts/python/sched-migration.py b/tools/perf/scripts/python/sched-migration.py
new file mode 100644
index 000000000000..b934383c3364
--- /dev/null
+++ b/tools/perf/scripts/python/sched-migration.py
@@ -0,0 +1,461 @@
+#!/usr/bin/python
+#
+# Cpu task migration overview toy
+#
+# Copyright (C) 2010 Frederic Weisbecker <fweisbec@gmail.com>
+#
+# perf trace event handlers have been generated by perf trace -g python
+#
+# This software is distributed under the terms of the GNU General
+# Public License ("GPL") version 2 as published by the Free Software
+# Foundation.
+
+
+import os
+import sys
+
+from collections import defaultdict
+from UserList import UserList
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+sys.path.append('scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from SchedGui import *
+
+
+threads = { 0 : "idle"}
+
+def thread_name(pid):
+        return "%s:%d" % (threads[pid], pid)
+
+class RunqueueEventUnknown:
+        @staticmethod
+        def color():
+                return None
+
+        def __repr__(self):
+                return "unknown"
+
+class RunqueueEventSleep:
+        @staticmethod
+        def color():
+                return (0, 0, 0xff)
+
+        def __init__(self, sleeper):
+                self.sleeper = sleeper
+
+        def __repr__(self):
+                return "%s gone to sleep" % thread_name(self.sleeper)
+
+class RunqueueEventWakeup:
+        @staticmethod
+        def color():
+                return (0xff, 0xff, 0)
+
+        def __init__(self, wakee):
+                self.wakee = wakee
+
+        def __repr__(self):
+                return "%s woke up" % thread_name(self.wakee)
+
+class RunqueueEventFork:
+        @staticmethod
+        def color():
+                return (0, 0xff, 0)
+
+        def __init__(self, child):
+                self.child = child
+
+        def __repr__(self):
+                return "new forked task %s" % thread_name(self.child)
+
+class RunqueueMigrateIn:
+        @staticmethod
+        def color():
+                return (0, 0xf0, 0xff)
+
+        def __init__(self, new):
+                self.new = new
+
+        def __repr__(self):
+                return "task migrated in %s" % thread_name(self.new)
+
+class RunqueueMigrateOut:
+        @staticmethod
+        def color():
+                return (0xff, 0, 0xff)
+
+        def __init__(self, old):
+                self.old = old
+
+        def __repr__(self):
+                return "task migrated out %s" % thread_name(self.old)
+
+class RunqueueSnapshot:
+        def __init__(self, tasks = [0], event = RunqueueEventUnknown()):
+                self.tasks = tuple(tasks)
+                self.event = event
+
+        def sched_switch(self, prev, prev_state, next):
+                event = RunqueueEventUnknown()
+
+                if taskState(prev_state) == "R" and next in self.tasks \
+                        and prev in self.tasks:
+                        return self
+
+                if taskState(prev_state) != "R":
+                        event = RunqueueEventSleep(prev)
+
+                next_tasks = list(self.tasks[:])
+                if prev in self.tasks:
+                        if taskState(prev_state) != "R":
+                                next_tasks.remove(prev)
+                elif taskState(prev_state) == "R":
+                        next_tasks.append(prev)
+
+                if next not in next_tasks:
+                        next_tasks.append(next)
+
+                return RunqueueSnapshot(next_tasks, event)
+
+        def migrate_out(self, old):
+                if old not in self.tasks:
+                        return self
+                next_tasks = [task for task in self.tasks if task != old]
+
+                return RunqueueSnapshot(next_tasks, RunqueueMigrateOut(old))
+
+        def __migrate_in(self, new, event):
+                if new in self.tasks:
+                        self.event = event
+                        return self
+                next_tasks = self.tasks[:] + tuple([new])
+
+                return RunqueueSnapshot(next_tasks, event)
+
+        def migrate_in(self, new):
+                return self.__migrate_in(new, RunqueueMigrateIn(new))
+
+        def wake_up(self, new):
+                return self.__migrate_in(new, RunqueueEventWakeup(new))
+
+        def wake_up_new(self, new):
+                return self.__migrate_in(new, RunqueueEventFork(new))
+
+        def load(self):
+                """ Provide the number of tasks on the runqueue.
+                    Don't count idle"""
+                return len(self.tasks) - 1
+
+        def __repr__(self):
+                ret = self.tasks.__repr__()
+                ret += self.origin_tostring()
+
+                return ret
+
+class TimeSlice:
+        def __init__(self, start, prev):
+                self.start = start
+                self.prev = prev
+                self.end = start
+                # cpus that triggered the event
+                self.event_cpus = []
+                if prev is not None:
+                        self.total_load = prev.total_load
+                        self.rqs = prev.rqs.copy()
+                else:
+                        self.rqs = defaultdict(RunqueueSnapshot)
+                        self.total_load = 0
+
+        def __update_total_load(self, old_rq, new_rq):
+                diff = new_rq.load() - old_rq.load()
+                self.total_load += diff
+
+        def sched_switch(self, ts_list, prev, prev_state, next, cpu):
+                old_rq = self.prev.rqs[cpu]
+                new_rq = old_rq.sched_switch(prev, prev_state, next)
+
+                if old_rq is new_rq:
+                        return
+
+                self.rqs[cpu] = new_rq
+                self.__update_total_load(old_rq, new_rq)
+                ts_list.append(self)
+                self.event_cpus = [cpu]
+
+        def migrate(self, ts_list, new, old_cpu, new_cpu):
+                if old_cpu == new_cpu:
+                        return
+                old_rq = self.prev.rqs[old_cpu]
+                out_rq = old_rq.migrate_out(new)
+                self.rqs[old_cpu] = out_rq
+                self.__update_total_load(old_rq, out_rq)
+
+                new_rq = self.prev.rqs[new_cpu]
+                in_rq = new_rq.migrate_in(new)
+                self.rqs[new_cpu] = in_rq
+                self.__update_total_load(new_rq, in_rq)
+
+                ts_list.append(self)
+
+                if old_rq is not out_rq:
+                        self.event_cpus.append(old_cpu)
+                self.event_cpus.append(new_cpu)
+
+        def wake_up(self, ts_list, pid, cpu, fork):
+                old_rq = self.prev.rqs[cpu]
+                if fork:
+                        new_rq = old_rq.wake_up_new(pid)
+                else:
+                        new_rq = old_rq.wake_up(pid)
+
+                if new_rq is old_rq:
+                        return
+                self.rqs[cpu] = new_rq
+                self.__update_total_load(old_rq, new_rq)
+                ts_list.append(self)
+                self.event_cpus = [cpu]
+
+        def next(self, t):
+                self.end = t
+                return TimeSlice(t, self)
+
+class TimeSliceList(UserList):
+        def __init__(self, arg = []):
+                self.data = arg
+
+        def get_time_slice(self, ts):
+                if len(self.data) == 0:
+                        slice = TimeSlice(ts, TimeSlice(-1, None))
+                else:
+                        slice = self.data[-1].next(ts)
+                return slice
+
+        def find_time_slice(self, ts):
+                start = 0
+                end = len(self.data)
+                found = -1
+                searching = True
+                while searching:
+                        if start == end or start == end - 1:
+                                searching = False
+
+                        i = (end + start) / 2
+                        if self.data[i].start <= ts and self.data[i].end >= ts:
+                                found = i
+                                end = i
+                                continue
+
+                        if self.data[i].end < ts:
+                                start = i
+
+                        elif self.data[i].start > ts:
+                                end = i
+
+                return found
+
+        def set_root_win(self, win):
+                self.root_win = win
+
+        def mouse_down(self, cpu, t):
+                idx = self.find_time_slice(t)
+                if idx == -1:
+                        return
+
+                ts = self[idx]
+                rq = ts.rqs[cpu]
+                raw = "CPU: %d\n" % cpu
+                raw += "Last event : %s\n" % rq.event.__repr__()
+                raw += "Timestamp : %d.%06d\n" % (ts.start / (10 ** 9), (ts.start % (10 ** 9)) / 1000)
+                raw += "Duration : %6d us\n" % ((ts.end - ts.start) / (10 ** 6))
+                raw += "Load = %d\n" % rq.load()
+                for t in rq.tasks:
+                        raw += "%s \n" % thread_name(t)
+
+                self.root_win.update_summary(raw)
+
+        def update_rectangle_cpu(self, slice, cpu):
+                rq = slice.rqs[cpu]
+
+                if slice.total_load != 0:
+                        load_rate = rq.load() / float(slice.total_load)
+                else:
+                        load_rate = 0
+
+                red_power = int(0xff - (0xff * load_rate))
+                color = (0xff, red_power, red_power)
+
+                top_color = None
+
+                if cpu in slice.event_cpus:
+                        top_color = rq.event.color()
+
+                self.root_win.paint_rectangle_zone(cpu, color, top_color, slice.start, slice.end)
+
+        def fill_zone(self, start, end):
+                i = self.find_time_slice(start)
+                if i == -1:
+                        return
+
+                for i in xrange(i, len(self.data)):
+                        timeslice = self.data[i]
+                        if timeslice.start > end:
+                                return
+
+                        for cpu in timeslice.rqs:
+                                self.update_rectangle_cpu(timeslice, cpu)
+
+        def interval(self):
+                if len(self.data) == 0:
+                        return (0, 0)
+
+                return (self.data[0].start, self.data[-1].end)
+
+        def nr_rectangles(self):
+                last_ts = self.data[-1]
+                max_cpu = 0
+                for cpu in last_ts.rqs:
+                        if cpu > max_cpu:
+                                max_cpu = cpu
+                return max_cpu
+
+
+class SchedEventProxy:
+        def __init__(self):
+                self.current_tsk = defaultdict(lambda : -1)
+                self.timeslices = TimeSliceList()
+
+        def sched_switch(self, headers, prev_comm, prev_pid, prev_prio, prev_state,
+                         next_comm, next_pid, next_prio):
+                """ Ensure the task we sched out this cpu is really the one
+                    we logged. Otherwise we may have missed traces """
+
+                on_cpu_task = self.current_tsk[headers.cpu]
+
+                if on_cpu_task != -1 and on_cpu_task != prev_pid:
+                        print "Sched switch event rejected ts: %s cpu: %d prev: %s(%d) next: %s(%d)" % \
+                                (headers.ts_format(), headers.cpu, prev_comm, prev_pid, next_comm, next_pid)
+
+                threads[prev_pid] = prev_comm
+                threads[next_pid] = next_comm
+                self.current_tsk[headers.cpu] = next_pid
+
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.sched_switch(self.timeslices, prev_pid, prev_state, next_pid, headers.cpu)
+
+        def migrate(self, headers, pid, prio, orig_cpu, dest_cpu):
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.migrate(self.timeslices, pid, orig_cpu, dest_cpu)
+
+        def wake_up(self, headers, comm, pid, success, target_cpu, fork):
+                if success == 0:
+                        return
+                ts = self.timeslices.get_time_slice(headers.ts())
+                ts.wake_up(self.timeslices, pid, target_cpu, fork)
+
+
+def trace_begin():
+        global parser
+        parser = SchedEventProxy()
+
+def trace_end():
+        app = wx.App(False)
+        timeslices = parser.timeslices
+        frame = RootFrame(timeslices, "Migration")
+        app.MainLoop()
+
+def sched__sched_stat_runtime(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, runtime, vruntime):
+        pass
+
+def sched__sched_stat_iowait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_stat_sleep(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_stat_wait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, delay):
+        pass
+
+def sched__sched_process_fork(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        parent_comm, parent_pid, child_comm, child_pid):
+        pass
+
+def sched__sched_process_wait(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_process_exit(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_process_free(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_migrate_task(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, orig_cpu,
+        dest_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.migrate(headers, pid, prio, orig_cpu, dest_cpu)
+
+def sched__sched_switch(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        prev_comm, prev_pid, prev_prio, prev_state,
+        next_comm, next_pid, next_prio):
+
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.sched_switch(headers, prev_comm, prev_pid, prev_prio, prev_state,
+                         next_comm, next_pid, next_prio)
+
+def sched__sched_wakeup_new(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, success,
+        target_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.wake_up(headers, comm, pid, success, target_cpu, 1)
+
+def sched__sched_wakeup(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio, success,
+        target_cpu):
+        headers = EventHeaders(common_cpu, common_secs, common_nsecs,
+                                common_pid, common_comm)
+        parser.wake_up(headers, comm, pid, success, target_cpu, 0)
+
+def sched__sched_wait_task(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid, prio):
+        pass
+
+def sched__sched_kthread_stop_ret(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        ret):
+        pass
+
+def sched__sched_kthread_stop(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        comm, pid):
+        pass
+
+def trace_unhandled(event_name, context, common_cpu, common_secs, common_nsecs,
+                common_pid, common_comm):
+        pass
diff --git a/tools/perf/scripts/python/sctop.py b/tools/perf/scripts/python/sctop.py
new file mode 100644
index 000000000000..6cafad40c296
--- /dev/null
+++ b/tools/perf/scripts/python/sctop.py
@@ -0,0 +1,78 @@
+# system call top
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Periodically displays system-wide system call totals, broken down by
+# syscall.  If a [comm] arg is specified, only syscalls called by
+# [comm] are displayed. If an [interval] arg is specified, the display
+# will be refreshed every [interval] seconds.  The default interval is
+# 3 seconds.
+
+import thread
+import time
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+from Util import *
+
+usage = "perf trace -s syscall-counts.py [comm] [interval]\n";
+
+for_comm = None
+default_interval = 3
+interval = default_interval
+
+if len(sys.argv) > 3:
+        sys.exit(usage)
+
+if len(sys.argv) > 2:
+        for_comm = sys.argv[1]
+        interval = int(sys.argv[2])
+elif len(sys.argv) > 1:
+        try:
+                interval = int(sys.argv[1])
+        except ValueError:
+                for_comm = sys.argv[1]
+                interval = default_interval
+
+syscalls = autodict()
+
+def trace_begin():
+        thread.start_new_thread(print_syscall_totals, (interval,))
+        pass
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+        try:
+                syscalls[id] += 1
+        except TypeError:
+                syscalls[id] = 1
+
+def print_syscall_totals(interval):
+        while 1:
+                clear_term()
+                if for_comm is not None:
+                        print "\nsyscall events for %s:\n\n" % (for_comm),
+                else:
+                        print "\nsyscall events:\n\n",
+
+                print "%-40s  %10s\n" % ("event", "count"),
+                print "%-40s  %10s\n" % ("----------------------------------------", \
+                                                 "----------"),
+
+                for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
+                                              reverse = True):
+                        try:
+                                print "%-40d  %10d\n" % (id, val),
+                        except TypeError:
+                                pass
+                syscalls.clear()
+                time.sleep(interval)
diff --git a/tools/perf/scripts/python/syscall-counts-by-pid.py b/tools/perf/scripts/python/syscall-counts-by-pid.py
new file mode 100644
index 000000000000..af722d6a4b3f
--- /dev/null
+++ b/tools/perf/scripts/python/syscall-counts-by-pid.py
@@ -0,0 +1,64 @@
+# system call counts, by pid
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide system call totals, broken down by syscall.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts-by-pid.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+        try:
+                syscalls[common_comm][common_pid][id] += 1
+        except TypeError:
+                syscalls[common_comm][common_pid][id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events by comm/pid:\n\n",
+
+    print "%-40s  %10s\n" % ("comm [pid]/syscalls", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "----------"),
+
+    comm_keys = syscalls.keys()
+    for comm in comm_keys:
+            pid_keys = syscalls[comm].keys()
+            for pid in pid_keys:
+                    print "\n%s [%d]\n" % (comm, pid),
+                    id_keys = syscalls[comm][pid].keys()
+                    for id, val in sorted(syscalls[comm][pid].iteritems(), \
+                                  key = lambda(k, v): (v, k),  reverse = True):
+                            print "  %-38d  %10d\n" % (id, val),
diff --git a/tools/perf/scripts/python/syscall-counts.py b/tools/perf/scripts/python/syscall-counts.py
new file mode 100644
index 000000000000..f977e85ff049
--- /dev/null
+++ b/tools/perf/scripts/python/syscall-counts.py
@@ -0,0 +1,58 @@
+# system call counts
+# (c) 2010, Tom Zanussi <tzanussi@gmail.com>
+# Licensed under the terms of the GNU GPL License version 2
+#
+# Displays system-wide system call totals, broken down by syscall.
+# If a [comm] arg is specified, only syscalls called by [comm] are displayed.
+
+import os
+import sys
+
+sys.path.append(os.environ['PERF_EXEC_PATH'] + \
+        '/scripts/python/Perf-Trace-Util/lib/Perf/Trace')
+
+from perf_trace_context import *
+from Core import *
+
+usage = "perf trace -s syscall-counts.py [comm]\n";
+
+for_comm = None
+
+if len(sys.argv) > 2:
+        sys.exit(usage)
+
+if len(sys.argv) > 1:
+        for_comm = sys.argv[1]
+
+syscalls = autodict()
+
+def trace_begin():
+        pass
+
+def trace_end():
+        print_syscall_totals()
+
+def raw_syscalls__sys_enter(event_name, context, common_cpu,
+        common_secs, common_nsecs, common_pid, common_comm,
+        id, args):
+        if for_comm is not None:
+                if common_comm != for_comm:
+                        return
+        try:
+                syscalls[id] += 1
+        except TypeError:
+                syscalls[id] = 1
+
+def print_syscall_totals():
+    if for_comm is not None:
+            print "\nsyscall events for %s:\n\n" % (for_comm),
+    else:
+            print "\nsyscall events:\n\n",
+
+    print "%-40s  %10s\n" % ("event", "count"),
+    print "%-40s  %10s\n" % ("----------------------------------------", \
+                                 "-----------"),
+
+    for id, val in sorted(syscalls.iteritems(), key = lambda(k, v): (v, k), \
+                                  reverse = True):
+            print "%-40d  %10d\n" % (id, val),
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 54552a00a117..97d76562a1a0 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -1,17 +1,17 @@
 #!/bin/sh
 
-GVF=PERF-VERSION-FILE
-DEF_VER=v0.0.2.PERF
+if [ $# -eq 1 ]  ; then
+        OUTPUT=$1
+fi
+
+GVF=${OUTPUT}PERF-VERSION-FILE
 
 LF='
 '
 
-# First see if there is a version file (included in release tarballs),
-# then try git-describe, then default.
-if test -f version
-then
-        VN=$(cat version) || VN="$DEF_VER"
-elif test -d .git -o -f .git &&
+# First check if there is a .git to get the version from git describe
+# otherwise try to get the version from the kernel makefile
+if test -d ../../.git -o -f ../../.git &&
         VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
         case "$VN" in
         *$LF*) (exit 1) ;;
@@ -23,7 +23,12 @@ elif test -d .git -o -f .git &&
 then
         VN=$(echo "$VN" | sed -e 's/-/./g');
 else
-        VN="$DEF_VER"
+        eval `grep '^VERSION\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^PATCHLEVEL\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^SUBLEVEL\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^EXTRAVERSION\s*=' ../../Makefile|tr -d ' '`
+
+        VN="${VERSION}.${PATCHLEVEL}.${SUBLEVEL}${EXTRAVERSION}"
 fi
 
 VN=$(expr "$VN" : v*'\(.*\)')
diff --git a/tools/perf/util/abspath.c b/tools/perf/util/abspath.c
index a791dd467261..0e76affe9c36 100644
--- a/tools/perf/util/abspath.c
+++ b/tools/perf/util/abspath.c
@@ -1,86 +1,5 @@
 #include "cache.h"
 
-/*
- * Do not use this for inspecting *tracked* content.  When path is a
- * symlink to a directory, we do not want to say it is a directory when
- * dealing with tracked content in the working tree.
- */
-static int is_directory(const char *path)
-{
-        struct stat st;
-        return (!stat(path, &st) && S_ISDIR(st.st_mode));
-}
-
-/* We allow "recursive" symbolic links. Only within reason, though. */
-#define MAXDEPTH 5
-
-const char *make_absolute_path(const char *path)
-{
-        static char bufs[2][PATH_MAX + 1], *buf = bufs[0], *next_buf = bufs[1];
-        char cwd[1024] = "";
-        int buf_index = 1, len;
-
-        int depth = MAXDEPTH;
-        char *last_elem = NULL;
-        struct stat st;
-
-        if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
-                die ("Too long path: %.*s", 60, path);
-
-        while (depth--) {
-                if (!is_directory(buf)) {
-                        char *last_slash = strrchr(buf, '/');
-                        if (last_slash) {
-                                *last_slash = '\0';
-                                last_elem = xstrdup(last_slash + 1);
-                        } else {
-                                last_elem = xstrdup(buf);
-                                *buf = '\0';
-                        }
-                }
-
-                if (*buf) {
-                        if (!*cwd && !getcwd(cwd, sizeof(cwd)))
-                                die ("Could not get current working directory");
-
-                        if (chdir(buf))
-                                die ("Could not switch to '%s'", buf);
-                }
-                if (!getcwd(buf, PATH_MAX))
-                        die ("Could not get current working directory");
-
-                if (last_elem) {
-                        len = strlen(buf);
-
-                        if (len + strlen(last_elem) + 2 > PATH_MAX)
-                                die ("Too long path name: '%s/%s'",
-                                                buf, last_elem);
-                        buf[len] = '/';
-                        strcpy(buf + len + 1, last_elem);
-                        free(last_elem);
-                        last_elem = NULL;
-                }
-
-                if (!lstat(buf, &st) && S_ISLNK(st.st_mode)) {
-                        len = readlink(buf, next_buf, PATH_MAX);
-                        if (len < 0)
-                                die ("Invalid symlink: %s", buf);
-                        if (PATH_MAX <= len)
-                                die("symbolic link too long: %s", buf);
-                        next_buf[len] = '\0';
-                        buf = next_buf;
-                        buf_index = 1 - buf_index;
-                        next_buf = bufs[buf_index];
-                } else
-                        break;
-        }
-
-        if (*cwd && chdir(cwd))
-                die ("Could not change back to '%s'", cwd);
-
-        return buf;
-}
-
 static const char *get_pwd_cwd(void)
 {
         static char cwd[PATH_MAX + 1];
diff --git a/tools/perf/util/bitmap.c b/tools/perf/util/bitmap.c
new file mode 100644
index 000000000000..5e230acae1e9
--- /dev/null
+++ b/tools/perf/util/bitmap.c
@@ -0,0 +1,21 @@
+/*
+ * From lib/bitmap.c
+ * Helper functions for bitmap.h.
+ *
+ * This source code is licensed under the GNU General Public License,
+ * Version 2.  See the file COPYING for more details.
+ */
+#include <linux/bitmap.h>
+
+int __bitmap_weight(const unsigned long *bitmap, int bits)
+{
+        int k, w = 0, lim = bits/BITS_PER_LONG;
+
+        for (k = 0; k < lim; k++)
+                w += hweight_long(bitmap[k]);
+
+        if (bits % BITS_PER_LONG)
+                w += hweight_long(bitmap[k] & BITMAP_LAST_WORD_MASK(bits));
+
+        return w;
+}
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
new file mode 100644
index 000000000000..e437edb72417
--- /dev/null
+++ b/tools/perf/util/build-id.c
@@ -0,0 +1,77 @@
+/*
+ * build-id.c
+ *
+ * build-id support
+ *
+ * Copyright (C) 2009, 2010 Red Hat Inc.
+ * Copyright (C) 2009, 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+#include "util.h"
+#include <stdio.h>
+#include "build-id.h"
+#include "event.h"
+#include "symbol.h"
+#include <linux/kernel.h>
+#include "debug.h"
+
+static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
+{
+        struct addr_location al;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        struct thread *thread = perf_session__findnew(session, event->ip.pid);
+
+        if (thread == NULL) {
+                pr_err("problem processing %d event, skipping it.\n",
+                        event->header.type);
+                return -1;
+        }
+
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              event->ip.pid, event->ip.ip, &al);
+
+        if (al.map != NULL)
+                al.map->dso->hit = 1;
+
+        return 0;
+}
+
+static int event__exit_del_thread(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->fork.tid);
+
+        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
+                    self->fork.ppid, self->fork.ptid);
+
+        if (thread) {
+                rb_erase(&thread->rb_node, &session->threads);
+                session->last_match = NULL;
+                thread__delete(thread);
+        }
+
+        return 0;
+}
+
+struct perf_event_ops build_id__mark_dso_hit_ops = {
+        .sample = build_id__mark_dso_hit,
+        .mmap   = event__process_mmap,
+        .fork   = event__process_task,
+        .exit   = event__exit_del_thread,
+};
+
+char *dso__build_id_filename(struct dso *self, char *bf, size_t size)
+{
+        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+
+        if (!self->has_build_id)
+                return NULL;
+
+        build_id__sprintf(self->build_id, sizeof(self->build_id), build_id_hex);
+        if (bf == NULL) {
+                if (asprintf(&bf, "%s/.build-id/%.2s/%s", buildid_dir,
+                             build_id_hex, build_id_hex + 2) < 0)
+                        return NULL;
+        } else
+                snprintf(bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
+                         build_id_hex, build_id_hex + 2);
+        return bf;
+}
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
new file mode 100644
index 000000000000..5dafb00eaa06
--- /dev/null
+++ b/tools/perf/util/build-id.h
@@ -0,0 +1,10 @@
+#ifndef PERF_BUILD_ID_H_
+#define PERF_BUILD_ID_H_ 1
+
+#include "session.h"
+
+extern struct perf_event_ops build_id__mark_dso_hit_ops;
+
+char *dso__build_id_filename(struct dso *self, char *bf, size_t size);
+
+#endif
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 918eb376abe3..27e9ebe4076e 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_CACHE_H
 #define __PERF_CACHE_H
 
+#include <stdbool.h>
 #include "util.h"
 #include "strbuf.h"
 #include "../perf.h"
@@ -12,56 +13,17 @@
 
 #define PERF_DIR_ENVIRONMENT "PERF_DIR"
 #define PERF_WORK_TREE_ENVIRONMENT "PERF_WORK_TREE"
-#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
-#define DB_ENVIRONMENT "PERF_OBJECT_DIRECTORY"
-#define INDEX_ENVIRONMENT "PERF_INDEX_FILE"
-#define GRAFT_ENVIRONMENT "PERF_GRAFT_FILE"
-#define TEMPLATE_DIR_ENVIRONMENT "PERF_TEMPLATE_DIR"
-#define CONFIG_ENVIRONMENT "PERF_CONFIG"
 #define EXEC_PATH_ENVIRONMENT "PERF_EXEC_PATH"
-#define CEILING_DIRECTORIES_ENVIRONMENT "PERF_CEILING_DIRECTORIES"
-#define PERFATTRIBUTES_FILE ".perfattributes"
-#define INFOATTRIBUTES_FILE "info/attributes"
-#define ATTRIBUTE_MACRO_PREFIX "[attr]"
+#define DEFAULT_PERF_DIR_ENVIRONMENT ".perf"
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
 
 typedef int (*config_fn_t)(const char *, const char *, void *);
 extern int perf_default_config(const char *, const char *, void *);
-extern int perf_config_from_file(config_fn_t fn, const char *, void *);
 extern int perf_config(config_fn_t fn, void *);
-extern int perf_parse_ulong(const char *, unsigned long *);
 extern int perf_config_int(const char *, const char *);
-extern unsigned long perf_config_ulong(const char *, const char *);
-extern int perf_config_bool_or_int(const char *, const char *, int *);
 extern int perf_config_bool(const char *, const char *);
-extern int perf_config_string(const char **, const char *, const char *);
-extern int perf_config_set(const char *, const char *);
-extern int perf_config_set_multivar(const char *, const char *, const char *, int);
-extern int perf_config_rename_section(const char *, const char *);
-extern const char *perf_etc_perfconfig(void);
-extern int check_repository_format_version(const char *var, const char *value, void *cb);
-extern int perf_config_system(void);
-extern int perf_config_global(void);
 extern int config_error_nonbool(const char *);
-extern const char *config_exclusive_filename;
-
-#define MAX_PERFNAME (1000)
-extern char perf_default_email[MAX_PERFNAME];
-extern char perf_default_name[MAX_PERFNAME];
-extern int user_ident_explicitly_given;
-
-extern const char *perf_log_output_encoding;
-extern const char *perf_mailmap_file;
-
-/* IO helper functions */
-extern void maybe_flush_or_die(FILE *, const char *);
-extern int copy_fd(int ifd, int ofd);
-extern int copy_file(const char *dst, const char *src, int mode);
-extern ssize_t write_in_full(int fd, const void *buf, size_t count);
-extern void write_or_die(int fd, const void *buf, size_t count);
-extern int write_or_whine(int fd, const void *buf, size_t count, const char *msg);
-extern int write_or_whine_pipe(int fd, const void *buf, size_t count, const char *msg);
-extern void fsync_or_die(int fd, const char *);
+extern const char *perf_config_dirname(const char *, const char *);
 
 /* pager.c */
 extern void setup_pager(void);
@@ -69,8 +31,18 @@ extern const char *pager_program;
 extern int pager_in_use(void);
 extern int pager_use_color;
 
-extern const char *editor_program;
-extern const char *excludes_file;
+extern int use_browser;
+
+#ifdef NO_NEWT_SUPPORT
+static inline void setup_browser(void)
+{
+        setup_pager();
+}
+static inline void exit_browser(bool wait_for_ok __used) {}
+#else
+void setup_browser(void);
+void exit_browser(bool wait_for_ok);
+#endif
 
 char *alias_lookup(const char *alias);
 int split_cmdline(char *cmdline, const char ***argv);
@@ -101,22 +73,12 @@ static inline int is_absolute_path(const char *path)
         return path[0] == '/';
 }
 
-const char *make_absolute_path(const char *path);
 const char *make_nonrelative_path(const char *path);
-const char *make_relative_path(const char *abs, const char *base);
-int normalize_path_copy(char *dst, const char *src);
-int longest_ancestor_length(const char *path, const char *prefix_list);
 char *strip_path_suffix(const char *path, const char *suffix);
 
 extern char *mkpath(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
 extern char *perf_path(const char *fmt, ...) __attribute__((format (printf, 1, 2)));
-/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
-extern int perf_mkstemp(char *path, size_t len, const char *template);
 
-extern char *mksnpath(char *buf, size_t n, const char *fmt, ...)
-        __attribute__((format (printf, 3, 4)));
-extern char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
-        __attribute__((format (printf, 3, 4)));
 extern char *perf_pathdup(const char *fmt, ...)
         __attribute__((format (printf, 1, 2)));
 
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index b3b71258272a..f231f43424d2 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
+ * Copyright (C) 2009-2010, Frederic Weisbecker <fweisbec@gmail.com>
  *
  * Handle the callchains from the stream in an ad-hoc radix tree and then
  * sort them in an rbtree.
@@ -15,8 +15,16 @@
 #include <errno.h>
 #include <math.h>
 
+#include "util.h"
 #include "callchain.h"
 
+bool ip_callchain__valid(struct ip_callchain *chain, const event_t *event)
+{
+        unsigned int chain_size = event->header.size;
+        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
+        return chain->nr * sizeof(u64) <= chain_size;
+}
+
 #define chain_for_each_child(child, parent)     \
         list_for_each_entry(child, &parent->children, brothers)
 
@@ -160,7 +168,7 @@ create_child(struct callchain_node *parent, bool inherit_children)
 {
         struct callchain_node *new;
 
-        new = malloc(sizeof(*new));
+        new = zalloc(sizeof(*new));
         if (!new) {
                 perror("not enough memory to create child for code path tree");
                 return NULL;
@@ -183,25 +191,36 @@ create_child(struct callchain_node *parent, bool inherit_children)
         return new;
 }
 
+
+struct resolved_ip {
+        u64               ip;
+        struct map_symbol ms;
+};
+
+struct resolved_chain {
+        u64                     nr;
+        struct resolved_ip      ips[0];
+};
+
+
 /*
  * Fill the node with callchain values
  */
 static void
-fill_node(struct callchain_node *node, struct ip_callchain *chain,
-          int start, struct symbol **syms)
+fill_node(struct callchain_node *node, struct resolved_chain *chain, int start)
 {
         unsigned int i;
 
         for (i = start; i < chain->nr; i++) {
                 struct callchain_list *call;
 
-                call = malloc(sizeof(*call));
+                call = zalloc(sizeof(*call));
                 if (!call) {
                         perror("not enough memory for the code path tree");
                         return;
                 }
-                call->ip = chain->ips[i];
-                call->sym = syms[i];
+                call->ip = chain->ips[i].ip;
+                call->ms = chain->ips[i].ms;
                 list_add_tail(&call->list, &node->val);
         }
         node->val_nr = chain->nr - start;
@@ -210,16 +229,16 @@ fill_node(struct callchain_node *node, struct ip_callchain *chain,
 }
 
 static void
-add_child(struct callchain_node *parent, struct ip_callchain *chain,
-          int start, struct symbol **syms)
+add_child(struct callchain_node *parent, struct resolved_chain *chain,
+          int start, u64 period)
 {
         struct callchain_node *new;
 
         new = create_child(parent, false);
-        fill_node(new, chain, start, syms);
+        fill_node(new, chain, start);
 
         new->children_hit = 0;
-        new->hit = 1;
+        new->hit = period;
 }
 
 /*
@@ -228,9 +247,9 @@ add_child(struct callchain_node *parent, struct ip_callchain *chain,
  * Then create another child to host the given callchain of new branch
  */
 static void
-split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
+split_add_child(struct callchain_node *parent, struct resolved_chain *chain,
                 struct callchain_list *to_split, int idx_parents, int idx_local,
-                struct symbol **syms)
+                u64 period)
 {
         struct callchain_node *new;
         struct list_head *old_tail;
@@ -257,40 +276,41 @@ split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
         /* create a new child for the new branch if any */
         if (idx_total < chain->nr) {
                 parent->hit = 0;
-                add_child(parent, chain, idx_total, syms);
-                parent->children_hit++;
+                add_child(parent, chain, idx_total, period);
+                parent->children_hit += period;
         } else {
-                parent->hit = 1;
+                parent->hit = period;
         }
 }
 
 static int
-__append_chain(struct callchain_node *root, struct ip_callchain *chain,
-               unsigned int start, struct symbol **syms);
+__append_chain(struct callchain_node *root, struct resolved_chain *chain,
+               unsigned int start, u64 period);
 
 static void
-__append_chain_children(struct callchain_node *root, struct ip_callchain *chain,
-                        struct symbol **syms, unsigned int start)
+__append_chain_children(struct callchain_node *root,
+                        struct resolved_chain *chain,
+                        unsigned int start, u64 period)
 {
         struct callchain_node *rnode;
 
         /* lookup in childrens */
         chain_for_each_child(rnode, root) {
-                unsigned int ret = __append_chain(rnode, chain, start, syms);
+                unsigned int ret = __append_chain(rnode, chain, start, period);
 
                 if (!ret)
                         goto inc_children_hit;
         }
         /* nothing in children, add to the current node */
-        add_child(root, chain, start, syms);
+        add_child(root, chain, start, period);
 
 inc_children_hit:
-        root->children_hit++;
+        root->children_hit += period;
 }
 
 static int
-__append_chain(struct callchain_node *root, struct ip_callchain *chain,
-               unsigned int start, struct symbol **syms)
+__append_chain(struct callchain_node *root, struct resolved_chain *chain,
+               unsigned int start, u64 period)
 {
         struct callchain_list *cnode;
         unsigned int i = start;
@@ -302,13 +322,19 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
          * anywhere inside a function.
          */
         list_for_each_entry(cnode, &root->val, list) {
+                struct symbol *sym;
+
                 if (i == chain->nr)
                         break;
-                if (cnode->sym && syms[i]) {
-                        if (cnode->sym->start != syms[i]->start)
+
+                sym = chain->ips[i].ms.sym;
+
+                if (cnode->ms.sym && sym) {
+                        if (cnode->ms.sym->start != sym->start)
                                 break;
-                } else if (cnode->ip != chain->ips[i])
+                } else if (cnode->ip != chain->ips[i].ip)
                         break;
+
                 if (!found)
                         found = true;
                 i++;
@@ -320,26 +346,61 @@ __append_chain(struct callchain_node *root, struct ip_callchain *chain,
 
         /* we match only a part of the node. Split it and add the new chain */
         if (i - start < root->val_nr) {
-                split_add_child(root, chain, cnode, start, i - start, syms);
+                split_add_child(root, chain, cnode, start, i - start, period);
                 return 0;
         }
 
         /* we match 100% of the path, increment the hit */
         if (i - start == root->val_nr && i == chain->nr) {
-                root->hit++;
+                root->hit += period;
                 return 0;
         }
 
         /* We match the node and still have a part remaining */
-        __append_chain_children(root, chain, syms, i);
+        __append_chain_children(root, chain, i, period);
 
         return 0;
 }
 
-void append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                  struct symbol **syms)
+static void filter_context(struct ip_callchain *old, struct resolved_chain *new,
+                           struct map_symbol *syms)
 {
+        int i, j = 0;
+
+        for (i = 0; i < (int)old->nr; i++) {
+                if (old->ips[i] >= PERF_CONTEXT_MAX)
+                        continue;
+
+                new->ips[j].ip = old->ips[i];
+                new->ips[j].ms = syms[i];
+                j++;
+        }
+
+        new->nr = j;
+}
+
+
+int append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                 struct map_symbol *syms, u64 period)
+{
+        struct resolved_chain *filtered;
+
         if (!chain->nr)
-                return;
-        __append_chain_children(root, chain, syms, 0);
+                return 0;
+
+        filtered = zalloc(sizeof(*filtered) +
+                          chain->nr * sizeof(struct resolved_ip));
+        if (!filtered)
+                return -ENOMEM;
+
+        filter_context(chain, filtered, syms);
+
+        if (!filtered->nr)
+                goto end;
+
+        __append_chain_children(root, filtered, 0, period);
+end:
+        free(filtered);
+
+        return 0;
 }
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index ad4626de4c2b..6de4313924fb 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -4,7 +4,7 @@
 #include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include "util.h"
+#include "event.h"
 #include "symbol.h"
 
 enum chain_mode {
@@ -33,13 +33,14 @@ typedef void (*sort_chain_func_t)(struct rb_root *, struct callchain_node *,
 
 struct callchain_param {
         enum chain_mode         mode;
+        u32                     print_limit;
         double                  min_percent;
         sort_chain_func_t       sort;
 };
 
 struct callchain_list {
         u64                     ip;
-        struct symbol           *sym;
+        struct map_symbol       ms;
         struct list_head        list;
 };
 
@@ -48,6 +49,10 @@ static inline void callchain_init(struct callchain_node *node)
         INIT_LIST_HEAD(&node->brothers);
         INIT_LIST_HEAD(&node->children);
         INIT_LIST_HEAD(&node->val);
+
+        node->children_hit = 0;
+        node->parent = NULL;
+        node->hit = 0;
 }
 
 static inline u64 cumul_hits(struct callchain_node *node)
@@ -56,6 +61,8 @@ static inline u64 cumul_hits(struct callchain_node *node)
 }
 
 int register_callchain_param(struct callchain_param *param);
-void append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                  struct symbol **syms);
+int append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                 struct map_symbol *syms, u64 period);
+
+bool ip_callchain__valid(struct ip_callchain *chain, const event_t *event);
 #endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index e88bca55a599..e191eb9a667f 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -166,6 +166,31 @@ int perf_color_default_config(const char *var, const char *value, void *cb)
         return perf_default_config(var, value, cb);
 }
 
+static int __color_vsnprintf(char *bf, size_t size, const char *color,
+                             const char *fmt, va_list args, const char *trail)
+{
+        int r = 0;
+
+        /*
+         * Auto-detect:
+         */
+        if (perf_use_color_default < 0) {
+                if (isatty(1) || pager_in_use())
+                        perf_use_color_default = 1;
+                else
+                        perf_use_color_default = 0;
+        }
+
+        if (perf_use_color_default && *color)
+                r += snprintf(bf, size, "%s", color);
+        r += vsnprintf(bf + r, size - r, fmt, args);
+        if (perf_use_color_default && *color)
+                r += snprintf(bf + r, size - r, "%s", PERF_COLOR_RESET);
+        if (trail)
+                r += snprintf(bf + r, size - r, "%s", trail);
+        return r;
+}
+
 static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
                 va_list args, const char *trail)
 {
@@ -191,11 +216,28 @@ static int __color_vfprintf(FILE *fp, const char *color, const char *fmt,
         return r;
 }
 
+int color_vsnprintf(char *bf, size_t size, const char *color,
+                    const char *fmt, va_list args)
+{
+        return __color_vsnprintf(bf, size, color, fmt, args, NULL);
+}
+
 int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args)
 {
         return __color_vfprintf(fp, color, fmt, args, NULL);
 }
 
+int color_snprintf(char *bf, size_t size, const char *color,
+                   const char *fmt, ...)
+{
+        va_list args;
+        int r;
+
+        va_start(args, fmt);
+        r = color_vsnprintf(bf, size, color, fmt, args);
+        va_end(args);
+        return r;
+}
 
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...)
 {
@@ -274,3 +316,9 @@ int percent_color_fprintf(FILE *fp, const char *fmt, double percent)
 
         return r;
 }
+
+int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent)
+{
+        const char *color = get_percent_color(percent);
+        return color_snprintf(bf, size, color, fmt, percent);
+}
diff --git a/tools/perf/util/color.h b/tools/perf/util/color.h
index 24e8809210bb..dea082b79602 100644
--- a/tools/perf/util/color.h
+++ b/tools/perf/util/color.h
@@ -32,10 +32,14 @@ int perf_color_default_config(const char *var, const char *value, void *cb);
 int perf_config_colorbool(const char *var, const char *value, int stdout_is_tty);
 void color_parse(const char *value, const char *var, char *dst);
 void color_parse_mem(const char *value, int len, const char *var, char *dst);
+int color_vsnprintf(char *bf, size_t size, const char *color,
+                    const char *fmt, va_list args);
 int color_vfprintf(FILE *fp, const char *color, const char *fmt, va_list args);
 int color_fprintf(FILE *fp, const char *color, const char *fmt, ...);
+int color_snprintf(char *bf, size_t size, const char *color, const char *fmt, ...);
 int color_fprintf_ln(FILE *fp, const char *color, const char *fmt, ...);
 int color_fwrite_lines(FILE *fp, const char *color, size_t count, const char *buf);
+int percent_color_snprintf(char *bf, size_t size, const char *fmt, double percent);
 int percent_color_fprintf(FILE *fp, const char *fmt, double percent);
 const char *get_percent_color(double percent);
 
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 8784649109ce..e02d78cae70f 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -11,12 +11,17 @@
 
 #define MAXNAME (256)
 
+#define DEBUG_CACHE_DIR ".debug"
+
+
+char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */
+
 static FILE *config_file;
 static const char *config_file_name;
 static int config_linenr;
 static int config_file_eof;
 
-const char *config_exclusive_filename = NULL;
+static const char *config_exclusive_filename;
 
 static int get_next_char(void)
 {
@@ -127,7 +132,7 @@ static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
                         break;
                 if (!iskeychar(c))
                         break;
-                name[len++] = tolower(c);
+                name[len++] = c;
                 if (len >= MAXNAME)
                         return -1;
         }
@@ -291,19 +296,6 @@ static int perf_parse_long(const char *value, long *ret)
         return 0;
 }
 
-int perf_parse_ulong(const char *value, unsigned long *ret)
-{
-        if (value && *value) {
-                char *end;
-                unsigned long val = strtoul(value, &end, 0);
-                if (!parse_unit_factor(end, &val))
-                        return 0;
-                *ret = val;
-                return 1;
-        }
-        return 0;
-}
-
 static void die_bad_config(const char *name)
 {
         if (config_file_name)
@@ -319,15 +311,7 @@ int perf_config_int(const char *name, const char *value)
         return ret;
 }
 
-unsigned long perf_config_ulong(const char *name, const char *value)
-{
-        unsigned long ret;
-        if (!perf_parse_ulong(value, &ret))
-                die_bad_config(name);
-        return ret;
-}
-
-int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
+static int perf_config_bool_or_int(const char *name, const char *value, int *is_bool)
 {
         *is_bool = 1;
         if (!value)
@@ -348,12 +332,11 @@ int perf_config_bool(const char *name, const char *value)
         return !!perf_config_bool_or_int(name, value, &discard);
 }
 
-int perf_config_string(const char **dest, const char *var, const char *value)
+const char *perf_config_dirname(const char *name, const char *value)
 {
-        if (!value)
-                return config_error_nonbool(var);
-        *dest = strdup(value);
-        return 0;
+        if (!name)
+                return NULL;
+        return value;
 }
 
 static int perf_default_core_config(const char *var __used, const char *value __used)
@@ -371,7 +354,7 @@ int perf_default_config(const char *var, const char *value, void *dummy __used)
         return 0;
 }
 
-int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
+static int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
 {
         int ret;
         FILE *f = fopen(filename, "r");
@@ -389,7 +372,7 @@ int perf_config_from_file(config_fn_t fn, const char *filename, void *data)
         return ret;
 }
 
-const char *perf_etc_perfconfig(void)
+static const char *perf_etc_perfconfig(void)
 {
         static const char *system_wide;
         if (!system_wide)
@@ -403,12 +386,12 @@ static int perf_env_bool(const char *k, int def)
         return v ? perf_config_bool(k, v) : def;
 }
 
-int perf_config_system(void)
+static int perf_config_system(void)
 {
         return !perf_env_bool("PERF_CONFIG_NOSYSTEM", 0);
 }
 
-int perf_config_global(void)
+static int perf_config_global(void)
 {
         return !perf_env_bool("PERF_CONFIG_NOGLOBAL", 0);
 }
@@ -450,430 +433,60 @@ int perf_config(config_fn_t fn, void *data)
 }
 
 /*
- * Find all the stuff for perf_config_set() below.
+ * Call this to report error for your variable that should not
+ * get a boolean value (i.e. "[my] var" means "true").
  */
-
-#define MAX_MATCHES 512
-
-static struct {
-        int baselen;
-        char* key;
-        int do_not_match;
-        regex_t* value_regex;
-        int multi_replace;
-        size_t offset[MAX_MATCHES];
-        enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
-        int seen;
-} store;
-
-static int matches(const char* key, const char* value)
-{
-        return !strcmp(key, store.key) &&
-                (store.value_regex == NULL ||
-                 (store.do_not_match ^
-                  !regexec(store.value_regex, value, 0, NULL, 0)));
-}
-
-static int store_aux(const char* key, const char* value, void *cb __used)
+int config_error_nonbool(const char *var)
 {
-        int section_len;
-        const char *ep;
-
-        switch (store.state) {
-        case KEY_SEEN:
-                if (matches(key, value)) {
-                        if (store.seen == 1 && store.multi_replace == 0) {
-                                warning("%s has multiple values", key);
-                        } else if (store.seen >= MAX_MATCHES) {
-                                error("too many matches for %s", key);
-                                return 1;
-                        }
-
-                        store.offset[store.seen] = ftell(config_file);
-                        store.seen++;
-                }
-                break;
-        case SECTION_SEEN:
-                /*
-                 * What we are looking for is in store.key (both
-                 * section and var), and its section part is baselen
-                 * long.  We found key (again, both section and var).
-                 * We would want to know if this key is in the same
-                 * section as what we are looking for.  We already
-                 * know we are in the same section as what should
-                 * hold store.key.
-                 */
-                ep = strrchr(key, '.');
-                section_len = ep - key;
-
-                if ((section_len != store.baselen) ||
-                    memcmp(key, store.key, section_len+1)) {
-                        store.state = SECTION_END_SEEN;
-                        break;
-                }
-
-                /*
-                 * Do not increment matches: this is no match, but we
-                 * just made sure we are in the desired section.
-                 */
-                store.offset[store.seen] = ftell(config_file);
-                /* fallthru */
-        case SECTION_END_SEEN:
-        case START:
-                if (matches(key, value)) {
-                        store.offset[store.seen] = ftell(config_file);
-                        store.state = KEY_SEEN;
-                        store.seen++;
-                } else {
-                        if (strrchr(key, '.') - key == store.baselen &&
-                              !strncmp(key, store.key, store.baselen)) {
-                                        store.state = SECTION_SEEN;
-                                        store.offset[store.seen] = ftell(config_file);
-                        }
-                }
-        default:
-                break;
-        }
-        return 0;
+        return error("Missing value for '%s'", var);
 }
 
-static int store_write_section(int fd, const char* key)
-{
-        const char *dot;
-        int i, success;
-        struct strbuf sb = STRBUF_INIT;
-
-        dot = memchr(key, '.', store.baselen);
-        if (dot) {
-                strbuf_addf(&sb, "[%.*s \"", (int)(dot - key), key);
-                for (i = dot - key + 1; i < store.baselen; i++) {
-                        if (key[i] == '"' || key[i] == '\\')
-                                strbuf_addch(&sb, '\\');
-                        strbuf_addch(&sb, key[i]);
-                }
-                strbuf_addstr(&sb, "\"]\n");
-        } else {
-                strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
-        }
-
-        success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
-        strbuf_release(&sb);
+struct buildid_dir_config {
+        char *dir;
+};
 
-        return success;
-}
-
-static int store_write_pair(int fd, const char* key, const char* value)
+static int buildid_dir_command_config(const char *var, const char *value,
+                                      void *data)
 {
-        int i, success;
-        int length = strlen(key + store.baselen + 1);
-        const char *quote = "";
-        struct strbuf sb = STRBUF_INIT;
-
-        /*
-         * Check to see if the value needs to be surrounded with a dq pair.
-         * Note that problematic characters are always backslash-quoted; this
-         * check is about not losing leading or trailing SP and strings that
-         * follow beginning-of-comment characters (i.e. ';' and '#') by the
-         * configuration parser.
-         */
-        if (value[0] == ' ')
-                quote = "\"";
-        for (i = 0; value[i]; i++)
-                if (value[i] == ';' || value[i] == '#')
-                        quote = "\"";
-        if (i && value[i - 1] == ' ')
-                quote = "\"";
-
-        strbuf_addf(&sb, "\t%.*s = %s",
-                    length, key + store.baselen + 1, quote);
-
-        for (i = 0; value[i]; i++)
-                switch (value[i]) {
-                case '\n':
-                        strbuf_addstr(&sb, "\\n");
-                        break;
-                case '\t':
-                        strbuf_addstr(&sb, "\\t");
-                        break;
-                case '"':
-                case '\\':
-                        strbuf_addch(&sb, '\\');
-                default:
-                        strbuf_addch(&sb, value[i]);
-                        break;
-                }
-        strbuf_addf(&sb, "%s\n", quote);
-
-        success = (write_in_full(fd, sb.buf, sb.len) == (ssize_t)sb.len);
-        strbuf_release(&sb);
-
-        return success;
-}
+        struct buildid_dir_config *c = data;
+        const char *v;
 
-static ssize_t find_beginning_of_line(const char* contents, size_t size,
-        size_t offset_, int* found_bracket)
-{
-        size_t equal_offset = size, bracket_offset = size;
-        ssize_t offset;
-
-contline:
-        for (offset = offset_-2; offset > 0
-                        && contents[offset] != '\n'; offset--)
-                switch (contents[offset]) {
-                        case '=': equal_offset = offset; break;
-                        case ']': bracket_offset = offset; break;
-                        default: break;
-                }
-        if (offset > 0 && contents[offset-1] == '\\') {
-                offset_ = offset;
-                goto contline;
+        /* same dir for all commands */
+        if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) {
+                v = perf_config_dirname(var, value);
+                if (!v)
+                        return -1;
+                strncpy(c->dir, v, MAXPATHLEN-1);
+                c->dir[MAXPATHLEN-1] = '\0';
         }
-        if (bracket_offset < equal_offset) {
-                *found_bracket = 1;
-                offset = bracket_offset+1;
-        } else
-                offset++;
-
-        return offset;
+        return 0;
 }
 
-int perf_config_set(const char* key, const char* value)
+static void check_buildid_dir_config(void)
 {
-        return perf_config_set_multivar(key, value, NULL, 0);
+        struct buildid_dir_config c;
+        c.dir = buildid_dir;
+        perf_config(buildid_dir_command_config, &c);
 }
 
-/*
- * If value==NULL, unset in (remove from) config,
- * if value_regex!=NULL, disregard key/value pairs where value does not match.
- * if multi_replace==0, nothing, or only one matching key/value is replaced,
- *     else all matching key/values (regardless how many) are removed,
- *     before the new pair is written.
- *
- * Returns 0 on success.
- *
- * This function does this:
- *
- * - it locks the config file by creating ".perf/config.lock"
- *
- * - it then parses the config using store_aux() as validator to find
- *   the position on the key/value pair to replace. If it is to be unset,
- *   it must be found exactly once.
- *
- * - the config file is mmap()ed and the part before the match (if any) is
- *   written to the lock file, then the changed part and the rest.
- *
- * - the config file is removed and the lock file rename()d to it.
- *
- */
-int perf_config_set_multivar(const char* key, const char* value,
-        const char* value_regex, int multi_replace)
+void set_buildid_dir(void)
 {
-        int i, dot;
-        int fd = -1, in_fd;
-        int ret = 0;
-        char* config_filename;
-        const char* last_dot = strrchr(key, '.');
-
-        if (config_exclusive_filename)
-                config_filename = strdup(config_exclusive_filename);
-        else
-                config_filename = perf_pathdup("config");
-
-        /*
-         * Since "key" actually contains the section name and the real
-         * key name separated by a dot, we have to know where the dot is.
-         */
-
-        if (last_dot == NULL) {
-                error("key does not contain a section: %s", key);
-                ret = 2;
-                goto out_free;
-        }
-        store.baselen = last_dot - key;
-
-        store.multi_replace = multi_replace;
-
-        /*
-         * Validate the key and while at it, lower case it for matching.
-         */
-        store.key = malloc(strlen(key) + 1);
-        dot = 0;
-        for (i = 0; key[i]; i++) {
-                unsigned char c = key[i];
-                if (c == '.')
-                        dot = 1;
-                /* Leave the extended basename untouched.. */
-                if (!dot || i > store.baselen) {
-                        if (!iskeychar(c) || (i == store.baselen+1 && !isalpha(c))) {
-                                error("invalid key: %s", key);
-                                free(store.key);
-                                ret = 1;
-                                goto out_free;
-                        }
-                        c = tolower(c);
-                } else if (c == '\n') {
-                        error("invalid key (newline): %s", key);
-                        free(store.key);
-                        ret = 1;
-                        goto out_free;
-                }
-                store.key[i] = c;
-        }
-        store.key[i] = 0;
-
-        /*
-         * If .perf/config does not exist yet, write a minimal version.
-         */
-        in_fd = open(config_filename, O_RDONLY);
-        if ( in_fd < 0 ) {
-                free(store.key);
-
-                if ( ENOENT != errno ) {
-                        error("opening %s: %s", config_filename,
-                              strerror(errno));
-                        ret = 3; /* same as "invalid config file" */
-                        goto out_free;
-                }
-                /* if nothing to unset, error out */
-                if (value == NULL) {
-                        ret = 5;
-                        goto out_free;
-                }
-
-                store.key = (char*)key;
-                if (!store_write_section(fd, key) ||
-                    !store_write_pair(fd, key, value))
-                        goto write_err_out;
-        } else {
-                struct stat st;
-                char *contents;
-                ssize_t contents_sz, copy_begin, copy_end;
-                int new_line = 0;
-
-                if (value_regex == NULL)
-                        store.value_regex = NULL;
-                else {
-                        if (value_regex[0] == '!') {
-                                store.do_not_match = 1;
-                                value_regex++;
-                        } else
-                                store.do_not_match = 0;
-
-                        store.value_regex = (regex_t*)malloc(sizeof(regex_t));
-                        if (regcomp(store.value_regex, value_regex,
-                                        REG_EXTENDED)) {
-                                error("invalid pattern: %s", value_regex);
-                                free(store.value_regex);
-                                ret = 6;
-                                goto out_free;
-                        }
-                }
-
-                store.offset[0] = 0;
-                store.state = START;
-                store.seen = 0;
-
-                /*
-                 * After this, store.offset will contain the *end* offset
-                 * of the last match, or remain at 0 if no match was found.
-                 * As a side effect, we make sure to transform only a valid
-                 * existing config file.
-                 */
-                if (perf_config_from_file(store_aux, config_filename, NULL)) {
-                        error("invalid config file %s", config_filename);
-                        free(store.key);
-                        if (store.value_regex != NULL) {
-                                regfree(store.value_regex);
-                                free(store.value_regex);
-                        }
-                        ret = 3;
-                        goto out_free;
-                }
+        buildid_dir[0] = '\0';
 
-                free(store.key);
-                if (store.value_regex != NULL) {
-                        regfree(store.value_regex);
-                        free(store.value_regex);
-                }
+        /* try config file */
+        check_buildid_dir_config();
 
-                /* if nothing to unset, or too many matches, error out */
-                if ((store.seen == 0 && value == NULL) ||
-                                (store.seen > 1 && multi_replace == 0)) {
-                        ret = 5;
-                        goto out_free;
-                }
-
-                fstat(in_fd, &st);
-                contents_sz = xsize_t(st.st_size);
-                contents = mmap(NULL, contents_sz, PROT_READ,
-                        MAP_PRIVATE, in_fd, 0);
-                close(in_fd);
-
-                if (store.seen == 0)
-                        store.seen = 1;
-
-                for (i = 0, copy_begin = 0; i < store.seen; i++) {
-                        if (store.offset[i] == 0) {
-                                store.offset[i] = copy_end = contents_sz;
-                        } else if (store.state != KEY_SEEN) {
-                                copy_end = store.offset[i];
-                        } else
-                                copy_end = find_beginning_of_line(
-                                        contents, contents_sz,
-                                        store.offset[i]-2, &new_line);
-
-                        if (copy_end > 0 && contents[copy_end-1] != '\n')
-                                new_line = 1;
-
-                        /* write the first part of the config */
-                        if (copy_end > copy_begin) {
-                                if (write_in_full(fd, contents + copy_begin,
-                                                  copy_end - copy_begin) <
-                                    copy_end - copy_begin)
-                                        goto write_err_out;
-                                if (new_line &&
-                                    write_in_full(fd, "\n", 1) != 1)
-                                        goto write_err_out;
-                        }
-                        copy_begin = store.offset[i];
-                }
-
-                /* write the pair (value == NULL means unset) */
-                if (value != NULL) {
-                        if (store.state == START) {
-                                if (!store_write_section(fd, key))
-                                        goto write_err_out;
-                        }
-                        if (!store_write_pair(fd, key, value))
-                                goto write_err_out;
+        /* default to $HOME/.debug */
+        if (buildid_dir[0] == '\0') {
+                char *v = getenv("HOME");
+                if (v) {
+                        snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s",
+                                 v, DEBUG_CACHE_DIR);
+                } else {
+                        strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1);
                 }
-
-                /* write the rest of the config */
-                if (copy_begin < contents_sz)
-                        if (write_in_full(fd, contents + copy_begin,
-                                          contents_sz - copy_begin) <
-                            contents_sz - copy_begin)
-                                goto write_err_out;
-
-                munmap(contents, contents_sz);
+                buildid_dir[MAXPATHLEN-1] = '\0';
         }
-
-        ret = 0;
-
-out_free:
-        free(config_filename);
-        return ret;
-
-write_err_out:
-        goto out_free;
-
-}
-
-/*
- * Call this to report error for your variable that should not
- * get a boolean value (i.e. "[my] var" means "true").
- */
-int config_error_nonbool(const char *var)
-{
-        return error("Missing value for '%s'", var);
+        /* for communicating with external commands */
+        setenv("PERF_BUILDID_DIR", buildid_dir, 1);
 }
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
new file mode 100644
index 000000000000..0f9b8d7a7d7e
--- /dev/null
+++ b/tools/perf/util/cpumap.c
@@ -0,0 +1,114 @@
+#include "util.h"
+#include "../perf.h"
+#include "cpumap.h"
+#include <assert.h>
+#include <stdio.h>
+
+int cpumap[MAX_NR_CPUS];
+
+static int default_cpu_map(void)
+{
+        int nr_cpus, i;
+
+        nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+        assert(nr_cpus <= MAX_NR_CPUS);
+        assert((int)nr_cpus >= 0);
+
+        for (i = 0; i < nr_cpus; ++i)
+                cpumap[i] = i;
+
+        return nr_cpus;
+}
+
+static int read_all_cpu_map(void)
+{
+        FILE *onlnf;
+        int nr_cpus = 0;
+        int n, cpu, prev;
+        char sep;
+
+        onlnf = fopen("/sys/devices/system/cpu/online", "r");
+        if (!onlnf)
+                return default_cpu_map();
+
+        sep = 0;
+        prev = -1;
+        for (;;) {
+                n = fscanf(onlnf, "%u%c", &cpu, &sep);
+                if (n <= 0)
+                        break;
+                if (prev >= 0) {
+                        assert(nr_cpus + cpu - prev - 1 < MAX_NR_CPUS);
+                        while (++prev < cpu)
+                                cpumap[nr_cpus++] = prev;
+                }
+                assert (nr_cpus < MAX_NR_CPUS);
+                cpumap[nr_cpus++] = cpu;
+                if (n == 2 && sep == '-')
+                        prev = cpu;
+                else
+                        prev = -1;
+                if (n == 1 || sep == '\n')
+                        break;
+        }
+        fclose(onlnf);
+        if (nr_cpus > 0)
+                return nr_cpus;
+
+        return default_cpu_map();
+}
+
+int read_cpu_map(const char *cpu_list)
+{
+        unsigned long start_cpu, end_cpu = 0;
+        char *p = NULL;
+        int i, nr_cpus = 0;
+
+        if (!cpu_list)
+                return read_all_cpu_map();
+
+        if (!isdigit(*cpu_list))
+                goto invalid;
+
+        while (isdigit(*cpu_list)) {
+                p = NULL;
+                start_cpu = strtoul(cpu_list, &p, 0);
+                if (start_cpu >= INT_MAX
+                    || (*p != '\0' && *p != ',' && *p != '-'))
+                        goto invalid;
+
+                if (*p == '-') {
+                        cpu_list = ++p;
+                        p = NULL;
+                        end_cpu = strtoul(cpu_list, &p, 0);
+
+                        if (end_cpu >= INT_MAX || (*p != '\0' && *p != ','))
+                                goto invalid;
+
+                        if (end_cpu < start_cpu)
+                                goto invalid;
+                } else {
+                        end_cpu = start_cpu;
+                }
+
+                for (; start_cpu <= end_cpu; start_cpu++) {
+                        /* check for duplicates */
+                        for (i = 0; i < nr_cpus; i++)
+                                if (cpumap[i] == (int)start_cpu)
+                                        goto invalid;
+
+                        assert(nr_cpus < MAX_NR_CPUS);
+                        cpumap[nr_cpus++] = (int)start_cpu;
+                }
+                if (*p)
+                        ++p;
+
+                cpu_list = p;
+        }
+        if (nr_cpus > 0)
+                return nr_cpus;
+
+        return default_cpu_map();
+invalid:
+        return -1;
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
new file mode 100644
index 000000000000..3e60f56e490e
--- /dev/null
+++ b/tools/perf/util/cpumap.h
@@ -0,0 +1,7 @@
+#ifndef __PERF_CPUMAP_H
+#define __PERF_CPUMAP_H
+
+extern int read_cpu_map(const char *cpu_list);
+extern int cpumap[];
+
+#endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/data_map.c b/tools/perf/util/data_map.c
deleted file mode 100644
index b557b836de3d..000000000000
--- a/tools/perf/util/data_map.c
+++ /dev/null
@@ -1,252 +0,0 @@
-#include "symbol.h"
-#include "util.h"
-#include "debug.h"
-#include "thread.h"
-#include "session.h"
-
-static int process_event_stub(event_t *event __used,
-                              struct perf_session *session __used)
-{
-        dump_printf(": unhandled!\n");
-        return 0;
-}
-
-static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
-{
-        if (!handler->process_sample_event)
-                handler->process_sample_event = process_event_stub;
-        if (!handler->process_mmap_event)
-                handler->process_mmap_event = process_event_stub;
-        if (!handler->process_comm_event)
-                handler->process_comm_event = process_event_stub;
-        if (!handler->process_fork_event)
-                handler->process_fork_event = process_event_stub;
-        if (!handler->process_exit_event)
-                handler->process_exit_event = process_event_stub;
-        if (!handler->process_lost_event)
-                handler->process_lost_event = process_event_stub;
-        if (!handler->process_read_event)
-                handler->process_read_event = process_event_stub;
-        if (!handler->process_throttle_event)
-                handler->process_throttle_event = process_event_stub;
-        if (!handler->process_unthrottle_event)
-                handler->process_unthrottle_event = process_event_stub;
-}
-
-static const char *event__name[] = {
-        [0]                      = "TOTAL",
-        [PERF_RECORD_MMAP]       = "MMAP",
-        [PERF_RECORD_LOST]       = "LOST",
-        [PERF_RECORD_COMM]       = "COMM",
-        [PERF_RECORD_EXIT]       = "EXIT",
-        [PERF_RECORD_THROTTLE]   = "THROTTLE",
-        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
-        [PERF_RECORD_FORK]       = "FORK",
-        [PERF_RECORD_READ]       = "READ",
-        [PERF_RECORD_SAMPLE]     = "SAMPLE",
-};
-
-unsigned long event__total[PERF_RECORD_MAX];
-
-void event__print_totals(void)
-{
-        int i;
-        for (i = 0; i < PERF_RECORD_MAX; ++i)
-                pr_info("%10s events: %10ld\n",
-                        event__name[i], event__total[i]);
-}
-
-static int process_event(event_t *event, struct perf_session *session,
-                         struct perf_event_ops *ops,
-                         unsigned long offset, unsigned long head)
-{
-        trace_event(event);
-
-        if (event->header.type < PERF_RECORD_MAX) {
-                dump_printf("%p [%p]: PERF_RECORD_%s",
-                            (void *)(offset + head),
-                            (void *)(long)(event->header.size),
-                            event__name[event->header.type]);
-                ++event__total[0];
-                ++event__total[event->header.type];
-        }
-
-        switch (event->header.type) {
-        case PERF_RECORD_SAMPLE:
-                return ops->process_sample_event(event, session);
-        case PERF_RECORD_MMAP:
-                return ops->process_mmap_event(event, session);
-        case PERF_RECORD_COMM:
-                return ops->process_comm_event(event, session);
-        case PERF_RECORD_FORK:
-                return ops->process_fork_event(event, session);
-        case PERF_RECORD_EXIT:
-                return ops->process_exit_event(event, session);
-        case PERF_RECORD_LOST:
-                return ops->process_lost_event(event, session);
-        case PERF_RECORD_READ:
-                return ops->process_read_event(event, session);
-        case PERF_RECORD_THROTTLE:
-                return ops->process_throttle_event(event, session);
-        case PERF_RECORD_UNTHROTTLE:
-                return ops->process_unthrottle_event(event, session);
-        default:
-                ops->total_unknown++;
-                return -1;
-        }
-}
-
-int perf_header__read_build_ids(int input, u64 offset, u64 size)
-{
-        struct build_id_event bev;
-        char filename[PATH_MAX];
-        u64 limit = offset + size;
-        int err = -1;
-
-        while (offset < limit) {
-                struct dso *dso;
-                ssize_t len;
-
-                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
-                        goto out;
-
-                len = bev.header.size - sizeof(bev);
-                if (read(input, filename, len) != len)
-                        goto out;
-
-                dso = dsos__findnew(filename);
-                if (dso != NULL)
-                        dso__set_build_id(dso, &bev.build_id);
-
-                offset += bev.header.size;
-        }
-        err = 0;
-out:
-        return err;
-}
-
-static struct thread *perf_session__register_idle_thread(struct perf_session *self)
-{
-        struct thread *thread = perf_session__findnew(self, 0);
-
-        if (!thread || thread__set_comm(thread, "swapper")) {
-                pr_err("problem inserting idle task.\n");
-                thread = NULL;
-        }
-
-        return thread;
-}
-
-int perf_session__process_events(struct perf_session *self,
-                                 struct perf_event_ops *ops)
-{
-        int err;
-        unsigned long head, shift;
-        unsigned long offset = 0;
-        size_t  page_size;
-        event_t *event;
-        uint32_t size;
-        char *buf;
-
-        if (perf_session__register_idle_thread(self) == NULL)
-                return -ENOMEM;
-
-        perf_event_ops__fill_defaults(ops);
-
-        page_size = getpagesize();
-
-        head = self->header.data_offset;
-        self->sample_type = perf_header__sample_type(&self->header);
-
-        err = -EINVAL;
-        if (ops->sample_type_check && ops->sample_type_check(self) < 0)
-                goto out_err;
-
-        if (!ops->full_paths) {
-                char bf[PATH_MAX];
-
-                if (getcwd(bf, sizeof(bf)) == NULL) {
-                        err = -errno;
-out_getcwd_err:
-                        pr_err("failed to get the current directory\n");
-                        goto out_err;
-                }
-                self->cwd = strdup(bf);
-                if (self->cwd == NULL) {
-                        err = -ENOMEM;
-                        goto out_getcwd_err;
-                }
-                self->cwdlen = strlen(self->cwd);
-        }
-
-        shift = page_size * (head / page_size);
-        offset += shift;
-        head -= shift;
-
-remap:
-        buf = mmap(NULL, page_size * self->mmap_window, PROT_READ,
-                   MAP_SHARED, self->fd, offset);
-        if (buf == MAP_FAILED) {
-                pr_err("failed to mmap file\n");
-                err = -errno;
-                goto out_err;
-        }
-
-more:
-        event = (event_t *)(buf + head);
-
-        size = event->header.size;
-        if (!size)
-                size = 8;
-
-        if (head + event->header.size >= page_size * self->mmap_window) {
-                int munmap_ret;
-
-                shift = page_size * (head / page_size);
-
-                munmap_ret = munmap(buf, page_size * self->mmap_window);
-                assert(munmap_ret == 0);
-
-                offset += shift;
-                head -= shift;
-                goto remap;
-        }
-
-        size = event->header.size;
-
-        dump_printf("\n%p [%p]: event: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)event->header.size,
-                        event->header.type);
-
-        if (!size || process_event(event, self, ops, offset, head) < 0) {
-
-                dump_printf("%p [%p]: skipping unknown header type: %d\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->header.type);
-
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
-
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
-        }
-
-        head += size;
-
-        if (offset + head >= self->header.data_offset + self->header.data_size)
-                goto done;
-
-        if (offset + head < self->size)
-                goto more;
-
-done:
-        err = 0;
-out_err:
-        return err;
-}
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 28d520d5a1fb..f9c7e3ad1aa7 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -6,12 +6,14 @@
 #include <stdarg.h>
 #include <stdio.h>
 
+#include "cache.h"
 #include "color.h"
 #include "event.h"
 #include "debug.h"
+#include "util.h"
 
 int verbose = 0;
-int dump_trace = 0;
+bool dump_trace = false;
 
 int eprintf(int level, const char *fmt, ...)
 {
@@ -20,7 +22,10 @@ int eprintf(int level, const char *fmt, ...)
 
         if (verbose >= level) {
                 va_start(args, fmt);
-                ret = vfprintf(stderr, fmt, args);
+                if (use_browser > 0)
+                        ret = ui_helpline__show_help(fmt, args);
+                else
+                        ret = vfprintf(stderr, fmt, args);
                 va_end(args);
         }
 
@@ -81,12 +86,10 @@ void trace_event(event_t *event)
                         dump_printf_color("  ", color);
                         for (j = 0; j < 15-(i & 15); j++)
                                 dump_printf_color("   ", color);
-                        for (j = 0; j < (i & 15); j++) {
-                                if (isprint(raw_event[i-15+j]))
-                                        dump_printf_color("%c", color,
-                                                          raw_event[i-15+j]);
-                                else
-                                        dump_printf_color(".", color);
+                        for (j = i & ~15; j <= i; j++) {
+                                dump_printf_color("%c", color,
+                                                isprint(raw_event[j]) ?
+                                                raw_event[j] : '.');
                         }
                         dump_printf_color("\n", color);
                 }
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index c6c24c522dea..7a17ee061bcb 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -2,14 +2,37 @@
 #ifndef __PERF_DEBUG_H
 #define __PERF_DEBUG_H
 
+#include <stdbool.h>
 #include "event.h"
 
 extern int verbose;
-extern int dump_trace;
+extern bool dump_trace;
 
-int eprintf(int level,
-            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(event_t *event);
 
+struct ui_progress;
+
+#ifdef NO_NEWT_SUPPORT
+static inline int ui_helpline__show_help(const char *format __used, va_list ap __used)
+{
+        return 0;
+}
+
+static inline struct ui_progress *ui_progress__new(const char *title __used,
+                                                   u64 total __used)
+{
+        return (struct ui_progress *)1;
+}
+
+static inline void ui_progress__update(struct ui_progress *self __used,
+                                       u64 curr __used) {}
+
+static inline void ui_progress__delete(struct ui_progress *self __used) {}
+#else
+extern char ui_helpline__last_msg[];
+int ui_helpline__show_help(const char *format, va_list ap);
+#include "ui/progress.h"
+#endif
+
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
index 06b73ee02c49..a88fefc0cc0a 100644
--- a/tools/perf/util/debugfs.c
+++ b/tools/perf/util/debugfs.c
@@ -106,16 +106,14 @@ int debugfs_valid_entry(const char *path)
         return 0;
 }
 
-/* mount the debugfs somewhere */
+/* mount the debugfs somewhere if it's not mounted */
 
-int debugfs_mount(const char *mountpoint)
+char *debugfs_mount(const char *mountpoint)
 {
-        char mountcmd[128];
-
         /* see if it's already mounted */
         if (debugfs_find_mountpoint()) {
                 debugfs_premounted = 1;
-                return 0;
+                return debugfs_mountpoint;
         }
 
         /* if not mounted and no argument */
@@ -127,13 +125,14 @@ int debugfs_mount(const char *mountpoint)
                         mountpoint = "/sys/kernel/debug";
         }
 
+        if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
+                return NULL;
+
         /* save the mountpoint */
         strncpy(debugfs_mountpoint, mountpoint, sizeof(debugfs_mountpoint));
+        debugfs_found = 1;
 
-        /* mount it */
-        snprintf(mountcmd, sizeof(mountcmd),
-                 "/bin/mount -t debugfs debugfs %s", mountpoint);
-        return system(mountcmd);
+        return debugfs_mountpoint;
 }
 
 /* umount the debugfs */
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
index 3cd14f9ae784..83a02879745f 100644
--- a/tools/perf/util/debugfs.h
+++ b/tools/perf/util/debugfs.h
@@ -15,7 +15,7 @@
 extern const char *debugfs_find_mountpoint(void);
 extern int debugfs_valid_mountpoint(const char *debugfs);
 extern int debugfs_valid_entry(const char *path);
-extern int debugfs_mount(const char *mountpoint);
+extern char *debugfs_mount(const char *mountpoint);
 extern int debugfs_umount(void);
 extern int debugfs_write(const char *entry, const char *value);
 extern int debugfs_read(const char *entry, char *buffer, size_t size);
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index bb0fd6da2d56..dab9e754a281 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -7,9 +7,25 @@
 #include "strlist.h"
 #include "thread.h"
 
+const char *event__name[] = {
+        [0]                      = "TOTAL",
+        [PERF_RECORD_MMAP]       = "MMAP",
+        [PERF_RECORD_LOST]       = "LOST",
+        [PERF_RECORD_COMM]       = "COMM",
+        [PERF_RECORD_EXIT]       = "EXIT",
+        [PERF_RECORD_THROTTLE]   = "THROTTLE",
+        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
+        [PERF_RECORD_FORK]       = "FORK",
+        [PERF_RECORD_READ]       = "READ",
+        [PERF_RECORD_SAMPLE]     = "SAMPLE",
+        [PERF_RECORD_HEADER_ATTR]        = "ATTR",
+        [PERF_RECORD_HEADER_EVENT_TYPE]  = "EVENT_TYPE",
+        [PERF_RECORD_HEADER_TRACING_DATA]        = "TRACING_DATA",
+        [PERF_RECORD_HEADER_BUILD_ID]    = "BUILD_ID",
+};
+
 static pid_t event__synthesize_comm(pid_t pid, int full,
-                                    int (*process)(event_t *event,
-                                                   struct perf_session *session),
+                                    event__handler_t process,
                                     struct perf_session *session)
 {
         event_t ev;
@@ -91,8 +107,7 @@ out_failure:
 }
 
 static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
-                                         int (*process)(event_t *event,
-                                                        struct perf_session *session),
+                                         event__handler_t process,
                                          struct perf_session *session)
 {
         char filename[PATH_MAX];
@@ -112,7 +127,14 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
         while (1) {
                 char bf[BUFSIZ], *pbf = bf;
                 event_t ev = {
-                        .header = { .type = PERF_RECORD_MMAP },
+                        .header = {
+                                .type = PERF_RECORD_MMAP,
+                                /*
+                                 * Just like the kernel, see __perf_event_mmap
+                                 * in kernel/perf_event.c
+                                 */
+                                .misc = PERF_RECORD_MISC_USER,
+                         },
                 };
                 int n;
                 size_t size;
@@ -138,6 +160,9 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                         if (execname == NULL)
                                 continue;
 
+                        pbf += 3;
+                        n = hex2u64(pbf, &ev.mmap.pgoff);
+
                         size = strlen(execname);
                         execname[size - 1] = '\0'; /* Remove \n */
                         memcpy(ev.mmap.filename, execname, size);
@@ -156,9 +181,51 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
         return 0;
 }
 
-int event__synthesize_thread(pid_t pid,
-                             int (*process)(event_t *event,
-                                            struct perf_session *session),
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session,
+                              struct machine *machine)
+{
+        struct rb_node *nd;
+        struct map_groups *kmaps = &machine->kmaps;
+        u16 misc;
+
+        /*
+         * kernel uses 0 for user space maps, see kernel/perf_event.c
+         * __perf_event_mmap
+         */
+        if (machine__is_host(machine))
+                misc = PERF_RECORD_MISC_KERNEL;
+        else
+                misc = PERF_RECORD_MISC_GUEST_KERNEL;
+
+        for (nd = rb_first(&kmaps->maps[MAP__FUNCTION]);
+             nd; nd = rb_next(nd)) {
+                event_t ev;
+                size_t size;
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+
+                if (pos->dso->kernel)
+                        continue;
+
+                size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
+                memset(&ev, 0, sizeof(ev));
+                ev.mmap.header.misc = misc;
+                ev.mmap.header.type = PERF_RECORD_MMAP;
+                ev.mmap.header.size = (sizeof(ev.mmap) -
+                                        (sizeof(ev.mmap.filename) - size));
+                ev.mmap.start = pos->start;
+                ev.mmap.len   = pos->end - pos->start;
+                ev.mmap.pid   = machine->pid;
+
+                memcpy(ev.mmap.filename, pos->dso->long_name,
+                       pos->dso->long_name_len + 1);
+                process(&ev, session);
+        }
+
+        return 0;
+}
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
                              struct perf_session *session)
 {
         pid_t tgid = event__synthesize_comm(pid, 1, process, session);
@@ -167,8 +234,7 @@ int event__synthesize_thread(pid_t pid,
         return event__synthesize_mmap_events(pid, tgid, process, session);
 }
 
-void event__synthesize_threads(int (*process)(event_t *event,
-                                              struct perf_session *session),
+void event__synthesize_threads(event__handler_t process,
                                struct perf_session *session)
 {
         DIR *proc;
@@ -189,41 +255,120 @@ void event__synthesize_threads(int (*process)(event_t *event,
         closedir(proc);
 }
 
-static void thread__comm_adjust(struct thread *self)
+struct process_symbol_args {
+        const char *name;
+        u64        start;
+};
+
+static int find_symbol_cb(void *arg, const char *name, char type, u64 start)
+{
+        struct process_symbol_args *args = arg;
+
+        /*
+         * Must be a function or at least an alias, as in PARISC64, where "_text" is
+         * an 'A' to the same address as "_stext".
+         */
+        if (!(symbol_type__is_a(type, MAP__FUNCTION) ||
+              type == 'A') || strcmp(name, args->name))
+                return 0;
+
+        args->start = start;
+        return 1;
+}
+
+int event__synthesize_kernel_mmap(event__handler_t process,
+                                  struct perf_session *session,
+                                  struct machine *machine,
+                                  const char *symbol_name)
+{
+        size_t size;
+        const char *filename, *mmap_name;
+        char path[PATH_MAX];
+        char name_buff[PATH_MAX];
+        struct map *map;
+
+        event_t ev = {
+                .header = {
+                        .type = PERF_RECORD_MMAP,
+                },
+        };
+        /*
+         * We should get this from /sys/kernel/sections/.text, but till that is
+         * available use this, and after it is use this as a fallback for older
+         * kernels.
+         */
+        struct process_symbol_args args = { .name = symbol_name, };
+
+        mmap_name = machine__mmap_name(machine, name_buff, sizeof(name_buff));
+        if (machine__is_host(machine)) {
+                /*
+                 * kernel uses PERF_RECORD_MISC_USER for user space maps,
+                 * see kernel/perf_event.c __perf_event_mmap
+                 */
+                ev.header.misc = PERF_RECORD_MISC_KERNEL;
+                filename = "/proc/kallsyms";
+        } else {
+                ev.header.misc = PERF_RECORD_MISC_GUEST_KERNEL;
+                if (machine__is_default_guest(machine))
+                        filename = (char *) symbol_conf.default_guest_kallsyms;
+                else {
+                        sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+                        filename = path;
+                }
+        }
+
+        if (kallsyms__parse(filename, &args, find_symbol_cb) <= 0)
+                return -ENOENT;
+
+        map = machine->vmlinux_maps[MAP__FUNCTION];
+        size = snprintf(ev.mmap.filename, sizeof(ev.mmap.filename),
+                        "%s%s", mmap_name, symbol_name) + 1;
+        size = ALIGN(size, sizeof(u64));
+        ev.mmap.header.size = (sizeof(ev.mmap) -
+                        (sizeof(ev.mmap.filename) - size));
+        ev.mmap.pgoff = args.start;
+        ev.mmap.start = map->start;
+        ev.mmap.len   = map->end - ev.mmap.start;
+        ev.mmap.pid   = machine->pid;
+
+        return process(&ev, session);
+}
+
+static void thread__comm_adjust(struct thread *self, struct hists *hists)
 {
         char *comm = self->comm;
 
         if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
             (!symbol_conf.comm_list ||
              strlist__has_entry(symbol_conf.comm_list, comm))) {
-                unsigned int slen = strlen(comm);
+                u16 slen = strlen(comm);
 
-                if (slen > comms__col_width) {
-                        comms__col_width = slen;
-                        threads__col_width = slen + 6;
-                }
+                if (hists__new_col_len(hists, HISTC_COMM, slen))
+                        hists__set_col_len(hists, HISTC_THREAD, slen + 6);
         }
 }
 
-static int thread__set_comm_adjust(struct thread *self, const char *comm)
+static int thread__set_comm_adjust(struct thread *self, const char *comm,
+                                   struct hists *hists)
 {
         int ret = thread__set_comm(self, comm);
 
         if (ret)
                 return ret;
 
-        thread__comm_adjust(self);
+        thread__comm_adjust(self, hists);
 
         return 0;
 }
 
 int event__process_comm(event_t *self, struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, self->comm.pid);
+        struct thread *thread = perf_session__findnew(session, self->comm.tid);
 
-        dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
+        dump_printf(": %s:%d\n", self->comm.comm, self->comm.tid);
 
-        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
+        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm,
+                                                      &session->hists)) {
                 dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                 return -1;
         }
@@ -234,46 +379,165 @@ int event__process_comm(event_t *self, struct perf_session *session)
 int event__process_lost(event_t *self, struct perf_session *session)
 {
         dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
-        session->events_stats.lost += self->lost.lost;
+        session->hists.stats.total_lost += self->lost.lost;
         return 0;
 }
 
-int event__process_mmap(event_t *self, struct perf_session *session)
+static void event_set_kernel_mmap_len(struct map **maps, event_t *self)
 {
-        struct thread *thread = perf_session__findnew(session, self->mmap.pid);
-        struct map *map = map__new(&self->mmap, MAP__FUNCTION,
-                                   session->cwd, session->cwdlen);
-
-        dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
-                    self->mmap.pid, self->mmap.tid,
-                    (void *)(long)self->mmap.start,
-                    (void *)(long)self->mmap.len,
-                    (void *)(long)self->mmap.pgoff,
-                    self->mmap.filename);
-
-        if (thread == NULL || map == NULL)
-                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
+        maps[MAP__FUNCTION]->start = self->mmap.start;
+        maps[MAP__FUNCTION]->end   = self->mmap.start + self->mmap.len;
+        /*
+         * Be a bit paranoid here, some perf.data file came with
+         * a zero sized synthesized MMAP event for the kernel.
+         */
+        if (maps[MAP__FUNCTION]->end == 0)
+                maps[MAP__FUNCTION]->end = ~0UL;
+}
+
+static int event__process_kernel_mmap(event_t *self,
+                        struct perf_session *session)
+{
+        struct map *map;
+        char kmmap_prefix[PATH_MAX];
+        struct machine *machine;
+        enum dso_kernel_type kernel_type;
+        bool is_kernel_mmap;
+
+        machine = perf_session__findnew_machine(session, self->mmap.pid);
+        if (!machine) {
+                pr_err("Can't find id %d's machine\n", self->mmap.pid);
+                goto out_problem;
+        }
+
+        machine__mmap_name(machine, kmmap_prefix, sizeof(kmmap_prefix));
+        if (machine__is_host(machine))
+                kernel_type = DSO_TYPE_KERNEL;
         else
-                thread__insert_map(thread, map);
+                kernel_type = DSO_TYPE_GUEST_KERNEL;
+
+        is_kernel_mmap = memcmp(self->mmap.filename,
+                                kmmap_prefix,
+                                strlen(kmmap_prefix)) == 0;
+        if (self->mmap.filename[0] == '/' ||
+            (!is_kernel_mmap && self->mmap.filename[0] == '[')) {
+
+                char short_module_name[1024];
+                char *name, *dot;
+
+                if (self->mmap.filename[0] == '/') {
+                        name = strrchr(self->mmap.filename, '/');
+                        if (name == NULL)
+                                goto out_problem;
+
+                        ++name; /* skip / */
+                        dot = strrchr(name, '.');
+                        if (dot == NULL)
+                                goto out_problem;
+                        snprintf(short_module_name, sizeof(short_module_name),
+                                        "[%.*s]", (int)(dot - name), name);
+                        strxfrchar(short_module_name, '-', '_');
+                } else
+                        strcpy(short_module_name, self->mmap.filename);
+
+                map = machine__new_module(machine, self->mmap.start,
+                                          self->mmap.filename);
+                if (map == NULL)
+                        goto out_problem;
+
+                name = strdup(short_module_name);
+                if (name == NULL)
+                        goto out_problem;
+
+                map->dso->short_name = name;
+                map->dso->sname_alloc = 1;
+                map->end = map->start + self->mmap.len;
+        } else if (is_kernel_mmap) {
+                const char *symbol_name = (self->mmap.filename +
+                                strlen(kmmap_prefix));
+                /*
+                 * Should be there already, from the build-id table in
+                 * the header.
+                 */
+                struct dso *kernel = __dsos__findnew(&machine->kernel_dsos,
+                                                     kmmap_prefix);
+                if (kernel == NULL)
+                        goto out_problem;
+
+                kernel->kernel = kernel_type;
+                if (__machine__create_kernel_maps(machine, kernel) < 0)
+                        goto out_problem;
+
+                event_set_kernel_mmap_len(machine->vmlinux_maps, self);
+                perf_session__set_kallsyms_ref_reloc_sym(machine->vmlinux_maps,
+                                                         symbol_name,
+                                                         self->mmap.pgoff);
+                if (machine__is_default_guest(machine)) {
+                        /*
+                         * preload dso of guest kernel and modules
+                         */
+                        dso__load(kernel, machine->vmlinux_maps[MAP__FUNCTION],
+                                  NULL);
+                }
+        }
+        return 0;
+out_problem:
+        return -1;
+}
+
+int event__process_mmap(event_t *self, struct perf_session *session)
+{
+        struct machine *machine;
+        struct thread *thread;
+        struct map *map;
+        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        int ret = 0;
+
+        dump_printf(" %d/%d: [%#Lx(%#Lx) @ %#Lx]: %s\n",
+                        self->mmap.pid, self->mmap.tid, self->mmap.start,
+                        self->mmap.len, self->mmap.pgoff, self->mmap.filename);
 
+        if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
+            cpumode == PERF_RECORD_MISC_KERNEL) {
+                ret = event__process_kernel_mmap(self, session);
+                if (ret < 0)
+                        goto out_problem;
+                return 0;
+        }
+
+        machine = perf_session__find_host_machine(session);
+        if (machine == NULL)
+                goto out_problem;
+        thread = perf_session__findnew(session, self->mmap.pid);
+        if (thread == NULL)
+                goto out_problem;
+        map = map__new(&machine->user_dsos, self->mmap.start,
+                        self->mmap.len, self->mmap.pgoff,
+                        self->mmap.pid, self->mmap.filename,
+                        MAP__FUNCTION);
+        if (map == NULL)
+                goto out_problem;
+
+        thread__insert_map(thread, map);
+        return 0;
+
+out_problem:
+        dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
         return 0;
 }
 
 int event__process_task(event_t *self, struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, self->fork.pid);
-        struct thread *parent = perf_session__findnew(session, self->fork.ppid);
+        struct thread *thread = perf_session__findnew(session, self->fork.tid);
+        struct thread *parent = perf_session__findnew(session, self->fork.ptid);
 
         dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
                     self->fork.ppid, self->fork.ptid);
-        /*
-         * A thread clone will have the same PID for both parent and child.
-         */
-        if (thread == parent)
-                return 0;
 
-        if (self->header.type == PERF_RECORD_EXIT)
+        if (self->header.type == PERF_RECORD_EXIT) {
+                perf_session__remove_thread(session, thread);
                 return 0;
+        }
 
         if (thread == NULL || parent == NULL ||
             thread__fork(thread, parent) < 0) {
@@ -284,26 +548,78 @@ int event__process_task(event_t *self, struct perf_session *session)
         return 0;
 }
 
-void thread__find_addr_location(struct thread *self,
-                                struct perf_session *session, u8 cpumode,
-                                enum map_type type, u64 addr,
-                                struct addr_location *al,
-                                symbol_filter_t filter)
+int event__process(event_t *event, struct perf_session *session)
+{
+        switch (event->header.type) {
+        case PERF_RECORD_COMM:
+                event__process_comm(event, session);
+                break;
+        case PERF_RECORD_MMAP:
+                event__process_mmap(event, session);
+                break;
+        case PERF_RECORD_FORK:
+        case PERF_RECORD_EXIT:
+                event__process_task(event, session);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, pid_t pid, u64 addr,
+                           struct addr_location *al)
 {
         struct map_groups *mg = &self->mg;
+        struct machine *machine = NULL;
 
         al->thread = self;
         al->addr = addr;
+        al->cpumode = cpumode;
+        al->filtered = false;
 
-        if (cpumode & PERF_RECORD_MISC_KERNEL) {
+        if (cpumode == PERF_RECORD_MISC_KERNEL && perf_host) {
                 al->level = 'k';
-                mg = &session->kmaps;
-        } else if (cpumode & PERF_RECORD_MISC_USER)
+                machine = perf_session__find_host_machine(session);
+                if (machine == NULL) {
+                        al->map = NULL;
+                        return;
+                }
+                mg = &machine->kmaps;
+        } else if (cpumode == PERF_RECORD_MISC_USER && perf_host) {
                 al->level = '.';
-        else {
-                al->level = 'H';
+                machine = perf_session__find_host_machine(session);
+        } else if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
+                al->level = 'g';
+                machine = perf_session__find_machine(session, pid);
+                if (machine == NULL) {
+                        al->map = NULL;
+                        return;
+                }
+                mg = &machine->kmaps;
+        } else {
+                /*
+                 * 'u' means guest os user space.
+                 * TODO: We don't support guest user space. Might support late.
+                 */
+                if (cpumode == PERF_RECORD_MISC_GUEST_USER && perf_guest)
+                        al->level = 'u';
+                else
+                        al->level = 'H';
                 al->map = NULL;
-                al->sym = NULL;
+
+                if ((cpumode == PERF_RECORD_MISC_GUEST_USER ||
+                        cpumode == PERF_RECORD_MISC_GUEST_KERNEL) &&
+                        !perf_guest)
+                        al->filtered = true;
+                if ((cpumode == PERF_RECORD_MISC_USER ||
+                        cpumode == PERF_RECORD_MISC_KERNEL) &&
+                        !perf_host)
+                        al->filtered = true;
+
                 return;
         }
 try_again:
@@ -318,36 +634,72 @@ try_again:
                  * "[vdso]" dso, but for now lets use the old trick of looking
                  * in the whole kernel symbol list.
                  */
-                if ((long long)al->addr < 0 && mg != &session->kmaps) {
-                        mg = &session->kmaps;
+                if ((long long)al->addr < 0 &&
+                    cpumode == PERF_RECORD_MISC_KERNEL &&
+                    machine && mg != &machine->kmaps) {
+                        mg = &machine->kmaps;
                         goto try_again;
                 }
-                al->sym = NULL;
-        } else {
+        } else
                 al->addr = al->map->map_ip(al->map, al->addr);
-                al->sym = map__find_symbol(al->map, session, al->addr, filter);
-        }
 }
 
-static void dso__calc_col_width(struct dso *self)
+void thread__find_addr_location(struct thread *self,
+                                struct perf_session *session, u8 cpumode,
+                                enum map_type type, pid_t pid, u64 addr,
+                                struct addr_location *al,
+                                symbol_filter_t filter)
+{
+        thread__find_addr_map(self, session, cpumode, type, pid, addr, al);
+        if (al->map != NULL)
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        else
+                al->sym = NULL;
+}
+
+static void dso__calc_col_width(struct dso *self, struct hists *hists)
 {
         if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
             (!symbol_conf.dso_list ||
              strlist__has_entry(symbol_conf.dso_list, self->name))) {
-                unsigned int slen = strlen(self->name);
-                if (slen > dsos__col_width)
-                        dsos__col_width = slen;
+                u16 slen = dso__name_len(self);
+                hists__new_col_len(hists, HISTC_DSO, slen);
         }
 
         self->slen_calculated = 1;
 }
 
 int event__preprocess_sample(const event_t *self, struct perf_session *session,
-                             struct addr_location *al, symbol_filter_t filter)
+                             struct addr_location *al, struct sample_data *data,
+                             symbol_filter_t filter)
 {
         u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = perf_session__findnew(session, self->ip.pid);
+        struct thread *thread;
+
+        event__parse_sample(self, session->sample_type, data);
+
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld cpu:%d\n",
+                    self->header.misc, data->pid, data->tid, data->ip,
+                    data->period, data->cpu);
+
+        if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
+                unsigned int i;
+
+                dump_printf("... chain: nr:%Lu\n", data->callchain->nr);
+
+                if (!ip_callchain__valid(data->callchain, self)) {
+                        pr_debug("call-chain problem with event, "
+                                 "skipping it.\n");
+                        goto out_filtered;
+                }
 
+                if (dump_trace) {
+                        for (i = 0; i < data->callchain->nr; i++)
+                                dump_printf("..... %2d: %016Lx\n",
+                                            i, data->callchain->ips[i]);
+                }
+        }
+        thread = perf_session__findnew(session, self->ip.pid);
         if (thread == NULL)
                 return -1;
 
@@ -356,31 +708,57 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
                 goto out_filtered;
 
         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+        /*
+         * Have we already created the kernel maps for the host machine?
+         *
+         * This should have happened earlier, when we processed the kernel MMAP
+         * events, but for older perf.data files there was no such thing, so do
+         * it now.
+         */
+        if (cpumode == PERF_RECORD_MISC_KERNEL &&
+            session->host_machine.vmlinux_maps[MAP__FUNCTION] == NULL)
+                machine__create_kernel_maps(&session->host_machine);
 
-        thread__find_addr_location(thread, session, cpumode, MAP__FUNCTION,
-                                   self->ip.ip, al, filter);
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              self->ip.pid, self->ip.ip, al);
         dump_printf(" ...... dso: %s\n",
                     al->map ? al->map->dso->long_name :
                         al->level == 'H' ? "[hypervisor]" : "<not found>");
-        /*
-         * We have to do this here as we may have a dso with no symbol hit that
-         * has a name longer than the ones with symbols sampled.
-         */
-        if (al->map && !sort_dso.elide && !al->map->dso->slen_calculated)
-                dso__calc_col_width(al->map->dso);
-
-        if (symbol_conf.dso_list &&
-            (!al->map || !al->map->dso ||
-             !(strlist__has_entry(symbol_conf.dso_list, al->map->dso->short_name) ||
-               (al->map->dso->short_name != al->map->dso->long_name &&
-                strlist__has_entry(symbol_conf.dso_list, al->map->dso->long_name)))))
-                goto out_filtered;
+        al->sym = NULL;
+        al->cpu = data->cpu;
+
+        if (al->map) {
+                if (symbol_conf.dso_list &&
+                    (!al->map || !al->map->dso ||
+                     !(strlist__has_entry(symbol_conf.dso_list,
+                                          al->map->dso->short_name) ||
+                       (al->map->dso->short_name != al->map->dso->long_name &&
+                        strlist__has_entry(symbol_conf.dso_list,
+                                           al->map->dso->long_name)))))
+                        goto out_filtered;
+                /*
+                 * We have to do this here as we may have a dso with no symbol
+                 * hit that has a name longer than the ones with symbols
+                 * sampled.
+                 */
+                if (!sort_dso.elide && !al->map->dso->slen_calculated)
+                        dso__calc_col_width(al->map->dso, &session->hists);
+
+                al->sym = map__find_symbol(al->map, al->addr, filter);
+        } else {
+                const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
+
+                if (hists__col_len(&session->hists, HISTC_DSO) < unresolved_col_width &&
+                    !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+                    !symbol_conf.dso_list)
+                        hists__set_col_len(&session->hists, HISTC_DSO,
+                                           unresolved_col_width);
+        }
 
         if (symbol_conf.sym_list && al->sym &&
             !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
                 goto out_filtered;
 
-        al->filtered = false;
         return 0;
 
 out_filtered:
@@ -388,9 +766,9 @@ out_filtered:
         return 0;
 }
 
-int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
+int event__parse_sample(const event_t *event, u64 type, struct sample_data *data)
 {
-        u64 *array = event->sample.array;
+        const u64 *array = event->sample.array;
 
         if (type & PERF_SAMPLE_IP) {
                 data->ip = event->ip.ip;
@@ -414,6 +792,7 @@ int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
                 array++;
         }
 
+        data->id = -1ULL;
         if (type & PERF_SAMPLE_ID) {
                 data->id = *array;
                 array++;
@@ -428,7 +807,8 @@ int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
                 u32 *p = (u32 *)array;
                 data->cpu = *p;
                 array++;
-        }
+        } else
+                data->cpu = -1;
 
         if (type & PERF_SAMPLE_PERIOD) {
                 data->period = *array;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 690a96d0467c..8e790dae7026 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -1,10 +1,10 @@
 #ifndef __PERF_RECORD_H
 #define __PERF_RECORD_H
 
+#include <limits.h>
+
 #include "../perf.h"
-#include "util.h"
-#include <linux/list.h>
-#include <linux/rbtree.h>
+#include "map.h"
 
 /*
  * PERF_SAMPLE_IP | PERF_SAMPLE_TID | *
@@ -68,21 +68,54 @@ struct sample_data {
         u64 addr;
         u64 id;
         u64 stream_id;
-        u32 cpu;
         u64 period;
-        struct ip_callchain *callchain;
+        u32 cpu;
         u32 raw_size;
         void *raw_data;
+        struct ip_callchain *callchain;
 };
 
 #define BUILD_ID_SIZE 20
 
 struct build_id_event {
         struct perf_event_header header;
+        pid_t                    pid;
         u8                       build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
         char                     filename[];
 };
 
+enum perf_user_event_type { /* above any possible kernel type */
+        PERF_RECORD_HEADER_ATTR                 = 64,
+        PERF_RECORD_HEADER_EVENT_TYPE           = 65,
+        PERF_RECORD_HEADER_TRACING_DATA         = 66,
+        PERF_RECORD_HEADER_BUILD_ID             = 67,
+        PERF_RECORD_FINISHED_ROUND              = 68,
+        PERF_RECORD_HEADER_MAX
+};
+
+struct attr_event {
+        struct perf_event_header header;
+        struct perf_event_attr attr;
+        u64 id[];
+};
+
+#define MAX_EVENT_NAME 64
+
+struct perf_trace_event_type {
+        u64     event_id;
+        char    name[MAX_EVENT_NAME];
+};
+
+struct event_type_event {
+        struct perf_event_header header;
+        struct perf_trace_event_type event_type;
+};
+
+struct tracing_data_event {
+        struct perf_event_header header;
+        u32 size;
+};
+
 typedef union event_union {
         struct perf_event_header        header;
         struct ip_event                 ip;
@@ -92,92 +125,43 @@ typedef union event_union {
         struct lost_event               lost;
         struct read_event               read;
         struct sample_event             sample;
+        struct attr_event               attr;
+        struct event_type_event         event_type;
+        struct tracing_data_event       tracing_data;
+        struct build_id_event           build_id;
 } event_t;
 
-struct events_stats {
-        u64 total;
-        u64 lost;
-};
-
 void event__print_totals(void);
 
-enum map_type {
-        MAP__FUNCTION = 0,
-        MAP__VARIABLE,
-};
-
-#define MAP__NR_TYPES (MAP__VARIABLE + 1)
-
-struct map {
-        union {
-                struct rb_node  rb_node;
-                struct list_head node;
-        };
-        u64                     start;
-        u64                     end;
-        enum map_type           type;
-        u64                     pgoff;
-        u64                     (*map_ip)(struct map *, u64);
-        u64                     (*unmap_ip)(struct map *, u64);
-        struct dso              *dso;
-};
-
-static inline u64 map__map_ip(struct map *map, u64 ip)
-{
-        return ip - map->start + map->pgoff;
-}
-
-static inline u64 map__unmap_ip(struct map *map, u64 ip)
-{
-        return ip + map->start - map->pgoff;
-}
-
-static inline u64 identity__map_ip(struct map *map __used, u64 ip)
-{
-        return ip;
-}
-
-struct symbol;
-
-typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
-
-void map__init(struct map *self, enum map_type type,
-               u64 start, u64 end, u64 pgoff, struct dso *dso);
-struct map *map__new(struct mmap_event *event, enum map_type,
-                     char *cwd, int cwdlen);
-void map__delete(struct map *self);
-struct map *map__clone(struct map *self);
-int map__overlap(struct map *l, struct map *r);
-size_t map__fprintf(struct map *self, FILE *fp);
-
 struct perf_session;
 
-int map__load(struct map *self, struct perf_session *session,
-              symbol_filter_t filter);
-struct symbol *map__find_symbol(struct map *self, struct perf_session *session,
-                                u64 addr, symbol_filter_t filter);
-struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
-                                        struct perf_session *session,
-                                        symbol_filter_t filter);
-void map__fixup_start(struct map *self);
-void map__fixup_end(struct map *self);
-
-int event__synthesize_thread(pid_t pid,
-                             int (*process)(event_t *event,
-                                            struct perf_session *session),
+typedef int (*event__handler_t)(event_t *event, struct perf_session *session);
+
+int event__synthesize_thread(pid_t pid, event__handler_t process,
                              struct perf_session *session);
-void event__synthesize_threads(int (*process)(event_t *event,
-                                              struct perf_session *session),
+void event__synthesize_threads(event__handler_t process,
                                struct perf_session *session);
+int event__synthesize_kernel_mmap(event__handler_t process,
+                                struct perf_session *session,
+                                struct machine *machine,
+                                const char *symbol_name);
+
+int event__synthesize_modules(event__handler_t process,
+                              struct perf_session *session,
+                              struct machine *machine);
 
 int event__process_comm(event_t *self, struct perf_session *session);
 int event__process_lost(event_t *self, struct perf_session *session);
 int event__process_mmap(event_t *self, struct perf_session *session);
 int event__process_task(event_t *self, struct perf_session *session);
+int event__process(event_t *event, struct perf_session *session);
 
 struct addr_location;
 int event__preprocess_sample(const event_t *self, struct perf_session *session,
-                             struct addr_location *al, symbol_filter_t filter);
-int event__parse_sample(event_t *event, u64 type, struct sample_data *data);
+                             struct addr_location *al, struct sample_data *data,
+                             symbol_filter_t filter);
+int event__parse_sample(const event_t *event, u64 type, struct sample_data *data);
+
+extern const char *event__name[];
 
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/exec_cmd.c b/tools/perf/util/exec_cmd.c
index 2745605dba11..67eeff571568 100644
--- a/tools/perf/util/exec_cmd.c
+++ b/tools/perf/util/exec_cmd.c
@@ -53,8 +53,8 @@ const char *perf_extract_argv0_path(const char *argv0)
                 slash--;
 
         if (slash >= argv0) {
-                argv0_path = xstrndup(argv0, slash - argv0);
-                return slash + 1;
+                argv0_path = strndup(argv0, slash - argv0);
+                return argv0_path ? slash + 1 : NULL;
         }
 
         return argv0;
@@ -116,7 +116,7 @@ void setup_path(void)
         strbuf_release(&new_path);
 }
 
-const char **prepare_perf_cmd(const char **argv)
+static const char **prepare_perf_cmd(const char **argv)
 {
         int argc;
         const char **nargv;
diff --git a/tools/perf/util/exec_cmd.h b/tools/perf/util/exec_cmd.h
index 31647ac92ed1..bc4b915963f5 100644
--- a/tools/perf/util/exec_cmd.h
+++ b/tools/perf/util/exec_cmd.h
@@ -5,7 +5,6 @@ extern void perf_set_argv_exec_path(const char *exec_path);
 extern const char *perf_extract_argv0_path(const char *path);
 extern const char *perf_exec_path(void);
 extern void setup_path(void);
-extern const char **prepare_perf_cmd(const char **argv);
 extern int execv_perf_cmd(const char **argv); /* NULL terminated */
 extern int execl_perf_cmd(const char *cmd, ...);
 extern const char *system_path(const char *path);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 8a0bca55106f..d7e67b167ea3 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -1,8 +1,12 @@
+#define _FILE_OFFSET_BITS 64
+
 #include <sys/types.h>
+#include <byteswap.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <linux/list.h>
+#include <linux/kernel.h>
 
 #include "util.h"
 #include "header.h"
@@ -12,6 +16,8 @@
 #include "symbol.h"
 #include "debug.h"
 
+static bool no_buildid_cache = false;
+
 /*
  * Create new perf.data header attribute:
  */
@@ -95,34 +101,31 @@ int perf_header__add_attr(struct perf_header *self,
         return 0;
 }
 
-#define MAX_EVENT_NAME 64
-
-struct perf_trace_event_type {
-        u64     event_id;
-        char    name[MAX_EVENT_NAME];
-};
-
 static int event_count;
 static struct perf_trace_event_type *events;
 
-void perf_header__push_event(u64 id, const char *name)
+int perf_header__push_event(u64 id, const char *name)
 {
         if (strlen(name) > MAX_EVENT_NAME)
                 pr_warning("Event %s will be truncated\n", name);
 
         if (!events) {
                 events = malloc(sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                if (events == NULL)
+                        return -ENOMEM;
         } else {
-                events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
-                if (!events)
-                        die("nomem");
+                struct perf_trace_event_type *nevents;
+
+                nevents = realloc(events, (event_count + 1) * sizeof(*events));
+                if (nevents == NULL)
+                        return -ENOMEM;
+                events = nevents;
         }
         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
         events[event_count].event_id = id;
         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
         event_count++;
+        return 0;
 }
 
 char *perf_header__find_event(u64 id)
@@ -169,31 +172,50 @@ static int do_write(int fd, const void *buf, size_t size)
         return 0;
 }
 
-static int __dsos__write_buildid_table(struct list_head *head, int fd)
+#define NAME_ALIGN 64
+
+static int write_padded(int fd, const void *bf, size_t count,
+                        size_t count_aligned)
 {
-#define NAME_ALIGN      64
-        struct dso *pos;
         static const char zero_buf[NAME_ALIGN];
+        int err = do_write(fd, bf, count);
+
+        if (!err)
+                err = do_write(fd, zero_buf, count_aligned - count);
+
+        return err;
+}
+
+#define dsos__for_each_with_build_id(pos, head) \
+        list_for_each_entry(pos, head, node)    \
+                if (!pos->has_build_id)         \
+                        continue;               \
+                else
 
-        list_for_each_entry(pos, head, node) {
+static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
+                                u16 misc, int fd)
+{
+        struct dso *pos;
+
+        dsos__for_each_with_build_id(pos, head) {
                 int err;
                 struct build_id_event b;
                 size_t len;
 
-                if (!pos->has_build_id)
+                if (!pos->hit)
                         continue;
                 len = pos->long_name_len + 1;
                 len = ALIGN(len, NAME_ALIGN);
                 memset(&b, 0, sizeof(b));
                 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
+                b.pid = pid;
+                b.header.misc = misc;
                 b.header.size = sizeof(b) + len;
                 err = do_write(fd, &b, sizeof(b));
                 if (err < 0)
                         return err;
-                err = do_write(fd, pos->long_name, pos->long_name_len + 1);
-                if (err < 0)
-                        return err;
-                err = do_write(fd, zero_buf, len - pos->long_name_len - 1);
+                err = write_padded(fd, pos->long_name,
+                                   pos->long_name_len + 1, len);
                 if (err < 0)
                         return err;
         }
@@ -201,23 +223,215 @@ static int __dsos__write_buildid_table(struct list_head *head, int fd)
         return 0;
 }
 
-static int dsos__write_buildid_table(int fd)
+static int machine__write_buildid_table(struct machine *self, int fd)
 {
-        int err = __dsos__write_buildid_table(&dsos__kernel, fd);
+        int err;
+        u16 kmisc = PERF_RECORD_MISC_KERNEL,
+            umisc = PERF_RECORD_MISC_USER;
+
+        if (!machine__is_host(self)) {
+                kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
+                umisc = PERF_RECORD_MISC_GUEST_USER;
+        }
+
+        err = __dsos__write_buildid_table(&self->kernel_dsos, self->pid,
+                                          kmisc, fd);
         if (err == 0)
-                err = __dsos__write_buildid_table(&dsos__user, fd);
+                err = __dsos__write_buildid_table(&self->user_dsos,
+                                                  self->pid, umisc, fd);
+        return err;
+}
+
+static int dsos__write_buildid_table(struct perf_header *header, int fd)
+{
+        struct perf_session *session = container_of(header,
+                        struct perf_session, header);
+        struct rb_node *nd;
+        int err = machine__write_buildid_table(&session->host_machine, fd);
+
+        if (err)
+                return err;
+
+        for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                err = machine__write_buildid_table(pos, fd);
+                if (err)
+                        break;
+        }
+        return err;
+}
+
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size), *targetname;
+        int len, err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        len = snprintf(filename, size, "%s%s%s",
+                       debugdir, is_kallsyms ? "/" : "", name);
+        if (mkdir_p(filename, 0755))
+                goto out_free;
+
+        snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
+
+        if (access(filename, F_OK)) {
+                if (is_kallsyms) {
+                         if (copyfile("/proc/kallsyms", filename))
+                                goto out_free;
+                } else if (link(name, filename) && copyfile(name, filename))
+                        goto out_free;
+        }
+
+        len = snprintf(linkname, size, "%s/.build-id/%.2s",
+                       debugdir, sbuild_id);
+
+        if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
+                goto out_free;
+
+        snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
+        targetname = filename + strlen(debugdir) - 5;
+        memcpy(targetname, "../..", 5);
+
+        if (symlink(targetname, linkname) == 0)
+                err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
+                                 const char *name, const char *debugdir,
+                                 bool is_kallsyms)
+{
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+        build_id__sprintf(build_id, build_id_size, sbuild_id);
+
+        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
+}
+
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
+{
+        const size_t size = PATH_MAX;
+        char *filename = malloc(size),
+             *linkname = malloc(size);
+        int err = -1;
+
+        if (filename == NULL || linkname == NULL)
+                goto out_free;
+
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, sbuild_id + 2);
+
+        if (access(linkname, F_OK))
+                goto out_free;
+
+        if (readlink(linkname, filename, size) < 0)
+                goto out_free;
+
+        if (unlink(linkname))
+                goto out_free;
+
+        /*
+         * Since the link is relative, we must make it absolute:
+         */
+        snprintf(linkname, size, "%s/.build-id/%.2s/%s",
+                 debugdir, sbuild_id, filename);
+
+        if (unlink(linkname))
+                goto out_free;
+
+        err = 0;
+out_free:
+        free(filename);
+        free(linkname);
+        return err;
+}
+
+static int dso__cache_build_id(struct dso *self, const char *debugdir)
+{
+        bool is_kallsyms = self->kernel && self->long_name[0] != '/';
+
+        return build_id_cache__add_b(self->build_id, sizeof(self->build_id),
+                                     self->long_name, debugdir, is_kallsyms);
+}
+
+static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
+{
+        struct dso *pos;
+        int err = 0;
+
+        dsos__for_each_with_build_id(pos, head)
+                if (dso__cache_build_id(pos, debugdir))
+                        err = -1;
+
         return err;
 }
 
+static int machine__cache_build_ids(struct machine *self, const char *debugdir)
+{
+        int ret = __dsos__cache_build_ids(&self->kernel_dsos, debugdir);
+        ret |= __dsos__cache_build_ids(&self->user_dsos, debugdir);
+        return ret;
+}
+
+static int perf_session__cache_build_ids(struct perf_session *self)
+{
+        struct rb_node *nd;
+        int ret;
+        char debugdir[PATH_MAX];
+
+        snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
+
+        if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
+                return -1;
+
+        ret = machine__cache_build_ids(&self->host_machine, debugdir);
+
+        for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= machine__cache_build_ids(pos, debugdir);
+        }
+        return ret ? -1 : 0;
+}
+
+static bool machine__read_build_ids(struct machine *self, bool with_hits)
+{
+        bool ret = __dsos__read_build_ids(&self->kernel_dsos, with_hits);
+        ret |= __dsos__read_build_ids(&self->user_dsos, with_hits);
+        return ret;
+}
+
+static bool perf_session__read_build_ids(struct perf_session *self, bool with_hits)
+{
+        struct rb_node *nd;
+        bool ret = machine__read_build_ids(&self->host_machine, with_hits);
+
+        for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret |= machine__read_build_ids(pos, with_hits);
+        }
+
+        return ret;
+}
+
 static int perf_header__adds_write(struct perf_header *self, int fd)
 {
         int nr_sections;
+        struct perf_session *session;
         struct perf_file_section *feat_sec;
         int sec_size;
         u64 sec_start;
         int idx = 0, err;
 
-        if (dsos__read_build_ids())
+        session = container_of(self, struct perf_session, header);
+        if (perf_session__read_build_ids(session, true))
                 perf_header__set_feat(self, HEADER_BUILD_ID);
 
         nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
@@ -244,7 +458,6 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
                 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
         }
 
-
         if (perf_header__has_feat(self, HEADER_BUILD_ID)) {
                 struct perf_file_section *buildid_sec;
 
@@ -252,12 +465,15 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
 
                 /* Write build-ids */
                 buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
-                err = dsos__write_buildid_table(fd);
+                err = dsos__write_buildid_table(self, fd);
                 if (err < 0) {
                         pr_debug("failed to write buildid table\n");
                         goto out_free;
                 }
-                buildid_sec->size = lseek(fd, 0, SEEK_CUR) - buildid_sec->offset;
+                buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
+                                          buildid_sec->offset;
+                if (!no_buildid_cache)
+                        perf_session__cache_build_ids(session);
         }
 
         lseek(fd, sec_start, SEEK_SET);
@@ -269,6 +485,25 @@ out_free:
         return err;
 }
 
+int perf_header__write_pipe(int fd)
+{
+        struct perf_pipe_file_header f_header;
+        int err;
+
+        f_header = (struct perf_pipe_file_header){
+                .magic     = PERF_MAGIC,
+                .size      = sizeof(f_header),
+        };
+
+        err = do_write(fd, &f_header, sizeof(f_header));
+        if (err < 0) {
+                pr_debug("failed to write perf pipe header\n");
+                return err;
+        }
+
+        return 0;
+}
+
 int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 {
         struct perf_file_header f_header;
@@ -278,7 +513,6 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
-
         for (i = 0; i < self->attrs; i++) {
                 attr = self->attr[i];
 
@@ -360,30 +594,28 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
         return 0;
 }
 
-static void do_read(int fd, void *buf, size_t size)
+static int perf_header__getbuffer64(struct perf_header *self,
+                                    int fd, void *buf, size_t size)
 {
-        while (size) {
-                int ret = read(fd, buf, size);
+        if (do_read(fd, buf, size) <= 0)
+                return -1;
 
-                if (ret < 0)
-                        die("failed to read");
-                if (ret == 0)
-                        die("failed to read: missing data");
+        if (self->needs_swap)
+                mem_bswap_64(buf, size);
 
-                size -= ret;
-                buf += ret;
-        }
+        return 0;
 }
 
 int perf_header__process_sections(struct perf_header *self, int fd,
                                   int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
                                                  int feat, int fd))
 {
         struct perf_file_section *feat_sec;
         int nr_sections;
         int sec_size;
         int idx = 0;
-        int err = 0, feat = 1;
+        int err = -1, feat = 1;
 
         nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS);
         if (!nr_sections)
@@ -397,33 +629,45 @@ int perf_header__process_sections(struct perf_header *self, int fd,
 
         lseek(fd, self->data_offset + self->data_size, SEEK_SET);
 
-        do_read(fd, feat_sec, sec_size);
+        if (perf_header__getbuffer64(self, fd, feat_sec, sec_size))
+                goto out_free;
 
+        err = 0;
         while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
                 if (perf_header__has_feat(self, feat)) {
                         struct perf_file_section *sec = &feat_sec[idx++];
 
-                        err = process(sec, feat, fd);
+                        err = process(sec, self, feat, fd);
                         if (err < 0)
                                 break;
                 }
                 ++feat;
         }
-
+out_free:
         free(feat_sec);
         return err;
-};
+}
 
 int perf_file_header__read(struct perf_file_header *self,
                            struct perf_header *ph, int fd)
 {
         lseek(fd, 0, SEEK_SET);
-        do_read(fd, self, sizeof(*self));
 
-        if (self->magic     != PERF_MAGIC ||
-            self->attr_size != sizeof(struct perf_file_attr))
+        if (do_read(fd, self, sizeof(*self)) <= 0 ||
+            memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
                 return -1;
 
+        if (self->attr_size != sizeof(struct perf_file_attr)) {
+                u64 attr_size = bswap_64(self->attr_size);
+
+                if (attr_size != sizeof(struct perf_file_attr))
+                        return -1;
+
+                mem_bswap_64(self, offsetof(struct perf_file_header,
+                                            adds_features));
+                ph->needs_swap = true;
+        }
+
         if (self->size != sizeof(*self)) {
                 /* Support the previous format */
                 if (self->size == offsetof(typeof(*self), adds_features))
@@ -433,19 +677,118 @@ int perf_file_header__read(struct perf_file_header *self,
         }
 
         memcpy(&ph->adds_features, &self->adds_features,
-               sizeof(self->adds_features));
+               sizeof(ph->adds_features));
+        /*
+         * FIXME: hack that assumes that if we need swap the perf.data file
+         * may be coming from an arch with a different word-size, ergo different
+         * DEFINE_BITMAP format, investigate more later, but for now its mostly
+         * safe to assume that we have a build-id section. Trace files probably
+         * have several other issues in this realm anyway...
+         */
+        if (ph->needs_swap) {
+                memset(&ph->adds_features, 0, sizeof(ph->adds_features));
+                perf_header__set_feat(ph, HEADER_BUILD_ID);
+        }
 
         ph->event_offset = self->event_types.offset;
-        ph->event_size   = self->event_types.size;
-        ph->data_offset  = self->data.offset;
+        ph->event_size   = self->event_types.size;
+        ph->data_offset  = self->data.offset;
         ph->data_size    = self->data.size;
         return 0;
 }
 
+static int __event_process_build_id(struct build_id_event *bev,
+                                    char *filename,
+                                    struct perf_session *session)
+{
+        int err = -1;
+        struct list_head *head;
+        struct machine *machine;
+        u16 misc;
+        struct dso *dso;
+        enum dso_kernel_type dso_type;
+
+        machine = perf_session__findnew_machine(session, bev->pid);
+        if (!machine)
+                goto out;
+
+        misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        switch (misc) {
+        case PERF_RECORD_MISC_KERNEL:
+                dso_type = DSO_TYPE_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                dso_type = DSO_TYPE_GUEST_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_USER:
+        case PERF_RECORD_MISC_GUEST_USER:
+                dso_type = DSO_TYPE_USER;
+                head = &machine->user_dsos;
+                break;
+        default:
+                goto out;
+        }
+
+        dso = __dsos__findnew(head, filename);
+        if (dso != NULL) {
+                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                dso__set_build_id(dso, &bev->build_id);
+
+                if (filename[0] == '[')
+                        dso->kernel = dso_type;
+
+                build_id__sprintf(dso->build_id, sizeof(dso->build_id),
+                                  sbuild_id);
+                pr_debug("build id event received for %s: %s\n",
+                         dso->long_name, sbuild_id);
+        }
+
+        err = 0;
+out:
+        return err;
+}
+
+static int perf_header__read_build_ids(struct perf_header *self,
+                        int input, u64 offset, u64 size)
+{
+        struct perf_session *session = container_of(self,
+                        struct perf_session, header);
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        u64 limit = offset + size;
+        int err = -1;
+
+        while (offset < limit) {
+                ssize_t len;
+
+                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                        goto out;
+
+                if (self->needs_swap)
+                        perf_event_header__bswap(&bev.header);
+
+                len = bev.header.size - sizeof(bev);
+                if (read(input, filename, len) != len)
+                        goto out;
+
+                __event_process_build_id(&bev, filename, session);
+
+                offset += bev.header.size;
+        }
+        err = 0;
+out:
+        return err;
+}
+
 static int perf_file_section__process(struct perf_file_section *self,
+                                      struct perf_header *ph,
                                       int feat, int fd)
 {
-        if (lseek(fd, self->offset, SEEK_SET) < 0) {
+        if (lseek(fd, self->offset, SEEK_SET) == (off_t)-1) {
                 pr_debug("Failed to lseek to %Ld offset for feature %d, "
                          "continuing...\n", self->offset, feat);
                 return 0;
@@ -453,11 +796,11 @@ static int perf_file_section__process(struct perf_file_section *self,
 
         switch (feat) {
         case HEADER_TRACE_INFO:
-                trace_report(fd);
+                trace_report(fd, false);
                 break;
 
         case HEADER_BUILD_ID:
-                if (perf_header__read_build_ids(fd, self->offset, self->size))
+                if (perf_header__read_build_ids(ph, fd, self->offset, self->size))
                         pr_debug("Failed to read buildids, continuing...\n");
                 break;
         default:
@@ -467,13 +810,56 @@ static int perf_file_section__process(struct perf_file_section *self,
         return 0;
 }
 
-int perf_header__read(struct perf_header *self, int fd)
+static int perf_file_header__read_pipe(struct perf_pipe_file_header *self,
+                                       struct perf_header *ph, int fd,
+                                       bool repipe)
 {
-        struct perf_file_header f_header;
+        if (do_read(fd, self, sizeof(*self)) <= 0 ||
+            memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
+                return -1;
+
+        if (repipe && do_write(STDOUT_FILENO, self, sizeof(*self)) < 0)
+                return -1;
+
+        if (self->size != sizeof(*self)) {
+                u64 size = bswap_64(self->size);
+
+                if (size != sizeof(*self))
+                        return -1;
+
+                ph->needs_swap = true;
+        }
+
+        return 0;
+}
+
+static int perf_header__read_pipe(struct perf_session *session, int fd)
+{
+        struct perf_header *self = &session->header;
+        struct perf_pipe_file_header f_header;
+
+        if (perf_file_header__read_pipe(&f_header, self, fd,
+                                        session->repipe) < 0) {
+                pr_debug("incompatible file format\n");
+                return -EINVAL;
+        }
+
+        session->fd = fd;
+
+        return 0;
+}
+
+int perf_header__read(struct perf_session *session, int fd)
+{
+        struct perf_header *self = &session->header;
+        struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         u64                     f_id;
         int nr_attrs, nr_ids, i, j;
 
+        if (session->fd_pipe)
+                return perf_header__read_pipe(session, fd);
+
         if (perf_file_header__read(&f_header, self, fd) < 0) {
                 pr_debug("incompatible file format\n");
                 return -EINVAL;
@@ -486,7 +872,9 @@ int perf_header__read(struct perf_header *self, int fd)
                 struct perf_header_attr *attr;
                 off_t tmp;
 
-                do_read(fd, &f_attr, sizeof(f_attr));
+                if (perf_header__getbuffer64(self, fd, &f_attr, sizeof(f_attr)))
+                        goto out_errno;
+
                 tmp = lseek(fd, 0, SEEK_CUR);
 
                 attr = perf_header_attr__new(&f_attr.attr);
@@ -497,7 +885,8 @@ int perf_header__read(struct perf_header *self, int fd)
                 lseek(fd, f_attr.ids.offset, SEEK_SET);
 
                 for (j = 0; j < nr_ids; j++) {
-                        do_read(fd, &f_id, sizeof(f_id));
+                        if (perf_header__getbuffer64(self, fd, &f_id, sizeof(f_id)))
+                                goto out_errno;
 
                         if (perf_header_attr__add_id(attr, f_id) < 0) {
                                 perf_header_attr__delete(attr);
@@ -517,7 +906,9 @@ int perf_header__read(struct perf_header *self, int fd)
                 events = malloc(f_header.event_types.size);
                 if (events == NULL)
                         return -ENOMEM;
-                do_read(fd, events, f_header.event_types.size);
+                if (perf_header__getbuffer64(self, fd, events,
+                                             f_header.event_types.size))
+                        goto out_errno;
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
 
@@ -527,6 +918,8 @@ int perf_header__read(struct perf_header *self, int fd)
 
         self->frozen = 1;
         return 0;
+out_errno:
+        return -errno;
 }
 
 u64 perf_header__sample_type(struct perf_header *header)
@@ -551,6 +944,14 @@ perf_header__find_attr(u64 id, struct perf_header *header)
 {
         int i;
 
+        /*
+         * We set id to -1 if the data file doesn't contain sample
+         * ids. Check for this and avoid walking through the entire
+         * list of ids which may be large.
+         */
+        if (id == -1ULL)
+                return NULL;
+
         for (i = 0; i < header->attrs; i++) {
                 struct perf_header_attr *attr = header->attr[i];
                 int j;
@@ -563,3 +964,236 @@ perf_header__find_attr(u64 id, struct perf_header *header)
 
         return NULL;
 }
+
+int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
+                           event__handler_t process,
+                           struct perf_session *session)
+{
+        event_t *ev;
+        size_t size;
+        int err;
+
+        size = sizeof(struct perf_event_attr);
+        size = ALIGN(size, sizeof(u64));
+        size += sizeof(struct perf_event_header);
+        size += ids * sizeof(u64);
+
+        ev = malloc(size);
+
+        ev->attr.attr = *attr;
+        memcpy(ev->attr.id, id, ids * sizeof(u64));
+
+        ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
+        ev->attr.header.size = size;
+
+        err = process(ev, session);
+
+        free(ev);
+
+        return err;
+}
+
+int event__synthesize_attrs(struct perf_header *self,
+                            event__handler_t process,
+                            struct perf_session *session)
+{
+        struct perf_header_attr *attr;
+        int i, err = 0;
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                err = event__synthesize_attr(&attr->attr, attr->ids, attr->id,
+                                             process, session);
+                if (err) {
+                        pr_debug("failed to create perf header attribute\n");
+                        return err;
+                }
+        }
+
+        return err;
+}
+
+int event__process_attr(event_t *self, struct perf_session *session)
+{
+        struct perf_header_attr *attr;
+        unsigned int i, ids, n_ids;
+
+        attr = perf_header_attr__new(&self->attr.attr);
+        if (attr == NULL)
+                return -ENOMEM;
+
+        ids = self->header.size;
+        ids -= (void *)&self->attr.id - (void *)self;
+        n_ids = ids / sizeof(u64);
+
+        for (i = 0; i < n_ids; i++) {
+                if (perf_header_attr__add_id(attr, self->attr.id[i]) < 0) {
+                        perf_header_attr__delete(attr);
+                        return -ENOMEM;
+                }
+        }
+
+        if (perf_header__add_attr(&session->header, attr) < 0) {
+                perf_header_attr__delete(attr);
+                return -ENOMEM;
+        }
+
+        perf_session__update_sample_type(session);
+
+        return 0;
+}
+
+int event__synthesize_event_type(u64 event_id, char *name,
+                                 event__handler_t process,
+                                 struct perf_session *session)
+{
+        event_t ev;
+        size_t size = 0;
+        int err = 0;
+
+        memset(&ev, 0, sizeof(ev));
+
+        ev.event_type.event_type.event_id = event_id;
+        memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
+        strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
+
+        ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
+        size = strlen(name);
+        size = ALIGN(size, sizeof(u64));
+        ev.event_type.header.size = sizeof(ev.event_type) -
+                (sizeof(ev.event_type.event_type.name) - size);
+
+        err = process(&ev, session);
+
+        return err;
+}
+
+int event__synthesize_event_types(event__handler_t process,
+                                  struct perf_session *session)
+{
+        struct perf_trace_event_type *type;
+        int i, err = 0;
+
+        for (i = 0; i < event_count; i++) {
+                type = &events[i];
+
+                err = event__synthesize_event_type(type->event_id, type->name,
+                                                   process, session);
+                if (err) {
+                        pr_debug("failed to create perf header event type\n");
+                        return err;
+                }
+        }
+
+        return err;
+}
+
+int event__process_event_type(event_t *self,
+                              struct perf_session *session __unused)
+{
+        if (perf_header__push_event(self->event_type.event_type.event_id,
+                                    self->event_type.event_type.name) < 0)
+                return -ENOMEM;
+
+        return 0;
+}
+
+int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
+                                   int nb_events,
+                                   event__handler_t process,
+                                   struct perf_session *session __unused)
+{
+        event_t ev;
+        ssize_t size = 0, aligned_size = 0, padding;
+        int err = 0;
+
+        memset(&ev, 0, sizeof(ev));
+
+        ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
+        size = read_tracing_data_size(fd, pattrs, nb_events);
+        if (size <= 0)
+                return size;
+        aligned_size = ALIGN(size, sizeof(u64));
+        padding = aligned_size - size;
+        ev.tracing_data.header.size = sizeof(ev.tracing_data);
+        ev.tracing_data.size = aligned_size;
+
+        process(&ev, session);
+
+        err = read_tracing_data(fd, pattrs, nb_events);
+        write_padded(fd, NULL, 0, padding);
+
+        return aligned_size;
+}
+
+int event__process_tracing_data(event_t *self,
+                                struct perf_session *session)
+{
+        ssize_t size_read, padding, size = self->tracing_data.size;
+        off_t offset = lseek(session->fd, 0, SEEK_CUR);
+        char buf[BUFSIZ];
+
+        /* setup for reading amidst mmap */
+        lseek(session->fd, offset + sizeof(struct tracing_data_event),
+              SEEK_SET);
+
+        size_read = trace_report(session->fd, session->repipe);
+
+        padding = ALIGN(size_read, sizeof(u64)) - size_read;
+
+        if (read(session->fd, buf, padding) < 0)
+                die("reading input file");
+        if (session->repipe) {
+                int retw = write(STDOUT_FILENO, buf, padding);
+                if (retw <= 0 || retw != padding)
+                        die("repiping tracing data padding");
+        }
+
+        if (size_read + padding != size)
+                die("tracing data size mismatch");
+
+        return size_read + padding;
+}
+
+int event__synthesize_build_id(struct dso *pos, u16 misc,
+                               event__handler_t process,
+                               struct machine *machine,
+                               struct perf_session *session)
+{
+        event_t ev;
+        size_t len;
+        int err = 0;
+
+        if (!pos->hit)
+                return err;
+
+        memset(&ev, 0, sizeof(ev));
+
+        len = pos->long_name_len + 1;
+        len = ALIGN(len, NAME_ALIGN);
+        memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
+        ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
+        ev.build_id.header.misc = misc;
+        ev.build_id.pid = machine->pid;
+        ev.build_id.header.size = sizeof(ev.build_id) + len;
+        memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
+
+        err = process(&ev, session);
+
+        return err;
+}
+
+int event__process_build_id(event_t *self,
+                            struct perf_session *session)
+{
+        __event_process_build_id(&self->build_id,
+                                 self->build_id.filename,
+                                 session);
+        return 0;
+}
+
+void disable_buildid_cache(void)
+{
+        no_buildid_cache = true;
+}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index d118d05d3abe..402ac2454cf8 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -5,6 +5,7 @@
 #include <sys/types.h>
 #include <stdbool.h>
 #include "types.h"
+#include "event.h"
 
 #include <linux/bitmap.h>
 
@@ -38,6 +39,11 @@ struct perf_file_header {
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
 };
 
+struct perf_pipe_file_header {
+        u64                             magic;
+        u64                             size;
+};
+
 struct perf_header;
 
 int perf_file_header__read(struct perf_file_header *self,
@@ -46,6 +52,7 @@ int perf_file_header__read(struct perf_file_header *self,
 struct perf_header {
         int                     frozen;
         int                     attrs, size;
+        bool                    needs_swap;
         struct perf_header_attr **attr;
         s64                     attr_offset;
         u64                     data_offset;
@@ -58,13 +65,14 @@ struct perf_header {
 int perf_header__init(struct perf_header *self);
 void perf_header__exit(struct perf_header *self);
 
-int perf_header__read(struct perf_header *self, int fd);
+int perf_header__read(struct perf_session *session, int fd);
 int perf_header__write(struct perf_header *self, int fd, bool at_exit);
+int perf_header__write_pipe(int fd);
 
 int perf_header__add_attr(struct perf_header *self,
                           struct perf_header_attr *attr);
 
-void perf_header__push_event(u64 id, const char *name);
+int perf_header__push_event(u64 id, const char *name);
 char *perf_header__find_event(u64 id);
 
 struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr);
@@ -80,6 +88,40 @@ bool perf_header__has_feat(const struct perf_header *self, int feat);
 
 int perf_header__process_sections(struct perf_header *self, int fd,
                                   int (*process)(struct perf_file_section *self,
+                                                 struct perf_header *ph,
                                                  int feat, int fd));
 
+int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
+                          const char *name, bool is_kallsyms);
+int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
+
+int event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
+                           event__handler_t process,
+                           struct perf_session *session);
+int event__synthesize_attrs(struct perf_header *self,
+                            event__handler_t process,
+                            struct perf_session *session);
+int event__process_attr(event_t *self, struct perf_session *session);
+
+int event__synthesize_event_type(u64 event_id, char *name,
+                                 event__handler_t process,
+                                 struct perf_session *session);
+int event__synthesize_event_types(event__handler_t process,
+                                  struct perf_session *session);
+int event__process_event_type(event_t *self,
+                              struct perf_session *session);
+
+int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
+                                   int nb_events,
+                                   event__handler_t process,
+                                   struct perf_session *session);
+int event__process_tracing_data(event_t *self,
+                                struct perf_session *session);
+
+int event__synthesize_build_id(struct dso *pos, u16 misc,
+                               event__handler_t process,
+                               struct machine *machine,
+                               struct perf_session *session);
+int event__process_build_id(event_t *self, struct perf_session *session);
+
 #endif /* __PERF_HEADER_H */
diff --git a/tools/perf/util/help.c b/tools/perf/util/help.c
index fbb00978b2e2..6f2975a00358 100644
--- a/tools/perf/util/help.c
+++ b/tools/perf/util/help.c
@@ -4,28 +4,6 @@
 #include "levenshtein.h"
 #include "help.h"
 
-/* most GUI terminals set COLUMNS (although some don't export it) */
-static int term_columns(void)
-{
-        char *col_string = getenv("COLUMNS");
-        int n_cols;
-
-        if (col_string && (n_cols = atoi(col_string)) > 0)
-                return n_cols;
-
-#ifdef TIOCGWINSZ
-        {
-                struct winsize ws;
-                if (!ioctl(1, TIOCGWINSZ, &ws)) {
-                        if (ws.ws_col)
-                                return ws.ws_col;
-                }
-        }
-#endif
-
-        return 80;
-}
-
 void add_cmdname(struct cmdnames *cmds, const char *name, size_t len)
 {
         struct cmdname *ent = malloc(sizeof(*ent) + len + 1);
@@ -96,9 +74,13 @@ static void pretty_print_string_list(struct cmdnames *cmds, int longest)
 {
         int cols = 1, rows;
         int space = longest + 1; /* min 1 SP between words */
-        int max_cols = term_columns() - 1; /* don't print *on* the edge */
+        struct winsize win;
+        int max_cols;
         int i, j;
 
+        get_term_dimensions(&win);
+        max_cols = win.ws_col - 1; /* don't print *on* the edge */
+
         if (space < max_cols)
                 cols = max_cols / space;
         rows = (cmds->cnt + cols - 1) / cols;
@@ -324,7 +306,7 @@ const char *help_unknown_cmd(const char *cmd)
 
                 main_cmds.names[0] = NULL;
                 clean_cmdnames(&main_cmds);
-                fprintf(stderr, "WARNING: You called a Git program named '%s', "
+                fprintf(stderr, "WARNING: You called a perf program named '%s', "
                         "which does not exist.\n"
                         "Continuing under the assumption that you meant '%s'\n",
                         cmd, assumed);
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index e8daf5ca6fd2..be22ae6ef055 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -1,33 +1,141 @@
+#include "util.h"
+#include "build-id.h"
 #include "hist.h"
 #include "session.h"
 #include "sort.h"
 #include <math.h>
 
+enum hist_filter {
+        HIST_FILTER__DSO,
+        HIST_FILTER__THREAD,
+        HIST_FILTER__PARENT,
+};
+
 struct callchain_param  callchain_param = {
         .mode   = CHAIN_GRAPH_REL,
         .min_percent = 0.5
 };
 
+u16 hists__col_len(struct hists *self, enum hist_column col)
+{
+        return self->col_len[col];
+}
+
+void hists__set_col_len(struct hists *self, enum hist_column col, u16 len)
+{
+        self->col_len[col] = len;
+}
+
+bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len)
+{
+        if (len > hists__col_len(self, col)) {
+                hists__set_col_len(self, col, len);
+                return true;
+        }
+        return false;
+}
+
+static void hists__reset_col_len(struct hists *self)
+{
+        enum hist_column col;
+
+        for (col = 0; col < HISTC_NR_COLS; ++col)
+                hists__set_col_len(self, col, 0);
+}
+
+static void hists__calc_col_len(struct hists *self, struct hist_entry *h)
+{
+        u16 len;
+
+        if (h->ms.sym)
+                hists__new_col_len(self, HISTC_SYMBOL, h->ms.sym->namelen);
+
+        len = thread__comm_len(h->thread);
+        if (hists__new_col_len(self, HISTC_COMM, len))
+                hists__set_col_len(self, HISTC_THREAD, len + 6);
+
+        if (h->ms.map) {
+                len = dso__name_len(h->ms.map->dso);
+                hists__new_col_len(self, HISTC_DSO, len);
+        }
+}
+
+static void hist_entry__add_cpumode_period(struct hist_entry *self,
+                                           unsigned int cpumode, u64 period)
+{
+        switch (cpumode) {
+        case PERF_RECORD_MISC_KERNEL:
+                self->period_sys += period;
+                break;
+        case PERF_RECORD_MISC_USER:
+                self->period_us += period;
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                self->period_guest_sys += period;
+                break;
+        case PERF_RECORD_MISC_GUEST_USER:
+                self->period_guest_us += period;
+                break;
+        default:
+                break;
+        }
+}
+
 /*
- * histogram, sorted on item, collects counts
+ * histogram, sorted on item, collects periods
  */
 
-struct hist_entry *__perf_session__add_hist_entry(struct perf_session *self,
-                                                  struct addr_location *al,
-                                                  struct symbol *sym_parent,
-                                                  u64 count, bool *hit)
+static struct hist_entry *hist_entry__new(struct hist_entry *template)
+{
+        size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_node) : 0;
+        struct hist_entry *self = malloc(sizeof(*self) + callchain_size);
+
+        if (self != NULL) {
+                *self = *template;
+                self->nr_events = 1;
+                if (self->ms.map)
+                        self->ms.map->referenced = true;
+                if (symbol_conf.use_callchain)
+                        callchain_init(self->callchain);
+        }
+
+        return self;
+}
+
+static void hists__inc_nr_entries(struct hists *self, struct hist_entry *h)
 {
-        struct rb_node **p = &self->hists.rb_node;
+        if (!h->filtered) {
+                hists__calc_col_len(self, h);
+                ++self->nr_entries;
+        }
+}
+
+static u8 symbol__parent_filter(const struct symbol *parent)
+{
+        if (symbol_conf.exclude_other && parent == NULL)
+                return 1 << HIST_FILTER__PARENT;
+        return 0;
+}
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                      struct addr_location *al,
+                                      struct symbol *sym_parent, u64 period)
+{
+        struct rb_node **p = &self->entries.rb_node;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
         struct hist_entry entry = {
                 .thread = al->thread,
-                .map    = al->map,
-                .sym    = al->sym,
+                .ms = {
+                        .map    = al->map,
+                        .sym    = al->sym,
+                },
+                .cpu    = al->cpu,
                 .ip     = al->addr,
                 .level  = al->level,
-                .count  = count,
+                .period = period,
                 .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
         };
         int cmp;
 
@@ -38,8 +146,9 @@ struct hist_entry *__perf_session__add_hist_entry(struct perf_session *self,
                 cmp = hist_entry__cmp(&entry, he);
 
                 if (!cmp) {
-                        *hit = true;
-                        return he;
+                        he->period += period;
+                        ++he->nr_events;
+                        goto out;
                 }
 
                 if (cmp < 0)
@@ -48,13 +157,14 @@ struct hist_entry *__perf_session__add_hist_entry(struct perf_session *self,
                         p = &(*p)->rb_right;
         }
 
-        he = malloc(sizeof(*he));
+        he = hist_entry__new(&entry);
         if (!he)
                 return NULL;
-        *he = entry;
         rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, &self->hists);
-        *hit = false;
+        rb_insert_color(&he->rb_node, &self->entries);
+        hists__inc_nr_entries(self, he);
+out:
+        hist_entry__add_cpumode_period(he, al->cpumode, period);
         return he;
 }
 
@@ -65,7 +175,7 @@ hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
         int64_t cmp = 0;
 
         list_for_each_entry(se, &hist_entry__sort_list, list) {
-                cmp = se->cmp(left, right);
+                cmp = se->se_cmp(left, right);
                 if (cmp)
                         break;
         }
@@ -82,7 +192,7 @@ hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 int64_t (*f)(struct hist_entry *, struct hist_entry *);
 
-                f = se->collapse ?: se->cmp;
+                f = se->se_collapse ?: se->se_cmp;
 
                 cmp = f(left, right);
                 if (cmp)
@@ -101,7 +211,7 @@ void hist_entry__free(struct hist_entry *he)
  * collapse the histogram
  */
 
-static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
+static bool collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
 {
         struct rb_node **p = &root->rb_node;
         struct rb_node *parent = NULL;
@@ -115,9 +225,9 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
                 cmp = hist_entry__collapse(iter, he);
 
                 if (!cmp) {
-                        iter->count += he->count;
+                        iter->period += he->period;
                         hist_entry__free(he);
-                        return;
+                        return false;
                 }
 
                 if (cmp < 0)
@@ -128,9 +238,10 @@ static void collapse__insert_entry(struct rb_root *root, struct hist_entry *he)
 
         rb_link_node(&he->rb_node, parent, p);
         rb_insert_color(&he->rb_node, root);
+        return true;
 }
 
-void perf_session__collapse_resort(struct perf_session *self)
+void hists__collapse_resort(struct hists *self)
 {
         struct rb_root tmp;
         struct rb_node *next;
@@ -140,72 +251,77 @@ void perf_session__collapse_resort(struct perf_session *self)
                 return;
 
         tmp = RB_ROOT;
-        next = rb_first(&self->hists);
+        next = rb_first(&self->entries);
+        self->nr_entries = 0;
+        hists__reset_col_len(self);
 
         while (next) {
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
 
-                rb_erase(&n->rb_node, &self->hists);
-                collapse__insert_entry(&tmp, n);
+                rb_erase(&n->rb_node, &self->entries);
+                if (collapse__insert_entry(&tmp, n))
+                        hists__inc_nr_entries(self, n);
         }
 
-        self->hists = tmp;
+        self->entries = tmp;
 }
 
 /*
- * reverse the map, sort on count.
+ * reverse the map, sort on period.
  */
 
-static void perf_session__insert_output_hist_entry(struct rb_root *root,
-                                                   struct hist_entry *he,
-                                                   u64 min_callchain_hits)
+static void __hists__insert_output_entry(struct rb_root *entries,
+                                         struct hist_entry *he,
+                                         u64 min_callchain_hits)
 {
-        struct rb_node **p = &root->rb_node;
+        struct rb_node **p = &entries->rb_node;
         struct rb_node *parent = NULL;
         struct hist_entry *iter;
 
         if (symbol_conf.use_callchain)
-                callchain_param.sort(&he->sorted_chain, &he->callchain,
+                callchain_param.sort(&he->sorted_chain, he->callchain,
                                       min_callchain_hits, &callchain_param);
 
         while (*p != NULL) {
                 parent = *p;
                 iter = rb_entry(parent, struct hist_entry, rb_node);
 
-                if (he->count > iter->count)
+                if (he->period > iter->period)
                         p = &(*p)->rb_left;
                 else
                         p = &(*p)->rb_right;
         }
 
         rb_link_node(&he->rb_node, parent, p);
-        rb_insert_color(&he->rb_node, root);
+        rb_insert_color(&he->rb_node, entries);
 }
 
-void perf_session__output_resort(struct perf_session *self, u64 total_samples)
+void hists__output_resort(struct hists *self)
 {
         struct rb_root tmp;
         struct rb_node *next;
         struct hist_entry *n;
         u64 min_callchain_hits;
 
-        min_callchain_hits =
-                total_samples * (callchain_param.min_percent / 100);
+        min_callchain_hits = self->stats.total_period * (callchain_param.min_percent / 100);
 
         tmp = RB_ROOT;
-        next = rb_first(&self->hists);
+        next = rb_first(&self->entries);
+
+        self->nr_entries = 0;
+        hists__reset_col_len(self);
 
         while (next) {
                 n = rb_entry(next, struct hist_entry, rb_node);
                 next = rb_next(&n->rb_node);
 
-                rb_erase(&n->rb_node, &self->hists);
-                perf_session__insert_output_hist_entry(&tmp, n,
-                                                       min_callchain_hits);
+                rb_erase(&n->rb_node, &self->entries);
+                __hists__insert_output_entry(&tmp, n, min_callchain_hits);
+                hists__inc_nr_entries(self, n);
         }
 
-        self->hists = tmp;
+        self->entries = tmp;
 }
 
 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
@@ -237,7 +353,7 @@ static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
 }
 
 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
-                                     int depth, int depth_mask, int count,
+                                     int depth, int depth_mask, int period,
                                      u64 total_samples, int hits,
                                      int left_margin)
 {
@@ -250,7 +366,7 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
                         ret += fprintf(fp, "|");
                 else
                         ret += fprintf(fp, " ");
-                if (!count && i == depth - 1) {
+                if (!period && i == depth - 1) {
                         double percent;
 
                         percent = hits * 100.0 / total_samples;
@@ -258,8 +374,8 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
                 } else
                         ret += fprintf(fp, "%s", "          ");
         }
-        if (chain->sym)
-                ret += fprintf(fp, "%s\n", chain->sym->name);
+        if (chain->ms.sym)
+                ret += fprintf(fp, "%s\n", chain->ms.sym->name);
         else
                 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
 
@@ -278,7 +394,7 @@ static void init_rem_hits(void)
         }
 
         strcpy(rem_sq_bracket->name, "[...]");
-        rem_hits.sym = rem_sq_bracket;
+        rem_hits.ms.sym = rem_sq_bracket;
 }
 
 static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
@@ -293,6 +409,7 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
         u64 remaining;
         size_t ret = 0;
         int i;
+        uint entries_printed = 0;
 
         if (callchain_param.mode == CHAIN_GRAPH_REL)
                 new_total = self->children_hit;
@@ -321,15 +438,13 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                         new_depth_mask &= ~(1 << (depth - 1));
 
                 /*
-                 * But we keep the older depth mask for the line seperator
+                 * But we keep the older depth mask for the line separator
                  * to keep the level link until we reach the last child
                  */
                 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
                                                    left_margin);
                 i = 0;
                 list_for_each_entry(chain, &child->val, list) {
-                        if (chain->ip >= PERF_CONTEXT_MAX)
-                                continue;
                         ret += ipchain__fprintf_graph(fp, chain, depth,
                                                       new_depth_mask, i++,
                                                       new_total,
@@ -341,6 +456,8 @@ static size_t __callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                                                   new_depth_mask | (1 << depth),
                                                   left_margin);
                 node = next;
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
         }
 
         if (callchain_param.mode == CHAIN_GRAPH_REL &&
@@ -366,11 +483,9 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
         bool printed = false;
         int i = 0;
         int ret = 0;
+        u32 entries_printed = 0;
 
         list_for_each_entry(chain, &self->val, list) {
-                if (chain->ip >= PERF_CONTEXT_MAX)
-                        continue;
-
                 if (!i++ && sort__first_dimension == SORT_SYM)
                         continue;
 
@@ -385,10 +500,13 @@ static size_t callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                 } else
                         ret += callchain__fprintf_left_margin(fp, left_margin);
 
-                if (chain->sym)
-                        ret += fprintf(fp, " %s\n", chain->sym->name);
+                if (chain->ms.sym)
+                        ret += fprintf(fp, " %s\n", chain->ms.sym->name);
                 else
                         ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
+
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
         }
 
         ret += __callchain__fprintf_graph(fp, self, total_samples, 1, 1, left_margin);
@@ -411,8 +529,8 @@ static size_t callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
         list_for_each_entry(chain, &self->val, list) {
                 if (chain->ip >= PERF_CONTEXT_MAX)
                         continue;
-                if (chain->sym)
-                        ret += fprintf(fp, "                %s\n", chain->sym->name);
+                if (chain->ms.sym)
+                        ret += fprintf(fp, "                %s\n", chain->ms.sym->name);
                 else
                         ret += fprintf(fp, "                %p\n",
                                         (void *)(long)chain->ip);
@@ -427,6 +545,7 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
         struct rb_node *rb_node;
         struct callchain_node *chain;
         size_t ret = 0;
+        u32 entries_printed = 0;
 
         rb_node = rb_first(&self->sorted_chain);
         while (rb_node) {
@@ -449,55 +568,89 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
                         break;
                 }
                 ret += fprintf(fp, "\n");
+                if (++entries_printed == callchain_param.print_limit)
+                        break;
                 rb_node = rb_next(rb_node);
         }
 
         return ret;
 }
 
-static size_t hist_entry__fprintf(struct hist_entry *self,
-                                  struct perf_session *session,
-                                  struct perf_session *pair_session,
-                                  bool show_displacement,
-                                  long displacement, FILE *fp)
+int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
+                         struct hists *hists, struct hists *pair_hists,
+                         bool show_displacement, long displacement,
+                         bool color, u64 session_total)
 {
         struct sort_entry *se;
-        u64 count, total;
+        u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
         const char *sep = symbol_conf.field_sep;
-        size_t ret;
+        int ret;
 
         if (symbol_conf.exclude_other && !self->parent)
                 return 0;
 
-        if (pair_session) {
-                count = self->pair ? self->pair->count : 0;
-                total = pair_session->events_stats.total;
+        if (pair_hists) {
+                period = self->pair ? self->pair->period : 0;
+                total = pair_hists->stats.total_period;
+                period_sys = self->pair ? self->pair->period_sys : 0;
+                period_us = self->pair ? self->pair->period_us : 0;
+                period_guest_sys = self->pair ? self->pair->period_guest_sys : 0;
+                period_guest_us = self->pair ? self->pair->period_guest_us : 0;
         } else {
-                count = self->count;
-                total = session->events_stats.total;
+                period = self->period;
+                total = session_total;
+                period_sys = self->period_sys;
+                period_us = self->period_us;
+                period_guest_sys = self->period_guest_sys;
+                period_guest_us = self->period_guest_us;
         }
 
-        if (total)
-                ret = percent_color_fprintf(fp, sep ? "%.2f" : "   %6.2f%%",
-                                            (count * 100.0) / total);
-        else
-                ret = fprintf(fp, sep ? "%lld" : "%12lld ", count);
+        if (total) {
+                if (color)
+                        ret = percent_color_snprintf(s, size,
+                                                     sep ? "%.2f" : "   %6.2f%%",
+                                                     (period * 100.0) / total);
+                else
+                        ret = snprintf(s, size, sep ? "%.2f" : "   %6.2f%%",
+                                       (period * 100.0) / total);
+                if (symbol_conf.show_cpu_utilization) {
+                        ret += percent_color_snprintf(s + ret, size - ret,
+                                        sep ? "%.2f" : "   %6.2f%%",
+                                        (period_sys * 100.0) / total);
+                        ret += percent_color_snprintf(s + ret, size - ret,
+                                        sep ? "%.2f" : "   %6.2f%%",
+                                        (period_us * 100.0) / total);
+                        if (perf_guest) {
+                                ret += percent_color_snprintf(s + ret,
+                                                size - ret,
+                                                sep ? "%.2f" : "   %6.2f%%",
+                                                (period_guest_sys * 100.0) /
+                                                                total);
+                                ret += percent_color_snprintf(s + ret,
+                                                size - ret,
+                                                sep ? "%.2f" : "   %6.2f%%",
+                                                (period_guest_us * 100.0) /
+                                                                total);
+                        }
+                }
+        } else
+                ret = snprintf(s, size, sep ? "%lld" : "%12lld ", period);
 
         if (symbol_conf.show_nr_samples) {
                 if (sep)
-                        fprintf(fp, "%c%lld", *sep, count);
+                        ret += snprintf(s + ret, size - ret, "%c%lld", *sep, period);
                 else
-                        fprintf(fp, "%11lld", count);
+                        ret += snprintf(s + ret, size - ret, "%11lld", period);
         }
 
-        if (pair_session) {
+        if (pair_hists) {
                 char bf[32];
                 double old_percent = 0, new_percent = 0, diff;
 
                 if (total > 0)
-                        old_percent = (count * 100.0) / total;
-                if (session->events_stats.total > 0)
-                        new_percent = (self->count * 100.0) / session->events_stats.total;
+                        old_percent = (period * 100.0) / total;
+                if (session_total > 0)
+                        new_percent = (self->period * 100.0) / session_total;
 
                 diff = new_percent - old_percent;
 
@@ -507,9 +660,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                         snprintf(bf, sizeof(bf), " ");
 
                 if (sep)
-                        ret += fprintf(fp, "%c%s", *sep, bf);
+                        ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
                 else
-                        ret += fprintf(fp, "%11.11s", bf);
+                        ret += snprintf(s + ret, size - ret, "%11.11s", bf);
 
                 if (show_displacement) {
                         if (displacement)
@@ -518,9 +671,9 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                                 snprintf(bf, sizeof(bf), " ");
 
                         if (sep)
-                                fprintf(fp, "%c%s", *sep, bf);
+                                ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
                         else
-                                fprintf(fp, "%6.6s", bf);
+                                ret += snprintf(s + ret, size - ret, "%6.6s", bf);
                 }
         }
 
@@ -528,32 +681,44 @@ static size_t hist_entry__fprintf(struct hist_entry *self,
                 if (se->elide)
                         continue;
 
-                fprintf(fp, "%s", sep ?: "  ");
-                ret += se->print(fp, self, se->width ? *se->width : 0);
+                ret += snprintf(s + ret, size - ret, "%s", sep ?: "  ");
+                ret += se->se_snprintf(self, s + ret, size - ret,
+                                       hists__col_len(hists, se->se_width_idx));
         }
 
-        ret += fprintf(fp, "\n");
+        return ret;
+}
 
-        if (symbol_conf.use_callchain) {
-                int left_margin = 0;
+int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
+                        struct hists *pair_hists, bool show_displacement,
+                        long displacement, FILE *fp, u64 session_total)
+{
+        char bf[512];
+        hist_entry__snprintf(self, bf, sizeof(bf), hists, pair_hists,
+                             show_displacement, displacement,
+                             true, session_total);
+        return fprintf(fp, "%s\n", bf);
+}
 
-                if (sort__first_dimension == SORT_COMM) {
-                        se = list_first_entry(&hist_entry__sort_list, typeof(*se),
-                                                list);
-                        left_margin = se->width ? *se->width : 0;
-                        left_margin -= thread__comm_len(self->thread);
-                }
+static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
+                                            struct hists *hists, FILE *fp,
+                                            u64 session_total)
+{
+        int left_margin = 0;
 
-                hist_entry_callchain__fprintf(fp, self, session->events_stats.total,
-                                              left_margin);
+        if (sort__first_dimension == SORT_COMM) {
+                struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
+                                                         typeof(*se), list);
+                left_margin = hists__col_len(hists, se->se_width_idx);
+                left_margin -= thread__comm_len(self->thread);
         }
 
-        return ret;
+        return hist_entry_callchain__fprintf(fp, self, session_total,
+                                             left_margin);
 }
 
-size_t perf_session__fprintf_hists(struct perf_session *self,
-                                   struct perf_session *pair,
-                                   bool show_displacement, FILE *fp)
+size_t hists__fprintf(struct hists *self, struct hists *pair,
+                      bool show_displacement, FILE *fp)
 {
         struct sort_entry *se;
         struct rb_node *nd;
@@ -562,7 +727,7 @@ size_t perf_session__fprintf_hists(struct perf_session *self,
         long displacement = 0;
         unsigned int width;
         const char *sep = symbol_conf.field_sep;
-        char *col_width = symbol_conf.col_width_list_str;
+        const char *col_width = symbol_conf.col_width_list_str;
 
         init_rem_hits();
 
@@ -575,6 +740,24 @@ size_t perf_session__fprintf_hists(struct perf_session *self,
                         fputs("  Samples  ", fp);
         }
 
+        if (symbol_conf.show_cpu_utilization) {
+                if (sep) {
+                        ret += fprintf(fp, "%csys", *sep);
+                        ret += fprintf(fp, "%cus", *sep);
+                        if (perf_guest) {
+                                ret += fprintf(fp, "%cguest sys", *sep);
+                                ret += fprintf(fp, "%cguest us", *sep);
+                        }
+                } else {
+                        ret += fprintf(fp, "  sys  ");
+                        ret += fprintf(fp, "  us  ");
+                        if (perf_guest) {
+                                ret += fprintf(fp, "  guest sys  ");
+                                ret += fprintf(fp, "  guest us  ");
+                        }
+                }
+        }
+
         if (pair) {
                 if (sep)
                         ret += fprintf(fp, "%cDelta", *sep);
@@ -593,22 +776,22 @@ size_t perf_session__fprintf_hists(struct perf_session *self,
                 if (se->elide)
                         continue;
                 if (sep) {
-                        fprintf(fp, "%c%s", *sep, se->header);
+                        fprintf(fp, "%c%s", *sep, se->se_header);
                         continue;
                 }
-                width = strlen(se->header);
-                if (se->width) {
-                        if (symbol_conf.col_width_list_str) {
-                                if (col_width) {
-                                        *se->width = atoi(col_width);
-                                        col_width = strchr(col_width, ',');
-                                        if (col_width)
-                                                ++col_width;
-                                }
+                width = strlen(se->se_header);
+                if (symbol_conf.col_width_list_str) {
+                        if (col_width) {
+                                hists__set_col_len(self, se->se_width_idx,
+                                                   atoi(col_width));
+                                col_width = strchr(col_width, ',');
+                                if (col_width)
+                                        ++col_width;
                         }
-                        width = *se->width = max(*se->width, width);
                 }
-                fprintf(fp, "  %*s", width, se->header);
+                if (!hists__new_col_len(self, se->se_width_idx, width))
+                        width = hists__col_len(self, se->se_width_idx);
+                fprintf(fp, "  %*s", width, se->se_header);
         }
         fprintf(fp, "\n");
 
@@ -630,10 +813,9 @@ size_t perf_session__fprintf_hists(struct perf_session *self,
                         continue;
 
                 fprintf(fp, "  ");
-                if (se->width)
-                        width = *se->width;
-                else
-                        width = strlen(se->header);
+                width = hists__col_len(self, se->se_width_idx);
+                if (width == 0)
+                        width = strlen(se->se_header);
                 for (i = 0; i < width; i++)
                         fprintf(fp, ".");
         }
@@ -641,7 +823,7 @@ size_t perf_session__fprintf_hists(struct perf_session *self,
         fprintf(fp, "\n#\n");
 
 print_entries:
-        for (nd = rb_first(&self->hists); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 if (show_displacement) {
@@ -653,10 +835,342 @@ print_entries:
                         ++position;
                 }
                 ret += hist_entry__fprintf(h, self, pair, show_displacement,
-                                           displacement, fp);
+                                           displacement, fp, self->stats.total_period);
+
+                if (symbol_conf.use_callchain)
+                        ret += hist_entry__fprintf_callchain(h, self, fp,
+                                                             self->stats.total_period);
+                if (h->ms.map == NULL && verbose > 1) {
+                        __map_groups__fprintf_maps(&h->thread->mg,
+                                                   MAP__FUNCTION, verbose, fp);
+                        fprintf(fp, "%.10s end\n", graph_dotted_line);
+                }
         }
 
         free(rem_sq_bracket);
 
         return ret;
 }
+
+/*
+ * See hists__fprintf to match the column widths
+ */
+unsigned int hists__sort_list_width(struct hists *self)
+{
+        struct sort_entry *se;
+        int ret = 9; /* total % */
+
+        if (symbol_conf.show_cpu_utilization) {
+                ret += 7; /* count_sys % */
+                ret += 6; /* count_us % */
+                if (perf_guest) {
+                        ret += 13; /* count_guest_sys % */
+                        ret += 12; /* count_guest_us % */
+                }
+        }
+
+        if (symbol_conf.show_nr_samples)
+                ret += 11;
+
+        list_for_each_entry(se, &hist_entry__sort_list, list)
+                if (!se->elide)
+                        ret += 2 + hists__col_len(self, se->se_width_idx);
+
+        if (verbose) /* Addr + origin */
+                ret += 3 + BITS_PER_LONG / 4;
+
+        return ret;
+}
+
+static void hists__remove_entry_filter(struct hists *self, struct hist_entry *h,
+                                       enum hist_filter filter)
+{
+        h->filtered &= ~(1 << filter);
+        if (h->filtered)
+                return;
+
+        ++self->nr_entries;
+        if (h->ms.unfolded)
+                self->nr_entries += h->nr_rows;
+        h->row_offset = 0;
+        self->stats.total_period += h->period;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
+
+        hists__calc_col_len(self, h);
+}
+
+void hists__filter_by_dso(struct hists *self, const struct dso *dso)
+{
+        struct rb_node *nd;
+
+        self->nr_entries = self->stats.total_period = 0;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        hists__reset_col_len(self);
+
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (symbol_conf.exclude_other && !h->parent)
+                        continue;
+
+                if (dso != NULL && (h->ms.map == NULL || h->ms.map->dso != dso)) {
+                        h->filtered |= (1 << HIST_FILTER__DSO);
+                        continue;
+                }
+
+                hists__remove_entry_filter(self, h, HIST_FILTER__DSO);
+        }
+}
+
+void hists__filter_by_thread(struct hists *self, const struct thread *thread)
+{
+        struct rb_node *nd;
+
+        self->nr_entries = self->stats.total_period = 0;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
+        hists__reset_col_len(self);
+
+        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (thread != NULL && h->thread != thread) {
+                        h->filtered |= (1 << HIST_FILTER__THREAD);
+                        continue;
+                }
+
+                hists__remove_entry_filter(self, h, HIST_FILTER__THREAD);
+        }
+}
+
+static int symbol__alloc_hist(struct symbol *self)
+{
+        struct sym_priv *priv = symbol__priv(self);
+        const int size = (sizeof(*priv->hist) +
+                          (self->end - self->start) * sizeof(u64));
+
+        priv->hist = zalloc(size);
+        return priv->hist == NULL ? -1 : 0;
+}
+
+int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip)
+{
+        unsigned int sym_size, offset;
+        struct symbol *sym = self->ms.sym;
+        struct sym_priv *priv;
+        struct sym_hist *h;
+
+        if (!sym || !self->ms.map)
+                return 0;
+
+        priv = symbol__priv(sym);
+        if (priv->hist == NULL && symbol__alloc_hist(sym) < 0)
+                return -ENOMEM;
+
+        sym_size = sym->end - sym->start;
+        offset = ip - sym->start;
+
+        pr_debug3("%s: ip=%#Lx\n", __func__, self->ms.map->unmap_ip(self->ms.map, ip));
+
+        if (offset >= sym_size)
+                return 0;
+
+        h = priv->hist;
+        h->sum++;
+        h->ip[offset]++;
+
+        pr_debug3("%#Lx %s: period++ [ip: %#Lx, %#Lx] => %Ld\n", self->ms.sym->start,
+                  self->ms.sym->name, ip, ip - self->ms.sym->start, h->ip[offset]);
+        return 0;
+}
+
+static struct objdump_line *objdump_line__new(s64 offset, char *line, size_t privsize)
+{
+        struct objdump_line *self = malloc(sizeof(*self) + privsize);
+
+        if (self != NULL) {
+                self->offset = offset;
+                self->line = line;
+        }
+
+        return self;
+}
+
+void objdump_line__free(struct objdump_line *self)
+{
+        free(self->line);
+        free(self);
+}
+
+static void objdump__add_line(struct list_head *head, struct objdump_line *line)
+{
+        list_add_tail(&line->node, head);
+}
+
+struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
+                                               struct objdump_line *pos)
+{
+        list_for_each_entry_continue(pos, head, node)
+                if (pos->offset >= 0)
+                        return pos;
+
+        return NULL;
+}
+
+static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
+                                          struct list_head *head, size_t privsize)
+{
+        struct symbol *sym = self->ms.sym;
+        struct objdump_line *objdump_line;
+        char *line = NULL, *tmp, *tmp2, *c;
+        size_t line_len;
+        s64 line_ip, offset = -1;
+
+        if (getline(&line, &line_len, file) < 0)
+                return -1;
+
+        if (!line)
+                return -1;
+
+        while (line_len != 0 && isspace(line[line_len - 1]))
+                line[--line_len] = '\0';
+
+        c = strchr(line, '\n');
+        if (c)
+                *c = 0;
+
+        line_ip = -1;
+
+        /*
+         * Strip leading spaces:
+         */
+        tmp = line;
+        while (*tmp) {
+                if (*tmp != ' ')
+                        break;
+                tmp++;
+        }
+
+        if (*tmp) {
+                /*
+                 * Parse hexa addresses followed by ':'
+                 */
+                line_ip = strtoull(tmp, &tmp2, 16);
+                if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0')
+                        line_ip = -1;
+        }
+
+        if (line_ip != -1) {
+                u64 start = map__rip_2objdump(self->ms.map, sym->start),
+                    end = map__rip_2objdump(self->ms.map, sym->end);
+
+                offset = line_ip - start;
+                if (offset < 0 || (u64)line_ip > end)
+                        offset = -1;
+        }
+
+        objdump_line = objdump_line__new(offset, line, privsize);
+        if (objdump_line == NULL) {
+                free(line);
+                return -1;
+        }
+        objdump__add_line(head, objdump_line);
+
+        return 0;
+}
+
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head,
+                         size_t privsize)
+{
+        struct symbol *sym = self->ms.sym;
+        struct map *map = self->ms.map;
+        struct dso *dso = map->dso;
+        char *filename = dso__build_id_filename(dso, NULL, 0);
+        bool free_filename = true;
+        char command[PATH_MAX * 2];
+        FILE *file;
+        int err = 0;
+        u64 len;
+
+        if (filename == NULL) {
+                if (dso->has_build_id) {
+                        pr_err("Can't annotate %s: not enough memory\n",
+                               sym->name);
+                        return -ENOMEM;
+                }
+                goto fallback;
+        } else if (readlink(filename, command, sizeof(command)) < 0 ||
+                   strstr(command, "[kernel.kallsyms]") ||
+                   access(filename, R_OK)) {
+                free(filename);
+fallback:
+                /*
+                 * If we don't have build-ids or the build-id file isn't in the
+                 * cache, or is just a kallsyms file, well, lets hope that this
+                 * DSO is the same as when 'perf record' ran.
+                 */
+                filename = dso->long_name;
+                free_filename = false;
+        }
+
+        if (dso->origin == DSO__ORIG_KERNEL) {
+                if (dso->annotate_warned)
+                        goto out_free_filename;
+                err = -ENOENT;
+                dso->annotate_warned = 1;
+                pr_err("Can't annotate %s: No vmlinux file was found in the "
+                       "path\n", sym->name);
+                goto out_free_filename;
+        }
+
+        pr_debug("%s: filename=%s, sym=%s, start=%#Lx, end=%#Lx\n", __func__,
+                 filename, sym->name, map->unmap_ip(map, sym->start),
+                 map->unmap_ip(map, sym->end));
+
+        len = sym->end - sym->start;
+
+        pr_debug("annotating [%p] %30s : [%p] %30s\n",
+                 dso, dso->long_name, sym, sym->name);
+
+        snprintf(command, sizeof(command),
+                 "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS -C %s|grep -v %s|expand",
+                 map__rip_2objdump(map, sym->start),
+                 map__rip_2objdump(map, sym->end),
+                 filename, filename);
+
+        pr_debug("Executing: %s\n", command);
+
+        file = popen(command, "r");
+        if (!file)
+                goto out_free_filename;
+
+        while (!feof(file))
+                if (hist_entry__parse_objdump_line(self, file, head, privsize) < 0)
+                        break;
+
+        pclose(file);
+out_free_filename:
+        if (free_filename)
+                free(filename);
+        return err;
+}
+
+void hists__inc_nr_events(struct hists *self, u32 type)
+{
+        ++self->stats.nr_events[0];
+        ++self->stats.nr_events[type];
+}
+
+size_t hists__fprintf_nr_events(struct hists *self, FILE *fp)
+{
+        int i;
+        size_t ret = 0;
+
+        for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
+                if (!event__name[i])
+                        continue;
+                ret += fprintf(fp, "%10s events: %10d\n",
+                               event__name[i], self->stats.nr_events[i]);
+        }
+
+        return ret;
+}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index e5f99b24048b..587d375d3430 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -6,22 +6,143 @@
 
 extern struct callchain_param callchain_param;
 
-struct perf_session;
 struct hist_entry;
 struct addr_location;
 struct symbol;
+struct rb_root;
 
-struct hist_entry *__perf_session__add_hist_entry(struct perf_session *self,
-                                                  struct addr_location *al,
-                                                  struct symbol *parent,
-                                                  u64 count, bool *hit);
+struct objdump_line {
+        struct list_head node;
+        s64              offset;
+        char             *line;
+};
+
+void objdump_line__free(struct objdump_line *self);
+struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
+                                               struct objdump_line *pos);
+
+struct sym_hist {
+        u64             sum;
+        u64             ip[0];
+};
+
+struct sym_ext {
+        struct rb_node  node;
+        double          percent;
+        char            *path;
+};
+
+struct sym_priv {
+        struct sym_hist *hist;
+        struct sym_ext  *ext;
+};
+
+/*
+ * The kernel collects the number of events it couldn't send in a stretch and
+ * when possible sends this number in a PERF_RECORD_LOST event. The number of
+ * such "chunks" of lost events is stored in .nr_events[PERF_EVENT_LOST] while
+ * total_lost tells exactly how many events the kernel in fact lost, i.e. it is
+ * the sum of all struct lost_event.lost fields reported.
+ *
+ * The total_period is needed because by default auto-freq is used, so
+ * multipling nr_events[PERF_EVENT_SAMPLE] by a frequency isn't possible to get
+ * the total number of low level events, it is necessary to to sum all struct
+ * sample_event.period and stash the result in total_period.
+ */
+struct events_stats {
+        u64 total_period;
+        u64 total_lost;
+        u32 nr_events[PERF_RECORD_HEADER_MAX];
+        u32 nr_unknown_events;
+};
+
+enum hist_column {
+        HISTC_SYMBOL,
+        HISTC_DSO,
+        HISTC_THREAD,
+        HISTC_COMM,
+        HISTC_PARENT,
+        HISTC_CPU,
+        HISTC_NR_COLS, /* Last entry */
+};
+
+struct hists {
+        struct rb_node          rb_node;
+        struct rb_root          entries;
+        u64                     nr_entries;
+        struct events_stats     stats;
+        u64                     config;
+        u64                     event_stream;
+        u32                     type;
+        u16                     col_len[HISTC_NR_COLS];
+};
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                      struct addr_location *al,
+                                      struct symbol *parent, u64 period);
 extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
+int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
+                        struct hists *pair_hists, bool show_displacement,
+                        long displacement, FILE *fp, u64 total);
+int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
+                         struct hists *hists, struct hists *pair_hists,
+                         bool show_displacement, long displacement,
+                         bool color, u64 total);
 void hist_entry__free(struct hist_entry *);
 
-void perf_session__output_resort(struct perf_session *self, u64 total_samples);
-void perf_session__collapse_resort(struct perf_session *self);
-size_t perf_session__fprintf_hists(struct perf_session *self,
-                                   struct perf_session *pair,
-                                   bool show_displacement, FILE *fp);
+void hists__output_resort(struct hists *self);
+void hists__collapse_resort(struct hists *self);
+
+void hists__inc_nr_events(struct hists *self, u32 type);
+size_t hists__fprintf_nr_events(struct hists *self, FILE *fp);
+
+size_t hists__fprintf(struct hists *self, struct hists *pair,
+                      bool show_displacement, FILE *fp);
+
+int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip);
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head,
+                         size_t privsize);
+
+void hists__filter_by_dso(struct hists *self, const struct dso *dso);
+void hists__filter_by_thread(struct hists *self, const struct thread *thread);
+
+u16 hists__col_len(struct hists *self, enum hist_column col);
+void hists__set_col_len(struct hists *self, enum hist_column col, u16 len);
+bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len);
+
+#ifdef NO_NEWT_SUPPORT
+static inline int hists__browse(struct hists *self __used,
+                                const char *helpline __used,
+                                const char *ev_name __used)
+{
+        return 0;
+}
+
+static inline int hists__tui_browse_tree(struct rb_root *self __used,
+                                         const char *help __used)
+{
+        return 0;
+}
+
+static inline int hist_entry__tui_annotate(struct hist_entry *self __used)
+{
+        return 0;
+}
+#define KEY_LEFT -1
+#define KEY_RIGHT -2
+#else
+#include <newt.h>
+int hists__browse(struct hists *self, const char *helpline,
+                  const char *ev_name);
+int hist_entry__tui_annotate(struct hist_entry *self);
+
+#define KEY_LEFT NEWT_KEY_LEFT
+#define KEY_RIGHT NEWT_KEY_RIGHT
+
+int hists__tui_browse_tree(struct rb_root *self, const char *help);
+#endif
+
+unsigned int hists__sort_list_width(struct hists *self);
+
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/hweight.c b/tools/perf/util/hweight.c
new file mode 100644
index 000000000000..5c1d0d099f0d
--- /dev/null
+++ b/tools/perf/util/hweight.c
@@ -0,0 +1,31 @@
+#include <linux/bitops.h>
+
+/**
+ * hweightN - returns the hamming weight of a N-bit word
+ * @x: the word to weigh
+ *
+ * The Hamming Weight of a number is the total number of bits set in it.
+ */
+
+unsigned int hweight32(unsigned int w)
+{
+        unsigned int res = w - ((w >> 1) & 0x55555555);
+        res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
+        res = (res + (res >> 4)) & 0x0F0F0F0F;
+        res = res + (res >> 8);
+        return (res + (res >> 16)) & 0x000000FF;
+}
+
+unsigned long hweight64(__u64 w)
+{
+#if BITS_PER_LONG == 32
+        return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w);
+#elif BITS_PER_LONG == 64
+        __u64 res = w - ((w >> 1) & 0x5555555555555555ul);
+        res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
+        res = (res + (res >> 4)) & 0x0F0F0F0F0F0F0F0Ful;
+        res = res + (res >> 8);
+        res = res + (res >> 16);
+        return (res + (res >> 32)) & 0x00000000000000FFul;
+#endif
+}
diff --git a/tools/perf/util/include/asm/bitops.h b/tools/perf/util/include/asm/bitops.h
deleted file mode 100644
index 58e9817ffae0..000000000000
--- a/tools/perf/util/include/asm/bitops.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef _PERF_ASM_BITOPS_H_
-#define _PERF_ASM_BITOPS_H_
-
-#include <sys/types.h>
-#include "../../types.h"
-#include <linux/compiler.h>
-
-/* CHECKME: Not sure both always match */
-#define BITS_PER_LONG   __WORDSIZE
-
-#include "../../../../include/asm-generic/bitops/__fls.h"
-#include "../../../../include/asm-generic/bitops/fls.h"
-#include "../../../../include/asm-generic/bitops/fls64.h"
-#include "../../../../include/asm-generic/bitops/__ffs.h"
-#include "../../../../include/asm-generic/bitops/ffz.h"
-#include "../../../../include/asm-generic/bitops/hweight.h"
-
-#endif
diff --git a/tools/perf/util/include/asm/hweight.h b/tools/perf/util/include/asm/hweight.h
new file mode 100644
index 000000000000..36cf26d434a5
--- /dev/null
+++ b/tools/perf/util/include/asm/hweight.h
@@ -0,0 +1,8 @@
+#ifndef PERF_HWEIGHT_H
+#define PERF_HWEIGHT_H
+
+#include <linux/types.h>
+unsigned int hweight32(unsigned int w);
+unsigned long hweight64(__u64 w);
+
+#endif /* PERF_HWEIGHT_H */
diff --git a/tools/perf/util/include/dwarf-regs.h b/tools/perf/util/include/dwarf-regs.h
new file mode 100644
index 000000000000..cf6727e99c44
--- /dev/null
+++ b/tools/perf/util/include/dwarf-regs.h
@@ -0,0 +1,8 @@
+#ifndef _PERF_DWARF_REGS_H_
+#define _PERF_DWARF_REGS_H_
+
+#ifdef DWARF_SUPPORT
+const char *get_arch_regstr(unsigned int n);
+#endif
+
+#endif
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
index 94507639a8c4..eda4416efa0a 100644
--- a/tools/perf/util/include/linux/bitmap.h
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -1,3 +1,35 @@
-#include "../../../../include/linux/bitmap.h"
-#include "../../../../include/asm-generic/bitops/find.h"
-#include <linux/errno.h>
+#ifndef _PERF_BITOPS_H
+#define _PERF_BITOPS_H
+
+#include <string.h>
+#include <linux/bitops.h>
+
+int __bitmap_weight(const unsigned long *bitmap, int bits);
+
+#define BITMAP_LAST_WORD_MASK(nbits)                                    \
+(                                                                       \
+        ((nbits) % BITS_PER_LONG) ?                                     \
+                (1UL<<((nbits) % BITS_PER_LONG))-1 : ~0UL               \
+)
+
+#define small_const_nbits(nbits) \
+        (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
+
+static inline void bitmap_zero(unsigned long *dst, int nbits)
+{
+        if (small_const_nbits(nbits))
+                *dst = 0UL;
+        else {
+                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                memset(dst, 0, len);
+        }
+}
+
+static inline int bitmap_weight(const unsigned long *src, int nbits)
+{
+        if (small_const_nbits(nbits))
+                return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
+        return __bitmap_weight(src, nbits);
+}
+
+#endif /* _PERF_BITOPS_H */
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index 8d63116e9435..bb4ac2e05385 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -1,13 +1,12 @@
 #ifndef _PERF_LINUX_BITOPS_H_
 #define _PERF_LINUX_BITOPS_H_
 
-#define __KERNEL__
+#include <linux/kernel.h>
+#include <asm/hweight.h>
 
-#define CONFIG_GENERIC_FIND_NEXT_BIT
-#define CONFIG_GENERIC_FIND_FIRST_BIT
-#include "../../../../include/linux/bitops.h"
-
-#undef __KERNEL__
+#define BITS_PER_LONG __WORDSIZE
+#define BITS_PER_BYTE           8
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 
 static inline void set_bit(int nr, unsigned long *addr)
 {
@@ -20,10 +19,9 @@ static __always_inline int test_bit(unsigned int nr, const unsigned long *addr)
                 (((unsigned long *)addr)[nr / BITS_PER_LONG])) != 0;
 }
 
-unsigned long generic_find_next_zero_le_bit(const unsigned long *addr, unsigned
-                long size, unsigned long offset);
-
-unsigned long generic_find_next_le_bit(const unsigned long *addr, unsigned
-                long size, unsigned long offset);
+static inline unsigned long hweight_long(unsigned long w)
+{
+        return sizeof(w) == 4 ? hweight32(w) : hweight64(w);
+}
 
 #endif
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index dfb0713ed47f..791f9dd27ebf 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -7,4 +7,6 @@
 #define __user
 #define __attribute_const__
 
+#define __used          __attribute__((__unused__))
+
 #endif
diff --git a/tools/perf/util/include/linux/hash.h b/tools/perf/util/include/linux/hash.h
new file mode 100644
index 000000000000..201f57397997
--- /dev/null
+++ b/tools/perf/util/include/linux/hash.h
@@ -0,0 +1,5 @@
+#include "../../../../include/linux/hash.h"
+
+#ifndef PERF_HASH_H
+#define PERF_HASH_H
+#endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index 21c0274c02fa..1eb804fd3fbf 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -28,6 +28,8 @@
         (type *)((char *)__mptr - offsetof(type, member)); })
 #endif
 
+#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
+
 #ifndef max
 #define max(x, y) ({                            \
         typeof(x) _max1 = (x);                  \
@@ -85,21 +87,25 @@ simple_strtoul(const char *nptr, char **endptr, int base)
         return strtoul(nptr, endptr, base);
 }
 
+int eprintf(int level,
+            const char *fmt, ...) __attribute__((format(printf, 2, 3)));
+
 #ifndef pr_fmt
 #define pr_fmt(fmt) fmt
 #endif
 
 #define pr_err(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_warning(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_info(fmt, ...) \
-        do { fprintf(stderr, pr_fmt(fmt), ##__VA_ARGS__); } while (0)
+        eprintf(0, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug(fmt, ...) \
         eprintf(1, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debugN(n, fmt, ...) \
         eprintf(n, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug2(fmt, ...) pr_debugN(2, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
+#define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
 
 #endif
diff --git a/tools/perf/util/include/linux/list.h b/tools/perf/util/include/linux/list.h
index dbe4b814382a..f5ca26e53fbb 100644
--- a/tools/perf/util/include/linux/list.h
+++ b/tools/perf/util/include/linux/list.h
@@ -15,4 +15,12 @@ static inline void list_del_range(struct list_head *begin,
         begin->prev->next = end->next;
         end->next->prev = begin->prev;
 }
+
+/**
+ * list_for_each_from   -       iterate over a list from one of its nodes
+ * @pos:  the &struct list_head to use as a loop cursor, from where to start
+ * @head: the head for your list.
+ */
+#define list_for_each_from(pos, head) \
+        for (; prefetch(pos->next), pos != (head); pos = pos->next)
 #endif
diff --git a/tools/perf/util/include/linux/types.h b/tools/perf/util/include/linux/types.h
index 196862a81a21..12de3b8112f9 100644
--- a/tools/perf/util/include/linux/types.h
+++ b/tools/perf/util/include/linux/types.h
@@ -6,4 +6,16 @@
 #define DECLARE_BITMAP(name,bits) \
         unsigned long name[BITS_TO_LONGS(bits)]
 
+struct list_head {
+        struct list_head *next, *prev;
+};
+
+struct hlist_head {
+        struct hlist_node *first;
+};
+
+struct hlist_node {
+        struct hlist_node *next, **pprev;
+};
+
 #endif
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index c4d55a0da2ea..3a7eb6ec0eec 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -1,25 +1,22 @@
-#include "event.h"
 #include "symbol.h"
+#include <errno.h>
+#include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
-#include "debug.h"
+#include <unistd.h>
+#include "map.h"
+
+const char *map_type__name[MAP__NR_TYPES] = {
+        [MAP__FUNCTION] = "Functions",
+        [MAP__VARIABLE] = "Variables",
+};
 
 static inline int is_anon_memory(const char *filename)
 {
         return strcmp(filename, "//anon") == 0;
 }
 
-static int strcommon(const char *pathname, char *cwd, int cwdlen)
-{
-        int n = 0;
-
-        while (n < cwdlen && pathname[n] == cwd[n])
-                ++n;
-
-        return n;
-}
-
 void map__init(struct map *self, enum map_type type,
                u64 start, u64 end, u64 pgoff, struct dso *dso)
 {
@@ -31,45 +28,41 @@ void map__init(struct map *self, enum map_type type,
         self->map_ip   = map__map_ip;
         self->unmap_ip = map__unmap_ip;
         RB_CLEAR_NODE(&self->rb_node);
+        self->groups   = NULL;
+        self->referenced = false;
 }
 
-struct map *map__new(struct mmap_event *event, enum map_type type,
-                     char *cwd, int cwdlen)
+struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+                     u64 pgoff, u32 pid, char *filename,
+                     enum map_type type)
 {
         struct map *self = malloc(sizeof(*self));
 
         if (self != NULL) {
-                const char *filename = event->filename;
                 char newfilename[PATH_MAX];
                 struct dso *dso;
                 int anon;
 
-                if (cwd) {
-                        int n = strcommon(filename, cwd, cwdlen);
-
-                        if (n == cwdlen) {
-                                snprintf(newfilename, sizeof(newfilename),
-                                         ".%s", filename + n);
-                                filename = newfilename;
-                        }
-                }
-
                 anon = is_anon_memory(filename);
 
                 if (anon) {
-                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
+                        snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", pid);
                         filename = newfilename;
                 }
 
-                dso = dsos__findnew(filename);
+                dso = __dsos__findnew(dsos__list, filename);
                 if (dso == NULL)
                         goto out_delete;
 
-                map__init(self, type, event->start, event->start + event->len,
-                          event->pgoff, dso);
+                map__init(self, type, start, start + len, pgoff, dso);
 
-                if (self->dso == vdso || anon)
+                if (anon) {
+set_identity:
                         self->map_ip = self->unmap_ip = identity__map_ip;
+                } else if (strcmp(filename, "[vdso]") == 0) {
+                        dso__set_loaded(dso, self->type);
+                        goto set_identity;
+                }
         }
         return self;
 out_delete:
@@ -104,8 +97,7 @@ void map__fixup_end(struct map *self)
 
 #define DSO__DELETED "(deleted)"
 
-int map__load(struct map *self, struct perf_session *session,
-              symbol_filter_t filter)
+int map__load(struct map *self, symbol_filter_t filter)
 {
         const char *name = self->dso->long_name;
         int nr;
@@ -113,7 +105,7 @@ int map__load(struct map *self, struct perf_session *session,
         if (dso__loaded(self->dso, self->type))
                 return 0;
 
-        nr = dso__load(self->dso, self, session, filter);
+        nr = dso__load(self->dso, self, filter);
         if (nr < 0) {
                 if (self->dso->has_build_id) {
                         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
@@ -144,24 +136,29 @@ int map__load(struct map *self, struct perf_session *session,
 
                 return -1;
         }
+        /*
+         * Only applies to the kernel, as its symtabs aren't relative like the
+         * module ones.
+         */
+        if (self->dso->kernel)
+                map__reloc_vmlinux(self);
 
         return 0;
 }
 
-struct symbol *map__find_symbol(struct map *self, struct perf_session *session,
-                                u64 addr, symbol_filter_t filter)
+struct symbol *map__find_symbol(struct map *self, u64 addr,
+                                symbol_filter_t filter)
 {
-        if (map__load(self, session, filter) < 0)
+        if (map__load(self, filter) < 0)
                 return NULL;
 
         return dso__find_symbol(self->dso, self->type, addr);
 }
 
 struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
-                                        struct perf_session *session,
                                         symbol_filter_t filter)
 {
-        if (map__load(self, session, filter) < 0)
+        if (map__load(self, filter) < 0)
                 return NULL;
 
         if (!dso__sorted_by_name(self->dso, self->type))
@@ -201,3 +198,485 @@ size_t map__fprintf(struct map *self, FILE *fp)
         return fprintf(fp, " %Lx-%Lx %Lx %s\n",
                        self->start, self->end, self->pgoff, self->dso->name);
 }
+
+/*
+ * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
+ * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
+ */
+u64 map__rip_2objdump(struct map *map, u64 rip)
+{
+        u64 addr = map->dso->adjust_symbols ?
+                        map->unmap_ip(map, rip) :       /* RIP -> IP */
+                        rip;
+        return addr;
+}
+
+u64 map__objdump_2ip(struct map *map, u64 addr)
+{
+        u64 ip = map->dso->adjust_symbols ?
+                        addr :
+                        map->unmap_ip(map, addr);       /* RIP -> IP */
+        return ip;
+}
+
+void map_groups__init(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                self->maps[i] = RB_ROOT;
+                INIT_LIST_HEAD(&self->removed_maps[i]);
+        }
+        self->machine = NULL;
+}
+
+static void maps__delete(struct rb_root *self)
+{
+        struct rb_node *next = rb_first(self);
+
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, self);
+                map__delete(pos);
+        }
+}
+
+static void maps__delete_removed(struct list_head *self)
+{
+        struct map *pos, *n;
+
+        list_for_each_entry_safe(pos, n, self, node) {
+                list_del(&pos->node);
+                map__delete(pos);
+        }
+}
+
+void map_groups__exit(struct map_groups *self)
+{
+        int i;
+
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                maps__delete(&self->maps[i]);
+                maps__delete_removed(&self->removed_maps[i]);
+        }
+}
+
+void map_groups__flush(struct map_groups *self)
+{
+        int type;
+
+        for (type = 0; type < MAP__NR_TYPES; type++) {
+                struct rb_root *root = &self->maps[type];
+                struct rb_node *next = rb_first(root);
+
+                while (next) {
+                        struct map *pos = rb_entry(next, struct map, rb_node);
+                        next = rb_next(&pos->rb_node);
+                        rb_erase(&pos->rb_node, root);
+                        /*
+                         * We may have references to this map, for
+                         * instance in some hist_entry instances, so
+                         * just move them to a separate list.
+                         */
+                        list_add_tail(&pos->node, &self->removed_maps[pos->type]);
+                }
+        }
+}
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       struct map **mapp,
+                                       symbol_filter_t filter)
+{
+        struct map *map = map_groups__find(self, type, addr);
+
+        if (map != NULL) {
+                if (mapp != NULL)
+                        *mapp = map;
+                return map__find_symbol(map, map->map_ip(map, addr), filter);
+        }
+
+        return NULL;
+}
+
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+                                               enum map_type type,
+                                               const char *name,
+                                               struct map **mapp,
+                                               symbol_filter_t filter)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+                struct symbol *sym = map__find_symbol_by_name(pos, name, filter);
+
+                if (sym == NULL)
+                        continue;
+                if (mapp != NULL)
+                        *mapp = pos;
+                return sym;
+        }
+
+        return NULL;
+}
+
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, int verbose, FILE *fp)
+{
+        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *pos = rb_entry(nd, struct map, rb_node);
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 2) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+
+        return printed;
+}
+
+size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_maps(self, i, verbose, fp);
+        return printed;
+}
+
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+                                                 enum map_type type,
+                                                 int verbose, FILE *fp)
+{
+        struct map *pos;
+        size_t printed = 0;
+
+        list_for_each_entry(pos, &self->removed_maps[type], node) {
+                printed += fprintf(fp, "Map:");
+                printed += map__fprintf(pos, fp);
+                if (verbose > 1) {
+                        printed += dso__fprintf(pos->dso, type, fp);
+                        printed += fprintf(fp, "--\n");
+                }
+        }
+        return printed;
+}
+
+static size_t map_groups__fprintf_removed_maps(struct map_groups *self,
+                                               int verbose, FILE *fp)
+{
+        size_t printed = 0, i;
+        for (i = 0; i < MAP__NR_TYPES; ++i)
+                printed += __map_groups__fprintf_removed_maps(self, i, verbose, fp);
+        return printed;
+}
+
+size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp)
+{
+        size_t printed = map_groups__fprintf_maps(self, verbose, fp);
+        printed += fprintf(fp, "Removed maps:\n");
+        return printed + map_groups__fprintf_removed_maps(self, verbose, fp);
+}
+
+int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+                                   int verbose, FILE *fp)
+{
+        struct rb_root *root = &self->maps[map->type];
+        struct rb_node *next = rb_first(root);
+        int err = 0;
+
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+                next = rb_next(&pos->rb_node);
+
+                if (!map__overlap(pos, map))
+                        continue;
+
+                if (verbose >= 2) {
+                        fputs("overlapping maps:\n", fp);
+                        map__fprintf(map, fp);
+                        map__fprintf(pos, fp);
+                }
+
+                rb_erase(&pos->rb_node, root);
+                /*
+                 * Now check if we need to create new maps for areas not
+                 * overlapped by the new map:
+                 */
+                if (map->start > pos->start) {
+                        struct map *before = map__clone(pos);
+
+                        if (before == NULL) {
+                                err = -ENOMEM;
+                                goto move_map;
+                        }
+
+                        before->end = map->start - 1;
+                        map_groups__insert(self, before);
+                        if (verbose >= 2)
+                                map__fprintf(before, fp);
+                }
+
+                if (map->end < pos->end) {
+                        struct map *after = map__clone(pos);
+
+                        if (after == NULL) {
+                                err = -ENOMEM;
+                                goto move_map;
+                        }
+
+                        after->start = map->end + 1;
+                        map_groups__insert(self, after);
+                        if (verbose >= 2)
+                                map__fprintf(after, fp);
+                }
+move_map:
+                /*
+                 * If we have references, just move them to a separate list.
+                 */
+                if (pos->referenced)
+                        list_add_tail(&pos->node, &self->removed_maps[map->type]);
+                else
+                        map__delete(pos);
+
+                if (err)
+                        return err;
+        }
+
+        return 0;
+}
+
+/*
+ * XXX This should not really _copy_ te maps, but refcount them.
+ */
+int map_groups__clone(struct map_groups *self,
+                      struct map_groups *parent, enum map_type type)
+{
+        struct rb_node *nd;
+        for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
+                struct map *map = rb_entry(nd, struct map, rb_node);
+                struct map *new = map__clone(map);
+                if (new == NULL)
+                        return -ENOMEM;
+                map_groups__insert(self, new);
+        }
+        return 0;
+}
+
+static u64 map__reloc_map_ip(struct map *map, u64 ip)
+{
+        return ip + (s64)map->pgoff;
+}
+
+static u64 map__reloc_unmap_ip(struct map *map, u64 ip)
+{
+        return ip - (s64)map->pgoff;
+}
+
+void map__reloc_vmlinux(struct map *self)
+{
+        struct kmap *kmap = map__kmap(self);
+        s64 reloc;
+
+        if (!kmap->ref_reloc_sym || !kmap->ref_reloc_sym->unrelocated_addr)
+                return;
+
+        reloc = (kmap->ref_reloc_sym->unrelocated_addr -
+                 kmap->ref_reloc_sym->addr);
+
+        if (!reloc)
+                return;
+
+        self->map_ip   = map__reloc_map_ip;
+        self->unmap_ip = map__reloc_unmap_ip;
+        self->pgoff    = reloc;
+}
+
+void maps__insert(struct rb_root *maps, struct map *map)
+{
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        const u64 ip = map->start;
+        struct map *m;
+
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&map->rb_node, parent, p);
+        rb_insert_color(&map->rb_node, maps);
+}
+
+void maps__remove(struct rb_root *self, struct map *map)
+{
+        rb_erase(&map->rb_node, self);
+}
+
+struct map *maps__find(struct rb_root *maps, u64 ip)
+{
+        struct rb_node **p = &maps->rb_node;
+        struct rb_node *parent = NULL;
+        struct map *m;
+
+        while (*p != NULL) {
+                parent = *p;
+                m = rb_entry(parent, struct map, rb_node);
+                if (ip < m->start)
+                        p = &(*p)->rb_left;
+                else if (ip > m->end)
+                        p = &(*p)->rb_right;
+                else
+                        return m;
+        }
+
+        return NULL;
+}
+
+int machine__init(struct machine *self, const char *root_dir, pid_t pid)
+{
+        map_groups__init(&self->kmaps);
+        RB_CLEAR_NODE(&self->rb_node);
+        INIT_LIST_HEAD(&self->user_dsos);
+        INIT_LIST_HEAD(&self->kernel_dsos);
+
+        self->kmaps.machine = self;
+        self->pid           = pid;
+        self->root_dir      = strdup(root_dir);
+        return self->root_dir == NULL ? -ENOMEM : 0;
+}
+
+static void dsos__delete(struct list_head *self)
+{
+        struct dso *pos, *n;
+
+        list_for_each_entry_safe(pos, n, self, node) {
+                list_del(&pos->node);
+                dso__delete(pos);
+        }
+}
+
+void machine__exit(struct machine *self)
+{
+        map_groups__exit(&self->kmaps);
+        dsos__delete(&self->user_dsos);
+        dsos__delete(&self->kernel_dsos);
+        free(self->root_dir);
+        self->root_dir = NULL;
+}
+
+void machine__delete(struct machine *self)
+{
+        machine__exit(self);
+        free(self);
+}
+
+struct machine *machines__add(struct rb_root *self, pid_t pid,
+                              const char *root_dir)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct machine *pos, *machine = malloc(sizeof(*machine));
+
+        if (!machine)
+                return NULL;
+
+        if (machine__init(machine, root_dir, pid) != 0) {
+                free(machine);
+                return NULL;
+        }
+
+        while (*p != NULL) {
+                parent = *p;
+                pos = rb_entry(parent, struct machine, rb_node);
+                if (pid < pos->pid)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&machine->rb_node, parent, p);
+        rb_insert_color(&machine->rb_node, self);
+
+        return machine;
+}
+
+struct machine *machines__find(struct rb_root *self, pid_t pid)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct machine *machine;
+        struct machine *default_machine = NULL;
+
+        while (*p != NULL) {
+                parent = *p;
+                machine = rb_entry(parent, struct machine, rb_node);
+                if (pid < machine->pid)
+                        p = &(*p)->rb_left;
+                else if (pid > machine->pid)
+                        p = &(*p)->rb_right;
+                else
+                        return machine;
+                if (!machine->pid)
+                        default_machine = machine;
+        }
+
+        return default_machine;
+}
+
+struct machine *machines__findnew(struct rb_root *self, pid_t pid)
+{
+        char path[PATH_MAX];
+        const char *root_dir;
+        struct machine *machine = machines__find(self, pid);
+
+        if (!machine || machine->pid != pid) {
+                if (pid == HOST_KERNEL_ID || pid == DEFAULT_GUEST_KERNEL_ID)
+                        root_dir = "";
+                else {
+                        if (!symbol_conf.guestmount)
+                                goto out;
+                        sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
+                        if (access(path, R_OK)) {
+                                pr_err("Can't access file %s\n", path);
+                                goto out;
+                        }
+                        root_dir = path;
+                }
+                machine = machines__add(self, pid, root_dir);
+        }
+
+out:
+        return machine;
+}
+
+void machines__process(struct rb_root *self, machine__process_t process, void *data)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                process(pos, data);
+        }
+}
+
+char *machine__mmap_name(struct machine *self, char *bf, size_t size)
+{
+        if (machine__is_host(self))
+                snprintf(bf, size, "[%s]", "kernel.kallsyms");
+        else if (machine__is_default_guest(self))
+                snprintf(bf, size, "[%s]", "guest.kernel.kallsyms");
+        else
+                snprintf(bf, size, "[%s.%d]", "guest.kernel.kallsyms", self->pid);
+
+        return bf;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
new file mode 100644
index 000000000000..78575796d5f3
--- /dev/null
+++ b/tools/perf/util/map.h
@@ -0,0 +1,227 @@
+#ifndef __PERF_MAP_H
+#define __PERF_MAP_H
+
+#include <linux/compiler.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "types.h"
+
+enum map_type {
+        MAP__FUNCTION = 0,
+        MAP__VARIABLE,
+};
+
+#define MAP__NR_TYPES (MAP__VARIABLE + 1)
+
+extern const char *map_type__name[MAP__NR_TYPES];
+
+struct dso;
+struct ref_reloc_sym;
+struct map_groups;
+struct machine;
+
+struct map {
+        union {
+                struct rb_node  rb_node;
+                struct list_head node;
+        };
+        u64                     start;
+        u64                     end;
+        u8 /* enum map_type */  type;
+        bool                    referenced;
+        u32                     priv;
+        u64                     pgoff;
+
+        /* ip -> dso rip */
+        u64                     (*map_ip)(struct map *, u64);
+        /* dso rip -> ip */
+        u64                     (*unmap_ip)(struct map *, u64);
+
+        struct dso              *dso;
+        struct map_groups       *groups;
+};
+
+struct kmap {
+        struct ref_reloc_sym    *ref_reloc_sym;
+        struct map_groups       *kmaps;
+};
+
+struct map_groups {
+        struct rb_root   maps[MAP__NR_TYPES];
+        struct list_head removed_maps[MAP__NR_TYPES];
+        struct machine   *machine;
+};
+
+/* Native host kernel uses -1 as pid index in machine */
+#define HOST_KERNEL_ID                  (-1)
+#define DEFAULT_GUEST_KERNEL_ID         (0)
+
+struct machine {
+        struct rb_node    rb_node;
+        pid_t             pid;
+        char              *root_dir;
+        struct list_head  user_dsos;
+        struct list_head  kernel_dsos;
+        struct map_groups kmaps;
+        struct map        *vmlinux_maps[MAP__NR_TYPES];
+};
+
+static inline
+struct map *machine__kernel_map(struct machine *self, enum map_type type)
+{
+        return self->vmlinux_maps[type];
+}
+
+static inline struct kmap *map__kmap(struct map *self)
+{
+        return (struct kmap *)(self + 1);
+}
+
+static inline u64 map__map_ip(struct map *map, u64 ip)
+{
+        return ip - map->start + map->pgoff;
+}
+
+static inline u64 map__unmap_ip(struct map *map, u64 ip)
+{
+        return ip + map->start - map->pgoff;
+}
+
+static inline u64 identity__map_ip(struct map *map __used, u64 ip)
+{
+        return ip;
+}
+
+
+/* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
+u64 map__rip_2objdump(struct map *map, u64 rip);
+u64 map__objdump_2ip(struct map *map, u64 addr);
+
+struct symbol;
+
+typedef int (*symbol_filter_t)(struct map *map, struct symbol *sym);
+
+void map__init(struct map *self, enum map_type type,
+               u64 start, u64 end, u64 pgoff, struct dso *dso);
+struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
+                     u64 pgoff, u32 pid, char *filename,
+                     enum map_type type);
+void map__delete(struct map *self);
+struct map *map__clone(struct map *self);
+int map__overlap(struct map *l, struct map *r);
+size_t map__fprintf(struct map *self, FILE *fp);
+
+int map__load(struct map *self, symbol_filter_t filter);
+struct symbol *map__find_symbol(struct map *self,
+                                u64 addr, symbol_filter_t filter);
+struct symbol *map__find_symbol_by_name(struct map *self, const char *name,
+                                        symbol_filter_t filter);
+void map__fixup_start(struct map *self);
+void map__fixup_end(struct map *self);
+
+void map__reloc_vmlinux(struct map *self);
+
+size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                  enum map_type type, int verbose, FILE *fp);
+void maps__insert(struct rb_root *maps, struct map *map);
+void maps__remove(struct rb_root *self, struct map *map);
+struct map *maps__find(struct rb_root *maps, u64 addr);
+void map_groups__init(struct map_groups *self);
+void map_groups__exit(struct map_groups *self);
+int map_groups__clone(struct map_groups *self,
+                      struct map_groups *parent, enum map_type type);
+size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
+size_t map_groups__fprintf_maps(struct map_groups *self, int verbose, FILE *fp);
+
+typedef void (*machine__process_t)(struct machine *self, void *data);
+
+void machines__process(struct rb_root *self, machine__process_t process, void *data);
+struct machine *machines__add(struct rb_root *self, pid_t pid,
+                              const char *root_dir);
+struct machine *machines__find_host(struct rb_root *self);
+struct machine *machines__find(struct rb_root *self, pid_t pid);
+struct machine *machines__findnew(struct rb_root *self, pid_t pid);
+char *machine__mmap_name(struct machine *self, char *bf, size_t size);
+int machine__init(struct machine *self, const char *root_dir, pid_t pid);
+void machine__exit(struct machine *self);
+void machine__delete(struct machine *self);
+
+/*
+ * Default guest kernel is defined by parameter --guestkallsyms
+ * and --guestmodules
+ */
+static inline bool machine__is_default_guest(struct machine *self)
+{
+        return self ? self->pid == DEFAULT_GUEST_KERNEL_ID : false;
+}
+
+static inline bool machine__is_host(struct machine *self)
+{
+        return self ? self->pid == HOST_KERNEL_ID : false;
+}
+
+static inline void map_groups__insert(struct map_groups *self, struct map *map)
+{
+        maps__insert(&self->maps[map->type], map);
+        map->groups = self;
+}
+
+static inline void map_groups__remove(struct map_groups *self, struct map *map)
+{
+        maps__remove(&self->maps[map->type], map);
+}
+
+static inline struct map *map_groups__find(struct map_groups *self,
+                                           enum map_type type, u64 addr)
+{
+        return maps__find(&self->maps[type], addr);
+}
+
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       struct map **mapp,
+                                       symbol_filter_t filter);
+
+struct symbol *map_groups__find_symbol_by_name(struct map_groups *self,
+                                               enum map_type type,
+                                               const char *name,
+                                               struct map **mapp,
+                                               symbol_filter_t filter);
+
+static inline
+struct symbol *machine__find_kernel_symbol(struct machine *self,
+                                           enum map_type type, u64 addr,
+                                           struct map **mapp,
+                                           symbol_filter_t filter)
+{
+        return map_groups__find_symbol(&self->kmaps, type, addr, mapp, filter);
+}
+
+static inline
+struct symbol *machine__find_kernel_function(struct machine *self, u64 addr,
+                                             struct map **mapp,
+                                             symbol_filter_t filter)
+{
+        return machine__find_kernel_symbol(self, MAP__FUNCTION, addr, mapp, filter);
+}
+
+static inline
+struct symbol *map_groups__find_function_by_name(struct map_groups *self,
+                                                 const char *name, struct map **mapp,
+                                                 symbol_filter_t filter)
+{
+        return map_groups__find_symbol_by_name(self, MAP__FUNCTION, name, mapp, filter);
+}
+
+int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
+                                   int verbose, FILE *fp);
+
+struct map *map_groups__find_by_name(struct map_groups *self,
+                                     enum map_type type, const char *name);
+struct map *machine__new_module(struct machine *self, u64 start, const char *filename);
+
+void map_groups__flush(struct map_groups *self);
+
+#endif /* __PERF_MAP_H */
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index e5bc0fb016b2..4af5bd59cfd1 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -5,6 +5,7 @@
 #include "parse-events.h"
 #include "exec_cmd.h"
 #include "string.h"
+#include "symbol.h"
 #include "cache.h"
 #include "header.h"
 #include "debugfs.h"
@@ -409,7 +410,6 @@ static enum event_result
 parse_single_tracepoint_event(char *sys_name,
                               const char *evt_name,
                               unsigned int evt_length,
-                              char *flags,
                               struct perf_event_attr *attr,
                               const char **strp)
 {
@@ -418,14 +418,6 @@ parse_single_tracepoint_event(char *sys_name,
         u64 id;
         int fd;
 
-        if (flags) {
-                if (!strncmp(flags, "record", strlen(flags))) {
-                        attr->sample_type |= PERF_SAMPLE_RAW;
-                        attr->sample_type |= PERF_SAMPLE_TIME;
-                        attr->sample_type |= PERF_SAMPLE_CPU;
-                }
-        }
-
         snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
                  sys_name, evt_name);
 
@@ -444,13 +436,21 @@ parse_single_tracepoint_event(char *sys_name,
         attr->type = PERF_TYPE_TRACEPOINT;
         *strp = evt_name + evt_length;
 
+        attr->sample_type |= PERF_SAMPLE_RAW;
+        attr->sample_type |= PERF_SAMPLE_TIME;
+        attr->sample_type |= PERF_SAMPLE_CPU;
+
+        attr->sample_period = 1;
+
+
         return EVT_HANDLED;
 }
 
 /* sys + ':' + event + ':' + flags*/
 #define MAX_EVOPT_LEN   (MAX_EVENT_LENGTH * 2 + 2 + 128)
 static enum event_result
-parse_subsystem_tracepoint_event(char *sys_name, char *flags)
+parse_multiple_tracepoint_event(char *sys_name, const char *evt_exp,
+                                char *flags)
 {
         char evt_path[MAXPATHLEN];
         struct dirent *evt_ent;
@@ -474,6 +474,9 @@ parse_subsystem_tracepoint_event(char *sys_name, char *flags)
                     || !strcmp(evt_ent->d_name, "filter"))
                         continue;
 
+                if (!strglobmatch(evt_ent->d_name, evt_exp))
+                        continue;
+
                 len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s%s%s", sys_name,
                                evt_ent->d_name, flags ? ":" : "",
                                flags ?: "");
@@ -522,13 +525,13 @@ static enum event_result parse_tracepoint_event(const char **strp,
         if (evt_length >= MAX_EVENT_LENGTH)
                 return EVT_FAILED;
 
-        if (!strcmp(evt_name, "*")) {
+        if (strpbrk(evt_name, "*?")) {
                 *strp = evt_name + evt_length;
-                return parse_subsystem_tracepoint_event(sys_name, flags);
+                return parse_multiple_tracepoint_event(sys_name, evt_name,
+                                                       flags);
         } else
                 return parse_single_tracepoint_event(sys_name, evt_name,
-                                                     evt_length, flags,
-                                                     attr, strp);
+                                                     evt_length, attr, strp);
 }
 
 static enum event_result
@@ -599,8 +602,15 @@ parse_breakpoint_event(const char **strp, struct perf_event_attr *attr)
                         return EVT_FAILED;
         }
 
-        /* We should find a nice way to override the access type */
-        attr->bp_len = HW_BREAKPOINT_LEN_4;
+        /*
+         * We should find a nice way to override the access length
+         * Provide some defaults for now
+         */
+        if (attr->bp_type == HW_BREAKPOINT_X)
+                attr->bp_len = sizeof(long);
+        else
+                attr->bp_len = HW_BREAKPOINT_LEN_4;
+
         attr->type = PERF_TYPE_BREAKPOINT;
 
         return EVT_HANDLED;
@@ -685,19 +695,29 @@ static enum event_result
 parse_event_modifier(const char **strp, struct perf_event_attr *attr)
 {
         const char *str = *strp;
-        int eu = 1, ek = 1, eh = 1;
+        int exclude = 0;
+        int eu = 0, ek = 0, eh = 0, precise = 0;
 
         if (*str++ != ':')
                 return 0;
         while (*str) {
-                if (*str == 'u')
+                if (*str == 'u') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         eu = 0;
-                else if (*str == 'k')
+                } else if (*str == 'k') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         ek = 0;
-                else if (*str == 'h')
+                } else if (*str == 'h') {
+                        if (!exclude)
+                                exclude = eu = ek = eh = 1;
                         eh = 0;
-                else
+                } else if (*str == 'p') {
+                        precise++;
+                } else
                         break;
+
                 ++str;
         }
         if (str >= *strp + 2) {
@@ -705,6 +725,7 @@ parse_event_modifier(const char **strp, struct perf_event_attr *attr)
                 attr->exclude_user   = eu;
                 attr->exclude_kernel = ek;
                 attr->exclude_hv     = eh;
+                attr->precise_ip     = precise;
                 return 1;
         }
         return 0;
@@ -753,11 +774,11 @@ modifier:
         return ret;
 }
 
-static void store_event_type(const char *orgname)
+static int store_event_type(const char *orgname)
 {
         char filename[PATH_MAX], *c;
         FILE *file;
-        int id;
+        int id, n;
 
         sprintf(filename, "%s/", debugfs_path);
         strncat(filename, orgname, strlen(orgname));
@@ -769,11 +790,14 @@ static void store_event_type(const char *orgname)
 
         file = fopen(filename, "r");
         if (!file)
-                return;
-        if (fscanf(file, "%i", &id) < 1)
-                die("cannot store event ID");
+                return 0;
+        n = fscanf(file, "%i", &id);
         fclose(file);
-        perf_header__push_event(id, orgname);
+        if (n < 1) {
+                pr_err("cannot store event ID\n");
+                return -EINVAL;
+        }
+        return perf_header__push_event(id, orgname);
 }
 
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
@@ -782,7 +806,8 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
         enum event_result ret;
 
         if (strchr(str, ':'))
-                store_event_type(str);
+                if (store_event_type(str) < 0)
+                        return -1;
 
         for (;;) {
                 if (nr_counters == MAX_COUNTERS)
@@ -835,11 +860,12 @@ int parse_filter(const struct option *opt __used, const char *str,
 }
 
 static const char * const event_type_descriptors[] = {
-        "",
         "Hardware event",
         "Software event",
         "Tracepoint event",
         "Hardware cache event",
+        "Raw hardware event descriptor",
+        "Hardware breakpoint",
 };
 
 /*
@@ -872,7 +898,7 @@ static void print_tracepoint_events(void)
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
                         printf("  %-42s [%s]\n", evt_path,
-                                event_type_descriptors[PERF_TYPE_TRACEPOINT+1]);
+                                event_type_descriptors[PERF_TYPE_TRACEPOINT]);
                 }
                 closedir(evt_dir);
         }
@@ -892,9 +918,7 @@ void print_events(void)
         printf("List of pre-defined events (to be used in -e):\n");
 
         for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
-                type = syms->type + 1;
-                if (type >= ARRAY_SIZE(event_type_descriptors))
-                        type = 0;
+                type = syms->type;
 
                 if (type != prev_type)
                         printf("\n");
@@ -919,17 +943,20 @@ void print_events(void)
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
                                 printf("  %-42s [%s]\n",
                                         event_cache_name(type, op, i),
-                                        event_type_descriptors[4]);
+                                        event_type_descriptors[PERF_TYPE_HW_CACHE]);
                         }
                 }
         }
 
         printf("\n");
-        printf("  %-42s [raw hardware event descriptor]\n",
-                "rNNN");
+        printf("  %-42s [%s]\n",
+                "rNNN (see 'perf list --help' on how to encode it)",
+               event_type_descriptors[PERF_TYPE_RAW]);
         printf("\n");
 
-        printf("  %-42s [hardware breakpoint]\n", "mem:<addr>[:access]");
+        printf("  %-42s [%s]\n",
+                        "mem:<addr>[:access]",
+                        event_type_descriptors[PERF_TYPE_BREAKPOINT]);
         printf("\n");
 
         print_tracepoint_events();
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index b8c1f64bc935..fc4ab3fe877a 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -13,6 +13,7 @@ struct tracepoint_path {
 };
 
 extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
+extern bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events);
 
 extern int                      nr_counters;
 
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index efebd5b476b3..99d02aa57dbf 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -49,8 +49,9 @@ static int get_value(struct parse_opt_ctx_t *p,
                                 break;
                         /* FALLTHROUGH */
                 case OPTION_BOOLEAN:
+                case OPTION_INCR:
                 case OPTION_BIT:
-                case OPTION_SET_INT:
+                case OPTION_SET_UINT:
                 case OPTION_SET_PTR:
                         return opterror(opt, "takes no value", flags);
                 case OPTION_END:
@@ -58,7 +59,9 @@ static int get_value(struct parse_opt_ctx_t *p,
                 case OPTION_GROUP:
                 case OPTION_STRING:
                 case OPTION_INTEGER:
+                case OPTION_UINTEGER:
                 case OPTION_LONG:
+                case OPTION_U64:
                 default:
                         break;
                 }
@@ -73,11 +76,15 @@ static int get_value(struct parse_opt_ctx_t *p,
                 return 0;
 
         case OPTION_BOOLEAN:
+                *(bool *)opt->value = unset ? false : true;
+                return 0;
+
+        case OPTION_INCR:
                 *(int *)opt->value = unset ? 0 : *(int *)opt->value + 1;
                 return 0;
 
-        case OPTION_SET_INT:
-                *(int *)opt->value = unset ? 0 : opt->defval;
+        case OPTION_SET_UINT:
+                *(unsigned int *)opt->value = unset ? 0 : opt->defval;
                 return 0;
 
         case OPTION_SET_PTR:
@@ -120,6 +127,22 @@ static int get_value(struct parse_opt_ctx_t *p,
                         return opterror(opt, "expects a numerical value", flags);
                 return 0;
 
+        case OPTION_UINTEGER:
+                if (unset) {
+                        *(unsigned int *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(unsigned int *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(unsigned int *)opt->value = strtol(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
         case OPTION_LONG:
                 if (unset) {
                         *(long *)opt->value = 0;
@@ -136,6 +159,22 @@ static int get_value(struct parse_opt_ctx_t *p,
                         return opterror(opt, "expects a numerical value", flags);
                 return 0;
 
+        case OPTION_U64:
+                if (unset) {
+                        *(u64 *)opt->value = 0;
+                        return 0;
+                }
+                if (opt->flags & PARSE_OPT_OPTARG && !p->opt) {
+                        *(u64 *)opt->value = opt->defval;
+                        return 0;
+                }
+                if (get_arg(p, opt, flags, &arg))
+                        return -1;
+                *(u64 *)opt->value = strtoull(arg, (char **)&s, 10);
+                if (*s)
+                        return opterror(opt, "expects a numerical value", flags);
+                return 0;
+
         case OPTION_END:
         case OPTION_ARGUMENT:
         case OPTION_GROUP:
@@ -441,7 +480,10 @@ int usage_with_options_internal(const char * const *usagestr,
                 switch (opts->type) {
                 case OPTION_ARGUMENT:
                         break;
+                case OPTION_LONG:
+                case OPTION_U64:
                 case OPTION_INTEGER:
+                case OPTION_UINTEGER:
                         if (opts->flags & PARSE_OPT_OPTARG)
                                 if (opts->long_name)
                                         pos += fprintf(stderr, "[=<n>]");
@@ -473,14 +515,14 @@ int usage_with_options_internal(const char * const *usagestr,
                                         pos += fprintf(stderr, " ...");
                         }
                         break;
-                default: /* OPTION_{BIT,BOOLEAN,SET_INT,SET_PTR} */
+                default: /* OPTION_{BIT,BOOLEAN,SET_UINT,SET_PTR} */
                 case OPTION_END:
                 case OPTION_GROUP:
                 case OPTION_BIT:
                 case OPTION_BOOLEAN:
-                case OPTION_SET_INT:
+                case OPTION_INCR:
+                case OPTION_SET_UINT:
                 case OPTION_SET_PTR:
-                case OPTION_LONG:
                         break;
                 }
 
@@ -500,6 +542,7 @@ int usage_with_options_internal(const char * const *usagestr,
 void usage_with_options(const char * const *usagestr,
                         const struct option *opts)
 {
+        exit_browser(false);
         usage_with_options_internal(usagestr, opts, 0);
         exit(129);
 }
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 948805af43c2..c7d72dce54b2 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -1,6 +1,9 @@
 #ifndef __PERF_PARSE_OPTIONS_H
 #define __PERF_PARSE_OPTIONS_H
 
+#include <linux/kernel.h>
+#include <stdbool.h>
+
 enum parse_opt_type {
         /* special types */
         OPTION_END,
@@ -8,14 +11,17 @@ enum parse_opt_type {
         OPTION_GROUP,
         /* options with no arguments */
         OPTION_BIT,
-        OPTION_BOOLEAN, /* _INCR would have been a better name */
-        OPTION_SET_INT,
+        OPTION_BOOLEAN,
+        OPTION_INCR,
+        OPTION_SET_UINT,
         OPTION_SET_PTR,
         /* options with arguments (usually) */
         OPTION_STRING,
         OPTION_INTEGER,
         OPTION_LONG,
         OPTION_CALLBACK,
+        OPTION_U64,
+        OPTION_UINTEGER,
 };
 
 enum parse_opt_flags {
@@ -73,7 +79,7 @@ typedef int parse_opt_cb(const struct option *, const char *arg, int unset);
  *
  * `defval`::
  *   default value to fill (*->value) with for PARSE_OPT_OPTARG.
- *   OPTION_{BIT,SET_INT,SET_PTR} store the {mask,integer,pointer} to put in
+ *   OPTION_{BIT,SET_UINT,SET_PTR} store the {mask,integer,pointer} to put in
  *   the value when met.
  *   CALLBACKS can use it like they want.
  */
@@ -90,16 +96,21 @@ struct option {
         intptr_t defval;
 };
 
+#define check_vtype(v, type) ( BUILD_BUG_ON_ZERO(!__builtin_types_compatible_p(typeof(v), type)) + v )
+
 #define OPT_END()                   { .type = OPTION_END }
 #define OPT_ARGUMENT(l, h)          { .type = OPTION_ARGUMENT, .long_name = (l), .help = (h) }
 #define OPT_GROUP(h)                { .type = OPTION_GROUP, .help = (h) }
-#define OPT_BIT(s, l, v, h, b)      { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (b) }
-#define OPT_BOOLEAN(s, l, v, h)     { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_SET_INT(s, l, v, h, i)  { .type = OPTION_SET_INT, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (i) }
+#define OPT_BIT(s, l, v, h, b)      { .type = OPTION_BIT, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h), .defval = (b) }
+#define OPT_BOOLEAN(s, l, v, h)     { .type = OPTION_BOOLEAN, .short_name = (s), .long_name = (l), .value = check_vtype(v, bool *), .help = (h) }
+#define OPT_INCR(s, l, v, h)        { .type = OPTION_INCR, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
+#define OPT_SET_UINT(s, l, v, h, i)  { .type = OPTION_SET_UINT, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h), .defval = (i) }
 #define OPT_SET_PTR(s, l, v, h, p)  { .type = OPTION_SET_PTR, .short_name = (s), .long_name = (l), .value = (v), .help = (h), .defval = (p) }
-#define OPT_INTEGER(s, l, v, h)     { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = (v), .help = (h) }
-#define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h) }
+#define OPT_INTEGER(s, l, v, h)     { .type = OPTION_INTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, int *), .help = (h) }
+#define OPT_UINTEGER(s, l, v, h)    { .type = OPTION_UINTEGER, .short_name = (s), .long_name = (l), .value = check_vtype(v, unsigned int *), .help = (h) }
+#define OPT_LONG(s, l, v, h)        { .type = OPTION_LONG, .short_name = (s), .long_name = (l), .value = check_vtype(v, long *), .help = (h) }
+#define OPT_U64(s, l, v, h)         { .type = OPTION_U64, .short_name = (s), .long_name = (l), .value = check_vtype(v, u64 *), .help = (h) }
+#define OPT_STRING(s, l, v, a, h)   { .type = OPTION_STRING,  .short_name = (s), .long_name = (l), .value = check_vtype(v, const char **), (a), .help = (h) }
 #define OPT_DATE(s, l, v, h) \
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
 #define OPT_CALLBACK(s, l, v, a, h, f) \
diff --git a/tools/perf/util/path.c b/tools/perf/util/path.c
index fd1f2faaade4..58a470d036dd 100644
--- a/tools/perf/util/path.c
+++ b/tools/perf/util/path.c
@@ -54,21 +54,6 @@ static char *cleanup_path(char *path)
         return path;
 }
 
-char *mksnpath(char *buf, size_t n, const char *fmt, ...)
-{
-        va_list args;
-        unsigned len;
-
-        va_start(args, fmt);
-        len = vsnprintf(buf, n, fmt, args);
-        va_end(args);
-        if (len >= n) {
-                strlcpy(buf, bad_path, n);
-                return buf;
-        }
-        return cleanup_path(buf);
-}
-
 static char *perf_vsnpath(char *buf, size_t n, const char *fmt, va_list args)
 {
         const char *perf_dir = get_perf_dir();
@@ -89,15 +74,6 @@ bad:
         return buf;
 }
 
-char *perf_snpath(char *buf, size_t n, const char *fmt, ...)
-{
-        va_list args;
-        va_start(args, fmt);
-        (void)perf_vsnpath(buf, n, fmt, args);
-        va_end(args);
-        return buf;
-}
-
 char *perf_pathdup(const char *fmt, ...)
 {
         char path[PATH_MAX];
@@ -143,184 +119,6 @@ char *perf_path(const char *fmt, ...)
         return cleanup_path(pathname);
 }
 
-
-/* perf_mkstemp() - create tmp file honoring TMPDIR variable */
-int perf_mkstemp(char *path, size_t len, const char *template)
-{
-        const char *tmp;
-        size_t n;
-
-        tmp = getenv("TMPDIR");
-        if (!tmp)
-                tmp = "/tmp";
-        n = snprintf(path, len, "%s/%s", tmp, template);
-        if (len <= n) {
-                errno = ENAMETOOLONG;
-                return -1;
-        }
-        return mkstemp(path);
-}
-
-
-const char *make_relative_path(const char *abs_path, const char *base)
-{
-        static char buf[PATH_MAX + 1];
-        int baselen;
-
-        if (!base)
-                return abs_path;
-
-        baselen = strlen(base);
-        if (prefixcmp(abs_path, base))
-                return abs_path;
-        if (abs_path[baselen] == '/')
-                baselen++;
-        else if (base[baselen - 1] != '/')
-                return abs_path;
-
-        strcpy(buf, abs_path + baselen);
-
-        return buf;
-}
-
-/*
- * It is okay if dst == src, but they should not overlap otherwise.
- *
- * Performs the following normalizations on src, storing the result in dst:
- * - Ensures that components are separated by '/' (Windows only)
- * - Squashes sequences of '/'.
- * - Removes "." components.
- * - Removes ".." components, and the components the precede them.
- * Returns failure (non-zero) if a ".." component appears as first path
- * component anytime during the normalization. Otherwise, returns success (0).
- *
- * Note that this function is purely textual.  It does not follow symlinks,
- * verify the existence of the path, or make any system calls.
- */
-int normalize_path_copy(char *dst, const char *src)
-{
-        char *dst0;
-
-        if (has_dos_drive_prefix(src)) {
-                *dst++ = *src++;
-                *dst++ = *src++;
-        }
-        dst0 = dst;
-
-        if (is_dir_sep(*src)) {
-                *dst++ = '/';
-                while (is_dir_sep(*src))
-                        src++;
-        }
-
-        for (;;) {
-                char c = *src;
-
-                /*
-                 * A path component that begins with . could be
-                 * special:
-                 * (1) "." and ends   -- ignore and terminate.
-                 * (2) "./"           -- ignore them, eat slash and continue.
-                 * (3) ".." and ends  -- strip one and terminate.
-                 * (4) "../"          -- strip one, eat slash and continue.
-                 */
-                if (c == '.') {
-                        if (!src[1]) {
-                                /* (1) */
-                                src++;
-                        } else if (is_dir_sep(src[1])) {
-                                /* (2) */
-                                src += 2;
-                                while (is_dir_sep(*src))
-                                        src++;
-                                continue;
-                        } else if (src[1] == '.') {
-                                if (!src[2]) {
-                                        /* (3) */
-                                        src += 2;
-                                        goto up_one;
-                                } else if (is_dir_sep(src[2])) {
-                                        /* (4) */
-                                        src += 3;
-                                        while (is_dir_sep(*src))
-                                                src++;
-                                        goto up_one;
-                                }
-                        }
-                }
-
-                /* copy up to the next '/', and eat all '/' */
-                while ((c = *src++) != '\0' && !is_dir_sep(c))
-                        *dst++ = c;
-                if (is_dir_sep(c)) {
-                        *dst++ = '/';
-                        while (is_dir_sep(c))
-                                c = *src++;
-                        src--;
-                } else if (!c)
-                        break;
-                continue;
-
-        up_one:
-                /*
-                 * dst0..dst is prefix portion, and dst[-1] is '/';
-                 * go up one level.
-                 */
-                dst--;  /* go to trailing '/' */
-                if (dst <= dst0)
-                        return -1;
-                /* Windows: dst[-1] cannot be backslash anymore */
-                while (dst0 < dst && dst[-1] != '/')
-                        dst--;
-        }
-        *dst = '\0';
-        return 0;
-}
-
-/*
- * path = Canonical absolute path
- * prefix_list = Colon-separated list of absolute paths
- *
- * Determines, for each path in prefix_list, whether the "prefix" really
- * is an ancestor directory of path.  Returns the length of the longest
- * ancestor directory, excluding any trailing slashes, or -1 if no prefix
- * is an ancestor.  (Note that this means 0 is returned if prefix_list is
- * "/".) "/foo" is not considered an ancestor of "/foobar".  Directories
- * are not considered to be their own ancestors.  path must be in a
- * canonical form: empty components, or "." or ".." components are not
- * allowed.  prefix_list may be null, which is like "".
- */
-int longest_ancestor_length(const char *path, const char *prefix_list)
-{
-        char buf[PATH_MAX+1];
-        const char *ceil, *colon;
-        int len, max_len = -1;
-
-        if (prefix_list == NULL || !strcmp(path, "/"))
-                return -1;
-
-        for (colon = ceil = prefix_list; *colon; ceil = colon+1) {
-                for (colon = ceil; *colon && *colon != PATH_SEP; colon++);
-                len = colon - ceil;
-                if (len == 0 || len > PATH_MAX || !is_absolute_path(ceil))
-                        continue;
-                strlcpy(buf, ceil, len+1);
-                if (normalize_path_copy(buf, buf) < 0)
-                        continue;
-                len = strlen(buf);
-                if (len > 0 && buf[len-1] == '/')
-                        buf[--len] = '\0';
-
-                if (!strncmp(path, buf, len) &&
-                    path[len] == '/' &&
-                    len > max_len) {
-                        max_len = len;
-                }
-        }
-
-        return max_len;
-}
-
 /* strip arbitrary amount of directory separators at end of path */
 static inline int chomp_trailing_dir_sep(const char *path, int len)
 {
@@ -354,5 +152,5 @@ char *strip_path_suffix(const char *path, const char *suffix)
 
         if (path_len && !is_dir_sep(path[path_len - 1]))
                 return NULL;
-        return xstrndup(path, chomp_trailing_dir_sep(path, path_len));
+        return strndup(path, chomp_trailing_dir_sep(path, path_len));
 }
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 29465d440043..fcc16e4349df 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1,5 +1,5 @@
 /*
- * probe-event.c : perf-probe definition to kprobe_events format converter
+ * probe-event.c : perf-probe definition to probe_events format converter
  *
  * Written by Masami Hiramatsu <mhiramat@redhat.com>
  *
@@ -33,18 +33,27 @@
 #include <limits.h>
 
 #undef _GNU_SOURCE
+#include "util.h"
 #include "event.h"
 #include "string.h"
 #include "strlist.h"
 #include "debug.h"
-#include "parse-events.h"  /* For debugfs_path */
+#include "cache.h"
+#include "color.h"
+#include "symbol.h"
+#include "thread.h"
+#include "debugfs.h"
+#include "trace-event.h"        /* For __unused */
 #include "probe-event.h"
+#include "probe-finder.h"
 
 #define MAX_CMDLEN 256
 #define MAX_PROBE_ARGS 128
 #define PERFPROBE_GROUP "probe"
 
-#define semantic_error(msg ...) die("Semantic error :" msg)
+bool probe_event_dry_run;       /* Dry run flag */
+
+#define semantic_error(msg ...) pr_err("Semantic error :" msg)
 
 /* If there is no space to write, returns -E2BIG. */
 static int e_snprintf(char *str, size_t size, const char *format, ...)
@@ -62,6 +71,398 @@ static int e_snprintf(char *str, size_t size, const char *format, ...)
         return ret;
 }
 
+static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
+static struct machine machine;
+
+/* Initialize symbol maps and path of vmlinux */
+static int init_vmlinux(void)
+{
+        struct dso *kernel;
+        int ret;
+
+        symbol_conf.sort_by_name = true;
+        if (symbol_conf.vmlinux_name == NULL)
+                symbol_conf.try_vmlinux_path = true;
+        else
+                pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
+        ret = symbol__init();
+        if (ret < 0) {
+                pr_debug("Failed to init symbol map.\n");
+                goto out;
+        }
+
+        ret = machine__init(&machine, "/", 0);
+        if (ret < 0)
+                goto out;
+
+        kernel = dso__new_kernel(symbol_conf.vmlinux_name);
+        if (kernel == NULL)
+                die("Failed to create kernel dso.");
+
+        ret = __machine__create_kernel_maps(&machine, kernel);
+        if (ret < 0)
+                pr_debug("Failed to create kernel maps.\n");
+
+out:
+        if (ret < 0)
+                pr_warning("Failed to init vmlinux path.\n");
+        return ret;
+}
+
+#ifdef DWARF_SUPPORT
+static int open_vmlinux(void)
+{
+        if (map__load(machine.vmlinux_maps[MAP__FUNCTION], NULL) < 0) {
+                pr_debug("Failed to load kernel map.\n");
+                return -EINVAL;
+        }
+        pr_debug("Try to open %s\n", machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name);
+        return open(machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
+}
+
+/*
+ * Convert trace point to probe point with debuginfo
+ * Currently only handles kprobes.
+ */
+static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
+                                       struct perf_probe_point *pp)
+{
+        struct symbol *sym;
+        int fd, ret = -ENOENT;
+
+        sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
+                                       tp->symbol, NULL);
+        if (sym) {
+                fd = open_vmlinux();
+                if (fd >= 0) {
+                        ret = find_perf_probe_point(fd,
+                                                 sym->start + tp->offset, pp);
+                        close(fd);
+                }
+        }
+        if (ret <= 0) {
+                pr_debug("Failed to find corresponding probes from "
+                         "debuginfo. Use kprobe event information.\n");
+                pp->function = strdup(tp->symbol);
+                if (pp->function == NULL)
+                        return -ENOMEM;
+                pp->offset = tp->offset;
+        }
+        pp->retprobe = tp->retprobe;
+
+        return 0;
+}
+
+/* Try to find perf_probe_event with debuginfo */
+static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
+                                           struct probe_trace_event **tevs,
+                                           int max_tevs)
+{
+        bool need_dwarf = perf_probe_event_need_dwarf(pev);
+        int fd, ntevs;
+
+        fd = open_vmlinux();
+        if (fd < 0) {
+                if (need_dwarf) {
+                        pr_warning("Failed to open debuginfo file.\n");
+                        return fd;
+                }
+                pr_debug("Could not open vmlinux. Try to use symbols.\n");
+                return 0;
+        }
+
+        /* Searching trace events corresponding to probe event */
+        ntevs = find_probe_trace_events(fd, pev, tevs, max_tevs);
+        close(fd);
+
+        if (ntevs > 0) {        /* Succeeded to find trace events */
+                pr_debug("find %d probe_trace_events.\n", ntevs);
+                return ntevs;
+        }
+
+        if (ntevs == 0) {       /* No error but failed to find probe point. */
+                pr_warning("Probe point '%s' not found.\n",
+                           synthesize_perf_probe_point(&pev->point));
+                return -ENOENT;
+        }
+        /* Error path : ntevs < 0 */
+        pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
+        if (ntevs == -EBADF) {
+                pr_warning("Warning: No dwarf info found in the vmlinux - "
+                        "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
+                if (!need_dwarf) {
+                        pr_debug("Trying to use symbols.\nn");
+                        return 0;
+                }
+        }
+        return ntevs;
+}
+
+/*
+ * Find a src file from a DWARF tag path. Prepend optional source path prefix
+ * and chop off leading directories that do not exist. Result is passed back as
+ * a newly allocated path on success.
+ * Return 0 if file was found and readable, -errno otherwise.
+ */
+static int get_real_path(const char *raw_path, const char *comp_dir,
+                         char **new_path)
+{
+        const char *prefix = symbol_conf.source_prefix;
+
+        if (!prefix) {
+                if (raw_path[0] != '/' && comp_dir)
+                        /* If not an absolute path, try to use comp_dir */
+                        prefix = comp_dir;
+                else {
+                        if (access(raw_path, R_OK) == 0) {
+                                *new_path = strdup(raw_path);
+                                return 0;
+                        } else
+                                return -errno;
+                }
+        }
+
+        *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
+        if (!*new_path)
+                return -ENOMEM;
+
+        for (;;) {
+                sprintf(*new_path, "%s/%s", prefix, raw_path);
+
+                if (access(*new_path, R_OK) == 0)
+                        return 0;
+
+                if (!symbol_conf.source_prefix)
+                        /* In case of searching comp_dir, don't retry */
+                        return -errno;
+
+                switch (errno) {
+                case ENAMETOOLONG:
+                case ENOENT:
+                case EROFS:
+                case EFAULT:
+                        raw_path = strchr(++raw_path, '/');
+                        if (!raw_path) {
+                                free(*new_path);
+                                *new_path = NULL;
+                                return -ENOENT;
+                        }
+                        continue;
+
+                default:
+                        free(*new_path);
+                        *new_path = NULL;
+                        return -errno;
+                }
+        }
+}
+
+#define LINEBUF_SIZE 256
+#define NR_ADDITIONAL_LINES 2
+
+static int show_one_line(FILE *fp, int l, bool skip, bool show_num)
+{
+        char buf[LINEBUF_SIZE];
+        const char *color = PERF_COLOR_BLUE;
+
+        if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                goto error;
+        if (!skip) {
+                if (show_num)
+                        fprintf(stdout, "%7d  %s", l, buf);
+                else
+                        color_fprintf(stdout, color, "         %s", buf);
+        }
+
+        while (strlen(buf) == LINEBUF_SIZE - 1 &&
+               buf[LINEBUF_SIZE - 2] != '\n') {
+                if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
+                        goto error;
+                if (!skip) {
+                        if (show_num)
+                                fprintf(stdout, "%s", buf);
+                        else
+                                color_fprintf(stdout, color, "%s", buf);
+                }
+        }
+
+        return 0;
+error:
+        if (feof(fp))
+                pr_warning("Source file is shorter than expected.\n");
+        else
+                pr_warning("File read error: %s\n", strerror(errno));
+
+        return -1;
+}
+
+/*
+ * Show line-range always requires debuginfo to find source file and
+ * line number.
+ */
+int show_line_range(struct line_range *lr)
+{
+        int l = 1;
+        struct line_node *ln;
+        FILE *fp;
+        int fd, ret;
+        char *tmp;
+
+        /* Search a line range */
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        fd = open_vmlinux();
+        if (fd < 0) {
+                pr_warning("Failed to open debuginfo file.\n");
+                return fd;
+        }
+
+        ret = find_line_range(fd, lr);
+        close(fd);
+        if (ret == 0) {
+                pr_warning("Specified source line is not found.\n");
+                return -ENOENT;
+        } else if (ret < 0) {
+                pr_warning("Debuginfo analysis failed. (%d)\n", ret);
+                return ret;
+        }
+
+        /* Convert source file path */
+        tmp = lr->path;
+        ret = get_real_path(tmp, lr->comp_dir, &lr->path);
+        free(tmp);      /* Free old path */
+        if (ret < 0) {
+                pr_warning("Failed to find source file. (%d)\n", ret);
+                return ret;
+        }
+
+        setup_pager();
+
+        if (lr->function)
+                fprintf(stdout, "<%s:%d>\n", lr->function,
+                        lr->start - lr->offset);
+        else
+                fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
+
+        fp = fopen(lr->path, "r");
+        if (fp == NULL) {
+                pr_warning("Failed to open %s: %s\n", lr->path,
+                           strerror(errno));
+                return -errno;
+        }
+        /* Skip to starting line number */
+        while (l < lr->start && ret >= 0)
+                ret = show_one_line(fp, l++, true, false);
+        if (ret < 0)
+                goto end;
+
+        list_for_each_entry(ln, &lr->line_list, list) {
+                while (ln->line > l && ret >= 0)
+                        ret = show_one_line(fp, (l++) - lr->offset,
+                                            false, false);
+                if (ret >= 0)
+                        ret = show_one_line(fp, (l++) - lr->offset,
+                                            false, true);
+                if (ret < 0)
+                        goto end;
+        }
+
+        if (lr->end == INT_MAX)
+                lr->end = l + NR_ADDITIONAL_LINES;
+        while (l <= lr->end && !feof(fp) && ret >= 0)
+                ret = show_one_line(fp, (l++) - lr->offset, false, false);
+end:
+        fclose(fp);
+        return ret;
+}
+
+#else   /* !DWARF_SUPPORT */
+
+static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
+                                       struct perf_probe_point *pp)
+{
+        pp->function = strdup(tp->symbol);
+        if (pp->function == NULL)
+                return -ENOMEM;
+        pp->offset = tp->offset;
+        pp->retprobe = tp->retprobe;
+
+        return 0;
+}
+
+static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
+                                struct probe_trace_event **tevs __unused,
+                                int max_tevs __unused)
+{
+        if (perf_probe_event_need_dwarf(pev)) {
+                pr_warning("Debuginfo-analysis is not supported.\n");
+                return -ENOSYS;
+        }
+        return 0;
+}
+
+int show_line_range(struct line_range *lr __unused)
+{
+        pr_warning("Debuginfo-analysis is not supported.\n");
+        return -ENOSYS;
+}
+
+#endif
+
+int parse_line_range_desc(const char *arg, struct line_range *lr)
+{
+        const char *ptr;
+        char *tmp;
+        /*
+         * <Syntax>
+         * SRC:SLN[+NUM|-ELN]
+         * FUNC[:SLN[+NUM|-ELN]]
+         */
+        ptr = strchr(arg, ':');
+        if (ptr) {
+                lr->start = (int)strtoul(ptr + 1, &tmp, 0);
+                if (*tmp == '+') {
+                        lr->end = lr->start + (int)strtoul(tmp + 1, &tmp, 0);
+                        lr->end--;      /*
+                                         * Adjust the number of lines here.
+                                         * If the number of lines == 1, the
+                                         * the end of line should be equal to
+                                         * the start of line.
+                                         */
+                } else if (*tmp == '-')
+                        lr->end = (int)strtoul(tmp + 1, &tmp, 0);
+                else
+                        lr->end = INT_MAX;
+                pr_debug("Line range is %d to %d\n", lr->start, lr->end);
+                if (lr->start > lr->end) {
+                        semantic_error("Start line must be smaller"
+                                       " than end line.\n");
+                        return -EINVAL;
+                }
+                if (*tmp != '\0') {
+                        semantic_error("Tailing with invalid character '%d'.\n",
+                                       *tmp);
+                        return -EINVAL;
+                }
+                tmp = strndup(arg, (ptr - arg));
+        } else {
+                tmp = strdup(arg);
+                lr->end = INT_MAX;
+        }
+
+        if (tmp == NULL)
+                return -ENOMEM;
+
+        if (strchr(tmp, '.'))
+                lr->file = tmp;
+        else
+                lr->function = tmp;
+
+        return 0;
+}
+
 /* Check the name is good for event/group */
 static bool check_event_name(const char *name)
 {
@@ -75,50 +476,66 @@ static bool check_event_name(const char *name)
 }
 
 /* Parse probepoint definition. */
-static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
+static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 {
+        struct perf_probe_point *pp = &pev->point;
         char *ptr, *tmp;
         char c, nc = 0;
         /*
          * <Syntax>
-         * perf probe [EVENT=]SRC:LN
-         * perf probe [EVENT=]FUNC[+OFFS|%return][@SRC]
+         * perf probe [EVENT=]SRC[:LN|;PTN]
+         * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
          *
          * TODO:Group name support
          */
 
-        ptr = strchr(arg, '=');
-        if (ptr) {      /* Event name */
+        ptr = strpbrk(arg, ";=@+%");
+        if (ptr && *ptr == '=') {       /* Event name */
                 *ptr = '\0';
                 tmp = ptr + 1;
-                ptr = strchr(arg, ':');
-                if (ptr)        /* Group name is not supported yet. */
-                        semantic_error("Group name is not supported yet.");
-                if (!check_event_name(arg))
+                if (strchr(arg, ':')) {
+                        semantic_error("Group name is not supported yet.\n");
+                        return -ENOTSUP;
+                }
+                if (!check_event_name(arg)) {
                         semantic_error("%s is bad for event name -it must "
-                                       "follow C symbol-naming rule.", arg);
-                pp->event = strdup(arg);
+                                       "follow C symbol-naming rule.\n", arg);
+                        return -EINVAL;
+                }
+                pev->event = strdup(arg);
+                if (pev->event == NULL)
+                        return -ENOMEM;
+                pev->group = NULL;
                 arg = tmp;
         }
 
-        ptr = strpbrk(arg, ":+@%");
+        ptr = strpbrk(arg, ";:+@%");
         if (ptr) {
                 nc = *ptr;
                 *ptr++ = '\0';
         }
 
+        tmp = strdup(arg);
+        if (tmp == NULL)
+                return -ENOMEM;
+
         /* Check arg is function or file and copy it */
-        if (strchr(arg, '.'))   /* File */
-                pp->file = strdup(arg);
+        if (strchr(tmp, '.'))   /* File */
+                pp->file = tmp;
         else                    /* Function */
-                pp->function = strdup(arg);
-        DIE_IF(pp->file == NULL && pp->function == NULL);
+                pp->function = tmp;
 
         /* Parse other options */
         while (ptr) {
                 arg = ptr;
                 c = nc;
-                ptr = strpbrk(arg, ":+@%");
+                if (c == ';') { /* Lazy pattern must be the last part */
+                        pp->lazy_line = strdup(arg);
+                        if (pp->lazy_line == NULL)
+                                return -ENOMEM;
+                        break;
+                }
+                ptr = strpbrk(arg, ";:+@%");
                 if (ptr) {
                         nc = *ptr;
                         *ptr++ = '\0';
@@ -126,258 +543,690 @@ static void parse_perf_probe_probepoint(char *arg, struct probe_point *pp)
                 switch (c) {
                 case ':':       /* Line number */
                         pp->line = strtoul(arg, &tmp, 0);
-                        if (*tmp != '\0')
-                                semantic_error("There is non-digit charactor"
-                                                " in line number.");
+                        if (*tmp != '\0') {
+                                semantic_error("There is non-digit char"
+                                               " in line number.\n");
+                                return -EINVAL;
+                        }
                         break;
                 case '+':       /* Byte offset from a symbol */
                         pp->offset = strtoul(arg, &tmp, 0);
-                        if (*tmp != '\0')
-                                semantic_error("There is non-digit charactor"
-                                                " in offset.");
+                        if (*tmp != '\0') {
+                                semantic_error("There is non-digit character"
+                                                " in offset.\n");
+                                return -EINVAL;
+                        }
                         break;
                 case '@':       /* File name */
-                        if (pp->file)
-                                semantic_error("SRC@SRC is not allowed.");
+                        if (pp->file) {
+                                semantic_error("SRC@SRC is not allowed.\n");
+                                return -EINVAL;
+                        }
                         pp->file = strdup(arg);
-                        DIE_IF(pp->file == NULL);
-                        if (ptr)
-                                semantic_error("@SRC must be the last "
-                                               "option.");
+                        if (pp->file == NULL)
+                                return -ENOMEM;
                         break;
                 case '%':       /* Probe places */
                         if (strcmp(arg, "return") == 0) {
                                 pp->retprobe = 1;
-                        } else  /* Others not supported yet */
-                                semantic_error("%%%s is not supported.", arg);
+                        } else {        /* Others not supported yet */
+                                semantic_error("%%%s is not supported.\n", arg);
+                                return -ENOTSUP;
+                        }
                         break;
-                default:
-                        DIE_IF("Program has a bug.");
+                default:        /* Buggy case */
+                        pr_err("This program has a bug at %s:%d.\n",
+                                __FILE__, __LINE__);
+                        return -ENOTSUP;
                         break;
                 }
         }
 
         /* Exclusion check */
-        if (pp->line && pp->offset)
+        if (pp->lazy_line && pp->line) {
+                semantic_error("Lazy pattern can't be used with line number.");
+                return -EINVAL;
+        }
+
+        if (pp->lazy_line && pp->offset) {
+                semantic_error("Lazy pattern can't be used with offset.");
+                return -EINVAL;
+        }
+
+        if (pp->line && pp->offset) {
                 semantic_error("Offset can't be used with line number.");
+                return -EINVAL;
+        }
 
-        if (!pp->line && pp->file && !pp->function)
-                semantic_error("File always requires line number.");
+        if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
+                semantic_error("File always requires line number or "
+                               "lazy pattern.");
+                return -EINVAL;
+        }
 
-        if (pp->offset && !pp->function)
+        if (pp->offset && !pp->function) {
                 semantic_error("Offset requires an entry function.");
+                return -EINVAL;
+        }
 
-        if (pp->retprobe && !pp->function)
+        if (pp->retprobe && !pp->function) {
                 semantic_error("Return probe requires an entry function.");
+                return -EINVAL;
+        }
 
-        if ((pp->offset || pp->line) && pp->retprobe)
-                semantic_error("Offset/Line can't be used with return probe.");
+        if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
+                semantic_error("Offset/Line/Lazy pattern can't be used with "
+                               "return probe.");
+                return -EINVAL;
+        }
 
-        pr_debug("symbol:%s file:%s line:%d offset:%d, return:%d\n",
-                 pp->function, pp->file, pp->line, pp->offset, pp->retprobe);
+        pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
+                 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
+                 pp->lazy_line);
+        return 0;
 }
 
-/* Parse perf-probe event definition */
-void parse_perf_probe_event(const char *str, struct probe_point *pp,
-                            bool *need_dwarf)
+/* Parse perf-probe event argument */
+static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 {
-        char **argv;
-        int argc, i;
+        char *tmp, *goodname;
+        struct perf_probe_arg_field **fieldp;
+
+        pr_debug("parsing arg: %s into ", str);
+
+        tmp = strchr(str, '=');
+        if (tmp) {
+                arg->name = strndup(str, tmp - str);
+                if (arg->name == NULL)
+                        return -ENOMEM;
+                pr_debug("name:%s ", arg->name);
+                str = tmp + 1;
+        }
 
-        *need_dwarf = false;
+        tmp = strchr(str, ':');
+        if (tmp) {      /* Type setting */
+                *tmp = '\0';
+                arg->type = strdup(tmp + 1);
+                if (arg->type == NULL)
+                        return -ENOMEM;
+                pr_debug("type:%s ", arg->type);
+        }
 
-        argv = argv_split(str, &argc);
-        if (!argv)
-                die("argv_split failed.");
-        if (argc > MAX_PROBE_ARGS + 1)
-                semantic_error("Too many arguments");
+        tmp = strpbrk(str, "-.[");
+        if (!is_c_varname(str) || !tmp) {
+                /* A variable, register, symbol or special value */
+                arg->var = strdup(str);
+                if (arg->var == NULL)
+                        return -ENOMEM;
+                pr_debug("%s\n", arg->var);
+                return 0;
+        }
 
+        /* Structure fields or array element */
+        arg->var = strndup(str, tmp - str);
+        if (arg->var == NULL)
+                return -ENOMEM;
+        goodname = arg->var;
+        pr_debug("%s, ", arg->var);
+        fieldp = &arg->field;
+
+        do {
+                *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
+                if (*fieldp == NULL)
+                        return -ENOMEM;
+                if (*tmp == '[') {      /* Array */
+                        str = tmp;
+                        (*fieldp)->index = strtol(str + 1, &tmp, 0);
+                        (*fieldp)->ref = true;
+                        if (*tmp != ']' || tmp == str + 1) {
+                                semantic_error("Array index must be a"
+                                                " number.\n");
+                                return -EINVAL;
+                        }
+                        tmp++;
+                        if (*tmp == '\0')
+                                tmp = NULL;
+                } else {                /* Structure */
+                        if (*tmp == '.') {
+                                str = tmp + 1;
+                                (*fieldp)->ref = false;
+                        } else if (tmp[1] == '>') {
+                                str = tmp + 2;
+                                (*fieldp)->ref = true;
+                        } else {
+                                semantic_error("Argument parse error: %s\n",
+                                               str);
+                                return -EINVAL;
+                        }
+                        tmp = strpbrk(str, "-.[");
+                }
+                if (tmp) {
+                        (*fieldp)->name = strndup(str, tmp - str);
+                        if ((*fieldp)->name == NULL)
+                                return -ENOMEM;
+                        if (*str != '[')
+                                goodname = (*fieldp)->name;
+                        pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
+                        fieldp = &(*fieldp)->next;
+                }
+        } while (tmp);
+        (*fieldp)->name = strdup(str);
+        if ((*fieldp)->name == NULL)
+                return -ENOMEM;
+        if (*str != '[')
+                goodname = (*fieldp)->name;
+        pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
+
+        /* If no name is specified, set the last field name (not array index)*/
+        if (!arg->name) {
+                arg->name = strdup(goodname);
+                if (arg->name == NULL)
+                        return -ENOMEM;
+        }
+        return 0;
+}
+
+/* Parse perf-probe event command */
+int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
+{
+        char **argv;
+        int argc, i, ret = 0;
+
+        argv = argv_split(cmd, &argc);
+        if (!argv) {
+                pr_debug("Failed to split arguments.\n");
+                return -ENOMEM;
+        }
+        if (argc - 1 > MAX_PROBE_ARGS) {
+                semantic_error("Too many probe arguments (%d).\n", argc - 1);
+                ret = -ERANGE;
+                goto out;
+        }
         /* Parse probe point */
-        parse_perf_probe_probepoint(argv[0], pp);
-        if (pp->file || pp->line)
-                *need_dwarf = true;
+        ret = parse_perf_probe_point(argv[0], pev);
+        if (ret < 0)
+                goto out;
 
         /* Copy arguments and ensure return probe has no C argument */
-        pp->nr_args = argc - 1;
-        pp->args = zalloc(sizeof(char *) * pp->nr_args);
-        for (i = 0; i < pp->nr_args; i++) {
-                pp->args[i] = strdup(argv[i + 1]);
-                if (!pp->args[i])
-                        die("Failed to copy argument.");
-                if (is_c_varname(pp->args[i])) {
-                        if (pp->retprobe)
-                                semantic_error("You can't specify local"
-                                                " variable for kretprobe");
-                        *need_dwarf = true;
+        pev->nargs = argc - 1;
+        pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
+        if (pev->args == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        for (i = 0; i < pev->nargs && ret >= 0; i++) {
+                ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
+                if (ret >= 0 &&
+                    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
+                        semantic_error("You can't specify local variable for"
+                                       " kretprobe.\n");
+                        ret = -EINVAL;
                 }
         }
-
+out:
         argv_free(argv);
+
+        return ret;
 }
 
-/* Parse kprobe_events event into struct probe_point */
-void parse_trace_kprobe_event(const char *str, struct probe_point *pp)
+/* Return true if this perf_probe_event requires debuginfo */
+bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
 {
+        int i;
+
+        if (pev->point.file || pev->point.line || pev->point.lazy_line)
+                return true;
+
+        for (i = 0; i < pev->nargs; i++)
+                if (is_c_varname(pev->args[i].var))
+                        return true;
+
+        return false;
+}
+
+/* Parse probe_events event into struct probe_point */
+static int parse_probe_trace_command(const char *cmd,
+                                        struct probe_trace_event *tev)
+{
+        struct probe_trace_point *tp = &tev->point;
         char pr;
         char *p;
         int ret, i, argc;
         char **argv;
 
-        pr_debug("Parsing kprobe_events: %s\n", str);
-        argv = argv_split(str, &argc);
-        if (!argv)
-                die("argv_split failed.");
-        if (argc < 2)
-                semantic_error("Too less arguments.");
+        pr_debug("Parsing probe_events: %s\n", cmd);
+        argv = argv_split(cmd, &argc);
+        if (!argv) {
+                pr_debug("Failed to split arguments.\n");
+                return -ENOMEM;
+        }
+        if (argc < 2) {
+                semantic_error("Too few probe arguments.\n");
+                ret = -ERANGE;
+                goto out;
+        }
 
         /* Scan event and group name. */
         ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
-                     &pr, (float *)(void *)&pp->group,
-                     (float *)(void *)&pp->event);
-        if (ret != 3)
-                semantic_error("Failed to parse event name: %s", argv[0]);
-        pr_debug("Group:%s Event:%s probe:%c\n", pp->group, pp->event, pr);
+                     &pr, (float *)(void *)&tev->group,
+                     (float *)(void *)&tev->event);
+        if (ret != 3) {
+                semantic_error("Failed to parse event name: %s\n", argv[0]);
+                ret = -EINVAL;
+                goto out;
+        }
+        pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 
-        pp->retprobe = (pr == 'r');
+        tp->retprobe = (pr == 'r');
 
         /* Scan function name and offset */
-        ret = sscanf(argv[1], "%a[^+]+%d", (float *)(void *)&pp->function,
-                     &pp->offset);
+        ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol,
+                     &tp->offset);
         if (ret == 1)
-                pp->offset = 0;
+                tp->offset = 0;
 
-        /* kprobe_events doesn't have this information */
-        pp->line = 0;
-        pp->file = NULL;
-
-        pp->nr_args = argc - 2;
-        pp->args = zalloc(sizeof(char *) * pp->nr_args);
-        for (i = 0; i < pp->nr_args; i++) {
+        tev->nargs = argc - 2;
+        tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
+        if (tev->args == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        for (i = 0; i < tev->nargs; i++) {
                 p = strchr(argv[i + 2], '=');
                 if (p)  /* We don't need which register is assigned. */
-                        *p = '\0';
-                pp->args[i] = strdup(argv[i + 2]);
-                if (!pp->args[i])
-                        die("Failed to copy argument.");
+                        *p++ = '\0';
+                else
+                        p = argv[i + 2];
+                tev->args[i].name = strdup(argv[i + 2]);
+                /* TODO: parse regs and offset */
+                tev->args[i].value = strdup(p);
+                if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
+                        ret = -ENOMEM;
+                        goto out;
+                }
         }
-
+        ret = 0;
+out:
         argv_free(argv);
+        return ret;
 }
 
-/* Synthesize only probe point (not argument) */
-int synthesize_perf_probe_point(struct probe_point *pp)
+/* Compose only probe arg */
+int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 {
-        char *buf;
-        char offs[64] = "", line[64] = "";
+        struct perf_probe_arg_field *field = pa->field;
         int ret;
+        char *tmp = buf;
 
-        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
-        if (!buf)
-                die("Failed to allocate memory by zalloc.");
+        if (pa->name && pa->var)
+                ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
+        else
+                ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
+        if (ret <= 0)
+                goto error;
+        tmp += ret;
+        len -= ret;
+
+        while (field) {
+                if (field->name[0] == '[')
+                        ret = e_snprintf(tmp, len, "%s", field->name);
+                else
+                        ret = e_snprintf(tmp, len, "%s%s",
+                                         field->ref ? "->" : ".", field->name);
+                if (ret <= 0)
+                        goto error;
+                tmp += ret;
+                len -= ret;
+                field = field->next;
+        }
+
+        if (pa->type) {
+                ret = e_snprintf(tmp, len, ":%s", pa->type);
+                if (ret <= 0)
+                        goto error;
+                tmp += ret;
+                len -= ret;
+        }
+
+        return tmp - buf;
+error:
+        pr_debug("Failed to synthesize perf probe argument: %s",
+                 strerror(-ret));
+        return ret;
+}
+
+/* Compose only probe point (not argument) */
+static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
+{
+        char *buf, *tmp;
+        char offs[32] = "", line[32] = "", file[32] = "";
+        int ret, len;
+
+        buf = zalloc(MAX_CMDLEN);
+        if (buf == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
         if (pp->offset) {
-                ret = e_snprintf(offs, 64, "+%d", pp->offset);
+                ret = e_snprintf(offs, 32, "+%lu", pp->offset);
                 if (ret <= 0)
                         goto error;
         }
         if (pp->line) {
-                ret = e_snprintf(line, 64, ":%d", pp->line);
+                ret = e_snprintf(line, 32, ":%d", pp->line);
+                if (ret <= 0)
+                        goto error;
+        }
+        if (pp->file) {
+                len = strlen(pp->file) - 31;
+                if (len < 0)
+                        len = 0;
+                tmp = strchr(pp->file + len, '/');
+                if (!tmp)
+                        tmp = pp->file + len;
+                ret = e_snprintf(file, 32, "@%s", tmp + 1);
                 if (ret <= 0)
                         goto error;
         }
 
         if (pp->function)
-                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s", pp->function,
-                                 offs, pp->retprobe ? "%return" : "", line);
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
+                                 offs, pp->retprobe ? "%return" : "", line,
+                                 file);
         else
-                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", pp->file, line);
-        if (ret <= 0) {
+                ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
+        if (ret <= 0)
+                goto error;
+
+        return buf;
 error:
-                free(pp->probes[0]);
-                pp->probes[0] = NULL;
-        }
-        return ret;
+        pr_debug("Failed to synthesize perf probe point: %s",
+                 strerror(-ret));
+        if (buf)
+                free(buf);
+        return NULL;
 }
 
-int synthesize_perf_probe_event(struct probe_point *pp)
+#if 0
+char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 {
         char *buf;
         int i, len, ret;
 
-        len = synthesize_perf_probe_point(pp);
-        if (len < 0)
-                return 0;
+        buf = synthesize_perf_probe_point(&pev->point);
+        if (!buf)
+                return NULL;
 
-        buf = pp->probes[0];
-        for (i = 0; i < pp->nr_args; i++) {
+        len = strlen(buf);
+        for (i = 0; i < pev->nargs; i++) {
                 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
-                                 pp->args[i]);
-                if (ret <= 0)
-                        goto error;
+                                 pev->args[i].name);
+                if (ret <= 0) {
+                        free(buf);
+                        return NULL;
+                }
                 len += ret;
         }
-        pp->found = 1;
 
-        return pp->found;
-error:
-        free(pp->probes[0]);
-        pp->probes[0] = NULL;
+        return buf;
+}
+#endif
 
-        return ret;
+static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
+                                             char **buf, size_t *buflen,
+                                             int depth)
+{
+        int ret;
+        if (ref->next) {
+                depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
+                                                         buflen, depth + 1);
+                if (depth < 0)
+                        goto out;
+        }
+
+        ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
+        if (ret < 0)
+                depth = ret;
+        else {
+                *buf += ret;
+                *buflen -= ret;
+        }
+out:
+        return depth;
+
+}
+
+static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
+                                       char *buf, size_t buflen)
+{
+        struct probe_trace_arg_ref *ref = arg->ref;
+        int ret, depth = 0;
+        char *tmp = buf;
+
+        /* Argument name or separator */
+        if (arg->name)
+                ret = e_snprintf(buf, buflen, " %s=", arg->name);
+        else
+                ret = e_snprintf(buf, buflen, " ");
+        if (ret < 0)
+                return ret;
+        buf += ret;
+        buflen -= ret;
+
+        /* Special case: @XXX */
+        if (arg->value[0] == '@' && arg->ref)
+                        ref = ref->next;
+
+        /* Dereferencing arguments */
+        if (ref) {
+                depth = __synthesize_probe_trace_arg_ref(ref, &buf,
+                                                          &buflen, 1);
+                if (depth < 0)
+                        return depth;
+        }
+
+        /* Print argument value */
+        if (arg->value[0] == '@' && arg->ref)
+                ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
+                                 arg->ref->offset);
+        else
+                ret = e_snprintf(buf, buflen, "%s", arg->value);
+        if (ret < 0)
+                return ret;
+        buf += ret;
+        buflen -= ret;
+
+        /* Closing */
+        while (depth--) {
+                ret = e_snprintf(buf, buflen, ")");
+                if (ret < 0)
+                        return ret;
+                buf += ret;
+                buflen -= ret;
+        }
+        /* Print argument type */
+        if (arg->type) {
+                ret = e_snprintf(buf, buflen, ":%s", arg->type);
+                if (ret <= 0)
+                        return ret;
+                buf += ret;
+        }
+
+        return buf - tmp;
 }
 
-int synthesize_trace_kprobe_event(struct probe_point *pp)
+char *synthesize_probe_trace_command(struct probe_trace_event *tev)
 {
+        struct probe_trace_point *tp = &tev->point;
         char *buf;
         int i, len, ret;
 
-        pp->probes[0] = buf = zalloc(MAX_CMDLEN);
-        if (!buf)
-                die("Failed to allocate memory by zalloc.");
-        ret = e_snprintf(buf, MAX_CMDLEN, "%s+%d", pp->function, pp->offset);
-        if (ret <= 0)
+        buf = zalloc(MAX_CMDLEN);
+        if (buf == NULL)
+                return NULL;
+
+        len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu",
+                         tp->retprobe ? 'r' : 'p',
+                         tev->group, tev->event,
+                         tp->symbol, tp->offset);
+        if (len <= 0)
                 goto error;
-        len = ret;
 
-        for (i = 0; i < pp->nr_args; i++) {
-                ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
-                                 pp->args[i]);
+        for (i = 0; i < tev->nargs; i++) {
+                ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
+                                                  MAX_CMDLEN - len);
                 if (ret <= 0)
                         goto error;
                 len += ret;
         }
-        pp->found = 1;
 
-        return pp->found;
+        return buf;
 error:
-        free(pp->probes[0]);
-        pp->probes[0] = NULL;
+        free(buf);
+        return NULL;
+}
+
+static int convert_to_perf_probe_event(struct probe_trace_event *tev,
+                                struct perf_probe_event *pev)
+{
+        char buf[64] = "";
+        int i, ret;
+
+        /* Convert event/group name */
+        pev->event = strdup(tev->event);
+        pev->group = strdup(tev->group);
+        if (pev->event == NULL || pev->group == NULL)
+                return -ENOMEM;
+
+        /* Convert trace_point to probe_point */
+        ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
+        if (ret < 0)
+                return ret;
+
+        /* Convert trace_arg to probe_arg */
+        pev->nargs = tev->nargs;
+        pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
+        if (pev->args == NULL)
+                return -ENOMEM;
+        for (i = 0; i < tev->nargs && ret >= 0; i++) {
+                if (tev->args[i].name)
+                        pev->args[i].name = strdup(tev->args[i].name);
+                else {
+                        ret = synthesize_probe_trace_arg(&tev->args[i],
+                                                          buf, 64);
+                        pev->args[i].name = strdup(buf);
+                }
+                if (pev->args[i].name == NULL && ret >= 0)
+                        ret = -ENOMEM;
+        }
+
+        if (ret < 0)
+                clear_perf_probe_event(pev);
 
         return ret;
 }
 
-static int open_kprobe_events(int flags, int mode)
+void clear_perf_probe_event(struct perf_probe_event *pev)
+{
+        struct perf_probe_point *pp = &pev->point;
+        struct perf_probe_arg_field *field, *next;
+        int i;
+
+        if (pev->event)
+                free(pev->event);
+        if (pev->group)
+                free(pev->group);
+        if (pp->file)
+                free(pp->file);
+        if (pp->function)
+                free(pp->function);
+        if (pp->lazy_line)
+                free(pp->lazy_line);
+        for (i = 0; i < pev->nargs; i++) {
+                if (pev->args[i].name)
+                        free(pev->args[i].name);
+                if (pev->args[i].var)
+                        free(pev->args[i].var);
+                if (pev->args[i].type)
+                        free(pev->args[i].type);
+                field = pev->args[i].field;
+                while (field) {
+                        next = field->next;
+                        if (field->name)
+                                free(field->name);
+                        free(field);
+                        field = next;
+                }
+        }
+        if (pev->args)
+                free(pev->args);
+        memset(pev, 0, sizeof(*pev));
+}
+
+static void clear_probe_trace_event(struct probe_trace_event *tev)
+{
+        struct probe_trace_arg_ref *ref, *next;
+        int i;
+
+        if (tev->event)
+                free(tev->event);
+        if (tev->group)
+                free(tev->group);
+        if (tev->point.symbol)
+                free(tev->point.symbol);
+        for (i = 0; i < tev->nargs; i++) {
+                if (tev->args[i].name)
+                        free(tev->args[i].name);
+                if (tev->args[i].value)
+                        free(tev->args[i].value);
+                if (tev->args[i].type)
+                        free(tev->args[i].type);
+                ref = tev->args[i].ref;
+                while (ref) {
+                        next = ref->next;
+                        free(ref);
+                        ref = next;
+                }
+        }
+        if (tev->args)
+                free(tev->args);
+        memset(tev, 0, sizeof(*tev));
+}
+
+static int open_kprobe_events(bool readwrite)
 {
         char buf[PATH_MAX];
+        const char *__debugfs;
         int ret;
 
-        ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path);
-        if (ret < 0)
-                die("Failed to make kprobe_events path.");
+        __debugfs = debugfs_find_mountpoint();
+        if (__debugfs == NULL) {
+                pr_warning("Debugfs is not mounted.\n");
+                return -ENOENT;
+        }
+
+        ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
+        if (ret >= 0) {
+                pr_debug("Opening %s write=%d\n", buf, readwrite);
+                if (readwrite && !probe_event_dry_run)
+                        ret = open(buf, O_RDWR, O_APPEND);
+                else
+                        ret = open(buf, O_RDONLY, 0);
+        }
 
-        ret = open(buf, flags, mode);
         if (ret < 0) {
                 if (errno == ENOENT)
-                        die("kprobe_events file does not exist -"
-                            " please rebuild with CONFIG_KPROBE_TRACER.");
+                        pr_warning("kprobe_events file does not exist - please"
+                                 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
                 else
-                        die("Could not open kprobe_events file: %s",
-                            strerror(errno));
+                        pr_warning("Failed to open kprobe_events file: %s\n",
+                                   strerror(errno));
         }
         return ret;
 }
 
 /* Get raw string list of current kprobe_events */
-static struct strlist *get_trace_kprobe_event_rawlist(int fd)
+static struct strlist *get_probe_trace_command_rawlist(int fd)
 {
         int ret, idx;
         FILE *fp;
@@ -397,266 +1246,491 @@ static struct strlist *get_trace_kprobe_event_rawlist(int fd)
                 if (p[idx] == '\n')
                         p[idx] = '\0';
                 ret = strlist__add(sl, buf);
-                if (ret < 0)
-                        die("strlist__add failed: %s", strerror(-ret));
+                if (ret < 0) {
+                        pr_debug("strlist__add failed: %s\n", strerror(-ret));
+                        strlist__delete(sl);
+                        return NULL;
+                }
         }
         fclose(fp);
 
         return sl;
 }
 
-/* Free and zero clear probe_point */
-static void clear_probe_point(struct probe_point *pp)
-{
-        int i;
-
-        if (pp->event)
-                free(pp->event);
-        if (pp->group)
-                free(pp->group);
-        if (pp->function)
-                free(pp->function);
-        if (pp->file)
-                free(pp->file);
-        for (i = 0; i < pp->nr_args; i++)
-                free(pp->args[i]);
-        if (pp->args)
-                free(pp->args);
-        for (i = 0; i < pp->found; i++)
-                free(pp->probes[i]);
-        memset(pp, 0, sizeof(*pp));
-}
-
 /* Show an event */
-static void show_perf_probe_event(const char *event, const char *place,
-                                  struct probe_point *pp)
+static int show_perf_probe_event(struct perf_probe_event *pev)
 {
         int i, ret;
         char buf[128];
+        char *place;
 
-        ret = e_snprintf(buf, 128, "%s:%s", pp->group, event);
+        /* Synthesize only event probe point */
+        place = synthesize_perf_probe_point(&pev->point);
+        if (!place)
+                return -EINVAL;
+
+        ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
         if (ret < 0)
-                die("Failed to copy event: %s", strerror(-ret));
-        printf("  %-40s (on %s", buf, place);
+                return ret;
+
+        printf("  %-20s (on %s", buf, place);
 
-        if (pp->nr_args > 0) {
+        if (pev->nargs > 0) {
                 printf(" with");
-                for (i = 0; i < pp->nr_args; i++)
-                        printf(" %s", pp->args[i]);
+                for (i = 0; i < pev->nargs; i++) {
+                        ret = synthesize_perf_probe_arg(&pev->args[i],
+                                                        buf, 128);
+                        if (ret < 0)
+                                break;
+                        printf(" %s", buf);
+                }
         }
         printf(")\n");
+        free(place);
+        return ret;
 }
 
 /* List up current perf-probe events */
-void show_perf_probe_events(void)
+int show_perf_probe_events(void)
 {
-        int fd;
-        struct probe_point pp;
+        int fd, ret;
+        struct probe_trace_event tev;
+        struct perf_probe_event pev;
         struct strlist *rawlist;
         struct str_node *ent;
 
-        fd = open_kprobe_events(O_RDONLY, 0);
-        rawlist = get_trace_kprobe_event_rawlist(fd);
+        setup_pager();
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        memset(&tev, 0, sizeof(tev));
+        memset(&pev, 0, sizeof(pev));
+
+        fd = open_kprobe_events(false);
+        if (fd < 0)
+                return fd;
+
+        rawlist = get_probe_trace_command_rawlist(fd);
         close(fd);
+        if (!rawlist)
+                return -ENOENT;
 
         strlist__for_each(ent, rawlist) {
-                parse_trace_kprobe_event(ent->s, &pp);
-                /* Synthesize only event probe point */
-                synthesize_perf_probe_point(&pp);
-                /* Show an event */
-                show_perf_probe_event(pp.event, pp.probes[0], &pp);
-                clear_probe_point(&pp);
+                ret = parse_probe_trace_command(ent->s, &tev);
+                if (ret >= 0) {
+                        ret = convert_to_perf_probe_event(&tev, &pev);
+                        if (ret >= 0)
+                                ret = show_perf_probe_event(&pev);
+                }
+                clear_perf_probe_event(&pev);
+                clear_probe_trace_event(&tev);
+                if (ret < 0)
+                        break;
         }
-
         strlist__delete(rawlist);
+
+        return ret;
 }
 
 /* Get current perf-probe event names */
-static struct strlist *get_perf_event_names(int fd, bool include_group)
+static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 {
         char buf[128];
         struct strlist *sl, *rawlist;
         struct str_node *ent;
-        struct probe_point pp;
-
-        memset(&pp, 0, sizeof(pp));
-        rawlist = get_trace_kprobe_event_rawlist(fd);
+        struct probe_trace_event tev;
+        int ret = 0;
 
+        memset(&tev, 0, sizeof(tev));
+        rawlist = get_probe_trace_command_rawlist(fd);
         sl = strlist__new(true, NULL);
         strlist__for_each(ent, rawlist) {
-                parse_trace_kprobe_event(ent->s, &pp);
+                ret = parse_probe_trace_command(ent->s, &tev);
+                if (ret < 0)
+                        break;
                 if (include_group) {
-                        if (e_snprintf(buf, 128, "%s:%s", pp.group,
-                                       pp.event) < 0)
-                                die("Failed to copy group:event name.");
-                        strlist__add(sl, buf);
+                        ret = e_snprintf(buf, 128, "%s:%s", tev.group,
+                                        tev.event);
+                        if (ret >= 0)
+                                ret = strlist__add(sl, buf);
                 } else
-                        strlist__add(sl, pp.event);
-                clear_probe_point(&pp);
+                        ret = strlist__add(sl, tev.event);
+                clear_probe_trace_event(&tev);
+                if (ret < 0)
+                        break;
         }
-
         strlist__delete(rawlist);
 
+        if (ret < 0) {
+                strlist__delete(sl);
+                return NULL;
+        }
         return sl;
 }
 
-static void write_trace_kprobe_event(int fd, const char *buf)
+static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
 {
-        int ret;
+        int ret = 0;
+        char *buf = synthesize_probe_trace_command(tev);
+
+        if (!buf) {
+                pr_debug("Failed to synthesize probe trace event.\n");
+                return -EINVAL;
+        }
 
         pr_debug("Writing event: %s\n", buf);
-        ret = write(fd, buf, strlen(buf));
-        if (ret <= 0)
-                die("Failed to write event: %s", strerror(errno));
+        if (!probe_event_dry_run) {
+                ret = write(fd, buf, strlen(buf));
+                if (ret <= 0)
+                        pr_warning("Failed to write event: %s\n",
+                                   strerror(errno));
+        }
+        free(buf);
+        return ret;
 }
 
-static void get_new_event_name(char *buf, size_t len, const char *base,
-                               struct strlist *namelist, bool allow_suffix)
+static int get_new_event_name(char *buf, size_t len, const char *base,
+                              struct strlist *namelist, bool allow_suffix)
 {
         int i, ret;
 
         /* Try no suffix */
         ret = e_snprintf(buf, len, "%s", base);
-        if (ret < 0)
-                die("snprintf() failed: %s", strerror(-ret));
+        if (ret < 0) {
+                pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                return ret;
+        }
         if (!strlist__has_entry(namelist, buf))
-                return;
+                return 0;
 
         if (!allow_suffix) {
                 pr_warning("Error: event \"%s\" already exists. "
                            "(Use -f to force duplicates.)\n", base);
-                die("Can't add new event.");
+                return -EEXIST;
         }
 
         /* Try to add suffix */
         for (i = 1; i < MAX_EVENT_INDEX; i++) {
                 ret = e_snprintf(buf, len, "%s_%d", base, i);
-                if (ret < 0)
-                        die("snprintf() failed: %s", strerror(-ret));
+                if (ret < 0) {
+                        pr_debug("snprintf() failed: %s\n", strerror(-ret));
+                        return ret;
+                }
                 if (!strlist__has_entry(namelist, buf))
                         break;
         }
-        if (i == MAX_EVENT_INDEX)
-                die("Too many events are on the same function.");
+        if (i == MAX_EVENT_INDEX) {
+                pr_warning("Too many events are on the same function.\n");
+                ret = -ERANGE;
+        }
+
+        return ret;
 }
 
-void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
-                             bool force_add)
+static int __add_probe_trace_events(struct perf_probe_event *pev,
+                                     struct probe_trace_event *tevs,
+                                     int ntevs, bool allow_suffix)
 {
-        int i, j, fd;
-        struct probe_point *pp;
-        char buf[MAX_CMDLEN];
-        char event[64];
+        int i, fd, ret;
+        struct probe_trace_event *tev = NULL;
+        char buf[64];
+        const char *event, *group;
         struct strlist *namelist;
-        bool allow_suffix;
 
-        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        fd = open_kprobe_events(true);
+        if (fd < 0)
+                return fd;
         /* Get current event names */
-        namelist = get_perf_event_names(fd, false);
-
-        for (j = 0; j < nr_probes; j++) {
-                pp = probes + j;
-                if (!pp->event)
-                        pp->event = strdup(pp->function);
-                if (!pp->group)
-                        pp->group = strdup(PERFPROBE_GROUP);
-                DIE_IF(!pp->event || !pp->group);
-                /* If force_add is true, suffix search is allowed */
-                allow_suffix = force_add;
-                for (i = 0; i < pp->found; i++) {
-                        /* Get an unused new event name */
-                        get_new_event_name(event, 64, pp->event, namelist,
-                                           allow_suffix);
-                        snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s\n",
-                                 pp->retprobe ? 'r' : 'p',
-                                 pp->group, event,
-                                 pp->probes[i]);
-                        write_trace_kprobe_event(fd, buf);
-                        printf("Added new event:\n");
-                        /* Get the first parameter (probe-point) */
-                        sscanf(pp->probes[i], "%s", buf);
-                        show_perf_probe_event(event, buf, pp);
-                        /* Add added event name to namelist */
-                        strlist__add(namelist, event);
-                        /*
-                         * Probes after the first probe which comes from same
-                         * user input are always allowed to add suffix, because
-                         * there might be several addresses corresponding to
-                         * one code line.
-                         */
-                        allow_suffix = true;
+        namelist = get_probe_trace_event_names(fd, false);
+        if (!namelist) {
+                pr_debug("Failed to get current event list.\n");
+                return -EIO;
+        }
+
+        ret = 0;
+        printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
+        for (i = 0; i < ntevs; i++) {
+                tev = &tevs[i];
+                if (pev->event)
+                        event = pev->event;
+                else
+                        if (pev->point.function)
+                                event = pev->point.function;
+                        else
+                                event = tev->point.symbol;
+                if (pev->group)
+                        group = pev->group;
+                else
+                        group = PERFPROBE_GROUP;
+
+                /* Get an unused new event name */
+                ret = get_new_event_name(buf, 64, event,
+                                         namelist, allow_suffix);
+                if (ret < 0)
+                        break;
+                event = buf;
+
+                tev->event = strdup(event);
+                tev->group = strdup(group);
+                if (tev->event == NULL || tev->group == NULL) {
+                        ret = -ENOMEM;
+                        break;
                 }
+                ret = write_probe_trace_event(fd, tev);
+                if (ret < 0)
+                        break;
+                /* Add added event name to namelist */
+                strlist__add(namelist, event);
+
+                /* Trick here - save current event/group */
+                event = pev->event;
+                group = pev->group;
+                pev->event = tev->event;
+                pev->group = tev->group;
+                show_perf_probe_event(pev);
+                /* Trick here - restore current event/group */
+                pev->event = (char *)event;
+                pev->group = (char *)group;
+
+                /*
+                 * Probes after the first probe which comes from same
+                 * user input are always allowed to add suffix, because
+                 * there might be several addresses corresponding to
+                 * one code line.
+                 */
+                allow_suffix = true;
+        }
+
+        if (ret >= 0) {
+                /* Show how to use the event. */
+                printf("\nYou can now use it on all perf tools, such as:\n\n");
+                printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
+                         tev->event);
         }
-        /* Show how to use the event. */
-        printf("\nYou can now use it on all perf tools, such as:\n\n");
-        printf("\tperf record -e %s:%s -a sleep 1\n\n", PERFPROBE_GROUP, event);
 
         strlist__delete(namelist);
         close(fd);
+        return ret;
 }
 
-static void __del_trace_kprobe_event(int fd, struct str_node *ent)
+static int convert_to_probe_trace_events(struct perf_probe_event *pev,
+                                          struct probe_trace_event **tevs,
+                                          int max_tevs)
+{
+        struct symbol *sym;
+        int ret = 0, i;
+        struct probe_trace_event *tev;
+
+        /* Convert perf_probe_event with debuginfo */
+        ret = try_to_find_probe_trace_events(pev, tevs, max_tevs);
+        if (ret != 0)
+                return ret;
+
+        /* Allocate trace event buffer */
+        tev = *tevs = zalloc(sizeof(struct probe_trace_event));
+        if (tev == NULL)
+                return -ENOMEM;
+
+        /* Copy parameters */
+        tev->point.symbol = strdup(pev->point.function);
+        if (tev->point.symbol == NULL) {
+                ret = -ENOMEM;
+                goto error;
+        }
+        tev->point.offset = pev->point.offset;
+        tev->point.retprobe = pev->point.retprobe;
+        tev->nargs = pev->nargs;
+        if (tev->nargs) {
+                tev->args = zalloc(sizeof(struct probe_trace_arg)
+                                   * tev->nargs);
+                if (tev->args == NULL) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                for (i = 0; i < tev->nargs; i++) {
+                        if (pev->args[i].name) {
+                                tev->args[i].name = strdup(pev->args[i].name);
+                                if (tev->args[i].name == NULL) {
+                                        ret = -ENOMEM;
+                                        goto error;
+                                }
+                        }
+                        tev->args[i].value = strdup(pev->args[i].var);
+                        if (tev->args[i].value == NULL) {
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+                        if (pev->args[i].type) {
+                                tev->args[i].type = strdup(pev->args[i].type);
+                                if (tev->args[i].type == NULL) {
+                                        ret = -ENOMEM;
+                                        goto error;
+                                }
+                        }
+                }
+        }
+
+        /* Currently just checking function name from symbol map */
+        sym = map__find_symbol_by_name(machine.vmlinux_maps[MAP__FUNCTION],
+                                       tev->point.symbol, NULL);
+        if (!sym) {
+                pr_warning("Kernel symbol \'%s\' not found.\n",
+                           tev->point.symbol);
+                ret = -ENOENT;
+                goto error;
+        }
+
+        return 1;
+error:
+        clear_probe_trace_event(tev);
+        free(tev);
+        *tevs = NULL;
+        return ret;
+}
+
+struct __event_package {
+        struct perf_probe_event         *pev;
+        struct probe_trace_event        *tevs;
+        int                             ntevs;
+};
+
+int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
+                          bool force_add, int max_tevs)
+{
+        int i, j, ret;
+        struct __event_package *pkgs;
+
+        pkgs = zalloc(sizeof(struct __event_package) * npevs);
+        if (pkgs == NULL)
+                return -ENOMEM;
+
+        /* Init vmlinux path */
+        ret = init_vmlinux();
+        if (ret < 0) {
+                free(pkgs);
+                return ret;
+        }
+
+        /* Loop 1: convert all events */
+        for (i = 0; i < npevs; i++) {
+                pkgs[i].pev = &pevs[i];
+                /* Convert with or without debuginfo */
+                ret  = convert_to_probe_trace_events(pkgs[i].pev,
+                                                      &pkgs[i].tevs, max_tevs);
+                if (ret < 0)
+                        goto end;
+                pkgs[i].ntevs = ret;
+        }
+
+        /* Loop 2: add all events */
+        for (i = 0; i < npevs && ret >= 0; i++)
+                ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
+                                                pkgs[i].ntevs, force_add);
+end:
+        /* Loop 3: cleanup and free trace events  */
+        for (i = 0; i < npevs; i++) {
+                for (j = 0; j < pkgs[i].ntevs; j++)
+                        clear_probe_trace_event(&pkgs[i].tevs[j]);
+                free(pkgs[i].tevs);
+        }
+        free(pkgs);
+
+        return ret;
+}
+
+static int __del_trace_probe_event(int fd, struct str_node *ent)
 {
         char *p;
         char buf[128];
+        int ret;
+
+        /* Convert from perf-probe event to trace-probe event */
+        ret = e_snprintf(buf, 128, "-:%s", ent->s);
+        if (ret < 0)
+                goto error;
 
-        /* Convert from perf-probe event to trace-kprobe event */
-        if (e_snprintf(buf, 128, "-:%s", ent->s) < 0)
-                die("Failed to copy event.");
         p = strchr(buf + 2, ':');
-        if (!p)
-                die("Internal error: %s should have ':' but not.", ent->s);
+        if (!p) {
+                pr_debug("Internal error: %s should have ':' but not.\n",
+                         ent->s);
+                ret = -ENOTSUP;
+                goto error;
+        }
         *p = '/';
 
-        write_trace_kprobe_event(fd, buf);
+        pr_debug("Writing event: %s\n", buf);
+        ret = write(fd, buf, strlen(buf));
+        if (ret < 0)
+                goto error;
+
         printf("Remove event: %s\n", ent->s);
+        return 0;
+error:
+        pr_warning("Failed to delete event: %s\n", strerror(-ret));
+        return ret;
 }
 
-static void del_trace_kprobe_event(int fd, const char *group,
-                                   const char *event, struct strlist *namelist)
+static int del_trace_probe_event(int fd, const char *group,
+                                  const char *event, struct strlist *namelist)
 {
         char buf[128];
         struct str_node *ent, *n;
-        int found = 0;
+        int found = 0, ret = 0;
 
-        if (e_snprintf(buf, 128, "%s:%s", group, event) < 0)
-                die("Failed to copy event.");
+        ret = e_snprintf(buf, 128, "%s:%s", group, event);
+        if (ret < 0) {
+                pr_err("Failed to copy event.");
+                return ret;
+        }
 
         if (strpbrk(buf, "*?")) { /* Glob-exp */
                 strlist__for_each_safe(ent, n, namelist)
                         if (strglobmatch(ent->s, buf)) {
                                 found++;
-                                __del_trace_kprobe_event(fd, ent);
+                                ret = __del_trace_probe_event(fd, ent);
+                                if (ret < 0)
+                                        break;
                                 strlist__remove(namelist, ent);
                         }
         } else {
                 ent = strlist__find(namelist, buf);
                 if (ent) {
                         found++;
-                        __del_trace_kprobe_event(fd, ent);
-                        strlist__remove(namelist, ent);
+                        ret = __del_trace_probe_event(fd, ent);
+                        if (ret >= 0)
+                                strlist__remove(namelist, ent);
                 }
         }
-        if (found == 0)
-                pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf);
+        if (found == 0 && ret >= 0)
+                pr_info("Info: Event \"%s\" does not exist.\n", buf);
+
+        return ret;
 }
 
-void del_trace_kprobe_events(struct strlist *dellist)
+int del_perf_probe_events(struct strlist *dellist)
 {
-        int fd;
+        int fd, ret = 0;
         const char *group, *event;
         char *p, *str;
         struct str_node *ent;
         struct strlist *namelist;
 
-        fd = open_kprobe_events(O_RDWR, O_APPEND);
+        fd = open_kprobe_events(true);
+        if (fd < 0)
+                return fd;
+
         /* Get current event names */
-        namelist = get_perf_event_names(fd, true);
+        namelist = get_probe_trace_event_names(fd, true);
+        if (namelist == NULL)
+                return -EINVAL;
 
         strlist__for_each(ent, dellist) {
                 str = strdup(ent->s);
-                if (!str)
-                        die("Failed to copy event.");
+                if (str == NULL) {
+                        ret = -ENOMEM;
+                        break;
+                }
                 pr_debug("Parsing: %s\n", str);
                 p = strchr(str, ':');
                 if (p) {
@@ -668,10 +1742,14 @@ void del_trace_kprobe_events(struct strlist *dellist)
                         event = str;
                 }
                 pr_debug("Group: %s, Event: %s\n", group, event);
-                del_trace_kprobe_event(fd, group, event, namelist);
+                ret = del_trace_probe_event(fd, group, event, namelist);
                 free(str);
+                if (ret < 0)
+                        break;
         }
         strlist__delete(namelist);
         close(fd);
+
+        return ret;
 }
 
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index 7f1d499118c0..5af39243a25b 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -2,19 +2,120 @@
 #define _PROBE_EVENT_H
 
 #include <stdbool.h>
-#include "probe-finder.h"
 #include "strlist.h"
 
-extern void parse_perf_probe_event(const char *str, struct probe_point *pp,
-                                   bool *need_dwarf);
-extern int synthesize_perf_probe_point(struct probe_point *pp);
-extern int synthesize_perf_probe_event(struct probe_point *pp);
-extern void parse_trace_kprobe_event(const char *str, struct probe_point *pp);
-extern int synthesize_trace_kprobe_event(struct probe_point *pp);
-extern void add_trace_kprobe_events(struct probe_point *probes, int nr_probes,
-                                    bool force_add);
-extern void del_trace_kprobe_events(struct strlist *dellist);
-extern void show_perf_probe_events(void);
+extern bool probe_event_dry_run;
+
+/* kprobe-tracer tracing point */
+struct probe_trace_point {
+        char            *symbol;        /* Base symbol */
+        unsigned long   offset;         /* Offset from symbol */
+        bool            retprobe;       /* Return probe flag */
+};
+
+/* probe-tracer tracing argument referencing offset */
+struct probe_trace_arg_ref {
+        struct probe_trace_arg_ref      *next;  /* Next reference */
+        long                            offset; /* Offset value */
+};
+
+/* kprobe-tracer tracing argument */
+struct probe_trace_arg {
+        char                            *name;  /* Argument name */
+        char                            *value; /* Base value */
+        char                            *type;  /* Type name */
+        struct probe_trace_arg_ref      *ref;   /* Referencing offset */
+};
+
+/* kprobe-tracer tracing event (point + arg) */
+struct probe_trace_event {
+        char                            *event; /* Event name */
+        char                            *group; /* Group name */
+        struct probe_trace_point        point;  /* Trace point */
+        int                             nargs;  /* Number of args */
+        struct probe_trace_arg          *args;  /* Arguments */
+};
+
+/* Perf probe probing point */
+struct perf_probe_point {
+        char            *file;          /* File path */
+        char            *function;      /* Function name */
+        int             line;           /* Line number */
+        bool            retprobe;       /* Return probe flag */
+        char            *lazy_line;     /* Lazy matching pattern */
+        unsigned long   offset;         /* Offset from function entry */
+};
+
+/* Perf probe probing argument field chain */
+struct perf_probe_arg_field {
+        struct perf_probe_arg_field     *next;  /* Next field */
+        char                            *name;  /* Name of the field */
+        long                            index;  /* Array index number */
+        bool                            ref;    /* Referencing flag */
+};
+
+/* Perf probe probing argument */
+struct perf_probe_arg {
+        char                            *name;  /* Argument name */
+        char                            *var;   /* Variable name */
+        char                            *type;  /* Type name */
+        struct perf_probe_arg_field     *field; /* Structure fields */
+};
+
+/* Perf probe probing event (point + arg) */
+struct perf_probe_event {
+        char                    *event; /* Event name */
+        char                    *group; /* Group name */
+        struct perf_probe_point point;  /* Probe point */
+        int                     nargs;  /* Number of arguments */
+        struct perf_probe_arg   *args;  /* Arguments */
+};
+
+
+/* Line number container */
+struct line_node {
+        struct list_head        list;
+        int                     line;
+};
+
+/* Line range */
+struct line_range {
+        char                    *file;          /* File name */
+        char                    *function;      /* Function name */
+        int                     start;          /* Start line number */
+        int                     end;            /* End line number */
+        int                     offset;         /* Start line offset */
+        char                    *path;          /* Real path name */
+        char                    *comp_dir;      /* Compile directory */
+        struct list_head        line_list;      /* Visible lines */
+};
+
+/* Command string to events */
+extern int parse_perf_probe_command(const char *cmd,
+                                    struct perf_probe_event *pev);
+
+/* Events to command string */
+extern char *synthesize_perf_probe_command(struct perf_probe_event *pev);
+extern char *synthesize_probe_trace_command(struct probe_trace_event *tev);
+extern int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf,
+                                     size_t len);
+
+/* Check the perf_probe_event needs debuginfo */
+extern bool perf_probe_event_need_dwarf(struct perf_probe_event *pev);
+
+/* Release event contents */
+extern void clear_perf_probe_event(struct perf_probe_event *pev);
+
+/* Command string to line-range */
+extern int parse_line_range_desc(const char *cmd, struct line_range *lr);
+
+
+extern int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
+                                 bool force_add, int max_probe_points);
+extern int del_perf_probe_events(struct strlist *dellist);
+extern int show_perf_probe_events(void);
+extern int show_line_range(struct line_range *lr);
+
 
 /* Maximum index number of event-name postfix */
 #define MAX_EVENT_INDEX 1024
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 4b852c0d16a5..32b81f707ff5 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -31,72 +31,16 @@
 #include <string.h>
 #include <stdarg.h>
 #include <ctype.h>
+#include <dwarf-regs.h>
 
 #include "event.h"
 #include "debug.h"
 #include "util.h"
+#include "symbol.h"
 #include "probe-finder.h"
 
-
-/* Dwarf_Die Linkage to parent Die */
-struct die_link {
-        struct die_link *parent;        /* Parent die */
-        Dwarf_Die die;                  /* Current die */
-};
-
-static Dwarf_Debug __dw_debug;
-static Dwarf_Error __dw_error;
-
-/*
- * Generic dwarf analysis helpers
- */
-
-#define X86_32_MAX_REGS 8
-const char *x86_32_regs_table[X86_32_MAX_REGS] = {
-        "%ax",
-        "%cx",
-        "%dx",
-        "%bx",
-        "$stack",       /* Stack address instead of %sp */
-        "%bp",
-        "%si",
-        "%di",
-};
-
-#define X86_64_MAX_REGS 16
-const char *x86_64_regs_table[X86_64_MAX_REGS] = {
-        "%ax",
-        "%dx",
-        "%cx",
-        "%bx",
-        "%si",
-        "%di",
-        "%bp",
-        "%sp",
-        "%r8",
-        "%r9",
-        "%r10",
-        "%r11",
-        "%r12",
-        "%r13",
-        "%r14",
-        "%r15",
-};
-
-/* TODO: switching by dwarf address size */
-#ifdef __x86_64__
-#define ARCH_MAX_REGS X86_64_MAX_REGS
-#define arch_regs_table x86_64_regs_table
-#else
-#define ARCH_MAX_REGS X86_32_MAX_REGS
-#define arch_regs_table x86_32_regs_table
-#endif
-
-/* Return architecture dependent register string (for kprobe-tracer) */
-static const char *get_arch_regstr(unsigned int n)
-{
-        return (n <= ARCH_MAX_REGS) ? arch_regs_table[n] : NULL;
-}
+/* Kprobe tracer basic type is up to u64 */
+#define MAX_BASIC_TYPE_BITS     64
 
 /*
  * Compare the tail of two strings.
@@ -113,618 +57,1401 @@ static int strtailcmp(const char *s1, const char *s2)
         return 0;
 }
 
-/* Find the fileno of the target file. */
-static Dwarf_Unsigned cu_find_fileno(Dwarf_Die cu_die, const char *fname)
+/* Line number list operations */
+
+/* Add a line to line number list */
+static int line_list__add_line(struct list_head *head, int line)
+{
+        struct line_node *ln;
+        struct list_head *p;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry_reverse(ln, head, list) {
+                if (ln->line < line) {
+                        p = &ln->list;
+                        goto found;
+                } else if (ln->line == line)    /* Already exist */
+                        return 1;
+        }
+        /* List is empty, or the smallest entry */
+        p = head;
+found:
+        pr_debug("line list: add a line %u\n", line);
+        ln = zalloc(sizeof(struct line_node));
+        if (ln == NULL)
+                return -ENOMEM;
+        ln->line = line;
+        INIT_LIST_HEAD(&ln->list);
+        list_add(&ln->list, p);
+        return 0;
+}
+
+/* Check if the line in line number list */
+static int line_list__has_line(struct list_head *head, int line)
 {
-        Dwarf_Signed cnt, i;
-        Dwarf_Unsigned found = 0;
-        char **srcs;
+        struct line_node *ln;
+
+        /* Reverse search, because new line will be the last one */
+        list_for_each_entry(ln, head, list)
+                if (ln->line == line)
+                        return 1;
+
+        return 0;
+}
+
+/* Init line number list */
+static void line_list__init(struct list_head *head)
+{
+        INIT_LIST_HEAD(head);
+}
+
+/* Free line number list */
+static void line_list__free(struct list_head *head)
+{
+        struct line_node *ln;
+        while (!list_empty(head)) {
+                ln = list_first_entry(head, struct line_node, list);
+                list_del(&ln->list);
+                free(ln);
+        }
+}
+
+/* Dwarf wrappers */
+
+/* Find the realpath of the target file. */
+static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
+{
+        Dwarf_Files *files;
+        size_t nfiles, i;
+        const char *src = NULL;
         int ret;
 
         if (!fname)
-                return 0;
+                return NULL;
 
-        ret = dwarf_srcfiles(cu_die, &srcs, &cnt, &__dw_error);
-        if (ret == DW_DLV_OK) {
-                for (i = 0; i < cnt && !found; i++) {
-                        if (strtailcmp(srcs[i], fname) == 0)
-                                found = i + 1;
-                        dwarf_dealloc(__dw_debug, srcs[i], DW_DLA_STRING);
-                }
-                for (; i < cnt; i++)
-                        dwarf_dealloc(__dw_debug, srcs[i], DW_DLA_STRING);
-                dwarf_dealloc(__dw_debug, srcs, DW_DLA_LIST);
+        ret = dwarf_getsrcfiles(cu_die, &files, &nfiles);
+        if (ret != 0)
+                return NULL;
+
+        for (i = 0; i < nfiles; i++) {
+                src = dwarf_filesrc(files, i, NULL, NULL);
+                if (strtailcmp(src, fname) == 0)
+                        break;
         }
-        if (found)
-                pr_debug("found fno: %d\n", (int)found);
-        return found;
+        if (i == nfiles)
+                return NULL;
+        return src;
 }
 
-/* Compare diename and tname */
-static int die_compare_name(Dwarf_Die dw_die, const char *tname)
+/* Get DW_AT_comp_dir (should be NULL with older gcc) */
+static const char *cu_get_comp_dir(Dwarf_Die *cu_die)
 {
-        char *name;
-        int ret;
-        ret = dwarf_diename(dw_die, &name, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_OK) {
-                ret = strcmp(tname, name);
-                dwarf_dealloc(__dw_debug, name, DW_DLA_STRING);
-        } else
-                ret = -1;
-        return ret;
+        Dwarf_Attribute attr;
+        if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
+                return NULL;
+        return dwarf_formstring(&attr);
 }
 
-/* Check the address is in the subprogram(function). */
-static int die_within_subprogram(Dwarf_Die sp_die, Dwarf_Addr addr,
-                                 Dwarf_Signed *offs)
+/* Compare diename and tname */
+static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 {
-        Dwarf_Addr lopc, hipc;
-        int ret;
+        const char *name;
+        name = dwarf_diename(dw_die);
+        return name ? (strcmp(tname, name) == 0) : false;
+}
 
-        /* TODO: check ranges */
-        ret = dwarf_lowpc(sp_die, &lopc, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_NO_ENTRY)
-                return 0;
-        ret = dwarf_highpc(sp_die, &hipc, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        if (lopc <= addr && addr < hipc) {
-                *offs = addr - lopc;
-                return 1;
-        } else
-                return 0;
+/* Get type die, but skip qualifiers and typedef */
+static Dwarf_Die *die_get_real_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem)
+{
+        Dwarf_Attribute attr;
+        int tag;
+
+        do {
+                if (dwarf_attr(vr_die, DW_AT_type, &attr) == NULL ||
+                    dwarf_formref_die(&attr, die_mem) == NULL)
+                        return NULL;
+
+                tag = dwarf_tag(die_mem);
+                vr_die = die_mem;
+        } while (tag == DW_TAG_const_type ||
+                 tag == DW_TAG_restrict_type ||
+                 tag == DW_TAG_volatile_type ||
+                 tag == DW_TAG_shared_type ||
+                 tag == DW_TAG_typedef);
+
+        return die_mem;
 }
 
-/* Check the die is inlined function */
-static Dwarf_Bool die_inlined_subprogram(Dwarf_Die dw_die)
+static bool die_is_signed_type(Dwarf_Die *tp_die)
 {
-        /* TODO: check strictly */
-        Dwarf_Bool inl;
-        int ret;
+        Dwarf_Attribute attr;
+        Dwarf_Word ret;
+
+        if (dwarf_attr(tp_die, DW_AT_encoding, &attr) == NULL ||
+            dwarf_formudata(&attr, &ret) != 0)
+                return false;
 
-        ret = dwarf_hasattr(dw_die, DW_AT_inline, &inl, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        return inl;
+        return (ret == DW_ATE_signed_char || ret == DW_ATE_signed ||
+                ret == DW_ATE_signed_fixed);
 }
 
-/* Get the offset of abstruct_origin */
-static Dwarf_Off die_get_abstract_origin(Dwarf_Die dw_die)
+static int die_get_byte_size(Dwarf_Die *tp_die)
 {
         Dwarf_Attribute attr;
-        Dwarf_Off cu_offs;
-        int ret;
+        Dwarf_Word ret;
 
-        ret = dwarf_attr(dw_die, DW_AT_abstract_origin, &attr, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        ret = dwarf_formref(attr, &cu_offs, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
-        return cu_offs;
+        if (dwarf_attr(tp_die, DW_AT_byte_size, &attr) == NULL ||
+            dwarf_formudata(&attr, &ret) != 0)
+                return 0;
+
+        return (int)ret;
 }
 
-/* Get entry pc(or low pc, 1st entry of ranges)  of the die */
-static Dwarf_Addr die_get_entrypc(Dwarf_Die dw_die)
+/* Get data_member_location offset */
+static int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
 {
         Dwarf_Attribute attr;
-        Dwarf_Addr addr;
-        Dwarf_Off offs;
-        Dwarf_Ranges *ranges;
-        Dwarf_Signed cnt;
+        Dwarf_Op *expr;
+        size_t nexpr;
         int ret;
 
-        /* Try to get entry pc */
-        ret = dwarf_attr(dw_die, DW_AT_entry_pc, &attr, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_OK) {
-                ret = dwarf_formaddr(attr, &addr, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
-                dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
-                return addr;
-        }
-
-        /* Try to get low pc */
-        ret = dwarf_lowpc(dw_die, &addr, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_OK)
-                return addr;
-
-        /* Try to get ranges */
-        ret = dwarf_attr(dw_die, DW_AT_ranges, &attr, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        ret = dwarf_formref(attr, &offs, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        ret = dwarf_get_ranges(__dw_debug, offs, &ranges, &cnt, NULL,
-                                &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        addr = ranges[0].dwr_addr1;
-        dwarf_ranges_dealloc(__dw_debug, ranges, cnt);
-        return addr;
+        if (dwarf_attr(mb_die, DW_AT_data_member_location, &attr) == NULL)
+                return -ENOENT;
+
+        if (dwarf_formudata(&attr, offs) != 0) {
+                /* DW_AT_data_member_location should be DW_OP_plus_uconst */
+                ret = dwarf_getlocation(&attr, &expr, &nexpr);
+                if (ret < 0 || nexpr == 0)
+                        return -ENOENT;
+
+                if (expr[0].atom != DW_OP_plus_uconst || nexpr != 1) {
+                        pr_debug("Unable to get offset:Unexpected OP %x (%zd)\n",
+                                 expr[0].atom, nexpr);
+                        return -ENOTSUP;
+                }
+                *offs = (Dwarf_Word)expr[0].number;
+        }
+        return 0;
 }
 
-/*
- * Search a Die from Die tree.
- * Note: cur_link->die should be deallocated in this function.
- */
-static int __search_die_tree(struct die_link *cur_link,
-                             int (*die_cb)(struct die_link *, void *),
-                             void *data)
+/* Return values for die_find callbacks */
+enum {
+        DIE_FIND_CB_FOUND = 0,          /* End of Search */
+        DIE_FIND_CB_CHILD = 1,          /* Search only children */
+        DIE_FIND_CB_SIBLING = 2,        /* Search only siblings */
+        DIE_FIND_CB_CONTINUE = 3,       /* Search children and siblings */
+};
+
+/* Search a child die */
+static Dwarf_Die *die_find_child(Dwarf_Die *rt_die,
+                                 int (*callback)(Dwarf_Die *, void *),
+                                 void *data, Dwarf_Die *die_mem)
 {
-        Dwarf_Die new_die;
-        struct die_link new_link;
+        Dwarf_Die child_die;
         int ret;
 
-        if (!die_cb)
-                return 0;
+        ret = dwarf_child(rt_die, die_mem);
+        if (ret != 0)
+                return NULL;
 
-        /* Check current die */
-        while (!(ret = die_cb(cur_link, data))) {
-                /* Check child die */
-                ret = dwarf_child(cur_link->die, &new_die, &__dw_error);
-                DIE_IF(ret == DW_DLV_ERROR);
-                if (ret == DW_DLV_OK) {
-                        new_link.parent = cur_link;
-                        new_link.die = new_die;
-                        ret = __search_die_tree(&new_link, die_cb, data);
-                        if (ret)
-                                break;
-                }
-
-                /* Move to next sibling */
-                ret = dwarf_siblingof(__dw_debug, cur_link->die, &new_die,
-                                      &__dw_error);
-                DIE_IF(ret == DW_DLV_ERROR);
-                dwarf_dealloc(__dw_debug, cur_link->die, DW_DLA_DIE);
-                cur_link->die = new_die;
-                if (ret == DW_DLV_NO_ENTRY)
-                        return 0;
-        }
-        dwarf_dealloc(__dw_debug, cur_link->die, DW_DLA_DIE);
-        return ret;
+        do {
+                ret = callback(die_mem, data);
+                if (ret == DIE_FIND_CB_FOUND)
+                        return die_mem;
+
+                if ((ret & DIE_FIND_CB_CHILD) &&
+                    die_find_child(die_mem, callback, data, &child_die)) {
+                        memcpy(die_mem, &child_die, sizeof(Dwarf_Die));
+                        return die_mem;
+                }
+        } while ((ret & DIE_FIND_CB_SIBLING) &&
+                 dwarf_siblingof(die_mem, die_mem) == 0);
+
+        return NULL;
 }
 
-/* Search a die in its children's die tree */
-static int search_die_from_children(Dwarf_Die parent_die,
-                                    int (*die_cb)(struct die_link *, void *),
-                                    void *data)
+struct __addr_die_search_param {
+        Dwarf_Addr      addr;
+        Dwarf_Die       *die_mem;
+};
+
+static int __die_search_func_cb(Dwarf_Die *fn_die, void *data)
 {
-        struct die_link new_link;
-        int ret;
+        struct __addr_die_search_param *ad = data;
+
+        if (dwarf_tag(fn_die) == DW_TAG_subprogram &&
+            dwarf_haspc(fn_die, ad->addr)) {
+                memcpy(ad->die_mem, fn_die, sizeof(Dwarf_Die));
+                return DWARF_CB_ABORT;
+        }
+        return DWARF_CB_OK;
+}
 
-        new_link.parent = NULL;
-        ret = dwarf_child(parent_die, &new_link.die, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_OK)
-                return __search_die_tree(&new_link, die_cb, data);
+/* Search a real subprogram including this line, */
+static Dwarf_Die *die_find_real_subprogram(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                                           Dwarf_Die *die_mem)
+{
+        struct __addr_die_search_param ad;
+        ad.addr = addr;
+        ad.die_mem = die_mem;
+        /* dwarf_getscopes can't find subprogram. */
+        if (!dwarf_getfuncs(cu_die, __die_search_func_cb, &ad, 0))
+                return NULL;
         else
-                return 0;
+                return die_mem;
 }
 
-/* Find a locdesc corresponding to the address */
-static int attr_get_locdesc(Dwarf_Attribute attr, Dwarf_Locdesc *desc,
-                            Dwarf_Addr addr)
+/* die_find callback for inline function search */
+static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data)
 {
-        Dwarf_Signed lcnt;
-        Dwarf_Locdesc **llbuf;
-        int ret, i;
+        Dwarf_Addr *addr = data;
 
-        ret = dwarf_loclist_n(attr, &llbuf, &lcnt, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        ret = DW_DLV_NO_ENTRY;
-        for (i = 0; i < lcnt; ++i) {
-                if (llbuf[i]->ld_lopc <= addr &&
-                    llbuf[i]->ld_hipc > addr) {
-                        memcpy(desc, llbuf[i], sizeof(Dwarf_Locdesc));
-                        desc->ld_s =
-                                malloc(sizeof(Dwarf_Loc) * llbuf[i]->ld_cents);
-                        DIE_IF(desc->ld_s == NULL);
-                        memcpy(desc->ld_s, llbuf[i]->ld_s,
-                                sizeof(Dwarf_Loc) * llbuf[i]->ld_cents);
-                        ret = DW_DLV_OK;
-                        break;
-                }
-                dwarf_dealloc(__dw_debug, llbuf[i]->ld_s, DW_DLA_LOC_BLOCK);
-                dwarf_dealloc(__dw_debug, llbuf[i], DW_DLA_LOCDESC);
-        }
-        /* Releasing loop */
-        for (; i < lcnt; ++i) {
-                dwarf_dealloc(__dw_debug, llbuf[i]->ld_s, DW_DLA_LOC_BLOCK);
-                dwarf_dealloc(__dw_debug, llbuf[i], DW_DLA_LOCDESC);
-        }
-        dwarf_dealloc(__dw_debug, llbuf, DW_DLA_LIST);
-        return ret;
+        if (dwarf_tag(die_mem) == DW_TAG_inlined_subroutine &&
+            dwarf_haspc(die_mem, *addr))
+                return DIE_FIND_CB_FOUND;
+
+        return DIE_FIND_CB_CONTINUE;
 }
 
-/* Get decl_file attribute value (file number) */
-static Dwarf_Unsigned die_get_decl_file(Dwarf_Die sp_die)
+/* Similar to dwarf_getfuncs, but returns inlined_subroutine if exists. */
+static Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
+                                      Dwarf_Die *die_mem)
 {
-        Dwarf_Attribute attr;
-        Dwarf_Unsigned fno;
-        int ret;
+        return die_find_child(sp_die, __die_find_inline_cb, &addr, die_mem);
+}
+
+static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
+{
+        const char *name = data;
+        int tag;
 
-        ret = dwarf_attr(sp_die, DW_AT_decl_file, &attr, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_formudata(attr, &fno, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
-        return fno;
+        tag = dwarf_tag(die_mem);
+        if ((tag == DW_TAG_formal_parameter ||
+             tag == DW_TAG_variable) &&
+            die_compare_name(die_mem, name))
+                return DIE_FIND_CB_FOUND;
+
+        return DIE_FIND_CB_CONTINUE;
 }
 
-/* Get decl_line attribute value (line number) */
-static Dwarf_Unsigned die_get_decl_line(Dwarf_Die sp_die)
+/* Find a variable called 'name' */
+static Dwarf_Die *die_find_variable(Dwarf_Die *sp_die, const char *name,
+                                    Dwarf_Die *die_mem)
 {
-        Dwarf_Attribute attr;
-        Dwarf_Unsigned lno;
-        int ret;
+        return die_find_child(sp_die, __die_find_variable_cb, (void *)name,
+                              die_mem);
+}
 
-        ret = dwarf_attr(sp_die, DW_AT_decl_line, &attr, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_formudata(attr, &lno, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
-        return lno;
+static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
+{
+        const char *name = data;
+
+        if ((dwarf_tag(die_mem) == DW_TAG_member) &&
+            die_compare_name(die_mem, name))
+                return DIE_FIND_CB_FOUND;
+
+        return DIE_FIND_CB_SIBLING;
+}
+
+/* Find a member called 'name' */
+static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
+                                  Dwarf_Die *die_mem)
+{
+        return die_find_child(st_die, __die_find_member_cb, (void *)name,
+                              die_mem);
 }
 
 /*
  * Probe finder related functions
  */
 
+static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
+{
+        struct probe_trace_arg_ref *ref;
+        ref = zalloc(sizeof(struct probe_trace_arg_ref));
+        if (ref != NULL)
+                ref->offset = offs;
+        return ref;
+}
+
 /* Show a location */
-static void show_location(Dwarf_Loc *loc, struct probe_finder *pf)
+static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf)
 {
-        Dwarf_Small op;
-        Dwarf_Unsigned regn;
-        Dwarf_Signed offs;
-        int deref = 0, ret;
+        Dwarf_Attribute attr;
+        Dwarf_Op *op;
+        size_t nops;
+        unsigned int regn;
+        Dwarf_Word offs = 0;
+        bool ref = false;
         const char *regs;
+        struct probe_trace_arg *tvar = pf->tvar;
+        int ret;
 
-        op = loc->lr_atom;
+        /* TODO: handle more than 1 exprs */
+        if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL ||
+            dwarf_getlocation_addr(&attr, pf->addr, &op, &nops, 1) <= 0 ||
+            nops == 0) {
+                /* TODO: Support const_value */
+                pr_err("Failed to find the location of %s at this address.\n"
+                       " Perhaps, it has been optimized out.\n", pf->pvar->var);
+                return -ENOENT;
+        }
+
+        if (op->atom == DW_OP_addr) {
+                /* Static variables on memory (not stack), make @varname */
+                ret = strlen(dwarf_diename(vr_die));
+                tvar->value = zalloc(ret + 2);
+                if (tvar->value == NULL)
+                        return -ENOMEM;
+                snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
+                tvar->ref = alloc_trace_arg_ref((long)offs);
+                if (tvar->ref == NULL)
+                        return -ENOMEM;
+                return 0;
+        }
 
         /* If this is based on frame buffer, set the offset */
-        if (op == DW_OP_fbreg) {
-                deref = 1;
-                offs = (Dwarf_Signed)loc->lr_number;
-                op = pf->fbloc.ld_s[0].lr_atom;
-                loc = &pf->fbloc.ld_s[0];
-        } else
-                offs = 0;
-
-        if (op >= DW_OP_breg0 && op <= DW_OP_breg31) {
-                regn = op - DW_OP_breg0;
-                offs += (Dwarf_Signed)loc->lr_number;
-                deref = 1;
-        } else if (op >= DW_OP_reg0 && op <= DW_OP_reg31) {
-                regn = op - DW_OP_reg0;
-        } else if (op == DW_OP_bregx) {
-                regn = loc->lr_number;
-                offs += (Dwarf_Signed)loc->lr_number2;
-                deref = 1;
-        } else if (op == DW_OP_regx) {
-                regn = loc->lr_number;
-        } else
-                die("Dwarf_OP %d is not supported.\n", op);
+        if (op->atom == DW_OP_fbreg) {
+                if (pf->fb_ops == NULL) {
+                        pr_warning("The attribute of frame base is not "
+                                   "supported.\n");
+                        return -ENOTSUP;
+                }
+                ref = true;
+                offs = op->number;
+                op = &pf->fb_ops[0];
+        }
+
+        if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
+                regn = op->atom - DW_OP_breg0;
+                offs += op->number;
+                ref = true;
+        } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
+                regn = op->atom - DW_OP_reg0;
+        } else if (op->atom == DW_OP_bregx) {
+                regn = op->number;
+                offs += op->number2;
+                ref = true;
+        } else if (op->atom == DW_OP_regx) {
+                regn = op->number;
+        } else {
+                pr_warning("DW_OP %x is not supported.\n", op->atom);
+                return -ENOTSUP;
+        }
 
         regs = get_arch_regstr(regn);
-        if (!regs)
-                die("%lld exceeds max register number.\n", regn);
+        if (!regs) {
+                pr_warning("Mapping for DWARF register number %u missing on this architecture.", regn);
+                return -ERANGE;
+        }
 
-        if (deref)
-                ret = snprintf(pf->buf, pf->len,
-                                 " %s=%+lld(%s)", pf->var, offs, regs);
-        else
-                ret = snprintf(pf->buf, pf->len, " %s=%s", pf->var, regs);
-        DIE_IF(ret < 0);
-        DIE_IF(ret >= pf->len);
+        tvar->value = strdup(regs);
+        if (tvar->value == NULL)
+                return -ENOMEM;
+
+        if (ref) {
+                tvar->ref = alloc_trace_arg_ref((long)offs);
+                if (tvar->ref == NULL)
+                        return -ENOMEM;
+        }
+        return 0;
 }
 
-/* Show a variables in kprobe event format */
-static void show_variable(Dwarf_Die vr_die, struct probe_finder *pf)
+static int convert_variable_type(Dwarf_Die *vr_die,
+                                 struct probe_trace_arg *tvar,
+                                 const char *cast)
 {
-        Dwarf_Attribute attr;
-        Dwarf_Locdesc ld;
+        struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
+        Dwarf_Die type;
+        char buf[16];
         int ret;
 
-        ret = dwarf_attr(vr_die, DW_AT_location, &attr, &__dw_error);
-        if (ret != DW_DLV_OK)
-                goto error;
-        ret = attr_get_locdesc(attr, &ld, (pf->addr - pf->cu_base));
-        if (ret != DW_DLV_OK)
-                goto error;
-        /* TODO? */
-        DIE_IF(ld.ld_cents != 1);
-        show_location(&ld.ld_s[0], pf);
-        free(ld.ld_s);
-        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
-        return ;
-error:
-        die("Failed to find the location of %s at this address.\n"
-            " Perhaps, it has been optimized out.\n", pf->var);
-}
-
-static int variable_callback(struct die_link *dlink, void *data)
-{
-        struct probe_finder *pf = (struct probe_finder *)data;
-        Dwarf_Half tag;
-        int ret;
+        /* TODO: check all types */
+        if (cast && strcmp(cast, "string") != 0) {
+                /* Non string type is OK */
+                tvar->type = strdup(cast);
+                return (tvar->type == NULL) ? -ENOMEM : 0;
+        }
 
-        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if ((tag == DW_TAG_formal_parameter ||
-             tag == DW_TAG_variable) &&
-            (die_compare_name(dlink->die, pf->var) == 0)) {
-                show_variable(dlink->die, pf);
-                return 1;
+        if (die_get_real_type(vr_die, &type) == NULL) {
+                pr_warning("Failed to get a type information of %s.\n",
+                           dwarf_diename(vr_die));
+                return -ENOENT;
+        }
+
+        pr_debug("%s type is %s.\n",
+                 dwarf_diename(vr_die), dwarf_diename(&type));
+
+        if (cast && strcmp(cast, "string") == 0) {      /* String type */
+                ret = dwarf_tag(&type);
+                if (ret != DW_TAG_pointer_type &&
+                    ret != DW_TAG_array_type) {
+                        pr_warning("Failed to cast into string: "
+                                   "%s(%s) is not a pointer nor array.",
+                                   dwarf_diename(vr_die), dwarf_diename(&type));
+                        return -EINVAL;
+                }
+                if (ret == DW_TAG_pointer_type) {
+                        if (die_get_real_type(&type, &type) == NULL) {
+                                pr_warning("Failed to get a type information.");
+                                return -ENOENT;
+                        }
+                        while (*ref_ptr)
+                                ref_ptr = &(*ref_ptr)->next;
+                        /* Add new reference with offset +0 */
+                        *ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
+                        if (*ref_ptr == NULL) {
+                                pr_warning("Out of memory error\n");
+                                return -ENOMEM;
+                        }
+                }
+                if (!die_compare_name(&type, "char") &&
+                    !die_compare_name(&type, "unsigned char")) {
+                        pr_warning("Failed to cast into string: "
+                                   "%s is not (unsigned) char *.",
+                                   dwarf_diename(vr_die));
+                        return -EINVAL;
+                }
+                tvar->type = strdup(cast);
+                return (tvar->type == NULL) ? -ENOMEM : 0;
+        }
+
+        ret = die_get_byte_size(&type) * 8;
+        if (ret) {
+                /* Check the bitwidth */
+                if (ret > MAX_BASIC_TYPE_BITS) {
+                        pr_info("%s exceeds max-bitwidth."
+                                " Cut down to %d bits.\n",
+                                dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
+                        ret = MAX_BASIC_TYPE_BITS;
+                }
+
+                ret = snprintf(buf, 16, "%c%d",
+                               die_is_signed_type(&type) ? 's' : 'u', ret);
+                if (ret < 0 || ret >= 16) {
+                        if (ret >= 16)
+                                ret = -E2BIG;
+                        pr_warning("Failed to convert variable type: %s\n",
+                                   strerror(-ret));
+                        return ret;
+                }
+                tvar->type = strdup(buf);
+                if (tvar->type == NULL)
+                        return -ENOMEM;
         }
-        /* TODO: Support struct members and arrays */
         return 0;
 }
 
-/* Find a variable in a subprogram die */
-static void find_variable(Dwarf_Die sp_die, struct probe_finder *pf)
+static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
+                                    struct perf_probe_arg_field *field,
+                                    struct probe_trace_arg_ref **ref_ptr,
+                                    Dwarf_Die *die_mem)
 {
-        int ret;
+        struct probe_trace_arg_ref *ref = *ref_ptr;
+        Dwarf_Die type;
+        Dwarf_Word offs;
+        int ret, tag;
+
+        pr_debug("converting %s in %s\n", field->name, varname);
+        if (die_get_real_type(vr_die, &type) == NULL) {
+                pr_warning("Failed to get the type of %s.\n", varname);
+                return -ENOENT;
+        }
+        pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
+        tag = dwarf_tag(&type);
+
+        if (field->name[0] == '[' &&
+            (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
+                if (field->next)
+                        /* Save original type for next field */
+                        memcpy(die_mem, &type, sizeof(*die_mem));
+                /* Get the type of this array */
+                if (die_get_real_type(&type, &type) == NULL) {
+                        pr_warning("Failed to get the type of %s.\n", varname);
+                        return -ENOENT;
+                }
+                pr_debug2("Array real type: (%x)\n",
+                         (unsigned)dwarf_dieoffset(&type));
+                if (tag == DW_TAG_pointer_type) {
+                        ref = zalloc(sizeof(struct probe_trace_arg_ref));
+                        if (ref == NULL)
+                                return -ENOMEM;
+                        if (*ref_ptr)
+                                (*ref_ptr)->next = ref;
+                        else
+                                *ref_ptr = ref;
+                }
+                ref->offset += die_get_byte_size(&type) * field->index;
+                if (!field->next)
+                        /* Save vr_die for converting types */
+                        memcpy(die_mem, vr_die, sizeof(*die_mem));
+                goto next;
+        } else if (tag == DW_TAG_pointer_type) {
+                /* Check the pointer and dereference */
+                if (!field->ref) {
+                        pr_err("Semantic error: %s must be referred by '->'\n",
+                               field->name);
+                        return -EINVAL;
+                }
+                /* Get the type pointed by this pointer */
+                if (die_get_real_type(&type, &type) == NULL) {
+                        pr_warning("Failed to get the type of %s.\n", varname);
+                        return -ENOENT;
+                }
+                /* Verify it is a data structure  */
+                if (dwarf_tag(&type) != DW_TAG_structure_type) {
+                        pr_warning("%s is not a data structure.\n", varname);
+                        return -EINVAL;
+                }
 
-        if (!is_c_varname(pf->var)) {
-                /* Output raw parameters */
-                ret = snprintf(pf->buf, pf->len, " %s", pf->var);
-                DIE_IF(ret < 0);
-                DIE_IF(ret >= pf->len);
-                return ;
+                ref = zalloc(sizeof(struct probe_trace_arg_ref));
+                if (ref == NULL)
+                        return -ENOMEM;
+                if (*ref_ptr)
+                        (*ref_ptr)->next = ref;
+                else
+                        *ref_ptr = ref;
+        } else {
+                /* Verify it is a data structure  */
+                if (tag != DW_TAG_structure_type) {
+                        pr_warning("%s is not a data structure.\n", varname);
+                        return -EINVAL;
+                }
+                if (field->name[0] == '[') {
+                        pr_err("Semantic error: %s is not a pointor nor array.",
+                               varname);
+                        return -EINVAL;
+                }
+                if (field->ref) {
+                        pr_err("Semantic error: %s must be referred by '.'\n",
+                               field->name);
+                        return -EINVAL;
+                }
+                if (!ref) {
+                        pr_warning("Structure on a register is not "
+                                   "supported yet.\n");
+                        return -ENOTSUP;
+                }
         }
 
-        pr_debug("Searching '%s' variable in context.\n", pf->var);
-        /* Search child die for local variables and parameters. */
-        ret = search_die_from_children(sp_die, variable_callback, pf);
-        if (!ret)
-                die("Failed to find '%s' in this function.\n", pf->var);
+        if (die_find_member(&type, field->name, die_mem) == NULL) {
+                pr_warning("%s(tyep:%s) has no member %s.\n", varname,
+                           dwarf_diename(&type), field->name);
+                return -EINVAL;
+        }
+
+        /* Get the offset of the field */
+        ret = die_get_data_member_location(die_mem, &offs);
+        if (ret < 0) {
+                pr_warning("Failed to get the offset of %s.\n", field->name);
+                return ret;
+        }
+        ref->offset += (long)offs;
+
+next:
+        /* Converting next field */
+        if (field->next)
+                return convert_variable_fields(die_mem, field->name,
+                                        field->next, &ref, die_mem);
+        else
+                return 0;
 }
 
-/* Get a frame base on the address */
-static void get_current_frame_base(Dwarf_Die sp_die, struct probe_finder *pf)
+/* Show a variables in kprobe event format */
+static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
 {
-        Dwarf_Attribute attr;
+        Dwarf_Die die_mem;
         int ret;
 
-        ret = dwarf_attr(sp_die, DW_AT_frame_base, &attr, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
-        ret = attr_get_locdesc(attr, &pf->fbloc, (pf->addr - pf->cu_base));
-        DIE_IF(ret != DW_DLV_OK);
-        dwarf_dealloc(__dw_debug, attr, DW_DLA_ATTR);
+        pr_debug("Converting variable %s into trace event.\n",
+                 dwarf_diename(vr_die));
+
+        ret = convert_variable_location(vr_die, pf);
+        if (ret == 0 && pf->pvar->field) {
+                ret = convert_variable_fields(vr_die, pf->pvar->var,
+                                              pf->pvar->field, &pf->tvar->ref,
+                                              &die_mem);
+                vr_die = &die_mem;
+        }
+        if (ret == 0)
+                ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
+        /* *expr will be cached in libdw. Don't free it. */
+        return ret;
 }
 
-static void free_current_frame_base(struct probe_finder *pf)
+/* Find a variable in a subprogram die */
+static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
-        free(pf->fbloc.ld_s);
-        memset(&pf->fbloc, 0, sizeof(Dwarf_Locdesc));
+        Dwarf_Die vr_die, *scopes;
+        char buf[32], *ptr;
+        int ret, nscopes;
+
+        if (!is_c_varname(pf->pvar->var)) {
+                /* Copy raw parameters */
+                pf->tvar->value = strdup(pf->pvar->var);
+                if (pf->tvar->value == NULL)
+                        return -ENOMEM;
+                if (pf->pvar->type) {
+                        pf->tvar->type = strdup(pf->pvar->type);
+                        if (pf->tvar->type == NULL)
+                                return -ENOMEM;
+                }
+                if (pf->pvar->name) {
+                        pf->tvar->name = strdup(pf->pvar->name);
+                        if (pf->tvar->name == NULL)
+                                return -ENOMEM;
+                } else
+                        pf->tvar->name = NULL;
+                return 0;
+        }
+
+        if (pf->pvar->name)
+                pf->tvar->name = strdup(pf->pvar->name);
+        else {
+                ret = synthesize_perf_probe_arg(pf->pvar, buf, 32);
+                if (ret < 0)
+                        return ret;
+                ptr = strchr(buf, ':'); /* Change type separator to _ */
+                if (ptr)
+                        *ptr = '_';
+                pf->tvar->name = strdup(buf);
+        }
+        if (pf->tvar->name == NULL)
+                return -ENOMEM;
+
+        pr_debug("Searching '%s' variable in context.\n",
+                 pf->pvar->var);
+        /* Search child die for local variables and parameters. */
+        if (die_find_variable(sp_die, pf->pvar->var, &vr_die))
+                ret = convert_variable(&vr_die, pf);
+        else {
+                /* Search upper class */
+                nscopes = dwarf_getscopes_die(sp_die, &scopes);
+                if (nscopes > 0) {
+                        ret = dwarf_getscopevar(scopes, nscopes, pf->pvar->var,
+                                                0, NULL, 0, 0, &vr_die);
+                        if (ret >= 0)
+                                ret = convert_variable(&vr_die, pf);
+                        else
+                                ret = -ENOENT;
+                        free(scopes);
+                } else
+                        ret = -ENOENT;
+        }
+        if (ret < 0)
+                pr_warning("Failed to find '%s' in this function.\n",
+                           pf->pvar->var);
+        return ret;
 }
 
 /* Show a probe point to output buffer */
-static void show_probepoint(Dwarf_Die sp_die, Dwarf_Signed offs,
-                            struct probe_finder *pf)
-{
-        struct probe_point *pp = pf->pp;
-        char *name;
-        char tmp[MAX_PROBE_BUFFER];
-        int ret, i, len;
-
-        /* Output name of probe point */
-        ret = dwarf_diename(sp_die, &name, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (ret == DW_DLV_OK) {
-                ret = snprintf(tmp, MAX_PROBE_BUFFER, "%s+%u", name,
-                                (unsigned int)offs);
-                /* Copy the function name if possible */
-                if (!pp->function) {
-                        pp->function = strdup(name);
-                        pp->offset = offs;
-                }
-                dwarf_dealloc(__dw_debug, name, DW_DLA_STRING);
-        } else {
+static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        struct probe_trace_event *tev;
+        Dwarf_Addr eaddr;
+        Dwarf_Die die_mem;
+        const char *name;
+        int ret, i;
+        Dwarf_Attribute fb_attr;
+        size_t nops;
+
+        if (pf->ntevs == pf->max_tevs) {
+                pr_warning("Too many( > %d) probe point found.\n",
+                           pf->max_tevs);
+                return -ERANGE;
+        }
+        tev = &pf->tevs[pf->ntevs++];
+
+        /* If no real subprogram, find a real one */
+        if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
+                sp_die = die_find_real_subprogram(&pf->cu_die,
+                                                 pf->addr, &die_mem);
+                if (!sp_die) {
+                        pr_warning("Failed to find probe point in any "
+                                   "functions.\n");
+                        return -ENOENT;
+                }
+        }
+
+        /* Copy the name of probe point */
+        name = dwarf_diename(sp_die);
+        if (name) {
+                if (dwarf_entrypc(sp_die, &eaddr) != 0) {
+                        pr_warning("Failed to get entry pc of %s\n",
+                                   dwarf_diename(sp_die));
+                        return -ENOENT;
+                }
+                tev->point.symbol = strdup(name);
+                if (tev->point.symbol == NULL)
+                        return -ENOMEM;
+                tev->point.offset = (unsigned long)(pf->addr - eaddr);
+        } else
                 /* This function has no name. */
-                ret = snprintf(tmp, MAX_PROBE_BUFFER, "0x%llx", pf->addr);
-                if (!pp->function) {
-                        /* TODO: Use _stext */
-                        pp->function = strdup("");
-                        pp->offset = (int)pf->addr;
+                tev->point.offset = (unsigned long)pf->addr;
+
+        /* Return probe must be on the head of a subprogram */
+        if (pf->pev->point.retprobe) {
+                if (tev->point.offset != 0) {
+                        pr_warning("Return probe must be on the head of"
+                                   " a real function\n");
+                        return -EINVAL;
                 }
+                tev->point.retprobe = true;
+        }
+
+        pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
+                 tev->point.offset);
+
+        /* Get the frame base attribute/ops */
+        dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
+        ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
+        if (ret <= 0 || nops == 0) {
+                pf->fb_ops = NULL;
+#if _ELFUTILS_PREREQ(0, 142)
+        } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
+                   pf->cfi != NULL) {
+                Dwarf_Frame *frame;
+                if (dwarf_cfi_addrframe(pf->cfi, pf->addr, &frame) != 0 ||
+                    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
+                        pr_warning("Failed to get CFA on 0x%jx\n",
+                                   (uintmax_t)pf->addr);
+                        return -ENOENT;
+                }
+#endif
         }
-        DIE_IF(ret < 0);
-        DIE_IF(ret >= MAX_PROBE_BUFFER);
-        len = ret;
-        pr_debug("Probe point found: %s\n", tmp);
 
         /* Find each argument */
-        get_current_frame_base(sp_die, pf);
-        for (i = 0; i < pp->nr_args; i++) {
-                pf->var = pp->args[i];
-                pf->buf = &tmp[len];
-                pf->len = MAX_PROBE_BUFFER - len;
-                find_variable(sp_die, pf);
-                len += strlen(pf->buf);
+        tev->nargs = pf->pev->nargs;
+        tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
+        if (tev->args == NULL)
+                return -ENOMEM;
+        for (i = 0; i < pf->pev->nargs; i++) {
+                pf->pvar = &pf->pev->args[i];
+                pf->tvar = &tev->args[i];
+                ret = find_variable(sp_die, pf);
+                if (ret != 0)
+                        return ret;
         }
-        free_current_frame_base(pf);
 
-        pp->probes[pp->found] = strdup(tmp);
-        pp->found++;
+        /* *pf->fb_ops will be cached in libdw. Don't free it. */
+        pf->fb_ops = NULL;
+        return 0;
 }
 
-static int probeaddr_callback(struct die_link *dlink, void *data)
+/* Find probe point from its line number */
+static int find_probe_point_by_line(struct probe_finder *pf)
 {
-        struct probe_finder *pf = (struct probe_finder *)data;
-        Dwarf_Half tag;
-        Dwarf_Signed offs;
-        int ret;
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        int lineno;
+        int ret = 0;
 
-        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        /* Check the address is in this subprogram */
-        if (tag == DW_TAG_subprogram &&
-            die_within_subprogram(dlink->die, pf->addr, &offs)) {
-                show_probepoint(dlink->die, offs, pf);
-                return 1;
+        if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
+                return -ENOENT;
         }
-        return 0;
+
+        for (i = 0; i < nlines && ret == 0; i++) {
+                line = dwarf_onesrcline(lines, i);
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    lineno != pf->lno)
+                        continue;
+
+                /* TODO: Get fileno from line, but how? */
+                if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
+                        continue;
+
+                if (dwarf_lineaddr(line, &addr) != 0) {
+                        pr_warning("Failed to get the address of the line.\n");
+                        return -ENOENT;
+                }
+                pr_debug("Probe line found: line[%d]:%d addr:0x%jx\n",
+                         (int)i, lineno, (uintmax_t)addr);
+                pf->addr = addr;
+
+                ret = convert_probe_point(NULL, pf);
+                /* Continuing, because target line might be inlined. */
+        }
+        return ret;
 }
 
-/* Find probe point from its line number */
-static void find_by_line(struct probe_finder *pf)
+/* Find lines which match lazy pattern */
+static int find_lazy_match_lines(struct list_head *head,
+                                 const char *fname, const char *pat)
 {
-        Dwarf_Signed cnt, i, clm;
-        Dwarf_Line *lines;
-        Dwarf_Unsigned lineno = 0;
+        char *fbuf, *p1, *p2;
+        int fd, line, nlines = -1;
+        struct stat st;
+
+        fd = open(fname, O_RDONLY);
+        if (fd < 0) {
+                pr_warning("Failed to open %s: %s\n", fname, strerror(-fd));
+                return -errno;
+        }
+
+        if (fstat(fd, &st) < 0) {
+                pr_warning("Failed to get the size of %s: %s\n",
+                           fname, strerror(errno));
+                nlines = -errno;
+                goto out_close;
+        }
+
+        nlines = -ENOMEM;
+        fbuf = malloc(st.st_size + 2);
+        if (fbuf == NULL)
+                goto out_close;
+        if (read(fd, fbuf, st.st_size) < 0) {
+                pr_warning("Failed to read %s: %s\n", fname, strerror(errno));
+                nlines = -errno;
+                goto out_free_fbuf;
+        }
+        fbuf[st.st_size] = '\n';        /* Dummy line */
+        fbuf[st.st_size + 1] = '\0';
+        p1 = fbuf;
+        line = 1;
+        nlines = 0;
+        while ((p2 = strchr(p1, '\n')) != NULL) {
+                *p2 = '\0';
+                if (strlazymatch(p1, pat)) {
+                        line_list__add_line(head, line);
+                        nlines++;
+                }
+                line++;
+                p1 = p2 + 1;
+        }
+out_free_fbuf:
+        free(fbuf);
+out_close:
+        close(fd);
+        return nlines;
+}
+
+/* Find probe points from lazy pattern  */
+static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
         Dwarf_Addr addr;
-        Dwarf_Unsigned fno;
-        int ret;
+        Dwarf_Die die_mem;
+        int lineno;
+        int ret = 0;
+
+        if (list_empty(&pf->lcache)) {
+                /* Matching lazy line pattern */
+                ret = find_lazy_match_lines(&pf->lcache, pf->fname,
+                                            pf->pev->point.lazy_line);
+                if (ret == 0) {
+                        pr_debug("No matched lines found in %s.\n", pf->fname);
+                        return 0;
+                } else if (ret < 0)
+                        return ret;
+        }
 
-        ret = dwarf_srclines(pf->cu_die, &lines, &cnt, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
+        if (dwarf_getsrclines(&pf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
+                return -ENOENT;
+        }
 
-        for (i = 0; i < cnt; i++) {
-                ret = dwarf_line_srcfileno(lines[i], &fno, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
-                if (fno != pf->fno)
+        for (i = 0; i < nlines && ret >= 0; i++) {
+                line = dwarf_onesrcline(lines, i);
+
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    !line_list__has_line(&pf->lcache, lineno))
                         continue;
 
-                ret = dwarf_lineno(lines[i], &lineno, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
-                if (lineno != pf->lno)
+                /* TODO: Get fileno from line, but how? */
+                if (strtailcmp(dwarf_linesrc(line, NULL, NULL), pf->fname) != 0)
                         continue;
 
-                ret = dwarf_lineoff(lines[i], &clm, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
+                if (dwarf_lineaddr(line, &addr) != 0) {
+                        pr_debug("Failed to get the address of line %d.\n",
+                                 lineno);
+                        continue;
+                }
+                if (sp_die) {
+                        /* Address filtering 1: does sp_die include addr? */
+                        if (!dwarf_haspc(sp_die, addr))
+                                continue;
+                        /* Address filtering 2: No child include addr? */
+                        if (die_find_inlinefunc(sp_die, addr, &die_mem))
+                                continue;
+                }
 
-                ret = dwarf_lineaddr(lines[i], &addr, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
-                pr_debug("Probe line found: line[%d]:%u,%d addr:0x%llx\n",
-                         (int)i, (unsigned)lineno, (int)clm, addr);
+                pr_debug("Probe line found: line[%d]:%d addr:0x%llx\n",
+                         (int)i, lineno, (unsigned long long)addr);
                 pf->addr = addr;
-                /* Search a real subprogram including this line, */
-                ret = search_die_from_children(pf->cu_die,
-                                               probeaddr_callback, pf);
-                if (ret == 0)
-                        die("Probe point is not found in subprograms.\n");
+
+                ret = convert_probe_point(sp_die, pf);
                 /* Continuing, because target line might be inlined. */
         }
-        dwarf_srclines_dealloc(__dw_debug, lines, cnt);
+        /* TODO: deallocate lines, but how? */
+        return ret;
 }
 
-/* Search function from function name */
-static int probefunc_callback(struct die_link *dlink, void *data)
+/* Callback parameter with return value */
+struct dwarf_callback_param {
+        void *data;
+        int retval;
+};
+
+static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct probe_finder *pf = (struct probe_finder *)data;
-        struct probe_point *pp = pf->pp;
-        struct die_link *lk;
-        Dwarf_Signed offs;
-        Dwarf_Half tag;
-        int ret;
+        struct dwarf_callback_param *param = data;
+        struct probe_finder *pf = param->data;
+        struct perf_probe_point *pp = &pf->pev->point;
+        Dwarf_Addr addr;
 
-        ret = dwarf_tag(dlink->die, &tag, &__dw_error);
-        DIE_IF(ret == DW_DLV_ERROR);
-        if (tag == DW_TAG_subprogram) {
-                if (die_compare_name(dlink->die, pp->function) == 0) {
-                        if (pp->line) { /* Function relative line */
-                                pf->fno = die_get_decl_file(dlink->die);
-                                pf->lno = die_get_decl_line(dlink->die)
-                                         + pp->line;
-                                find_by_line(pf);
-                                return 1;
-                        }
-                        if (die_inlined_subprogram(dlink->die)) {
-                                /* Inlined function, save it. */
-                                ret = dwarf_die_CU_offset(dlink->die,
-                                                          &pf->inl_offs,
-                                                          &__dw_error);
-                                DIE_IF(ret != DW_DLV_OK);
-                                pr_debug("inline definition offset %lld\n",
-                                         pf->inl_offs);
-                                return 0;       /* Continue to search */
+        if (pp->lazy_line)
+                param->retval = find_probe_point_lazy(in_die, pf);
+        else {
+                /* Get probe address */
+                if (dwarf_entrypc(in_die, &addr) != 0) {
+                        pr_warning("Failed to get entry pc of %s.\n",
+                                   dwarf_diename(in_die));
+                        param->retval = -ENOENT;
+                        return DWARF_CB_ABORT;
+                }
+                pf->addr = addr;
+                pf->addr += pp->offset;
+                pr_debug("found inline addr: 0x%jx\n",
+                         (uintmax_t)pf->addr);
+
+                param->retval = convert_probe_point(in_die, pf);
+                if (param->retval < 0)
+                        return DWARF_CB_ABORT;
+        }
+
+        return DWARF_CB_OK;
+}
+
+/* Search function from function name */
+static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
+{
+        struct dwarf_callback_param *param = data;
+        struct probe_finder *pf = param->data;
+        struct perf_probe_point *pp = &pf->pev->point;
+
+        /* Check tag and diename */
+        if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
+            !die_compare_name(sp_die, pp->function))
+                return DWARF_CB_OK;
+
+        pf->fname = dwarf_decl_file(sp_die);
+        if (pp->line) { /* Function relative line */
+                dwarf_decl_line(sp_die, &pf->lno);
+                pf->lno += pp->line;
+                param->retval = find_probe_point_by_line(pf);
+        } else if (!dwarf_func_inline(sp_die)) {
+                /* Real function */
+                if (pp->lazy_line)
+                        param->retval = find_probe_point_lazy(sp_die, pf);
+                else {
+                        if (dwarf_entrypc(sp_die, &pf->addr) != 0) {
+                                pr_warning("Failed to get entry pc of %s.\n",
+                                           dwarf_diename(sp_die));
+                                param->retval = -ENOENT;
+                                return DWARF_CB_ABORT;
                         }
-                        /* Get probe address */
-                        pf->addr = die_get_entrypc(dlink->die);
                         pf->addr += pp->offset;
                         /* TODO: Check the address in this function */
-                        show_probepoint(dlink->die, pp->offset, pf);
-                        return 1; /* Exit; no same symbol in this CU. */
+                        param->retval = convert_probe_point(sp_die, pf);
                 }
-        } else if (tag == DW_TAG_inlined_subroutine && pf->inl_offs) {
-                if (die_get_abstract_origin(dlink->die) == pf->inl_offs) {
-                        /* Get probe address */
-                        pf->addr = die_get_entrypc(dlink->die);
-                        pf->addr += pp->offset;
-                        pr_debug("found inline addr: 0x%llx\n", pf->addr);
-                        /* Inlined function. Get a real subprogram */
-                        for (lk = dlink->parent; lk != NULL; lk = lk->parent) {
-                                tag = 0;
-                                dwarf_tag(lk->die, &tag, &__dw_error);
-                                DIE_IF(ret == DW_DLV_ERROR);
-                                if (tag == DW_TAG_subprogram &&
-                                    !die_inlined_subprogram(lk->die))
-                                        goto found;
+        } else {
+                struct dwarf_callback_param _param = {.data = (void *)pf,
+                                                      .retval = 0};
+                /* Inlined function: search instances */
+                dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
+                                            &_param);
+                param->retval = _param.retval;
+        }
+
+        return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
+}
+
+static int find_probe_point_by_func(struct probe_finder *pf)
+{
+        struct dwarf_callback_param _param = {.data = (void *)pf,
+                                              .retval = 0};
+        dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
+        return _param.retval;
+}
+
+/* Find probe_trace_events specified by perf_probe_event from debuginfo */
+int find_probe_trace_events(int fd, struct perf_probe_event *pev,
+                             struct probe_trace_event **tevs, int max_tevs)
+{
+        struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs};
+        struct perf_probe_point *pp = &pev->point;
+        Dwarf_Off off, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+        int ret = 0;
+
+        pf.tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
+        if (pf.tevs == NULL)
+                return -ENOMEM;
+        *tevs = pf.tevs;
+        pf.ntevs = 0;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg) {
+                pr_warning("No dwarf info found in the vmlinux - "
+                        "please rebuild with CONFIG_DEBUG_INFO=y.\n");
+                free(pf.tevs);
+                *tevs = NULL;
+                return -EBADF;
+        }
+
+#if _ELFUTILS_PREREQ(0, 142)
+        /* Get the call frame information from this dwarf */
+        pf.cfi = dwarf_getcfi(dbg);
+#endif
+
+        off = 0;
+        line_list__init(&pf.lcache);
+        /* Loop on CUs (Compilation Unit) */
+        while (!dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) &&
+               ret >= 0) {
+                /* Get the DIE(Debugging Information Entry) of this CU */
+                diep = dwarf_offdie(dbg, off + cuhl, &pf.cu_die);
+                if (!diep)
+                        continue;
+
+                /* Check if target file is included. */
+                if (pp->file)
+                        pf.fname = cu_find_realpath(&pf.cu_die, pp->file);
+                else
+                        pf.fname = NULL;
+
+                if (!pp->file || pf.fname) {
+                        if (pp->function)
+                                ret = find_probe_point_by_func(&pf);
+                        else if (pp->lazy_line)
+                                ret = find_probe_point_lazy(NULL, &pf);
+                        else {
+                                pf.lno = pp->line;
+                                ret = find_probe_point_by_line(&pf);
                         }
-                        die("Failed to find real subprogram.\n");
+                }
+                off = noff;
+        }
+        line_list__free(&pf.lcache);
+        dwarf_end(dbg);
+
+        return (ret < 0) ? ret : pf.ntevs;
+}
+
+/* Reverse search */
+int find_perf_probe_point(int fd, unsigned long addr,
+                          struct perf_probe_point *ppt)
+{
+        Dwarf_Die cudie, spdie, indie;
+        Dwarf *dbg;
+        Dwarf_Line *line;
+        Dwarf_Addr laddr, eaddr;
+        const char *tmp;
+        int lineno, ret = 0;
+        bool found = false;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg)
+                return -EBADF;
+
+        /* Find cu die */
+        if (!dwarf_addrdie(dbg, (Dwarf_Addr)addr, &cudie)) {
+                ret = -EINVAL;
+                goto end;
+        }
+
+        /* Find a corresponding line */
+        line = dwarf_getsrc_die(&cudie, (Dwarf_Addr)addr);
+        if (line) {
+                if (dwarf_lineaddr(line, &laddr) == 0 &&
+                    (Dwarf_Addr)addr == laddr &&
+                    dwarf_lineno(line, &lineno) == 0) {
+                        tmp = dwarf_linesrc(line, NULL, NULL);
+                        if (tmp) {
+                                ppt->line = lineno;
+                                ppt->file = strdup(tmp);
+                                if (ppt->file == NULL) {
+                                        ret = -ENOMEM;
+                                        goto end;
+                                }
+                                found = true;
+                        }
+                }
+        }
+
+        /* Find a corresponding function */
+        if (die_find_real_subprogram(&cudie, (Dwarf_Addr)addr, &spdie)) {
+                tmp = dwarf_diename(&spdie);
+                if (!tmp || dwarf_entrypc(&spdie, &eaddr) != 0)
+                        goto end;
+
+                if (ppt->line) {
+                        if (die_find_inlinefunc(&spdie, (Dwarf_Addr)addr,
+                                                &indie)) {
+                                /* addr in an inline function */
+                                tmp = dwarf_diename(&indie);
+                                if (!tmp)
+                                        goto end;
+                                ret = dwarf_decl_line(&indie, &lineno);
+                        } else {
+                                if (eaddr == addr) {    /* Function entry */
+                                        lineno = ppt->line;
+                                        ret = 0;
+                                } else
+                                        ret = dwarf_decl_line(&spdie, &lineno);
+                        }
+                        if (ret == 0) {
+                                /* Make a relative line number */
+                                ppt->line -= lineno;
+                                goto found;
+                        }
+                }
+                /* We don't have a line number, let's use offset */
+                ppt->offset = addr - (unsigned long)eaddr;
 found:
-                        /* Get offset from subprogram */
-                        ret = die_within_subprogram(lk->die, pf->addr, &offs);
-                        DIE_IF(!ret);
-                        show_probepoint(lk->die, offs, pf);
-                        /* Continue to search */
+                ppt->function = strdup(tmp);
+                if (ppt->function == NULL) {
+                        ret = -ENOMEM;
+                        goto end;
                 }
+                found = true;
         }
-        return 0;
+
+end:
+        dwarf_end(dbg);
+        if (ret >= 0)
+                ret = found ? 1 : 0;
+        return ret;
 }
 
-static void find_by_func(struct probe_finder *pf)
+/* Add a line and store the src path */
+static int line_range_add_line(const char *src, unsigned int lineno,
+                               struct line_range *lr)
 {
-        search_die_from_children(pf->cu_die, probefunc_callback, pf);
+        /* Copy source path */
+        if (!lr->path) {
+                lr->path = strdup(src);
+                if (lr->path == NULL)
+                        return -ENOMEM;
+        }
+        return line_list__add_line(&lr->line_list, lineno);
 }
 
-/* Find a probe point */
-int find_probepoint(int fd, struct probe_point *pp)
+/* Search function declaration lines */
+static int line_range_funcdecl_cb(Dwarf_Die *sp_die, void *data)
 {
-        Dwarf_Half addr_size = 0;
-        Dwarf_Unsigned next_cuh = 0;
-        int cu_number = 0, ret;
-        struct probe_finder pf = {.pp = pp};
+        struct dwarf_callback_param *param = data;
+        struct line_finder *lf = param->data;
+        const char *src;
+        int lineno;
+
+        src = dwarf_decl_file(sp_die);
+        if (src && strtailcmp(src, lf->fname) != 0)
+                return DWARF_CB_OK;
+
+        if (dwarf_decl_line(sp_die, &lineno) != 0 ||
+            (lf->lno_s > lineno || lf->lno_e < lineno))
+                return DWARF_CB_OK;
+
+        param->retval = line_range_add_line(src, lineno, lf->lr);
+        if (param->retval < 0)
+                return DWARF_CB_ABORT;
+        return DWARF_CB_OK;
+}
 
-        ret = dwarf_init(fd, DW_DLC_READ, 0, 0, &__dw_debug, &__dw_error);
-        if (ret != DW_DLV_OK)
+static int find_line_range_func_decl_lines(struct line_finder *lf)
+{
+        struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
+        dwarf_getfuncs(&lf->cu_die, line_range_funcdecl_cb, &param, 0);
+        return param.retval;
+}
+
+/* Find line range from its line number */
+static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
+{
+        Dwarf_Lines *lines;
+        Dwarf_Line *line;
+        size_t nlines, i;
+        Dwarf_Addr addr;
+        int lineno, ret = 0;
+        const char *src;
+        Dwarf_Die die_mem;
+
+        line_list__init(&lf->lr->line_list);
+        if (dwarf_getsrclines(&lf->cu_die, &lines, &nlines) != 0) {
+                pr_warning("No source lines found in this CU.\n");
                 return -ENOENT;
+        }
+
+        /* Search probable lines on lines list */
+        for (i = 0; i < nlines; i++) {
+                line = dwarf_onesrcline(lines, i);
+                if (dwarf_lineno(line, &lineno) != 0 ||
+                    (lf->lno_s > lineno || lf->lno_e < lineno))
+                        continue;
+
+                if (sp_die) {
+                        /* Address filtering 1: does sp_die include addr? */
+                        if (dwarf_lineaddr(line, &addr) != 0 ||
+                            !dwarf_haspc(sp_die, addr))
+                                continue;
+
+                        /* Address filtering 2: No child include addr? */
+                        if (die_find_inlinefunc(sp_die, addr, &die_mem))
+                                continue;
+                }
+
+                /* TODO: Get fileno from line, but how? */
+                src = dwarf_linesrc(line, NULL, NULL);
+                if (strtailcmp(src, lf->fname) != 0)
+                        continue;
+
+                ret = line_range_add_line(src, lineno, lf->lr);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /*
+         * Dwarf lines doesn't include function declarations. We have to
+         * check functions list or given function.
+         */
+        if (sp_die) {
+                src = dwarf_decl_file(sp_die);
+                if (src && dwarf_decl_line(sp_die, &lineno) == 0 &&
+                    (lf->lno_s <= lineno && lf->lno_e >= lineno))
+                        ret = line_range_add_line(src, lineno, lf->lr);
+        } else
+                ret = find_line_range_func_decl_lines(lf);
+
+        /* Update status */
+        if (ret >= 0)
+                if (!list_empty(&lf->lr->line_list))
+                        ret = lf->found = 1;
+                else
+                        ret = 0;        /* Lines are not found */
+        else {
+                free(lf->lr->path);
+                lf->lr->path = NULL;
+        }
+        return ret;
+}
+
+static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
+{
+        struct dwarf_callback_param *param = data;
 
-        pp->found = 0;
-        while (++cu_number) {
-                /* Search CU (Compilation Unit) */
-                ret = dwarf_next_cu_header(__dw_debug, NULL, NULL, NULL,
-                        &addr_size, &next_cuh, &__dw_error);
-                DIE_IF(ret == DW_DLV_ERROR);
-                if (ret == DW_DLV_NO_ENTRY)
+        param->retval = find_line_range_by_line(in_die, param->data);
+        return DWARF_CB_ABORT;  /* No need to find other instances */
+}
+
+/* Search function from function name */
+static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
+{
+        struct dwarf_callback_param *param = data;
+        struct line_finder *lf = param->data;
+        struct line_range *lr = lf->lr;
+
+        if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
+            die_compare_name(sp_die, lr->function)) {
+                lf->fname = dwarf_decl_file(sp_die);
+                dwarf_decl_line(sp_die, &lr->offset);
+                pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
+                lf->lno_s = lr->offset + lr->start;
+                if (lf->lno_s < 0)      /* Overflow */
+                        lf->lno_s = INT_MAX;
+                lf->lno_e = lr->offset + lr->end;
+                if (lf->lno_e < 0)      /* Overflow */
+                        lf->lno_e = INT_MAX;
+                pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
+                lr->start = lf->lno_s;
+                lr->end = lf->lno_e;
+                if (dwarf_func_inline(sp_die)) {
+                        struct dwarf_callback_param _param;
+                        _param.data = (void *)lf;
+                        _param.retval = 0;
+                        dwarf_func_inline_instances(sp_die,
+                                                    line_range_inline_cb,
+                                                    &_param);
+                        param->retval = _param.retval;
+                } else
+                        param->retval = find_line_range_by_line(sp_die, lf);
+                return DWARF_CB_ABORT;
+        }
+        return DWARF_CB_OK;
+}
+
+static int find_line_range_by_func(struct line_finder *lf)
+{
+        struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
+        dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
+        return param.retval;
+}
+
+int find_line_range(int fd, struct line_range *lr)
+{
+        struct line_finder lf = {.lr = lr, .found = 0};
+        int ret = 0;
+        Dwarf_Off off = 0, noff;
+        size_t cuhl;
+        Dwarf_Die *diep;
+        Dwarf *dbg;
+        const char *comp_dir;
+
+        dbg = dwarf_begin(fd, DWARF_C_READ);
+        if (!dbg) {
+                pr_warning("No dwarf info found in the vmlinux - "
+                        "please rebuild with CONFIG_DEBUG_INFO=y.\n");
+                return -EBADF;
+        }
+
+        /* Loop on CUs (Compilation Unit) */
+        while (!lf.found && ret >= 0) {
+                if (dwarf_nextcu(dbg, off, &noff, &cuhl, NULL, NULL, NULL) != 0)
                         break;
 
                 /* Get the DIE(Debugging Information Entry) of this CU */
-                ret = dwarf_siblingof(__dw_debug, 0, &pf.cu_die, &__dw_error);
-                DIE_IF(ret != DW_DLV_OK);
+                diep = dwarf_offdie(dbg, off + cuhl, &lf.cu_die);
+                if (!diep)
+                        continue;
 
                 /* Check if target file is included. */
-                if (pp->file)
-                        pf.fno = cu_find_fileno(pf.cu_die, pp->file);
-
-                if (!pp->file || pf.fno) {
-                        /* Save CU base address (for frame_base) */
-                        ret = dwarf_lowpc(pf.cu_die, &pf.cu_base, &__dw_error);
-                        DIE_IF(ret == DW_DLV_ERROR);
-                        if (ret == DW_DLV_NO_ENTRY)
-                                pf.cu_base = 0;
-                        if (pp->function)
-                                find_by_func(&pf);
+                if (lr->file)
+                        lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
+                else
+                        lf.fname = 0;
+
+                if (!lr->file || lf.fname) {
+                        if (lr->function)
+                                ret = find_line_range_by_func(&lf);
                         else {
-                                pf.lno = pp->line;
-                                find_by_line(&pf);
+                                lf.lno_s = lr->start;
+                                lf.lno_e = lr->end;
+                                ret = find_line_range_by_line(NULL, &lf);
                         }
                 }
-                dwarf_dealloc(__dw_debug, pf.cu_die, DW_DLA_DIE);
+                off = noff;
         }
-        ret = dwarf_finish(__dw_debug, &__dw_error);
-        DIE_IF(ret != DW_DLV_OK);
 
-        return pp->found;
+        /* Store comp_dir */
+        if (lf.found) {
+                comp_dir = cu_get_comp_dir(&lf.cu_die);
+                if (comp_dir) {
+                        lr->comp_dir = strdup(comp_dir);
+                        if (!lr->comp_dir)
+                                ret = -ENOMEM;
+                }
+        }
+
+        pr_debug("path: %s\n", lr->path);
+        dwarf_end(dbg);
+
+        return (ret < 0) ? ret : lf.found;
 }
 
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index a4086aaddb73..4507d519f183 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -1,6 +1,10 @@
 #ifndef _PROBE_FINDER_H
 #define _PROBE_FINDER_H
 
+#include <stdbool.h>
+#include "util.h"
+#include "probe-event.h"
+
 #define MAX_PATH_LEN             256
 #define MAX_PROBE_BUFFER        1024
 #define MAX_PROBES               128
@@ -11,55 +15,54 @@ static inline int is_c_varname(const char *name)
         return isalpha(name[0]) || name[0] == '_';
 }
 
-struct probe_point {
-        char                    *event;                 /* Event name */
-        char                    *group;                 /* Event group */
-
-        /* Inputs */
-        char                    *file;                  /* File name */
-        int                     line;                   /* Line number */
+#ifdef DWARF_SUPPORT
+/* Find probe_trace_events specified by perf_probe_event from debuginfo */
+extern int find_probe_trace_events(int fd, struct perf_probe_event *pev,
+                                    struct probe_trace_event **tevs,
+                                    int max_tevs);
 
-        char                    *function;              /* Function name */
-        int                     offset;                 /* Offset bytes */
+/* Find a perf_probe_point from debuginfo */
+extern int find_perf_probe_point(int fd, unsigned long addr,
+                                 struct perf_probe_point *ppt);
 
-        int                     nr_args;                /* Number of arguments */
-        char                    **args;                 /* Arguments */
-
-        int                     retprobe;               /* Return probe */
-
-        /* Output */
-        int                     found;                  /* Number of found probe points */
-        char                    *probes[MAX_PROBES];    /* Output buffers (will be allocated)*/
-};
-
-#ifndef NO_LIBDWARF
-extern int find_probepoint(int fd, struct probe_point *pp);
-
-/* Workaround for undefined _MIPS_SZLONG bug in libdwarf.h: */
-#ifndef _MIPS_SZLONG
-# define _MIPS_SZLONG           0
-#endif
+extern int find_line_range(int fd, struct line_range *lr);
 
 #include <dwarf.h>
-#include <libdwarf.h>
+#include <libdw.h>
+#include <version.h>
 
 struct probe_finder {
-        struct probe_point      *pp;                    /* Target probe point */
+        struct perf_probe_event *pev;           /* Target probe event */
+        struct probe_trace_event *tevs;         /* Result trace events */
+        int                     ntevs;          /* Number of trace events */
+        int                     max_tevs;       /* Max number of trace events */
 
         /* For function searching */
-        Dwarf_Addr              addr;                   /* Address */
-        Dwarf_Unsigned          fno;                    /* File number */
-        Dwarf_Unsigned          lno;                    /* Line number */
-        Dwarf_Off               inl_offs;               /* Inline offset */
-        Dwarf_Die               cu_die;                 /* Current CU */
+        int                     lno;            /* Line number */
+        Dwarf_Addr              addr;           /* Address */
+        const char              *fname;         /* Real file name */
+        Dwarf_Die               cu_die;         /* Current CU */
+        struct list_head        lcache;         /* Line cache for lazy match */
 
         /* For variable searching */
-        Dwarf_Addr              cu_base;                /* Current CU base address */
-        Dwarf_Locdesc           fbloc;                  /* Location of Current Frame Base */
-        const char              *var;                   /* Current variable name */
-        char                    *buf;                   /* Current output buffer */
-        int                     len;                    /* Length of output buffer */
+#if _ELFUTILS_PREREQ(0, 142)
+        Dwarf_CFI               *cfi;           /* Call Frame Information */
+#endif
+        Dwarf_Op                *fb_ops;        /* Frame base attribute */
+        struct perf_probe_arg   *pvar;          /* Current target variable */
+        struct probe_trace_arg  *tvar;          /* Current result variable */
+};
+
+struct line_finder {
+        struct line_range       *lr;            /* Target line range */
+
+        const char              *fname;         /* File name */
+        int                     lno_s;          /* Start line number */
+        int                     lno_e;          /* End line number */
+        Dwarf_Die               cu_die;         /* Current CU */
+        int                     found;
 };
-#endif /* NO_LIBDWARF */
+
+#endif /* DWARF_SUPPORT */
 
 #endif /*_PROBE_FINDER_H */
diff --git a/tools/perf/util/pstack.c b/tools/perf/util/pstack.c
new file mode 100644
index 000000000000..13d36faf64eb
--- /dev/null
+++ b/tools/perf/util/pstack.c
@@ -0,0 +1,75 @@
+/*
+ * Simple pointer stack
+ *
+ * (c) 2010 Arnaldo Carvalho de Melo <acme@redhat.com>
+ */
+
+#include "util.h"
+#include "pstack.h"
+#include <linux/kernel.h>
+#include <stdlib.h>
+
+struct pstack {
+        unsigned short  top;
+        unsigned short  max_nr_entries;
+        void            *entries[0];
+};
+
+struct pstack *pstack__new(unsigned short max_nr_entries)
+{
+        struct pstack *self = zalloc((sizeof(*self) +
+                                     max_nr_entries * sizeof(void *)));
+        if (self != NULL)
+                self->max_nr_entries = max_nr_entries;
+        return self;
+}
+
+void pstack__delete(struct pstack *self)
+{
+        free(self);
+}
+
+bool pstack__empty(const struct pstack *self)
+{
+        return self->top == 0;
+}
+
+void pstack__remove(struct pstack *self, void *key)
+{
+        unsigned short i = self->top, last_index = self->top - 1;
+
+        while (i-- != 0) {
+                if (self->entries[i] == key) {
+                        if (i < last_index)
+                                memmove(self->entries + i,
+                                        self->entries + i + 1,
+                                        (last_index - i) * sizeof(void *));
+                        --self->top;
+                        return;
+                }
+        }
+        pr_err("%s: %p not on the pstack!\n", __func__, key);
+}
+
+void pstack__push(struct pstack *self, void *key)
+{
+        if (self->top == self->max_nr_entries) {
+                pr_err("%s: top=%d, overflow!\n", __func__, self->top);
+                return;
+        }
+        self->entries[self->top++] = key;
+}
+
+void *pstack__pop(struct pstack *self)
+{
+        void *ret;
+
+        if (self->top == 0) {
+                pr_err("%s: underflow!\n", __func__);
+                return NULL;
+        }
+
+        ret = self->entries[--self->top];
+        self->entries[self->top] = NULL;
+        return ret;
+}
diff --git a/tools/perf/util/pstack.h b/tools/perf/util/pstack.h
new file mode 100644
index 000000000000..4cedea59f518
--- /dev/null
+++ b/tools/perf/util/pstack.h
@@ -0,0 +1,14 @@
+#ifndef _PERF_PSTACK_
+#define _PERF_PSTACK_
+
+#include <stdbool.h>
+
+struct pstack;
+struct pstack *pstack__new(unsigned short max_nr_entries);
+void pstack__delete(struct pstack *self);
+bool pstack__empty(const struct pstack *self);
+void pstack__remove(struct pstack *self, void *key);
+void pstack__push(struct pstack *self, void *key);
+void *pstack__pop(struct pstack *self);
+
+#endif /* _PERF_PSTACK_ */
diff --git a/tools/perf/util/quote.c b/tools/perf/util/quote.c
index 2726fe40eb5d..01f03242b86a 100644
--- a/tools/perf/util/quote.c
+++ b/tools/perf/util/quote.c
@@ -1,8 +1,6 @@
 #include "cache.h"
 #include "quote.h"
 
-int quote_path_fully = 1;
-
 /* Help to copy the thing properly quoted for the shell safety.
  * any single quote is replaced with '\'', any exclamation point
  * is replaced with '\!', and the whole thing is enclosed in a
@@ -19,7 +17,7 @@ static inline int need_bs_quote(char c)
         return (c == '\'' || c == '!');
 }
 
-void sq_quote_buf(struct strbuf *dst, const char *src)
+static void sq_quote_buf(struct strbuf *dst, const char *src)
 {
         char *to_free = NULL;
 
@@ -41,23 +39,6 @@ void sq_quote_buf(struct strbuf *dst, const char *src)
         free(to_free);
 }
 
-void sq_quote_print(FILE *stream, const char *src)
-{
-        char c;
-
-        fputc('\'', stream);
-        while ((c = *src++)) {
-                if (need_bs_quote(c)) {
-                        fputs("'\\", stream);
-                        fputc(c, stream);
-                        fputc('\'', stream);
-                } else {
-                        fputc(c, stream);
-                }
-        }
-        fputc('\'', stream);
-}
-
 void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
 {
         int i;
@@ -71,415 +52,3 @@ void sq_quote_argv(struct strbuf *dst, const char** argv, size_t maxlen)
                         die("Too many or long arguments");
         }
 }
-
-char *sq_dequote_step(char *arg, char **next)
-{
-        char *dst = arg;
-        char *src = arg;
-        char c;
-
-        if (*src != '\'')
-                return NULL;
-        for (;;) {
-                c = *++src;
-                if (!c)
-                        return NULL;
-                if (c != '\'') {
-                        *dst++ = c;
-                        continue;
-                }
-                /* We stepped out of sq */
-                switch (*++src) {
-                case '\0':
-                        *dst = 0;
-                        if (next)
-                                *next = NULL;
-                        return arg;
-                case '\\':
-                        c = *++src;
-                        if (need_bs_quote(c) && *++src == '\'') {
-                                *dst++ = c;
-                                continue;
-                        }
-                /* Fallthrough */
-                default:
-                        if (!next || !isspace(*src))
-                                return NULL;
-                        do {
-                                c = *++src;
-                        } while (isspace(c));
-                        *dst = 0;
-                        *next = src;
-                        return arg;
-                }
-        }
-}
-
-char *sq_dequote(char *arg)
-{
-        return sq_dequote_step(arg, NULL);
-}
-
-int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc)
-{
-        char *next = arg;
-
-        if (!*arg)
-                return 0;
-        do {
-                char *dequoted = sq_dequote_step(next, &next);
-                if (!dequoted)
-                        return -1;
-                ALLOC_GROW(*argv, *nr + 1, *alloc);
-                (*argv)[(*nr)++] = dequoted;
-        } while (next);
-
-        return 0;
-}
-
-/* 1 means: quote as octal
- * 0 means: quote as octal if (quote_path_fully)
- * -1 means: never quote
- * c: quote as "\\c"
- */
-#define X8(x)   x, x, x, x, x, x, x, x
-#define X16(x)  X8(x), X8(x)
-static signed char const sq_lookup[256] = {
-        /*           0    1    2    3    4    5    6    7 */
-        /* 0x00 */   1,   1,   1,   1,   1,   1,   1, 'a',
-        /* 0x08 */ 'b', 't', 'n', 'v', 'f', 'r',   1,   1,
-        /* 0x10 */ X16(1),
-        /* 0x20 */  -1,  -1, '"',  -1,  -1,  -1,  -1,  -1,
-        /* 0x28 */ X16(-1), X16(-1), X16(-1),
-        /* 0x58 */  -1,  -1,  -1,  -1,'\\',  -1,  -1,  -1,
-        /* 0x60 */ X16(-1), X8(-1),
-        /* 0x78 */  -1,  -1,  -1,  -1,  -1,  -1,  -1,   1,
-        /* 0x80 */ /* set to 0 */
-};
-
-static inline int sq_must_quote(char c)
-{
-        return sq_lookup[(unsigned char)c] + quote_path_fully > 0;
-}
-
-/*
- * Returns the longest prefix not needing a quote up to maxlen if
- * positive.
- * This stops at the first \0 because it's marked as a character
- * needing an escape.
- */
-static ssize_t next_quote_pos(const char *s, ssize_t maxlen)
-{
-        ssize_t len;
-
-        if (maxlen < 0) {
-                for (len = 0; !sq_must_quote(s[len]); len++);
-        } else {
-                for (len = 0; len < maxlen && !sq_must_quote(s[len]); len++);
-        }
-        return len;
-}
-
-/*
- * C-style name quoting.
- *
- * (1) if sb and fp are both NULL, inspect the input name and counts the
- *     number of bytes that are needed to hold c_style quoted version of name,
- *     counting the double quotes around it but not terminating NUL, and
- *     returns it.
- *     However, if name does not need c_style quoting, it returns 0.
- *
- * (2) if sb or fp are not NULL, it emits the c_style quoted version
- *     of name, enclosed with double quotes if asked and needed only.
- *     Return value is the same as in (1).
- */
-static size_t quote_c_style_counted(const char *name, ssize_t maxlen,
-                                    struct strbuf *sb, FILE *fp, int no_dq)
-{
-#define EMIT(c)                                                 \
-        do {                                                    \
-                if (sb) strbuf_addch(sb, (c));                  \
-                if (fp) fputc((c), fp);                         \
-                count++;                                        \
-        } while (0)
-
-#define EMITBUF(s, l)                                           \
-        do {                                                    \
-                int __ret;                                      \
-                if (sb) strbuf_add(sb, (s), (l));               \
-                if (fp) __ret = fwrite((s), (l), 1, fp);        \
-                count += (l);                                   \
-        } while (0)
-
-        ssize_t len, count = 0;
-        const char *p = name;
-
-        for (;;) {
-                int ch;
-
-                len = next_quote_pos(p, maxlen);
-                if (len == maxlen || !p[len])
-                        break;
-
-                if (!no_dq && p == name)
-                        EMIT('"');
-
-                EMITBUF(p, len);
-                EMIT('\\');
-                p += len;
-                ch = (unsigned char)*p++;
-                if (sq_lookup[ch] >= ' ') {
-                        EMIT(sq_lookup[ch]);
-                } else {
-                        EMIT(((ch >> 6) & 03) + '0');
-                        EMIT(((ch >> 3) & 07) + '0');
-                        EMIT(((ch >> 0) & 07) + '0');
-                }
-        }
-
-        EMITBUF(p, len);
-        if (p == name)   /* no ending quote needed */
-                return 0;
-
-        if (!no_dq)
-                EMIT('"');
-        return count;
-}
-
-size_t quote_c_style(const char *name, struct strbuf *sb, FILE *fp, int nodq)
-{
-        return quote_c_style_counted(name, -1, sb, fp, nodq);
-}
-
-void quote_two_c_style(struct strbuf *sb, const char *prefix, const char *path, int nodq)
-{
-        if (quote_c_style(prefix, NULL, NULL, 0) ||
-            quote_c_style(path, NULL, NULL, 0)) {
-                if (!nodq)
-                        strbuf_addch(sb, '"');
-                quote_c_style(prefix, sb, NULL, 1);
-                quote_c_style(path, sb, NULL, 1);
-                if (!nodq)
-                        strbuf_addch(sb, '"');
-        } else {
-                strbuf_addstr(sb, prefix);
-                strbuf_addstr(sb, path);
-        }
-}
-
-void write_name_quoted(const char *name, FILE *fp, int terminator)
-{
-        if (terminator) {
-                quote_c_style(name, NULL, fp, 0);
-        } else {
-                fputs(name, fp);
-        }
-        fputc(terminator, fp);
-}
-
-void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
-                          const char *name, FILE *fp, int terminator)
-{
-        int needquote = 0;
-
-        if (terminator) {
-                needquote = next_quote_pos(pfx, pfxlen) < pfxlen
-                        || name[next_quote_pos(name, -1)];
-        }
-        if (needquote) {
-                fputc('"', fp);
-                quote_c_style_counted(pfx, pfxlen, NULL, fp, 1);
-                quote_c_style(name, NULL, fp, 1);
-                fputc('"', fp);
-        } else {
-                int ret;
-
-                ret = fwrite(pfx, pfxlen, 1, fp);
-                fputs(name, fp);
-        }
-        fputc(terminator, fp);
-}
-
-/* quote path as relative to the given prefix */
-char *quote_path_relative(const char *in, int len,
-                          struct strbuf *out, const char *prefix)
-{
-        int needquote;
-
-        if (len < 0)
-                len = strlen(in);
-
-        /* "../" prefix itself does not need quoting, but "in" might. */
-        needquote = (next_quote_pos(in, len) < len);
-        strbuf_setlen(out, 0);
-        strbuf_grow(out, len);
-
-        if (needquote)
-                strbuf_addch(out, '"');
-        if (prefix) {
-                int off = 0;
-                while (off < len && prefix[off] && prefix[off] == in[off])
-                        if (prefix[off] == '/') {
-                                prefix += off + 1;
-                                in += off + 1;
-                                len -= off + 1;
-                                off = 0;
-                        } else
-                                off++;
-
-                for (; *prefix; prefix++)
-                        if (*prefix == '/')
-                                strbuf_addstr(out, "../");
-        }
-
-        quote_c_style_counted (in, len, out, NULL, 1);
-
-        if (needquote)
-                strbuf_addch(out, '"');
-        if (!out->len)
-                strbuf_addstr(out, "./");
-
-        return out->buf;
-}
-
-/*
- * C-style name unquoting.
- *
- * Quoted should point at the opening double quote.
- * + Returns 0 if it was able to unquote the string properly, and appends the
- *   result in the strbuf `sb'.
- * + Returns -1 in case of error, and doesn't touch the strbuf. Though note
- *   that this function will allocate memory in the strbuf, so calling
- *   strbuf_release is mandatory whichever result unquote_c_style returns.
- *
- * Updates endp pointer to point at one past the ending double quote if given.
- */
-int unquote_c_style(struct strbuf *sb, const char *quoted, const char **endp)
-{
-        size_t oldlen = sb->len, len;
-        int ch, ac;
-
-        if (*quoted++ != '"')
-                return -1;
-
-        for (;;) {
-                len = strcspn(quoted, "\"\\");
-                strbuf_add(sb, quoted, len);
-                quoted += len;
-
-                switch (*quoted++) {
-                  case '"':
-                        if (endp)
-                                *endp = quoted;
-                        return 0;
-                  case '\\':
-                        break;
-                  default:
-                        goto error;
-                }
-
-                switch ((ch = *quoted++)) {
-                case 'a': ch = '\a'; break;
-                case 'b': ch = '\b'; break;
-                case 'f': ch = '\f'; break;
-                case 'n': ch = '\n'; break;
-                case 'r': ch = '\r'; break;
-                case 't': ch = '\t'; break;
-                case 'v': ch = '\v'; break;
-
-                case '\\': case '"':
-                        break; /* verbatim */
-
-                /* octal values with first digit over 4 overflow */
-                case '0': case '1': case '2': case '3':
-                                        ac = ((ch - '0') << 6);
-                        if ((ch = *quoted++) < '0' || '7' < ch)
-                                goto error;
-                                        ac |= ((ch - '0') << 3);
-                        if ((ch = *quoted++) < '0' || '7' < ch)
-                                goto error;
-                                        ac |= (ch - '0');
-                                        ch = ac;
-                                        break;
-                                default:
-                        goto error;
-                        }
-                strbuf_addch(sb, ch);
-                }
-
-  error:
-        strbuf_setlen(sb, oldlen);
-        return -1;
-}
-
-/* quoting as a string literal for other languages */
-
-void perl_quote_print(FILE *stream, const char *src)
-{
-        const char sq = '\'';
-        const char bq = '\\';
-        char c;
-
-        fputc(sq, stream);
-        while ((c = *src++)) {
-                if (c == sq || c == bq)
-                        fputc(bq, stream);
-                fputc(c, stream);
-        }
-        fputc(sq, stream);
-}
-
-void python_quote_print(FILE *stream, const char *src)
-{
-        const char sq = '\'';
-        const char bq = '\\';
-        const char nl = '\n';
-        char c;
-
-        fputc(sq, stream);
-        while ((c = *src++)) {
-                if (c == nl) {
-                        fputc(bq, stream);
-                        fputc('n', stream);
-                        continue;
-                }
-                if (c == sq || c == bq)
-                        fputc(bq, stream);
-                fputc(c, stream);
-        }
-        fputc(sq, stream);
-}
-
-void tcl_quote_print(FILE *stream, const char *src)
-{
-        char c;
-
-        fputc('"', stream);
-        while ((c = *src++)) {
-                switch (c) {
-                case '[': case ']':
-                case '{': case '}':
-                case '$': case '\\': case '"':
-                        fputc('\\', stream);
-                default:
-                        fputc(c, stream);
-                        break;
-                case '\f':
-                        fputs("\\f", stream);
-                        break;
-                case '\r':
-                        fputs("\\r", stream);
-                        break;
-                case '\n':
-                        fputs("\\n", stream);
-                        break;
-                case '\t':
-                        fputs("\\t", stream);
-                        break;
-                case '\v':
-                        fputs("\\v", stream);
-                        break;
-                }
-        }
-        fputc('"', stream);
-}
diff --git a/tools/perf/util/quote.h b/tools/perf/util/quote.h
index b6a019733919..172889ea234f 100644
--- a/tools/perf/util/quote.h
+++ b/tools/perf/util/quote.h
@@ -22,47 +22,8 @@
  *
  * Note that the above examples leak memory!  Remember to free result from
  * sq_quote() in a real application.
- *
- * sq_quote_buf() writes to an existing buffer of specified size; it
- * will return the number of characters that would have been written
- * excluding the final null regardless of the buffer size.
  */
 
-extern void sq_quote_print(FILE *stream, const char *src);
-
-extern void sq_quote_buf(struct strbuf *, const char *src);
 extern void sq_quote_argv(struct strbuf *, const char **argv, size_t maxlen);
 
-/* This unwraps what sq_quote() produces in place, but returns
- * NULL if the input does not look like what sq_quote would have
- * produced.
- */
-extern char *sq_dequote(char *);
-
-/*
- * Same as the above, but can be used to unwrap many arguments in the
- * same string separated by space. "next" is changed to point to the
- * next argument that should be passed as first parameter. When there
- * is no more argument to be dequoted, "next" is updated to point to NULL.
- */
-extern char *sq_dequote_step(char *arg, char **next);
-extern int sq_dequote_to_argv(char *arg, const char ***argv, int *nr, int *alloc);
-
-extern int unquote_c_style(struct strbuf *, const char *quoted, const char **endp);
-extern size_t quote_c_style(const char *name, struct strbuf *, FILE *, int no_dq);
-extern void quote_two_c_style(struct strbuf *, const char *, const char *, int);
-
-extern void write_name_quoted(const char *name, FILE *, int terminator);
-extern void write_name_quotedpfx(const char *pfx, ssize_t pfxlen,
-                                 const char *name, FILE *, int terminator);
-
-/* quote path as relative to the given prefix */
-char *quote_path_relative(const char *in, int len,
-                          struct strbuf *out, const char *prefix);
-
-/* quoting as a string literal for other languages */
-extern void perl_quote_print(FILE *stream, const char *src);
-extern void python_quote_print(FILE *stream, const char *src);
-extern void tcl_quote_print(FILE *stream, const char *src);
-
 #endif /* __PERF_QUOTE_H */
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
index 2b615acf94d7..da8e9b285f51 100644
--- a/tools/perf/util/run-command.c
+++ b/tools/perf/util/run-command.c
@@ -212,93 +212,3 @@ int run_command_v_opt(const char **argv, int opt)
         prepare_run_command_v_opt(&cmd, argv, opt);
         return run_command(&cmd);
 }
-
-int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env)
-{
-        struct child_process cmd;
-        prepare_run_command_v_opt(&cmd, argv, opt);
-        cmd.dir = dir;
-        cmd.env = env;
-        return run_command(&cmd);
-}
-
-int start_async(struct async *async)
-{
-        int pipe_out[2];
-
-        if (pipe(pipe_out) < 0)
-                return error("cannot create pipe: %s", strerror(errno));
-        async->out = pipe_out[0];
-
-        /* Flush stdio before fork() to avoid cloning buffers */
-        fflush(NULL);
-
-        async->pid = fork();
-        if (async->pid < 0) {
-                error("fork (async) failed: %s", strerror(errno));
-                close_pair(pipe_out);
-                return -1;
-        }
-        if (!async->pid) {
-                close(pipe_out[0]);
-                exit(!!async->proc(pipe_out[1], async->data));
-        }
-        close(pipe_out[1]);
-
-        return 0;
-}
-
-int finish_async(struct async *async)
-{
-        int ret = 0;
-
-        if (wait_or_whine(async->pid))
-                ret = error("waitpid (async) failed");
-
-        return ret;
-}
-
-int run_hook(const char *index_file, const char *name, ...)
-{
-        struct child_process hook;
-        const char **argv = NULL, *env[2];
-        char idx[PATH_MAX];
-        va_list args;
-        int ret;
-        size_t i = 0, alloc = 0;
-
-        if (access(perf_path("hooks/%s", name), X_OK) < 0)
-                return 0;
-
-        va_start(args, name);
-        ALLOC_GROW(argv, i + 1, alloc);
-        argv[i++] = perf_path("hooks/%s", name);
-        while (argv[i-1]) {
-                ALLOC_GROW(argv, i + 1, alloc);
-                argv[i++] = va_arg(args, const char *);
-        }
-        va_end(args);
-
-        memset(&hook, 0, sizeof(hook));
-        hook.argv = argv;
-        hook.no_stdin = 1;
-        hook.stdout_to_stderr = 1;
-        if (index_file) {
-                snprintf(idx, sizeof(idx), "PERF_INDEX_FILE=%s", index_file);
-                env[0] = idx;
-                env[1] = NULL;
-                hook.env = env;
-        }
-
-        ret = start_command(&hook);
-        free(argv);
-        if (ret) {
-                warning("Could not spawn %s", argv[0]);
-                return ret;
-        }
-        ret = finish_command(&hook);
-        if (ret == -ERR_RUN_COMMAND_WAITPID_SIGNAL)
-                warning("%s exited due to uncaught signal", argv[0]);
-
-        return ret;
-}
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
index d79028727ce2..1ef264d5069c 100644
--- a/tools/perf/util/run-command.h
+++ b/tools/perf/util/run-command.h
@@ -50,39 +50,9 @@ int start_command(struct child_process *);
 int finish_command(struct child_process *);
 int run_command(struct child_process *);
 
-extern int run_hook(const char *index_file, const char *name, ...);
-
 #define RUN_COMMAND_NO_STDIN 1
 #define RUN_PERF_CMD         2  /*If this is to be perf sub-command */
 #define RUN_COMMAND_STDOUT_TO_STDERR 4
 int run_command_v_opt(const char **argv, int opt);
 
-/*
- * env (the environment) is to be formatted like environ: "VAR=VALUE".
- * To unset an environment variable use just "VAR".
- */
-int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const char *const *env);
-
-/*
- * The purpose of the following functions is to feed a pipe by running
- * a function asynchronously and providing output that the caller reads.
- *
- * It is expected that no synchronization and mutual exclusion between
- * the caller and the feed function is necessary so that the function
- * can run in a thread without interfering with the caller.
- */
-struct async {
-        /*
-         * proc writes to fd and closes it;
-         * returns 0 on success, non-zero on failure
-         */
-        int (*proc)(int fd, void *data);
-        void *data;
-        int out;        /* caller reads from here and closes it */
-        pid_t pid;
-};
-
-int start_async(struct async *async);
-int finish_async(struct async *async);
-
 #endif /* __PERF_RUN_COMMAND_H */
diff --git a/tools/perf/util/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 6d6d76b8a21e..b059dc50cc2d 100644
--- a/tools/perf/util/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -25,10 +25,16 @@
 #include <ctype.h>
 #include <errno.h>
 
-#include "../perf.h"
-#include "util.h"
-#include "trace-event.h"
-#include "trace-event-perl.h"
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+#include <EXTERN.h>
+#include <perl.h>
+
+void boot_Perf__Trace__Context(pTHX_ CV *cv);
+void boot_DynaLoader(pTHX_ CV *cv);
+typedef PerlInterpreter * INTERP;
 
 void xs_init(pTHX);
 
@@ -49,7 +55,7 @@ INTERP my_perl;
 
 struct event *events[FTRACE_MAX_EVENT];
 
-static struct scripting_context *scripting_context;
+extern struct scripting_context *scripting_context;
 
 static char *cur_field_name;
 static int zero_flag_atom;
@@ -239,33 +245,6 @@ static inline struct event *find_cache_event(int type)
         return event;
 }
 
-int common_pc(struct scripting_context *context)
-{
-        int pc;
-
-        pc = parse_common_pc(context->event_data);
-
-        return pc;
-}
-
-int common_flags(struct scripting_context *context)
-{
-        int flags;
-
-        flags = parse_common_flags(context->event_data);
-
-        return flags;
-}
-
-int common_lock_depth(struct scripting_context *context)
-{
-        int lock_depth;
-
-        lock_depth = parse_common_lock_depth(context->event_data);
-
-        return lock_depth;
-}
-
 static void perl_process_event(int cpu, void *data,
                                int size __unused,
                                unsigned long long nsecs, char *comm)
@@ -392,7 +371,6 @@ static int perl_start_script(const char *script, int argc, const char **argv)
         run_start_sub();
 
         free(command_line);
-        fprintf(stderr, "perf trace started with Perl script %s\n\n", script);
         return 0;
 error:
         perl_free(my_perl);
@@ -415,8 +393,6 @@ static int perl_stop_script(void)
         perl_destruct(my_perl);
         perl_free(my_perl);
 
-        fprintf(stderr, "\nperf trace Perl script stopped\n");
-
         return 0;
 }
 
@@ -587,75 +563,3 @@ struct scripting_ops perl_scripting_ops = {
         .process_event = perl_process_event,
         .generate_script = perl_generate_script,
 };
-
-static void print_unsupported_msg(void)
-{
-        fprintf(stderr, "Perl scripting not supported."
-                "  Install libperl and rebuild perf to enable it.\n"
-                "For example:\n  # apt-get install libperl-dev (ubuntu)"
-                "\n  # yum install perl-ExtUtils-Embed (Fedora)"
-                "\n  etc.\n");
-}
-
-static int perl_start_script_unsupported(const char *script __unused,
-                                         int argc __unused,
-                                         const char **argv __unused)
-{
-        print_unsupported_msg();
-
-        return -1;
-}
-
-static int perl_stop_script_unsupported(void)
-{
-        return 0;
-}
-
-static void perl_process_event_unsupported(int cpu __unused,
-                                           void *data __unused,
-                                           int size __unused,
-                                           unsigned long long nsecs __unused,
-                                           char *comm __unused)
-{
-}
-
-static int perl_generate_script_unsupported(const char *outfile __unused)
-{
-        print_unsupported_msg();
-
-        return -1;
-}
-
-struct scripting_ops perl_scripting_unsupported_ops = {
-        .name = "Perl",
-        .start_script = perl_start_script_unsupported,
-        .stop_script = perl_stop_script_unsupported,
-        .process_event = perl_process_event_unsupported,
-        .generate_script = perl_generate_script_unsupported,
-};
-
-static void register_perl_scripting(struct scripting_ops *scripting_ops)
-{
-        int err;
-        err = script_spec_register("Perl", scripting_ops);
-        if (err)
-                die("error registering Perl script extension");
-
-        err = script_spec_register("pl", scripting_ops);
-        if (err)
-                die("error registering pl script extension");
-
-        scripting_context = malloc(sizeof(struct scripting_context));
-}
-
-#ifdef NO_LIBPERL
-void setup_perl_scripting(void)
-{
-        register_perl_scripting(&perl_scripting_unsupported_ops);
-}
-#else
-void setup_perl_scripting(void)
-{
-        register_perl_scripting(&perl_scripting_ops);
-}
-#endif
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
new file mode 100644
index 000000000000..33a632523743
--- /dev/null
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -0,0 +1,594 @@
+/*
+ * trace-event-python.  Feed trace events to an embedded Python interpreter.
+ *
+ * Copyright (C) 2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <Python.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../../perf.h"
+#include "../util.h"
+#include "../trace-event.h"
+
+PyMODINIT_FUNC initperf_trace_context(void);
+
+#define FTRACE_MAX_EVENT                                \
+        ((1 << (sizeof(unsigned short) * 8)) - 1)
+
+struct event *events[FTRACE_MAX_EVENT];
+
+#define MAX_FIELDS      64
+#define N_COMMON_FIELDS 7
+
+extern struct scripting_context *scripting_context;
+
+static char *cur_field_name;
+static int zero_flag_atom;
+
+static PyObject *main_module, *main_dict;
+
+static void handler_call_die(const char *handler_name)
+{
+        PyErr_Print();
+        Py_FatalError("problem in Python trace event handler");
+}
+
+static void define_value(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *field_value,
+                         const char *field_str)
+{
+        const char *handler_name = "define_flag_value";
+        PyObject *handler, *t, *retval;
+        unsigned long long value;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_value";
+
+        t = PyTuple_New(4);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        value = eval_flag(field_value);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        PyTuple_SetItem(t, n++, PyInt_FromLong(value));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_str));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_values(enum print_arg_type field_type,
+                          struct print_flag_sym *field,
+                          const char *ev_name,
+                          const char *field_name)
+{
+        define_value(field_type, ev_name, field_name, field->value,
+                     field->str);
+
+        if (field->next)
+                define_values(field_type, field->next, ev_name, field_name);
+}
+
+static void define_field(enum print_arg_type field_type,
+                         const char *ev_name,
+                         const char *field_name,
+                         const char *delim)
+{
+        const char *handler_name = "define_flag_field";
+        PyObject *handler, *t, *retval;
+        unsigned n = 0;
+
+        if (field_type == PRINT_SYMBOL)
+                handler_name = "define_symbolic_field";
+
+        if (field_type == PRINT_FLAGS)
+                t = PyTuple_New(3);
+        else
+                t = PyTuple_New(2);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        PyTuple_SetItem(t, n++, PyString_FromString(ev_name));
+        PyTuple_SetItem(t, n++, PyString_FromString(field_name));
+        if (field_type == PRINT_FLAGS)
+                PyTuple_SetItem(t, n++, PyString_FromString(delim));
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && PyCallable_Check(handler)) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        }
+
+        Py_DECREF(t);
+}
+
+static void define_event_symbols(struct event *event,
+                                 const char *ev_name,
+                                 struct print_arg *args)
+{
+        switch (args->type) {
+        case PRINT_NULL:
+                break;
+        case PRINT_ATOM:
+                define_value(PRINT_FLAGS, ev_name, cur_field_name, "0",
+                             args->atom.atom);
+                zero_flag_atom = 0;
+                break;
+        case PRINT_FIELD:
+                if (cur_field_name)
+                        free(cur_field_name);
+                cur_field_name = strdup(args->field.name);
+                break;
+        case PRINT_FLAGS:
+                define_event_symbols(event, ev_name, args->flags.field);
+                define_field(PRINT_FLAGS, ev_name, cur_field_name,
+                             args->flags.delim);
+                define_values(PRINT_FLAGS, args->flags.flags, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_SYMBOL:
+                define_event_symbols(event, ev_name, args->symbol.field);
+                define_field(PRINT_SYMBOL, ev_name, cur_field_name, NULL);
+                define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
+                              cur_field_name);
+                break;
+        case PRINT_STRING:
+                break;
+        case PRINT_TYPE:
+                define_event_symbols(event, ev_name, args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        zero_flag_atom = 1;
+                define_event_symbols(event, ev_name, args->op.left);
+                define_event_symbols(event, ev_name, args->op.right);
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+
+        if (args->next)
+                define_event_symbols(event, ev_name, args->next);
+}
+
+static inline struct event *find_cache_event(int type)
+{
+        static char ev_name[256];
+        struct event *event;
+
+        if (events[type])
+                return events[type];
+
+        events[type] = event = trace_find_event(type);
+        if (!event)
+                return NULL;
+
+        sprintf(ev_name, "%s__%s", event->system, event->name);
+
+        define_event_symbols(event, ev_name, event->print_fmt.args);
+
+        return event;
+}
+
+static void python_process_event(int cpu, void *data,
+                                 int size __unused,
+                                 unsigned long long nsecs, char *comm)
+{
+        PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
+        static char handler_name[256];
+        struct format_field *field;
+        unsigned long long val;
+        unsigned long s, ns;
+        struct event *event;
+        unsigned n = 0;
+        int type;
+        int pid;
+
+        t = PyTuple_New(MAX_FIELDS);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        type = trace_parse_common_type(data);
+
+        event = find_cache_event(type);
+        if (!event)
+                die("ug! no event found for type %d", type);
+
+        pid = trace_parse_common_pid(data);
+
+        sprintf(handler_name, "%s__%s", event->system, event->name);
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && !PyCallable_Check(handler))
+                handler = NULL;
+        if (!handler) {
+                dict = PyDict_New();
+                if (!dict)
+                        Py_FatalError("couldn't create Python dict");
+        }
+        s = nsecs / NSECS_PER_SEC;
+        ns = nsecs - s * NSECS_PER_SEC;
+
+        scripting_context->event_data = data;
+
+        context = PyCObject_FromVoidPtr(scripting_context, NULL);
+
+        PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
+        PyTuple_SetItem(t, n++,
+                        PyCObject_FromVoidPtr(scripting_context, NULL));
+
+        if (handler) {
+                PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(s));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
+                PyTuple_SetItem(t, n++, PyString_FromString(comm));
+        } else {
+                PyDict_SetItemString(dict, "common_cpu", PyInt_FromLong(cpu));
+                PyDict_SetItemString(dict, "common_s", PyInt_FromLong(s));
+                PyDict_SetItemString(dict, "common_ns", PyInt_FromLong(ns));
+                PyDict_SetItemString(dict, "common_pid", PyInt_FromLong(pid));
+                PyDict_SetItemString(dict, "common_comm", PyString_FromString(comm));
+        }
+        for (field = event->format.fields; field; field = field->next) {
+                if (field->flags & FIELD_IS_STRING) {
+                        int offset;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                offset = *(int *)(data + field->offset);
+                                offset &= 0xffff;
+                        } else
+                                offset = field->offset;
+                        obj = PyString_FromString((char *)data + offset);
+                } else { /* FIELD_IS_NUMERIC */
+                        val = read_size(data + field->offset, field->size);
+                        if (field->flags & FIELD_IS_SIGNED) {
+                                if ((long long)val >= LONG_MIN &&
+                                    (long long)val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromLongLong(val);
+                        } else {
+                                if (val <= LONG_MAX)
+                                        obj = PyInt_FromLong(val);
+                                else
+                                        obj = PyLong_FromUnsignedLongLong(val);
+                        }
+                }
+                if (handler)
+                        PyTuple_SetItem(t, n++, obj);
+                else
+                        PyDict_SetItemString(dict, field->name, obj);
+
+        }
+        if (!handler)
+                PyTuple_SetItem(t, n++, dict);
+
+        if (_PyTuple_Resize(&t, n) == -1)
+                Py_FatalError("error resizing Python tuple");
+
+        if (handler) {
+                retval = PyObject_CallObject(handler, t);
+                if (retval == NULL)
+                        handler_call_die(handler_name);
+        } else {
+                handler = PyDict_GetItemString(main_dict, "trace_unhandled");
+                if (handler && PyCallable_Check(handler)) {
+
+                        retval = PyObject_CallObject(handler, t);
+                        if (retval == NULL)
+                                handler_call_die("trace_unhandled");
+                }
+                Py_DECREF(dict);
+        }
+
+        Py_DECREF(t);
+}
+
+static int run_start_sub(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        main_module = PyImport_AddModule("__main__");
+        if (main_module == NULL)
+                return -1;
+        Py_INCREF(main_module);
+
+        main_dict = PyModule_GetDict(main_module);
+        if (main_dict == NULL) {
+                err = -1;
+                goto error;
+        }
+        Py_INCREF(main_dict);
+
+        handler = PyDict_GetItemString(main_dict, "trace_begin");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_begin");
+
+        Py_DECREF(retval);
+        return err;
+error:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+out:
+        return err;
+}
+
+/*
+ * Start trace script
+ */
+static int python_start_script(const char *script, int argc, const char **argv)
+{
+        const char **command_line;
+        char buf[PATH_MAX];
+        int i, err = 0;
+        FILE *fp;
+
+        command_line = malloc((argc + 1) * sizeof(const char *));
+        command_line[0] = script;
+        for (i = 1; i < argc + 1; i++)
+                command_line[i] = argv[i - 1];
+
+        Py_Initialize();
+
+        initperf_trace_context();
+
+        PySys_SetArgv(argc + 1, (char **)command_line);
+
+        fp = fopen(script, "r");
+        if (!fp) {
+                sprintf(buf, "Can't open python script \"%s\"", script);
+                perror(buf);
+                err = -1;
+                goto error;
+        }
+
+        err = PyRun_SimpleFile(fp, script);
+        if (err) {
+                fprintf(stderr, "Error running python script %s\n", script);
+                goto error;
+        }
+
+        err = run_start_sub();
+        if (err) {
+                fprintf(stderr, "Error starting python script %s\n", script);
+                goto error;
+        }
+
+        free(command_line);
+
+        return err;
+error:
+        Py_Finalize();
+        free(command_line);
+
+        return err;
+}
+
+/*
+ * Stop trace script
+ */
+static int python_stop_script(void)
+{
+        PyObject *handler, *retval;
+        int err = 0;
+
+        handler = PyDict_GetItemString(main_dict, "trace_end");
+        if (handler == NULL || !PyCallable_Check(handler))
+                goto out;
+
+        retval = PyObject_CallObject(handler, NULL);
+        if (retval == NULL)
+                handler_call_die("trace_end");
+        else
+                Py_DECREF(retval);
+out:
+        Py_XDECREF(main_dict);
+        Py_XDECREF(main_module);
+        Py_Finalize();
+
+        return err;
+}
+
+static int python_generate_script(const char *outfile)
+{
+        struct event *event = NULL;
+        struct format_field *f;
+        char fname[PATH_MAX];
+        int not_first, count;
+        FILE *ofp;
+
+        sprintf(fname, "%s.py", outfile);
+        ofp = fopen(fname, "w");
+        if (ofp == NULL) {
+                fprintf(stderr, "couldn't open %s\n", fname);
+                return -1;
+        }
+        fprintf(ofp, "# perf trace event handlers, "
+                "generated by perf trace -g python\n");
+
+        fprintf(ofp, "# Licensed under the terms of the GNU GPL"
+                " License version 2\n\n");
+
+        fprintf(ofp, "# The common_* event handler fields are the most useful "
+                "fields common to\n");
+
+        fprintf(ofp, "# all events.  They don't necessarily correspond to "
+                "the 'common_*' fields\n");
+
+        fprintf(ofp, "# in the format files.  Those fields not available as "
+                "handler params can\n");
+
+        fprintf(ofp, "# be retrieved using Python functions of the form "
+                "common_*(context).\n");
+
+        fprintf(ofp, "# See the perf-trace-python Documentation for the list "
+                "of available functions.\n\n");
+
+        fprintf(ofp, "import os\n");
+        fprintf(ofp, "import sys\n\n");
+
+        fprintf(ofp, "sys.path.append(os.environ['PERF_EXEC_PATH'] + \\\n");
+        fprintf(ofp, "\t'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')\n");
+        fprintf(ofp, "\nfrom perf_trace_context import *\n");
+        fprintf(ofp, "from Core import *\n\n\n");
+
+        fprintf(ofp, "def trace_begin():\n");
+        fprintf(ofp, "\tprint \"in trace_begin\"\n\n");
+
+        fprintf(ofp, "def trace_end():\n");
+        fprintf(ofp, "\tprint \"in trace_end\"\n\n");
+
+        while ((event = trace_find_next_event(event))) {
+                fprintf(ofp, "def %s__%s(", event->system, event->name);
+                fprintf(ofp, "event_name, ");
+                fprintf(ofp, "context, ");
+                fprintf(ofp, "common_cpu,\n");
+                fprintf(ofp, "\tcommon_secs, ");
+                fprintf(ofp, "common_nsecs, ");
+                fprintf(ofp, "common_pid, ");
+                fprintf(ofp, "common_comm,\n\t");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t");
+
+                        fprintf(ofp, "%s", f->name);
+                }
+                fprintf(ofp, "):\n");
+
+                fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+                        "common_secs, common_nsecs,\n\t\t\t"
+                        "common_pid, common_comm)\n\n");
+
+                fprintf(ofp, "\t\tprint \"");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+                        if (count && count % 3 == 0) {
+                                fprintf(ofp, "\" \\\n\t\t\"");
+                        }
+                        count++;
+
+                        fprintf(ofp, "%s=", f->name);
+                        if (f->flags & FIELD_IS_STRING ||
+                            f->flags & FIELD_IS_FLAG ||
+                            f->flags & FIELD_IS_SYMBOLIC)
+                                fprintf(ofp, "%%s");
+                        else if (f->flags & FIELD_IS_SIGNED)
+                                fprintf(ofp, "%%d");
+                        else
+                                fprintf(ofp, "%%u");
+                }
+
+                fprintf(ofp, "\\n\" %% \\\n\t\t(");
+
+                not_first = 0;
+                count = 0;
+
+                for (f = event->format.fields; f; f = f->next) {
+                        if (not_first++)
+                                fprintf(ofp, ", ");
+
+                        if (++count % 5 == 0)
+                                fprintf(ofp, "\n\t\t");
+
+                        if (f->flags & FIELD_IS_FLAG) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "flag_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else if (f->flags & FIELD_IS_SYMBOLIC) {
+                                if ((count - 1) % 5 != 0) {
+                                        fprintf(ofp, "\n\t\t");
+                                        count = 4;
+                                }
+                                fprintf(ofp, "symbol_str(\"");
+                                fprintf(ofp, "%s__%s\", ", event->system,
+                                        event->name);
+                                fprintf(ofp, "\"%s\", %s)", f->name,
+                                        f->name);
+                        } else
+                                fprintf(ofp, "%s", f->name);
+                }
+
+                fprintf(ofp, "),\n\n");
+        }
+
+        fprintf(ofp, "def trace_unhandled(event_name, context, "
+                "event_fields_dict):\n");
+
+        fprintf(ofp, "\t\tprint ' '.join(['%%s=%%s'%%(k,str(v))"
+                "for k,v in sorted(event_fields_dict.items())])\n\n");
+
+        fprintf(ofp, "def print_header("
+                "event_name, cpu, secs, nsecs, pid, comm):\n"
+                "\tprint \"%%-20s %%5u %%05u.%%09u %%8u %%-20s \" %% \\\n\t"
+                "(event_name, cpu, secs, nsecs, pid, comm),\n");
+
+        fclose(ofp);
+
+        fprintf(stderr, "generated Python script: %s\n", fname);
+
+        return 0;
+}
+
+struct scripting_ops python_scripting_ops = {
+        .name = "Python",
+        .start_script = python_start_script,
+        .stop_script = python_stop_script,
+        .process_event = python_process_event,
+        .generate_script = python_generate_script,
+};
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index ce3a6c8abe76..fa9d652c2dc3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -1,7 +1,11 @@
+#define _FILE_OFFSET_BITS 64
+
 #include <linux/kernel.h>
 
+#include <byteswap.h>
 #include <unistd.h>
 #include <sys/types.h>
+#include <sys/mman.h>
 
 #include "session.h"
 #include "sort.h"
@@ -11,10 +15,22 @@ static int perf_session__open(struct perf_session *self, bool force)
 {
         struct stat input_stat;
 
+        if (!strcmp(self->filename, "-")) {
+                self->fd_pipe = true;
+                self->fd = STDIN_FILENO;
+
+                if (perf_header__read(self, self->fd) < 0)
+                        pr_err("incompatible file format");
+
+                return 0;
+        }
+
         self->fd = open(self->filename, O_RDONLY);
         if (self->fd < 0) {
-                pr_err("failed to open file: %s", self->filename);
-                if (!strcmp(self->filename, "perf.data"))
+                int err = errno;
+
+                pr_err("failed to open %s: %s", self->filename, strerror(err));
+                if (err == ENOENT && !strcmp(self->filename, "perf.data"))
                         pr_err("  (try 'perf record' first)");
                 pr_err("\n");
                 return -errno;
@@ -35,7 +51,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 goto out_close;
         }
 
-        if (perf_header__read(&self->header, self->fd) < 0) {
+        if (perf_header__read(self, self->fd) < 0) {
                 pr_err("incompatible file format");
                 goto out_close;
         }
@@ -49,7 +65,27 @@ out_close:
         return -1;
 }
 
-struct perf_session *perf_session__new(const char *filename, int mode, bool force)
+void perf_session__update_sample_type(struct perf_session *self)
+{
+        self->sample_type = perf_header__sample_type(&self->header);
+}
+
+int perf_session__create_kernel_maps(struct perf_session *self)
+{
+        int ret = machine__create_kernel_maps(&self->host_machine);
+
+        if (ret >= 0)
+                ret = machines__create_guest_kernel_maps(&self->machines);
+        return ret;
+}
+
+static void perf_session__destroy_kernel_maps(struct perf_session *self)
+{
+        machine__destroy_kernel_maps(&self->host_machine);
+        machines__destroy_guest_kernel_maps(&self->machines);
+}
+
+struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe)
 {
         size_t len = filename ? strlen(filename) + 1 : 0;
         struct perf_session *self = zalloc(sizeof(*self) + len);
@@ -62,17 +98,28 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
 
         memcpy(self->filename, filename, len);
         self->threads = RB_ROOT;
+        INIT_LIST_HEAD(&self->dead_threads);
+        self->hists_tree = RB_ROOT;
         self->last_match = NULL;
         self->mmap_window = 32;
-        self->cwd = NULL;
-        self->cwdlen = 0;
-        map_groups__init(&self->kmaps);
+        self->machines = RB_ROOT;
+        self->repipe = repipe;
+        INIT_LIST_HEAD(&self->ordered_samples.samples_head);
+        machine__init(&self->host_machine, "", HOST_KERNEL_ID);
 
-        if (perf_session__create_kernel_maps(self) < 0)
-                goto out_delete;
+        if (mode == O_RDONLY) {
+                if (perf_session__open(self, force) < 0)
+                        goto out_delete;
+        } else if (mode == O_WRONLY) {
+                /*
+                 * In O_RDONLY mode this will be performed when reading the
+                 * kernel MMAP event, in event__process_mmap().
+                 */
+                if (perf_session__create_kernel_maps(self) < 0)
+                        goto out_delete;
+        }
 
-        if (mode == O_RDONLY && perf_session__open(self, force) < 0)
-                goto out_delete;
+        perf_session__update_sample_type(self);
 out:
         return self;
 out_free:
@@ -83,14 +130,51 @@ out_delete:
         return NULL;
 }
 
+static void perf_session__delete_dead_threads(struct perf_session *self)
+{
+        struct thread *n, *t;
+
+        list_for_each_entry_safe(t, n, &self->dead_threads, node) {
+                list_del(&t->node);
+                thread__delete(t);
+        }
+}
+
+static void perf_session__delete_threads(struct perf_session *self)
+{
+        struct rb_node *nd = rb_first(&self->threads);
+
+        while (nd) {
+                struct thread *t = rb_entry(nd, struct thread, rb_node);
+
+                rb_erase(&t->rb_node, &self->threads);
+                nd = rb_next(nd);
+                thread__delete(t);
+        }
+}
+
 void perf_session__delete(struct perf_session *self)
 {
         perf_header__exit(&self->header);
+        perf_session__destroy_kernel_maps(self);
+        perf_session__delete_dead_threads(self);
+        perf_session__delete_threads(self);
+        machine__exit(&self->host_machine);
         close(self->fd);
-        free(self->cwd);
         free(self);
 }
 
+void perf_session__remove_thread(struct perf_session *self, struct thread *th)
+{
+        self->last_match = NULL;
+        rb_erase(&th->rb_node, &self->threads);
+        /*
+         * We may have references to this thread, for instance in some hist_entry
+         * instances, so just move them to a separate list.
+         */
+        list_add_tail(&th->node, &self->dead_threads);
+}
+
 static bool symbol__match_parent_regex(struct symbol *sym)
 {
         if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -99,22 +183,17 @@ static bool symbol__match_parent_regex(struct symbol *sym)
         return 0;
 }
 
-struct symbol **perf_session__resolve_callchain(struct perf_session *self,
-                                                struct thread *thread,
-                                                struct ip_callchain *chain,
-                                                struct symbol **parent)
+struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
+                                                   struct thread *thread,
+                                                   struct ip_callchain *chain,
+                                                   struct symbol **parent)
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
-        struct symbol **syms = NULL;
         unsigned int i;
+        struct map_symbol *syms = calloc(chain->nr, sizeof(*syms));
 
-        if (symbol_conf.use_callchain) {
-                syms = calloc(chain->nr, sizeof(*syms));
-                if (!syms) {
-                        fprintf(stderr, "Can't allocate memory for symbols\n");
-                        exit(-1);
-                }
-        }
+        if (!syms)
+                return NULL;
 
         for (i = 0; i < chain->nr; i++) {
                 u64 ip = chain->ips[i];
@@ -134,17 +213,719 @@ struct symbol **perf_session__resolve_callchain(struct perf_session *self,
                         continue;
                 }
 
+                al.filtered = false;
                 thread__find_addr_location(thread, self, cpumode,
-                                           MAP__FUNCTION, ip, &al, NULL);
+                                MAP__FUNCTION, thread->pid, ip, &al, NULL);
                 if (al.sym != NULL) {
                         if (sort__has_parent && !*parent &&
                             symbol__match_parent_regex(al.sym))
                                 *parent = al.sym;
                         if (!symbol_conf.use_callchain)
                                 break;
-                        syms[i] = al.sym;
+                        syms[i].map = al.map;
+                        syms[i].sym = al.sym;
                 }
         }
 
         return syms;
 }
+
+static int process_event_stub(event_t *event __used,
+                              struct perf_session *session __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static int process_finished_round_stub(event_t *event __used,
+                                       struct perf_session *session __used,
+                                       struct perf_event_ops *ops __used)
+{
+        dump_printf(": unhandled!\n");
+        return 0;
+}
+
+static int process_finished_round(event_t *event,
+                                  struct perf_session *session,
+                                  struct perf_event_ops *ops);
+
+static void perf_event_ops__fill_defaults(struct perf_event_ops *handler)
+{
+        if (handler->sample == NULL)
+                handler->sample = process_event_stub;
+        if (handler->mmap == NULL)
+                handler->mmap = process_event_stub;
+        if (handler->comm == NULL)
+                handler->comm = process_event_stub;
+        if (handler->fork == NULL)
+                handler->fork = process_event_stub;
+        if (handler->exit == NULL)
+                handler->exit = process_event_stub;
+        if (handler->lost == NULL)
+                handler->lost = process_event_stub;
+        if (handler->read == NULL)
+                handler->read = process_event_stub;
+        if (handler->throttle == NULL)
+                handler->throttle = process_event_stub;
+        if (handler->unthrottle == NULL)
+                handler->unthrottle = process_event_stub;
+        if (handler->attr == NULL)
+                handler->attr = process_event_stub;
+        if (handler->event_type == NULL)
+                handler->event_type = process_event_stub;
+        if (handler->tracing_data == NULL)
+                handler->tracing_data = process_event_stub;
+        if (handler->build_id == NULL)
+                handler->build_id = process_event_stub;
+        if (handler->finished_round == NULL) {
+                if (handler->ordered_samples)
+                        handler->finished_round = process_finished_round;
+                else
+                        handler->finished_round = process_finished_round_stub;
+        }
+}
+
+void mem_bswap_64(void *src, int byte_size)
+{
+        u64 *m = src;
+
+        while (byte_size > 0) {
+                *m = bswap_64(*m);
+                byte_size -= sizeof(u64);
+                ++m;
+        }
+}
+
+static void event__all64_swap(event_t *self)
+{
+        struct perf_event_header *hdr = &self->header;
+        mem_bswap_64(hdr + 1, self->header.size - sizeof(*hdr));
+}
+
+static void event__comm_swap(event_t *self)
+{
+        self->comm.pid = bswap_32(self->comm.pid);
+        self->comm.tid = bswap_32(self->comm.tid);
+}
+
+static void event__mmap_swap(event_t *self)
+{
+        self->mmap.pid   = bswap_32(self->mmap.pid);
+        self->mmap.tid   = bswap_32(self->mmap.tid);
+        self->mmap.start = bswap_64(self->mmap.start);
+        self->mmap.len   = bswap_64(self->mmap.len);
+        self->mmap.pgoff = bswap_64(self->mmap.pgoff);
+}
+
+static void event__task_swap(event_t *self)
+{
+        self->fork.pid  = bswap_32(self->fork.pid);
+        self->fork.tid  = bswap_32(self->fork.tid);
+        self->fork.ppid = bswap_32(self->fork.ppid);
+        self->fork.ptid = bswap_32(self->fork.ptid);
+        self->fork.time = bswap_64(self->fork.time);
+}
+
+static void event__read_swap(event_t *self)
+{
+        self->read.pid          = bswap_32(self->read.pid);
+        self->read.tid          = bswap_32(self->read.tid);
+        self->read.value        = bswap_64(self->read.value);
+        self->read.time_enabled = bswap_64(self->read.time_enabled);
+        self->read.time_running = bswap_64(self->read.time_running);
+        self->read.id           = bswap_64(self->read.id);
+}
+
+static void event__attr_swap(event_t *self)
+{
+        size_t size;
+
+        self->attr.attr.type            = bswap_32(self->attr.attr.type);
+        self->attr.attr.size            = bswap_32(self->attr.attr.size);
+        self->attr.attr.config          = bswap_64(self->attr.attr.config);
+        self->attr.attr.sample_period   = bswap_64(self->attr.attr.sample_period);
+        self->attr.attr.sample_type     = bswap_64(self->attr.attr.sample_type);
+        self->attr.attr.read_format     = bswap_64(self->attr.attr.read_format);
+        self->attr.attr.wakeup_events   = bswap_32(self->attr.attr.wakeup_events);
+        self->attr.attr.bp_type         = bswap_32(self->attr.attr.bp_type);
+        self->attr.attr.bp_addr         = bswap_64(self->attr.attr.bp_addr);
+        self->attr.attr.bp_len          = bswap_64(self->attr.attr.bp_len);
+
+        size = self->header.size;
+        size -= (void *)&self->attr.id - (void *)self;
+        mem_bswap_64(self->attr.id, size);
+}
+
+static void event__event_type_swap(event_t *self)
+{
+        self->event_type.event_type.event_id =
+                bswap_64(self->event_type.event_type.event_id);
+}
+
+static void event__tracing_data_swap(event_t *self)
+{
+        self->tracing_data.size = bswap_32(self->tracing_data.size);
+}
+
+typedef void (*event__swap_op)(event_t *self);
+
+static event__swap_op event__swap_ops[] = {
+        [PERF_RECORD_MMAP]   = event__mmap_swap,
+        [PERF_RECORD_COMM]   = event__comm_swap,
+        [PERF_RECORD_FORK]   = event__task_swap,
+        [PERF_RECORD_EXIT]   = event__task_swap,
+        [PERF_RECORD_LOST]   = event__all64_swap,
+        [PERF_RECORD_READ]   = event__read_swap,
+        [PERF_RECORD_SAMPLE] = event__all64_swap,
+        [PERF_RECORD_HEADER_ATTR]   = event__attr_swap,
+        [PERF_RECORD_HEADER_EVENT_TYPE]   = event__event_type_swap,
+        [PERF_RECORD_HEADER_TRACING_DATA]   = event__tracing_data_swap,
+        [PERF_RECORD_HEADER_BUILD_ID]   = NULL,
+        [PERF_RECORD_HEADER_MAX]    = NULL,
+};
+
+struct sample_queue {
+        u64                     timestamp;
+        struct sample_event     *event;
+        struct list_head        list;
+};
+
+static void flush_sample_queue(struct perf_session *s,
+                               struct perf_event_ops *ops)
+{
+        struct list_head *head = &s->ordered_samples.samples_head;
+        u64 limit = s->ordered_samples.next_flush;
+        struct sample_queue *tmp, *iter;
+
+        if (!ops->ordered_samples || !limit)
+                return;
+
+        list_for_each_entry_safe(iter, tmp, head, list) {
+                if (iter->timestamp > limit)
+                        return;
+
+                if (iter == s->ordered_samples.last_inserted)
+                        s->ordered_samples.last_inserted = NULL;
+
+                ops->sample((event_t *)iter->event, s);
+
+                s->ordered_samples.last_flush = iter->timestamp;
+                list_del(&iter->list);
+                free(iter->event);
+                free(iter);
+        }
+}
+
+/*
+ * When perf record finishes a pass on every buffers, it records this pseudo
+ * event.
+ * We record the max timestamp t found in the pass n.
+ * Assuming these timestamps are monotonic across cpus, we know that if
+ * a buffer still has events with timestamps below t, they will be all
+ * available and then read in the pass n + 1.
+ * Hence when we start to read the pass n + 2, we can safely flush every
+ * events with timestamps below t.
+ *
+ *    ============ PASS n =================
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          1          |         2
+ *          2          |         3
+ *          -          |         4  <--- max recorded
+ *
+ *    ============ PASS n + 1 ==============
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          3          |         5
+ *          4          |         6
+ *          5          |         7 <---- max recorded
+ *
+ *      Flush every events below timestamp 4
+ *
+ *    ============ PASS n + 2 ==============
+ *       CPU 0         |   CPU 1
+ *                     |
+ *    cnt1 timestamps  |   cnt2 timestamps
+ *          6          |         8
+ *          7          |         9
+ *          -          |         10
+ *
+ *      Flush every events below timestamp 7
+ *      etc...
+ */
+static int process_finished_round(event_t *event __used,
+                                  struct perf_session *session,
+                                  struct perf_event_ops *ops)
+{
+        flush_sample_queue(session, ops);
+        session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
+
+        return 0;
+}
+
+static void __queue_sample_end(struct sample_queue *new, struct list_head *head)
+{
+        struct sample_queue *iter;
+
+        list_for_each_entry_reverse(iter, head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, head);
+}
+
+static void __queue_sample_before(struct sample_queue *new,
+                                  struct sample_queue *iter,
+                                  struct list_head *head)
+{
+        list_for_each_entry_continue_reverse(iter, head, list) {
+                if (iter->timestamp < new->timestamp) {
+                        list_add(&new->list, &iter->list);
+                        return;
+                }
+        }
+
+        list_add(&new->list, head);
+}
+
+static void __queue_sample_after(struct sample_queue *new,
+                                 struct sample_queue *iter,
+                                 struct list_head *head)
+{
+        list_for_each_entry_continue(iter, head, list) {
+                if (iter->timestamp > new->timestamp) {
+                        list_add_tail(&new->list, &iter->list);
+                        return;
+                }
+        }
+        list_add_tail(&new->list, head);
+}
+
+/* The queue is ordered by time */
+static void __queue_sample_event(struct sample_queue *new,
+                                 struct perf_session *s)
+{
+        struct sample_queue *last_inserted = s->ordered_samples.last_inserted;
+        struct list_head *head = &s->ordered_samples.samples_head;
+
+
+        if (!last_inserted) {
+                __queue_sample_end(new, head);
+                return;
+        }
+
+        /*
+         * Most of the time the current event has a timestamp
+         * very close to the last event inserted, unless we just switched
+         * to another event buffer. Having a sorting based on a list and
+         * on the last inserted event that is close to the current one is
+         * probably more efficient than an rbtree based sorting.
+         */
+        if (last_inserted->timestamp >= new->timestamp)
+                __queue_sample_before(new, last_inserted, head);
+        else
+                __queue_sample_after(new, last_inserted, head);
+}
+
+static int queue_sample_event(event_t *event, struct sample_data *data,
+                              struct perf_session *s)
+{
+        u64 timestamp = data->time;
+        struct sample_queue *new;
+
+
+        if (timestamp < s->ordered_samples.last_flush) {
+                printf("Warning: Timestamp below last timeslice flush\n");
+                return -EINVAL;
+        }
+
+        new = malloc(sizeof(*new));
+        if (!new)
+                return -ENOMEM;
+
+        new->timestamp = timestamp;
+
+        new->event = malloc(event->header.size);
+        if (!new->event) {
+                free(new);
+                return -ENOMEM;
+        }
+
+        memcpy(new->event, event, event->header.size);
+
+        __queue_sample_event(new, s);
+        s->ordered_samples.last_inserted = new;
+
+        if (new->timestamp > s->ordered_samples.max_timestamp)
+                s->ordered_samples.max_timestamp = new->timestamp;
+
+        return 0;
+}
+
+static int perf_session__process_sample(event_t *event, struct perf_session *s,
+                                        struct perf_event_ops *ops)
+{
+        struct sample_data data;
+
+        if (!ops->ordered_samples)
+                return ops->sample(event, s);
+
+        bzero(&data, sizeof(struct sample_data));
+        event__parse_sample(event, s->sample_type, &data);
+
+        queue_sample_event(event, &data, s);
+
+        return 0;
+}
+
+static int perf_session__process_event(struct perf_session *self,
+                                       event_t *event,
+                                       struct perf_event_ops *ops,
+                                       u64 offset, u64 head)
+{
+        trace_event(event);
+
+        if (event->header.type < PERF_RECORD_HEADER_MAX) {
+                dump_printf("%#Lx [%#x]: PERF_RECORD_%s",
+                            offset + head, event->header.size,
+                            event__name[event->header.type]);
+                hists__inc_nr_events(&self->hists, event->header.type);
+        }
+
+        if (self->header.needs_swap && event__swap_ops[event->header.type])
+                event__swap_ops[event->header.type](event);
+
+        switch (event->header.type) {
+        case PERF_RECORD_SAMPLE:
+                return perf_session__process_sample(event, self, ops);
+        case PERF_RECORD_MMAP:
+                return ops->mmap(event, self);
+        case PERF_RECORD_COMM:
+                return ops->comm(event, self);
+        case PERF_RECORD_FORK:
+                return ops->fork(event, self);
+        case PERF_RECORD_EXIT:
+                return ops->exit(event, self);
+        case PERF_RECORD_LOST:
+                return ops->lost(event, self);
+        case PERF_RECORD_READ:
+                return ops->read(event, self);
+        case PERF_RECORD_THROTTLE:
+                return ops->throttle(event, self);
+        case PERF_RECORD_UNTHROTTLE:
+                return ops->unthrottle(event, self);
+        case PERF_RECORD_HEADER_ATTR:
+                return ops->attr(event, self);
+        case PERF_RECORD_HEADER_EVENT_TYPE:
+                return ops->event_type(event, self);
+        case PERF_RECORD_HEADER_TRACING_DATA:
+                /* setup for reading amidst mmap */
+                lseek(self->fd, offset + head, SEEK_SET);
+                return ops->tracing_data(event, self);
+        case PERF_RECORD_HEADER_BUILD_ID:
+                return ops->build_id(event, self);
+        case PERF_RECORD_FINISHED_ROUND:
+                return ops->finished_round(event, self, ops);
+        default:
+                ++self->hists.stats.nr_unknown_events;
+                return -1;
+        }
+}
+
+void perf_event_header__bswap(struct perf_event_header *self)
+{
+        self->type = bswap_32(self->type);
+        self->misc = bswap_16(self->misc);
+        self->size = bswap_16(self->size);
+}
+
+static struct thread *perf_session__register_idle_thread(struct perf_session *self)
+{
+        struct thread *thread = perf_session__findnew(self, 0);
+
+        if (thread == NULL || thread__set_comm(thread, "swapper")) {
+                pr_err("problem inserting idle task.\n");
+                thread = NULL;
+        }
+
+        return thread;
+}
+
+int do_read(int fd, void *buf, size_t size)
+{
+        void *buf_start = buf;
+
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret <= 0)
+                        return ret;
+
+                size -= ret;
+                buf += ret;
+        }
+
+        return buf - buf_start;
+}
+
+#define session_done()  (*(volatile int *)(&session_done))
+volatile int session_done;
+
+static int __perf_session__process_pipe_events(struct perf_session *self,
+                                               struct perf_event_ops *ops)
+{
+        event_t event;
+        uint32_t size;
+        int skip = 0;
+        u64 head;
+        int err;
+        void *p;
+
+        perf_event_ops__fill_defaults(ops);
+
+        head = 0;
+more:
+        err = do_read(self->fd, &event, sizeof(struct perf_event_header));
+        if (err <= 0) {
+                if (err == 0)
+                        goto done;
+
+                pr_err("failed to read event header\n");
+                goto out_err;
+        }
+
+        if (self->header.needs_swap)
+                perf_event_header__bswap(&event.header);
+
+        size = event.header.size;
+        if (size == 0)
+                size = 8;
+
+        p = &event;
+        p += sizeof(struct perf_event_header);
+
+        if (size - sizeof(struct perf_event_header)) {
+                err = do_read(self->fd, p,
+                              size - sizeof(struct perf_event_header));
+                if (err <= 0) {
+                        if (err == 0) {
+                                pr_err("unexpected end of event stream\n");
+                                goto done;
+                        }
+
+                        pr_err("failed to read event data\n");
+                        goto out_err;
+                }
+        }
+
+        if (size == 0 ||
+            (skip = perf_session__process_event(self, &event, ops,
+                                                0, head)) < 0) {
+                dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
+                            head, event.header.size, event.header.type);
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        dump_printf("\n%#Lx [%#x]: event: %d\n",
+                    head, event.header.size, event.header.type);
+
+        if (skip > 0)
+                head += skip;
+
+        if (!session_done())
+                goto more;
+done:
+        err = 0;
+out_err:
+        return err;
+}
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size,
+                                   u64 file_size, struct perf_event_ops *ops)
+{
+        int err, mmap_prot, mmap_flags;
+        u64 head, shift;
+        u64 offset = 0;
+        size_t  page_size;
+        event_t *event;
+        uint32_t size;
+        char *buf;
+        struct ui_progress *progress = ui_progress__new("Processing events...",
+                                                        self->size);
+        if (progress == NULL)
+                return -1;
+
+        perf_event_ops__fill_defaults(ops);
+
+        page_size = sysconf(_SC_PAGESIZE);
+
+        head = data_offset;
+        shift = page_size * (head / page_size);
+        offset += shift;
+        head -= shift;
+
+        mmap_prot  = PROT_READ;
+        mmap_flags = MAP_SHARED;
+
+        if (self->header.needs_swap) {
+                mmap_prot  |= PROT_WRITE;
+                mmap_flags = MAP_PRIVATE;
+        }
+remap:
+        buf = mmap(NULL, page_size * self->mmap_window, mmap_prot,
+                   mmap_flags, self->fd, offset);
+        if (buf == MAP_FAILED) {
+                pr_err("failed to mmap file\n");
+                err = -errno;
+                goto out_err;
+        }
+
+more:
+        event = (event_t *)(buf + head);
+        ui_progress__update(progress, offset);
+
+        if (self->header.needs_swap)
+                perf_event_header__bswap(&event->header);
+        size = event->header.size;
+        if (size == 0)
+                size = 8;
+
+        if (head + event->header.size >= page_size * self->mmap_window) {
+                int munmap_ret;
+
+                shift = page_size * (head / page_size);
+
+                munmap_ret = munmap(buf, page_size * self->mmap_window);
+                assert(munmap_ret == 0);
+
+                offset += shift;
+                head -= shift;
+                goto remap;
+        }
+
+        size = event->header.size;
+
+        dump_printf("\n%#Lx [%#x]: event: %d\n",
+                    offset + head, event->header.size, event->header.type);
+
+        if (size == 0 ||
+            perf_session__process_event(self, event, ops, offset, head) < 0) {
+                dump_printf("%#Lx [%#x]: skipping unknown header type: %d\n",
+                            offset + head, event->header.size,
+                            event->header.type);
+                /*
+                 * assume we lost track of the stream, check alignment, and
+                 * increment a single u64 in the hope to catch on again 'soon'.
+                 */
+                if (unlikely(head & 7))
+                        head &= ~7ULL;
+
+                size = 8;
+        }
+
+        head += size;
+
+        if (offset + head >= data_offset + data_size)
+                goto done;
+
+        if (offset + head < file_size)
+                goto more;
+done:
+        err = 0;
+        /* do the final flush for ordered samples */
+        self->ordered_samples.next_flush = ULLONG_MAX;
+        flush_sample_queue(self, ops);
+out_err:
+        ui_progress__delete(progress);
+        return err;
+}
+
+int perf_session__process_events(struct perf_session *self,
+                                 struct perf_event_ops *ops)
+{
+        int err;
+
+        if (perf_session__register_idle_thread(self) == NULL)
+                return -ENOMEM;
+
+        if (!self->fd_pipe)
+                err = __perf_session__process_events(self,
+                                                     self->header.data_offset,
+                                                     self->header.data_size,
+                                                     self->size, ops);
+        else
+                err = __perf_session__process_pipe_events(self, ops);
+
+        return err;
+}
+
+bool perf_session__has_traces(struct perf_session *self, const char *msg)
+{
+        if (!(self->sample_type & PERF_SAMPLE_RAW)) {
+                pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
+                return false;
+        }
+
+        return true;
+}
+
+int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
+                                             const char *symbol_name,
+                                             u64 addr)
+{
+        char *bracket;
+        enum map_type i;
+        struct ref_reloc_sym *ref;
+
+        ref = zalloc(sizeof(struct ref_reloc_sym));
+        if (ref == NULL)
+                return -ENOMEM;
+
+        ref->name = strdup(symbol_name);
+        if (ref->name == NULL) {
+                free(ref);
+                return -ENOMEM;
+        }
+
+        bracket = strchr(ref->name, ']');
+        if (bracket)
+                *bracket = '\0';
+
+        ref->addr = addr;
+
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                struct kmap *kmap = map__kmap(maps[i]);
+                kmap->ref_reloc_sym = ref;
+        }
+
+        return 0;
+}
+
+size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp)
+{
+        return __dsos__fprintf(&self->host_machine.kernel_dsos, fp) +
+               __dsos__fprintf(&self->host_machine.user_dsos, fp) +
+               machines__fprintf_dsos(&self->machines, fp);
+}
+
+size_t perf_session__fprintf_dsos_buildid(struct perf_session *self, FILE *fp,
+                                          bool with_hits)
+{
+        size_t ret = machine__fprintf_dsos_buildid(&self->host_machine, fp, with_hits);
+        return ret + machines__fprintf_dsos_buildid(&self->machines, fp, with_hits);
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 32eaa1bada06..9fa0fc2a863f 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -1,61 +1,145 @@
 #ifndef __PERF_SESSION_H
 #define __PERF_SESSION_H
 
+#include "hist.h"
 #include "event.h"
 #include "header.h"
+#include "symbol.h"
 #include "thread.h"
 #include <linux/rbtree.h>
 #include "../../../include/linux/perf_event.h"
 
+struct sample_queue;
 struct ip_callchain;
 struct thread;
-struct symbol;
+
+struct ordered_samples {
+        u64                     last_flush;
+        u64                     next_flush;
+        u64                     max_timestamp;
+        struct list_head        samples_head;
+        struct sample_queue     *last_inserted;
+};
 
 struct perf_session {
         struct perf_header      header;
         unsigned long           size;
         unsigned long           mmap_window;
-        struct map_groups       kmaps;
         struct rb_root          threads;
+        struct list_head        dead_threads;
         struct thread           *last_match;
-        struct events_stats     events_stats;
-        unsigned long           event_total[PERF_RECORD_MAX];
-        struct rb_root          hists;
+        struct machine          host_machine;
+        struct rb_root          machines;
+        struct rb_root          hists_tree;
+        /*
+         * FIXME: should point to the first entry in hists_tree and
+         *        be a hists instance. Right now its only 'report'
+         *        that is using ->hists_tree while all the rest use
+         *        ->hists.
+         */
+        struct hists            hists;
         u64                     sample_type;
         int                     fd;
+        bool                    fd_pipe;
+        bool                    repipe;
         int                     cwdlen;
         char                    *cwd;
+        struct ordered_samples  ordered_samples;
         char filename[0];
 };
 
+struct perf_event_ops;
+
 typedef int (*event_op)(event_t *self, struct perf_session *session);
+typedef int (*event_op2)(event_t *self, struct perf_session *session,
+                         struct perf_event_ops *ops);
 
 struct perf_event_ops {
-        event_op        process_sample_event;
-        event_op        process_mmap_event;
-        event_op        process_comm_event;
-        event_op        process_fork_event;
-        event_op        process_exit_event;
-        event_op        process_lost_event;
-        event_op        process_read_event;
-        event_op        process_throttle_event;
-        event_op        process_unthrottle_event;
-        int             (*sample_type_check)(struct perf_session *session);
-        unsigned long   total_unknown;
-        bool            full_paths;
+        event_op        sample,
+                        mmap,
+                        comm,
+                        fork,
+                        exit,
+                        lost,
+                        read,
+                        throttle,
+                        unthrottle,
+                        attr,
+                        event_type,
+                        tracing_data,
+                        build_id;
+        event_op2       finished_round;
+        bool            ordered_samples;
 };
 
-struct perf_session *perf_session__new(const char *filename, int mode, bool force);
+struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe);
 void perf_session__delete(struct perf_session *self);
 
+void perf_event_header__bswap(struct perf_event_header *self);
+
+int __perf_session__process_events(struct perf_session *self,
+                                   u64 data_offset, u64 data_size, u64 size,
+                                   struct perf_event_ops *ops);
 int perf_session__process_events(struct perf_session *self,
                                  struct perf_event_ops *event_ops);
 
-struct symbol **perf_session__resolve_callchain(struct perf_session *self,
-                                                struct thread *thread,
-                                                struct ip_callchain *chain,
-                                                struct symbol **parent);
+struct map_symbol *perf_session__resolve_callchain(struct perf_session *self,
+                                                   struct thread *thread,
+                                                   struct ip_callchain *chain,
+                                                   struct symbol **parent);
+
+bool perf_session__has_traces(struct perf_session *self, const char *msg);
+
+int perf_session__set_kallsyms_ref_reloc_sym(struct map **maps,
+                                             const char *symbol_name,
+                                             u64 addr);
+
+void mem_bswap_64(void *src, int byte_size);
+
+int perf_session__create_kernel_maps(struct perf_session *self);
+
+int do_read(int fd, void *buf, size_t size);
+void perf_session__update_sample_type(struct perf_session *self);
+void perf_session__remove_thread(struct perf_session *self, struct thread *th);
+
+static inline
+struct machine *perf_session__find_host_machine(struct perf_session *self)
+{
+        return &self->host_machine;
+}
+
+static inline
+struct machine *perf_session__find_machine(struct perf_session *self, pid_t pid)
+{
+        if (pid == HOST_KERNEL_ID)
+                return &self->host_machine;
+        return machines__find(&self->machines, pid);
+}
+
+static inline
+struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t pid)
+{
+        if (pid == HOST_KERNEL_ID)
+                return &self->host_machine;
+        return machines__findnew(&self->machines, pid);
+}
+
+static inline
+void perf_session__process_machines(struct perf_session *self,
+                                    machine__process_t process)
+{
+        process(&self->host_machine, self);
+        return machines__process(&self->machines, process, self);
+}
+
+size_t perf_session__fprintf_dsos(struct perf_session *self, FILE *fp);
 
-int perf_header__read_build_ids(int input, u64 offset, u64 file_size);
+size_t perf_session__fprintf_dsos_buildid(struct perf_session *self,
+                                          FILE *fp, bool with_hits);
 
+static inline
+size_t perf_session__fprintf_nr_events(struct perf_session *self, FILE *fp)
+{
+        return hists__fprintf_nr_events(&self->hists, fp);
+}
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sigchain.c b/tools/perf/util/sigchain.c
index 1118b99e57d3..ba785e9b1841 100644
--- a/tools/perf/util/sigchain.c
+++ b/tools/perf/util/sigchain.c
@@ -16,7 +16,7 @@ static void check_signum(int sig)
                 die("BUG: signal out of range: %d", sig);
 }
 
-int sigchain_push(int sig, sigchain_fun f)
+static int sigchain_push(int sig, sigchain_fun f)
 {
         struct sigchain_signal *s = signals + sig;
         check_signum(sig);
diff --git a/tools/perf/util/sigchain.h b/tools/perf/util/sigchain.h
index 1a53c11265fd..959d64eb5557 100644
--- a/tools/perf/util/sigchain.h
+++ b/tools/perf/util/sigchain.h
@@ -3,7 +3,6 @@
 
 typedef void (*sigchain_fun)(int);
 
-int sigchain_push(int sig, sigchain_fun f);
 int sigchain_pop(int sig);
 
 void sigchain_push_common(sigchain_fun f);
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index cb0f327de9e8..b62a553cc67d 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,56 +1,74 @@
 #include "sort.h"
+#include "hist.h"
 
 regex_t         parent_regex;
-char            default_parent_pattern[] = "^sys_|^do_page_fault";
-char            *parent_pattern = default_parent_pattern;
-char            default_sort_order[] = "comm,dso,symbol";
-char            *sort_order = default_sort_order;
+const char      default_parent_pattern[] = "^sys_|^do_page_fault";
+const char      *parent_pattern = default_parent_pattern;
+const char      default_sort_order[] = "comm,dso,symbol";
+const char      *sort_order = default_sort_order;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
 
 enum sort_type  sort__first_dimension;
 
-unsigned int dsos__col_width;
-unsigned int comms__col_width;
-unsigned int threads__col_width;
-static unsigned int parent_symbol__col_width;
 char * field_sep;
 
 LIST_HEAD(hist_entry__sort_list);
 
+static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width);
+static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
+                                     size_t size, unsigned int width);
+static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
+static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width);
+static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
+
 struct sort_entry sort_thread = {
-        .header = "Command:  Pid",
-        .cmp    = sort__thread_cmp,
-        .print  = sort__thread_print,
-        .width  = &threads__col_width,
+        .se_header      = "Command:  Pid",
+        .se_cmp         = sort__thread_cmp,
+        .se_snprintf    = hist_entry__thread_snprintf,
+        .se_width_idx   = HISTC_THREAD,
 };
 
 struct sort_entry sort_comm = {
-        .header         = "Command",
-        .cmp            = sort__comm_cmp,
-        .collapse       = sort__comm_collapse,
-        .print          = sort__comm_print,
-        .width          = &comms__col_width,
+        .se_header      = "Command",
+        .se_cmp         = sort__comm_cmp,
+        .se_collapse    = sort__comm_collapse,
+        .se_snprintf    = hist_entry__comm_snprintf,
+        .se_width_idx   = HISTC_COMM,
 };
 
 struct sort_entry sort_dso = {
-        .header = "Shared Object",
-        .cmp    = sort__dso_cmp,
-        .print  = sort__dso_print,
-        .width  = &dsos__col_width,
+        .se_header      = "Shared Object",
+        .se_cmp         = sort__dso_cmp,
+        .se_snprintf    = hist_entry__dso_snprintf,
+        .se_width_idx   = HISTC_DSO,
 };
 
 struct sort_entry sort_sym = {
-        .header = "Symbol",
-        .cmp    = sort__sym_cmp,
-        .print  = sort__sym_print,
+        .se_header      = "Symbol",
+        .se_cmp         = sort__sym_cmp,
+        .se_snprintf    = hist_entry__sym_snprintf,
+        .se_width_idx   = HISTC_SYMBOL,
 };
 
 struct sort_entry sort_parent = {
-        .header = "Parent symbol",
-        .cmp    = sort__parent_cmp,
-        .print  = sort__parent_print,
-        .width  = &parent_symbol__col_width,
+        .se_header      = "Parent symbol",
+        .se_cmp         = sort__parent_cmp,
+        .se_snprintf    = hist_entry__parent_snprintf,
+        .se_width_idx   = HISTC_PARENT,
+};
+ 
+struct sort_entry sort_cpu = {
+        .se_header      = "CPU",
+        .se_cmp         = sort__cpu_cmp,
+        .se_snprintf    = hist_entry__cpu_snprintf,
+        .se_width_idx   = HISTC_CPU,
 };
 
 struct sort_dimension {
@@ -65,6 +83,7 @@ static struct sort_dimension sort_dimensions[] = {
         { .name = "dso",        .entry = &sort_dso,     },
         { .name = "symbol",     .entry = &sort_sym,     },
         { .name = "parent",     .entry = &sort_parent,  },
+        { .name = "cpu",        .entry = &sort_cpu,     },
 };
 
 int64_t cmp_null(void *l, void *r)
@@ -85,45 +104,38 @@ sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
         return right->thread->pid - left->thread->pid;
 }
 
-int repsep_fprintf(FILE *fp, const char *fmt, ...)
+static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
 {
         int n;
         va_list ap;
 
         va_start(ap, fmt);
-        if (!field_sep)
-                n = vfprintf(fp, fmt, ap);
-        else {
-                char *bf = NULL;
-                n = vasprintf(&bf, fmt, ap);
-                if (n > 0) {
-                        char *sep = bf;
-
-                        while (1) {
-                                sep = strchr(sep, *field_sep);
-                                if (sep == NULL)
-                                        break;
-                                *sep = '.';
-                        }
+        n = vsnprintf(bf, size, fmt, ap);
+        if (field_sep && n > 0) {
+                char *sep = bf;
+
+                while (1) {
+                        sep = strchr(sep, *field_sep);
+                        if (sep == NULL)
+                                break;
+                        *sep = '.';
                 }
-                fputs(bf, fp);
-                free(bf);
         }
         va_end(ap);
         return n;
 }
 
-size_t
-sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__thread_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%*s:%5d", width - 6,
+        return repsep_snprintf(bf, size, "%*s:%5d", width,
                               self->thread->comm ?: "", self->thread->pid);
 }
 
-size_t
-sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
+                                     size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%*s", width, self->thread->comm);
+        return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
 }
 
 /* --sort dso */
@@ -131,8 +143,8 @@ sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
 int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-        struct dso *dso_l = left->map ? left->map->dso : NULL;
-        struct dso *dso_r = right->map ? right->map->dso : NULL;
+        struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
+        struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
         const char *dso_name_l, *dso_name_r;
 
         if (!dso_l || !dso_r)
@@ -149,16 +161,16 @@ sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
         return strcmp(dso_name_l, dso_name_r);
 }
 
-size_t
-sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
 {
-        if (self->map && self->map->dso) {
-                const char *dso_name = !verbose ? self->map->dso->short_name :
-                                                  self->map->dso->long_name;
-                return repsep_fprintf(fp, "%-*s", width, dso_name);
+        if (self->ms.map && self->ms.map->dso) {
+                const char *dso_name = !verbose ? self->ms.map->dso->short_name :
+                                                  self->ms.map->dso->long_name;
+                return repsep_snprintf(bf, size, "%-*s", width, dso_name);
         }
 
-        return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
+        return repsep_snprintf(bf, size, "%*Lx", width, self->ip);
 }
 
 /* --sort symbol */
@@ -168,31 +180,33 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {
         u64 ip_l, ip_r;
 
-        if (left->sym == right->sym)
+        if (left->ms.sym == right->ms.sym)
                 return 0;
 
-        ip_l = left->sym ? left->sym->start : left->ip;
-        ip_r = right->sym ? right->sym->start : right->ip;
+        ip_l = left->ms.sym ? left->ms.sym->start : left->ip;
+        ip_r = right->ms.sym ? right->ms.sym->start : right->ip;
 
         return (int64_t)(ip_r - ip_l);
 }
 
-
-size_t
-sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width __used)
 {
         size_t ret = 0;
 
         if (verbose) {
-                char o = self->map ? dso__symtab_origin(self->map->dso) : '!';
-                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip, o);
+                char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
+                ret += repsep_snprintf(bf, size, "%*Lx %c ",
+                                       BITS_PER_LONG / 4, self->ip, o);
         }
 
-        ret += repsep_fprintf(fp, "[%c] ", self->level);
-        if (self->sym)
-                ret += repsep_fprintf(fp, "%s", self->sym->name);
+        ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
+        if (self->ms.sym)
+                ret += repsep_snprintf(bf + ret, size - ret, "%s",
+                                       self->ms.sym->name);
         else
-                ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
+                ret += repsep_snprintf(bf + ret, size - ret, "%*Lx",
+                                       BITS_PER_LONG / 4, self->ip);
 
         return ret;
 }
@@ -231,13 +245,27 @@ sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
         return strcmp(sym_l->name, sym_r->name);
 }
 
-size_t
-sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
+static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
 {
-        return repsep_fprintf(fp, "%-*s", width,
+        return repsep_snprintf(bf, size, "%-*s", width,
                               self->parent ? self->parent->name : "[other]");
 }
 
+/* --sort cpu */
+
+int64_t
+sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->cpu - left->cpu;
+}
+
+static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*d", width, self->cpu);
+}
+
 int sort_dimension__add(const char *tok)
 {
         unsigned int i;
@@ -251,7 +279,7 @@ int sort_dimension__add(const char *tok)
                 if (strncasecmp(tok, sd->name, strlen(tok)))
                         continue;
 
-                if (sd->entry->collapse)
+                if (sd->entry->se_collapse)
                         sort__need_collapse = 1;
 
                 if (sd->entry == &sort_parent) {
@@ -260,9 +288,8 @@ int sort_dimension__add(const char *tok)
                                 char err[BUFSIZ];
 
                                 regerror(ret, &parent_regex, err, sizeof(err));
-                                fprintf(stderr, "Invalid regex: %s\n%s",
-                                        parent_pattern, err);
-                                exit(-1);
+                                pr_err("Invalid regex: %s\n%s", parent_pattern, err);
+                                return -EINVAL;
                         }
                         sort__has_parent = 1;
                 }
@@ -278,6 +305,8 @@ int sort_dimension__add(const char *tok)
                                 sort__first_dimension = SORT_SYM;
                         else if (!strcmp(sd->name, "parent"))
                                 sort__first_dimension = SORT_PARENT;
+                        else if (!strcmp(sd->name, "cpu"))
+                                sort__first_dimension = SORT_CPU;
                 }
 
                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 753f9ea99fb0..46e531d09e8b 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -25,10 +25,10 @@
 #include "sort.h"
 
 extern regex_t parent_regex;
-extern char *sort_order;
-extern char default_parent_pattern[];
-extern char *parent_pattern;
-extern char default_sort_order[];
+extern const char *sort_order;
+extern const char default_parent_pattern[];
+extern const char *parent_pattern;
+extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
 extern char *field_sep;
@@ -36,26 +36,41 @@ extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
 extern struct sort_entry sort_parent;
-extern unsigned int dsos__col_width;
-extern unsigned int comms__col_width;
-extern unsigned int threads__col_width;
 extern enum sort_type sort__first_dimension;
 
+/**
+ * struct hist_entry - histogram entry
+ *
+ * @row_offset - offset from the first callchain expanded to appear on screen
+ * @nr_rows - rows expanded in callchain, recalculated on folding/unfolding
+ */
 struct hist_entry {
         struct rb_node          rb_node;
-        u64                     count;
+        u64                     period;
+        u64                     period_sys;
+        u64                     period_us;
+        u64                     period_guest_sys;
+        u64                     period_guest_us;
+        struct map_symbol       ms;
         struct thread           *thread;
-        struct map              *map;
-        struct symbol           *sym;
         u64                     ip;
+        s32                     cpu;
+        u32                     nr_events;
+
+        /* XXX These two should move to some tree widget lib */
+        u16                     row_offset;
+        u16                     nr_rows;
+
+        bool                    init_have_children;
         char                    level;
-        struct symbol     *parent;
-        struct callchain_node   callchain;
+        u8                      filtered;
+        struct symbol           *parent;
         union {
                 unsigned long     position;
                 struct hist_entry *pair;
                 struct rb_root    sorted_chain;
         };
+        struct callchain_node   callchain[0];
 };
 
 enum sort_type {
@@ -63,7 +78,8 @@ enum sort_type {
         SORT_COMM,
         SORT_DSO,
         SORT_SYM,
-        SORT_PARENT
+        SORT_PARENT,
+        SORT_CPU,
 };
 
 /*
@@ -73,12 +89,13 @@ enum sort_type {
 struct sort_entry {
         struct list_head list;
 
-        const char *header;
+        const char *se_header;
 
-        int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
-        int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
-        size_t  (*print)(FILE *fp, struct hist_entry *, unsigned int width);
-        unsigned int *width;
+        int64_t (*se_cmp)(struct hist_entry *, struct hist_entry *);
+        int64_t (*se_collapse)(struct hist_entry *, struct hist_entry *);
+        int     (*se_snprintf)(struct hist_entry *self, char *bf, size_t size,
+                               unsigned int width);
+        u8      se_width_idx;
         bool    elide;
 };
 
@@ -87,7 +104,6 @@ extern struct list_head hist_entry__sort_list;
 
 void setup_sorting(const char * const usagestr[], const struct option *opts);
 
-extern int repsep_fprintf(FILE *fp, const char *fmt, ...);
 extern size_t sort__thread_print(FILE *, struct hist_entry *, unsigned int);
 extern size_t sort__comm_print(FILE *, struct hist_entry *, unsigned int);
 extern size_t sort__dso_print(FILE *, struct hist_entry *, unsigned int);
@@ -99,6 +115,7 @@ extern int64_t sort__comm_collapse(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__dso_cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__sym_cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__parent_cmp(struct hist_entry *, struct hist_entry *);
+int64_t sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right);
 extern size_t sort__parent_print(FILE *, struct hist_entry *, unsigned int);
 extern int sort_dimension__add(const char *);
 void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 5249d5a1b0c2..92e068517c1a 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -41,16 +41,6 @@ char *strbuf_detach(struct strbuf *sb, size_t *sz)
         return res;
 }
 
-void strbuf_attach(struct strbuf *sb, void *buf, size_t len, size_t alloc)
-{
-        strbuf_release(sb);
-        sb->buf   = buf;
-        sb->len   = len;
-        sb->alloc = alloc;
-        strbuf_grow(sb, 0);
-        sb->buf[sb->len] = '\0';
-}
-
 void strbuf_grow(struct strbuf *sb, size_t extra)
 {
         if (sb->len + extra + 1 <= sb->len)
@@ -60,94 +50,7 @@ void strbuf_grow(struct strbuf *sb, size_t extra)
         ALLOC_GROW(sb->buf, sb->len + extra + 1, sb->alloc);
 }
 
-void strbuf_trim(struct strbuf *sb)
-{
-        char *b = sb->buf;
-        while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
-                sb->len--;
-        while (sb->len > 0 && isspace(*b)) {
-                b++;
-                sb->len--;
-        }
-        memmove(sb->buf, b, sb->len);
-        sb->buf[sb->len] = '\0';
-}
-void strbuf_rtrim(struct strbuf *sb)
-{
-        while (sb->len > 0 && isspace((unsigned char)sb->buf[sb->len - 1]))
-                sb->len--;
-        sb->buf[sb->len] = '\0';
-}
-
-void strbuf_ltrim(struct strbuf *sb)
-{
-        char *b = sb->buf;
-        while (sb->len > 0 && isspace(*b)) {
-                b++;
-                sb->len--;
-        }
-        memmove(sb->buf, b, sb->len);
-        sb->buf[sb->len] = '\0';
-}
-
-void strbuf_tolower(struct strbuf *sb)
-{
-        unsigned int i;
-
-        for (i = 0; i < sb->len; i++)
-                sb->buf[i] = tolower(sb->buf[i]);
-}
-
-struct strbuf **strbuf_split(const struct strbuf *sb, int delim)
-{
-        int alloc = 2, pos = 0;
-        char *n, *p;
-        struct strbuf **ret;
-        struct strbuf *t;
-
-        ret = calloc(alloc, sizeof(struct strbuf *));
-        p = n = sb->buf;
-        while (n < sb->buf + sb->len) {
-                int len;
-                n = memchr(n, delim, sb->len - (n - sb->buf));
-                if (pos + 1 >= alloc) {
-                        alloc = alloc * 2;
-                        ret = realloc(ret, sizeof(struct strbuf *) * alloc);
-                }
-                if (!n)
-                        n = sb->buf + sb->len - 1;
-                len = n - p + 1;
-                t = malloc(sizeof(struct strbuf));
-                strbuf_init(t, len);
-                strbuf_add(t, p, len);
-                ret[pos] = t;
-                ret[++pos] = NULL;
-                p = ++n;
-        }
-        return ret;
-}
-
-void strbuf_list_free(struct strbuf **sbs)
-{
-        struct strbuf **s = sbs;
-
-        while (*s) {
-                strbuf_release(*s);
-                free(*s++);
-        }
-        free(sbs);
-}
-
-int strbuf_cmp(const struct strbuf *a, const struct strbuf *b)
-{
-        int len = a->len < b->len ? a->len: b->len;
-        int cmp = memcmp(a->buf, b->buf, len);
-        if (cmp)
-                return cmp;
-        return a->len < b->len ? -1: a->len != b->len;
-}
-
-void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
+static void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
                                    const void *data, size_t dlen)
 {
         if (pos + len < pos)
@@ -166,11 +69,6 @@ void strbuf_splice(struct strbuf *sb, size_t pos, size_t len,
         strbuf_setlen(sb, sb->len + dlen - len);
 }
 
-void strbuf_insert(struct strbuf *sb, size_t pos, const void *data, size_t len)
-{
-        strbuf_splice(sb, pos, 0, data, len);
-}
-
 void strbuf_remove(struct strbuf *sb, size_t pos, size_t len)
 {
         strbuf_splice(sb, pos, len, NULL, 0);
@@ -183,13 +81,6 @@ void strbuf_add(struct strbuf *sb, const void *data, size_t len)
         strbuf_setlen(sb, sb->len + len);
 }
 
-void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len)
-{
-        strbuf_grow(sb, len);
-        memcpy(sb->buf + sb->len, sb->buf + pos, len);
-        strbuf_setlen(sb, sb->len + len);
-}
-
 void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
 {
         int len;
@@ -214,57 +105,6 @@ void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
         strbuf_setlen(sb, sb->len + len);
 }
 
-void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn,
-                   void *context)
-{
-        for (;;) {
-                const char *percent;
-                size_t consumed;
-
-                percent = strchrnul(format, '%');
-                strbuf_add(sb, format, percent - format);
-                if (!*percent)
-                        break;
-                format = percent + 1;
-
-                consumed = fn(sb, format, context);
-                if (consumed)
-                        format += consumed;
-                else
-                        strbuf_addch(sb, '%');
-        }
-}
-
-size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder,
-                void *context)
-{
-        struct strbuf_expand_dict_entry *e = context;
-        size_t len;
-
-        for (; e->placeholder && (len = strlen(e->placeholder)); e++) {
-                if (!strncmp(placeholder, e->placeholder, len)) {
-                        if (e->value)
-                                strbuf_addstr(sb, e->value);
-                        return len;
-                }
-        }
-        return 0;
-}
-
-size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
-{
-        size_t res;
-        size_t oldalloc = sb->alloc;
-
-        strbuf_grow(sb, size);
-        res = fread(sb->buf + sb->len, 1, size, f);
-        if (res > 0)
-                strbuf_setlen(sb, sb->len + res);
-        else if (oldalloc == 0)
-                strbuf_release(sb);
-        return res;
-}
-
 ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
 {
         size_t oldlen = sb->len;
@@ -291,70 +131,3 @@ ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
         sb->buf[sb->len] = '\0';
         return sb->len - oldlen;
 }
-
-#define STRBUF_MAXLINK (2*PATH_MAX)
-
-int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint)
-{
-        size_t oldalloc = sb->alloc;
-
-        if (hint < 32)
-                hint = 32;
-
-        while (hint < STRBUF_MAXLINK) {
-                ssize_t len;
-
-                strbuf_grow(sb, hint);
-                len = readlink(path, sb->buf, hint);
-                if (len < 0) {
-                        if (errno != ERANGE)
-                                break;
-                } else if (len < hint) {
-                        strbuf_setlen(sb, len);
-                        return 0;
-                }
-
-                /* .. the buffer was too small - try again */
-                hint *= 2;
-        }
-        if (oldalloc == 0)
-                strbuf_release(sb);
-        return -1;
-}
-
-int strbuf_getline(struct strbuf *sb, FILE *fp, int term)
-{
-        int ch;
-
-        strbuf_grow(sb, 0);
-        if (feof(fp))
-                return EOF;
-
-        strbuf_reset(sb);
-        while ((ch = fgetc(fp)) != EOF) {
-                if (ch == term)
-                        break;
-                strbuf_grow(sb, 1);
-                sb->buf[sb->len++] = ch;
-        }
-        if (ch == EOF && sb->len == 0)
-                return EOF;
-
-        sb->buf[sb->len] = '\0';
-        return 0;
-}
-
-int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint)
-{
-        int fd, len;
-
-        fd = open(path, O_RDONLY);
-        if (fd < 0)
-                return -1;
-        len = strbuf_read(sb, fd, hint);
-        close(fd);
-        if (len < 0)
-                return -1;
-
-        return len;
-}
diff --git a/tools/perf/util/strbuf.h b/tools/perf/util/strbuf.h
index a3d121d6c83e..436ac319f6c7 100644
--- a/tools/perf/util/strbuf.h
+++ b/tools/perf/util/strbuf.h
@@ -53,12 +53,6 @@ struct strbuf {
 extern void strbuf_init(struct strbuf *buf, ssize_t hint);
 extern void strbuf_release(struct strbuf *);
 extern char *strbuf_detach(struct strbuf *, size_t *);
-extern void strbuf_attach(struct strbuf *, void *, size_t, size_t);
-static inline void strbuf_swap(struct strbuf *a, struct strbuf *b) {
-        struct strbuf tmp = *a;
-        *a = *b;
-        *b = tmp;
-}
 
 /*----- strbuf size related -----*/
 static inline ssize_t strbuf_avail(const struct strbuf *sb) {
@@ -74,17 +68,6 @@ static inline void strbuf_setlen(struct strbuf *sb, size_t len) {
         sb->len = len;
         sb->buf[len] = '\0';
 }
-#define strbuf_reset(sb)  strbuf_setlen(sb, 0)
-
-/*----- content related -----*/
-extern void strbuf_trim(struct strbuf *);
-extern void strbuf_rtrim(struct strbuf *);
-extern void strbuf_ltrim(struct strbuf *);
-extern int strbuf_cmp(const struct strbuf *, const struct strbuf *);
-extern void strbuf_tolower(struct strbuf *);
-
-extern struct strbuf **strbuf_split(const struct strbuf *, int delim);
-extern void strbuf_list_free(struct strbuf **);
 
 /*----- add data in your buffer -----*/
 static inline void strbuf_addch(struct strbuf *sb, int c) {
@@ -93,45 +76,17 @@ static inline void strbuf_addch(struct strbuf *sb, int c) {
         sb->buf[sb->len] = '\0';
 }
 
-extern void strbuf_insert(struct strbuf *, size_t pos, const void *, size_t);
 extern void strbuf_remove(struct strbuf *, size_t pos, size_t len);
 
-/* splice pos..pos+len with given data */
-extern void strbuf_splice(struct strbuf *, size_t pos, size_t len,
-                          const void *, size_t);
-
 extern void strbuf_add(struct strbuf *, const void *, size_t);
 static inline void strbuf_addstr(struct strbuf *sb, const char *s) {
         strbuf_add(sb, s, strlen(s));
 }
-static inline void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2) {
-        strbuf_add(sb, sb2->buf, sb2->len);
-}
-extern void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len);
-
-typedef size_t (*expand_fn_t) (struct strbuf *sb, const char *placeholder, void *context);
-extern void strbuf_expand(struct strbuf *sb, const char *format, expand_fn_t fn, void *context);
-struct strbuf_expand_dict_entry {
-        const char *placeholder;
-        const char *value;
-};
-extern size_t strbuf_expand_dict_cb(struct strbuf *sb, const char *placeholder, void *context);
 
 __attribute__((format(printf,2,3)))
 extern void strbuf_addf(struct strbuf *sb, const char *fmt, ...);
 
-extern size_t strbuf_fread(struct strbuf *, size_t, FILE *);
 /* XXX: if read fails, any partial read is undone */
 extern ssize_t strbuf_read(struct strbuf *, int fd, ssize_t hint);
-extern int strbuf_read_file(struct strbuf *sb, const char *path, ssize_t hint);
-extern int strbuf_readlink(struct strbuf *sb, const char *path, ssize_t hint);
-
-extern int strbuf_getline(struct strbuf *, FILE *, int);
-
-extern void stripspace(struct strbuf *buf, int skip_comments);
-extern int launch_editor(const char *path, struct strbuf *buffer, const char *const *env);
-
-extern int strbuf_branchname(struct strbuf *sb, const char *name);
-extern int strbuf_check_branch_ref(struct strbuf *sb, const char *name);
 
 #endif /* __PERF_STRBUF_H */
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index 5352d7dccc61..0409fc7c0058 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,48 +1,5 @@
-#include "string.h"
 #include "util.h"
-
-static int hex(char ch)
-{
-        if ((ch >= '0') && (ch <= '9'))
-                return ch - '0';
-        if ((ch >= 'a') && (ch <= 'f'))
-                return ch - 'a' + 10;
-        if ((ch >= 'A') && (ch <= 'F'))
-                return ch - 'A' + 10;
-        return -1;
-}
-
-/*
- * While we find nice hex chars, build a long_val.
- * Return number of chars processed.
- */
-int hex2u64(const char *ptr, u64 *long_val)
-{
-        const char *p = ptr;
-        *long_val = 0;
-
-        while (*p) {
-                const int hex_val = hex(*p);
-
-                if (hex_val < 0)
-                        break;
-
-                *long_val = (*long_val << 4) | hex_val;
-                p++;
-        }
-
-        return p - ptr;
-}
-
-char *strxfrchar(char *s, char from, char to)
-{
-        char *p = s;
-
-        while ((p = strchr(p, from)) != NULL)
-                *p++ = to;
-
-        return s;
-}
+#include "string.h"
 
 #define K 1024LL
 /*
@@ -227,16 +184,73 @@ fail:
         return NULL;
 }
 
-/* Glob expression pattern matching */
-bool strglobmatch(const char *str, const char *pat)
+/* Character class matching */
+static bool __match_charclass(const char *pat, char c, const char **npat)
+{
+        bool complement = false, ret = true;
+
+        if (*pat == '!') {
+                complement = true;
+                pat++;
+        }
+        if (*pat++ == c)        /* First character is special */
+                goto end;
+
+        while (*pat && *pat != ']') {   /* Matching */
+                if (*pat == '-' && *(pat + 1) != ']') { /* Range */
+                        if (*(pat - 1) <= c && c <= *(pat + 1))
+                                goto end;
+                        if (*(pat - 1) > *(pat + 1))
+                                goto error;
+                        pat += 2;
+                } else if (*pat++ == c)
+                        goto end;
+        }
+        if (!*pat)
+                goto error;
+        ret = false;
+
+end:
+        while (*pat && *pat != ']')     /* Searching closing */
+                pat++;
+        if (!*pat)
+                goto error;
+        *npat = pat + 1;
+        return complement ? !ret : ret;
+
+error:
+        return false;
+}
+
+/* Glob/lazy pattern matching */
+static bool __match_glob(const char *str, const char *pat, bool ignore_space)
 {
         while (*str && *pat && *pat != '*') {
-                if (*pat == '?') {
+                if (ignore_space) {
+                        /* Ignore spaces for lazy matching */
+                        if (isspace(*str)) {
+                                str++;
+                                continue;
+                        }
+                        if (isspace(*pat)) {
+                                pat++;
+                                continue;
+                        }
+                }
+                if (*pat == '?') {      /* Matches any single character */
                         str++;
                         pat++;
-                } else
-                        if (*str++ != *pat++)
+                        continue;
+                } else if (*pat == '[') /* Character classes/Ranges */
+                        if (__match_charclass(pat + 1, *str, &pat)) {
+                                str++;
+                                continue;
+                        } else
                                 return false;
+                else if (*pat == '\\') /* Escaped char match as normal char */
+                        pat++;
+                if (*str++ != *pat++)
+                        return false;
         }
         /* Check wild card */
         if (*pat == '*') {
@@ -251,3 +265,32 @@ bool strglobmatch(const char *str, const char *pat)
         return !*str && !*pat;
 }
 
+/**
+ * strglobmatch - glob expression pattern matching
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This returns true if the @str matches @pat. @pat can includes wildcards
+ * ('*','?') and character classes ([CHARS], complementation and ranges are
+ * also supported). Also, this supports escape character ('\') to use special
+ * characters as normal character.
+ *
+ * Note: if @pat syntax is broken, this always returns false.
+ */
+bool strglobmatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, false);
+}
+
+/**
+ * strlazymatch - matching pattern strings lazily with glob pattern
+ * @str: the target string to match
+ * @pat: the pattern string to match
+ *
+ * This is similar to strglobmatch, except this ignores spaces in
+ * the target string.
+ */
+bool strlazymatch(const char *str, const char *pat)
+{
+        return __match_glob(str, pat, true);
+}
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
deleted file mode 100644
index 02ede58c54b4..000000000000
--- a/tools/perf/util/string.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef __PERF_STRING_H_
-#define __PERF_STRING_H_
-
-#include <stdbool.h>
-#include "types.h"
-
-int hex2u64(const char *ptr, u64 *val);
-char *strxfrchar(char *s, char from, char to);
-s64 perf_atoll(const char *str);
-char **argv_split(const char *str, int *argcp);
-void argv_free(char **argv);
-bool strglobmatch(const char *str, const char *pat);
-
-#define _STR(x) #x
-#define STR(x) _STR(x)
-
-#endif /* __PERF_STRING_H */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index ab92763edb03..b2f5ae97f33d 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,14 +1,21 @@
-#include "util.h"
-#include "../perf.h"
-#include "session.h"
-#include "sort.h"
-#include "string.h"
-#include "symbol.h"
-#include "thread.h"
-
+#define _GNU_SOURCE
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/param.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "build-id.h"
 #include "debug.h"
+#include "symbol.h"
+#include "strlist.h"
 
-#include <asm/bug.h>
 #include <libelf.h>
 #include <gelf.h>
 #include <elf.h>
@@ -19,21 +26,14 @@
 #define NT_GNU_BUILD_ID 3
 #endif
 
-enum dso_origin {
-        DSO__ORIG_KERNEL = 0,
-        DSO__ORIG_JAVA_JIT,
-        DSO__ORIG_FEDORA,
-        DSO__ORIG_UBUNTU,
-        DSO__ORIG_BUILDID,
-        DSO__ORIG_DSO,
-        DSO__ORIG_KMODULE,
-        DSO__ORIG_NOT_FOUND,
-};
-
+static bool dso__build_id_equal(const struct dso *self, u8 *build_id);
+static int elf_read_build_id(Elf *elf, void *bf, size_t size);
 static void dsos__add(struct list_head *head, struct dso *dso);
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *self, struct map *map,
-                                struct perf_session *session, symbol_filter_t filter);
+                                symbol_filter_t filter);
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                        symbol_filter_t filter);
 static int vmlinux_path__nr_entries;
 static char **vmlinux_path;
 
@@ -43,6 +43,14 @@ struct symbol_conf symbol_conf = {
         .try_vmlinux_path = true,
 };
 
+int dso__name_len(const struct dso *self)
+{
+        if (verbose)
+                return self->long_name_len;
+
+        return self->short_name_len;
+}
+
 bool dso__loaded(const struct dso *self, enum map_type type)
 {
         return self->loaded & (1 << type);
@@ -53,17 +61,12 @@ bool dso__sorted_by_name(const struct dso *self, enum map_type type)
         return self->sorted_by_name & (1 << type);
 }
 
-static void dso__set_loaded(struct dso *self, enum map_type type)
-{
-        self->loaded |= (1 << type);
-}
-
 static void dso__set_sorted_by_name(struct dso *self, enum map_type type)
 {
         self->sorted_by_name |= (1 << type);
 }
 
-static bool symbol_type__is_a(char symbol_type, enum map_type map_type)
+bool symbol_type__is_a(char symbol_type, enum map_type map_type)
 {
         switch (map_type) {
         case MAP__FUNCTION:
@@ -128,39 +131,45 @@ static void map_groups__fixup_end(struct map_groups *self)
                 __map_groups__fixup_end(self, i);
 }
 
-static struct symbol *symbol__new(u64 start, u64 len, const char *name)
+static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
+                                  const char *name)
 {
         size_t namelen = strlen(name) + 1;
-        struct symbol *self = zalloc(symbol_conf.priv_size +
-                                     sizeof(*self) + namelen);
+        struct symbol *self = calloc(1, (symbol_conf.priv_size +
+                                         sizeof(*self) + namelen));
         if (self == NULL)
                 return NULL;
 
         if (symbol_conf.priv_size)
                 self = ((void *)self) + symbol_conf.priv_size;
 
-        self->start = start;
-        self->end   = len ? start + len - 1 : start;
+        self->start   = start;
+        self->end     = len ? start + len - 1 : start;
+        self->binding = binding;
+        self->namelen = namelen - 1;
 
-        pr_debug3("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
+        pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
 
         memcpy(self->name, name, namelen);
 
         return self;
 }
 
-static void symbol__delete(struct symbol *self)
+void symbol__delete(struct symbol *self)
 {
         free(((void *)self) - symbol_conf.priv_size);
 }
 
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 {
-        return fprintf(fp, " %llx-%llx %s\n",
-                       self->start, self->end, self->name);
+        return fprintf(fp, " %llx-%llx %c %s\n",
+                       self->start, self->end,
+                       self->binding == STB_GLOBAL ? 'g' :
+                       self->binding == STB_LOCAL  ? 'l' : 'w',
+                       self->name);
 }
 
-static void dso__set_long_name(struct dso *self, char *name)
+void dso__set_long_name(struct dso *self, char *name)
 {
         if (name == NULL)
                 return;
@@ -168,20 +177,28 @@ static void dso__set_long_name(struct dso *self, char *name)
         self->long_name_len = strlen(name);
 }
 
+static void dso__set_short_name(struct dso *self, const char *name)
+{
+        if (name == NULL)
+                return;
+        self->short_name = name;
+        self->short_name_len = strlen(name);
+}
+
 static void dso__set_basename(struct dso *self)
 {
-        self->short_name = basename(self->long_name);
+        dso__set_short_name(self, basename(self->long_name));
 }
 
 struct dso *dso__new(const char *name)
 {
-        struct dso *self = malloc(sizeof(*self) + strlen(name) + 1);
+        struct dso *self = calloc(1, sizeof(*self) + strlen(name) + 1);
 
         if (self != NULL) {
                 int i;
                 strcpy(self->name, name);
                 dso__set_long_name(self, self->name);
-                self->short_name = self->name;
+                dso__set_short_name(self, self->name);
                 for (i = 0; i < MAP__NR_TYPES; ++i)
                         self->symbols[i] = self->symbol_names[i] = RB_ROOT;
                 self->slen_calculated = 0;
@@ -189,6 +206,8 @@ struct dso *dso__new(const char *name)
                 self->loaded = 0;
                 self->sorted_by_name = 0;
                 self->has_build_id = 0;
+                self->kernel = DSO_TYPE_USER;
+                INIT_LIST_HEAD(&self->node);
         }
 
         return self;
@@ -212,7 +231,9 @@ void dso__delete(struct dso *self)
         int i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
                 symbols__delete(&self->symbols[i]);
-        if (self->long_name != self->name)
+        if (self->sname_alloc)
+                free((char *)self->short_name);
+        if (self->lname_alloc)
                 free(self->long_name);
         free(self);
 }
@@ -344,10 +365,10 @@ void dso__sort_by_name(struct dso *self, enum map_type type)
                                      &self->symbols[type]);
 }
 
-int build_id__sprintf(u8 *self, int len, char *bf)
+int build_id__sprintf(const u8 *self, int len, char *bf)
 {
         char *bid = bf;
-        u8 *raw = self;
+        const u8 *raw = self;
         int i;
 
         for (i = 0; i < len; ++i) {
@@ -372,6 +393,10 @@ size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
         struct rb_node *nd;
         size_t ret = fprintf(fp, "dso: %s (", self->short_name);
 
+        if (self->short_name != self->long_name)
+                ret += fprintf(fp, "%s, ", self->long_name);
+        ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
+                       self->loaded ? "" : "NOT ");
         ret += dso__fprintf_buildid(self, fp);
         ret += fprintf(fp, ")\n");
         for (nd = rb_first(&self->symbols[type]); nd; nd = rb_next(nd)) {
@@ -382,35 +407,28 @@ size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp)
         return ret;
 }
 
-/*
- * Loads the function entries in /proc/kallsyms into kernel_map->dso,
- * so that we can in the next step set the symbol ->end address and then
- * call kernel_maps__split_kallsyms.
- */
-static int dso__load_all_kallsyms(struct dso *self, struct map *map)
+int kallsyms__parse(const char *filename, void *arg,
+                    int (*process_symbol)(void *arg, const char *name,
+                                                     char type, u64 start))
 {
         char *line = NULL;
         size_t n;
-        struct rb_root *root = &self->symbols[map->type];
-        FILE *file = fopen("/proc/kallsyms", "r");
+        int err = 0;
+        FILE *file = fopen(filename, "r");
 
         if (file == NULL)
                 goto out_failure;
 
         while (!feof(file)) {
                 u64 start;
-                struct symbol *sym;
                 int line_len, len;
                 char symbol_type;
                 char *symbol_name;
 
                 line_len = getline(&line, &n, file);
-                if (line_len < 0)
+                if (line_len < 0 || !line)
                         break;
 
-                if (!line)
-                        goto out_failure;
-
                 line[--line_len] = '\0'; /* \n */
 
                 len = hex2u64(line, &start);
@@ -420,43 +438,82 @@ static int dso__load_all_kallsyms(struct dso *self, struct map *map)
                         continue;
 
                 symbol_type = toupper(line[len]);
-                if (!symbol_type__is_a(symbol_type, map->type))
-                        continue;
-
                 symbol_name = line + len + 2;
-                /*
-                 * Will fix up the end later, when we have all symbols sorted.
-                 */
-                sym = symbol__new(start, 0, symbol_name);
 
-                if (sym == NULL)
-                        goto out_delete_line;
-                /*
-                 * We will pass the symbols to the filter later, in
-                 * map__split_kallsyms, when we have split the maps per module
-                 */
-                symbols__insert(root, sym);
+                err = process_symbol(arg, symbol_name, symbol_type, start);
+                if (err)
+                        break;
         }
 
         free(line);
         fclose(file);
+        return err;
 
-        return 0;
-
-out_delete_line:
-        free(line);
 out_failure:
         return -1;
 }
 
+struct process_kallsyms_args {
+        struct map *map;
+        struct dso *dso;
+};
+
+static u8 kallsyms2elf_type(char type)
+{
+        if (type == 'W')
+                return STB_WEAK;
+
+        return isupper(type) ? STB_GLOBAL : STB_LOCAL;
+}
+
+static int map__process_kallsym_symbol(void *arg, const char *name,
+                                       char type, u64 start)
+{
+        struct symbol *sym;
+        struct process_kallsyms_args *a = arg;
+        struct rb_root *root = &a->dso->symbols[a->map->type];
+
+        if (!symbol_type__is_a(type, a->map->type))
+                return 0;
+
+        /*
+         * Will fix up the end later, when we have all symbols sorted.
+         */
+        sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
+
+        if (sym == NULL)
+                return -ENOMEM;
+        /*
+         * We will pass the symbols to the filter later, in
+         * map__split_kallsyms, when we have split the maps per module
+         */
+        symbols__insert(root, sym);
+
+        return 0;
+}
+
+/*
+ * Loads the function entries in /proc/kallsyms into kernel_map->dso,
+ * so that we can in the next step set the symbol ->end address and then
+ * call kernel_maps__split_kallsyms.
+ */
+static int dso__load_all_kallsyms(struct dso *self, const char *filename,
+                                  struct map *map)
+{
+        struct process_kallsyms_args args = { .map = map, .dso = self, };
+        return kallsyms__parse(filename, &args, map__process_kallsym_symbol);
+}
+
 /*
  * Split the symbols into maps, making sure there are no overlaps, i.e. the
  * kernel range is broken in several maps, named [kernel].N, as we don't have
  * the original ELF section names vmlinux have.
  */
 static int dso__split_kallsyms(struct dso *self, struct map *map,
-                               struct perf_session *session, symbol_filter_t filter)
+                               symbol_filter_t filter)
 {
+        struct map_groups *kmaps = map__kmap(map)->kmaps;
+        struct machine *machine = kmaps->machine;
         struct map *curr_map = map;
         struct symbol *pos;
         int count = 0;
@@ -477,13 +534,35 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
 
                         *module++ = '\0';
 
-                        if (strcmp(self->name, module)) {
-                                curr_map = map_groups__find_by_name(&session->kmaps, map->type, module);
+                        if (strcmp(curr_map->dso->short_name, module)) {
+                                if (curr_map != map &&
+                                    self->kernel == DSO_TYPE_GUEST_KERNEL &&
+                                    machine__is_default_guest(machine)) {
+                                        /*
+                                         * We assume all symbols of a module are
+                                         * continuous in * kallsyms, so curr_map
+                                         * points to a module and all its
+                                         * symbols are in its kmap. Mark it as
+                                         * loaded.
+                                         */
+                                        dso__set_loaded(curr_map->dso,
+                                                        curr_map->type);
+                                }
+
+                                curr_map = map_groups__find_by_name(kmaps,
+                                                        map->type, module);
                                 if (curr_map == NULL) {
-                                        pr_debug("/proc/{kallsyms,modules} "
-                                                 "inconsistency!\n");
-                                        return -1;
+                                        pr_debug("%s/proc/{kallsyms,modules} "
+                                                 "inconsistency while looking "
+                                                 "for \"%s\" module!\n",
+                                                 machine->root_dir, module);
+                                        curr_map = map;
+                                        goto discard_symbol;
                                 }
+
+                                if (curr_map->dso->loaded &&
+                                    !machine__is_default_guest(machine))
+                                        goto discard_symbol;
                         }
                         /*
                          * So that we look just like we get from .ko files,
@@ -495,21 +574,29 @@ static int dso__split_kallsyms(struct dso *self, struct map *map,
                         char dso_name[PATH_MAX];
                         struct dso *dso;
 
-                        snprintf(dso_name, sizeof(dso_name), "[kernel].%d",
-                                 kernel_range++);
+                        if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                                snprintf(dso_name, sizeof(dso_name),
+                                        "[guest.kernel].%d",
+                                        kernel_range++);
+                        else
+                                snprintf(dso_name, sizeof(dso_name),
+                                        "[kernel].%d",
+                                        kernel_range++);
 
                         dso = dso__new(dso_name);
                         if (dso == NULL)
                                 return -1;
 
+                        dso->kernel = self->kernel;
+
                         curr_map = map__new2(pos->start, dso, map->type);
-                        if (map == NULL) {
+                        if (curr_map == NULL) {
                                 dso__delete(dso);
                                 return -1;
                         }
 
                         curr_map->map_ip = curr_map->unmap_ip = identity__map_ip;
-                        map_groups__insert(&session->kmaps, curr_map);
+                        map_groups__insert(kmaps, curr_map);
                         ++kernel_range;
                 }
 
@@ -525,20 +612,28 @@ discard_symbol:		rb_erase(&pos->rb_node, root);
                 }
         }
 
+        if (curr_map != map &&
+            self->kernel == DSO_TYPE_GUEST_KERNEL &&
+            machine__is_default_guest(kmaps->machine)) {
+                dso__set_loaded(curr_map->dso, curr_map->type);
+        }
+
         return count;
 }
 
-
-static int dso__load_kallsyms(struct dso *self, struct map *map,
-                              struct perf_session *session, symbol_filter_t filter)
+int dso__load_kallsyms(struct dso *self, const char *filename,
+                       struct map *map, symbol_filter_t filter)
 {
-        if (dso__load_all_kallsyms(self, map) < 0)
+        if (dso__load_all_kallsyms(self, filename, map) < 0)
                 return -1;
 
         symbols__fixup_end(&self->symbols[map->type]);
-        self->origin = DSO__ORIG_KERNEL;
+        if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                self->origin = DSO__ORIG_GUEST_KERNEL;
+        else
+                self->origin = DSO__ORIG_KERNEL;
 
-        return dso__split_kallsyms(self, map, session, filter);
+        return dso__split_kallsyms(self, map, filter);
 }
 
 static int dso__load_perf_map(struct dso *self, struct map *map,
@@ -579,7 +674,7 @@ static int dso__load_perf_map(struct dso *self, struct map *map,
                 if (len + 2 >= line_len)
                         continue;
 
-                sym = symbol__new(start, size, line + len);
+                sym = symbol__new(start, size, STB_GLOBAL, line + len);
 
                 if (sym == NULL)
                         goto out_delete_line;
@@ -791,7 +886,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname);
+                                        STB_GLOBAL, sympltname);
                         if (!f)
                                 goto out_elf_end;
 
@@ -813,7 +908,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                  "%s@plt", elf_sym__name(&sym, symstrs));
 
                         f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname);
+                                        STB_GLOBAL, sympltname);
                         if (!f)
                                 goto out_elf_end;
 
@@ -835,8 +930,8 @@ out_close:
         if (err == 0)
                 return nr;
 out:
-        pr_warning("%s: problems reading %s PLT info.\n",
-                   __func__, self->long_name);
+        pr_debug("%s: problems reading %s PLT info.\n",
+                 __func__, self->long_name);
         return 0;
 }
 
@@ -864,43 +959,82 @@ static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type
         }
 }
 
-static int dso__load_sym(struct dso *self, struct map *map,
-                         struct perf_session *session, const char *name, int fd,
-                         symbol_filter_t filter, int kernel, int kmodule)
+static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
 {
+        Elf_Scn *sec = NULL;
+        GElf_Shdr shdr;
+        size_t cnt = 1;
+
+        while ((sec = elf_nextscn(elf, sec)) != NULL) {
+                gelf_getshdr(sec, &shdr);
+
+                if ((addr >= shdr.sh_addr) &&
+                    (addr < (shdr.sh_addr + shdr.sh_size)))
+                        return cnt;
+
+                ++cnt;
+        }
+
+        return -1;
+}
+
+static int dso__load_sym(struct dso *self, struct map *map, const char *name,
+                         int fd, symbol_filter_t filter, int kmodule,
+                         int want_symtab)
+{
+        struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
         struct map *curr_map = map;
         struct dso *curr_dso = self;
-        size_t dso_name_len = strlen(self->short_name);
         Elf_Data *symstrs, *secstrs;
         uint32_t nr_syms;
         int err = -1;
         uint32_t idx;
         GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
-        Elf_Data *syms;
+        GElf_Shdr shdr, opdshdr;
+        Elf_Data *syms, *opddata = NULL;
         GElf_Sym sym;
-        Elf_Scn *sec, *sec_strndx;
+        Elf_Scn *sec, *sec_strndx, *opdsec;
         Elf *elf;
         int nr = 0;
+        size_t opdidx = 0;
 
         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
         if (elf == NULL) {
-                pr_err("%s: cannot read %s ELF file.\n", __func__, name);
+                pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
                 goto out_close;
         }
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
-                pr_err("%s: cannot get elf header.\n", __func__);
+                pr_debug("%s: cannot get elf header.\n", __func__);
                 goto out_elf_end;
         }
 
+        /* Always reject images with a mismatched build-id: */
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (elf_read_build_id(elf, build_id,
+                                      BUILD_ID_SIZE) != BUILD_ID_SIZE)
+                        goto out_elf_end;
+
+                if (!dso__build_id_equal(self, build_id))
+                        goto out_elf_end;
+        }
+
         sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
         if (sec == NULL) {
+                if (want_symtab)
+                        goto out_elf_end;
+
                 sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
                 if (sec == NULL)
                         goto out_elf_end;
         }
 
+        opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
+        if (opdsec)
+                opddata = elf_rawdata(opdsec, NULL);
+
         syms = elf_getdata(sec, NULL);
         if (syms == NULL)
                 goto out_elf_end;
@@ -924,7 +1058,7 @@ static int dso__load_sym(struct dso *self, struct map *map,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-        if (!kernel) {
+        if (self->kernel == DSO_TYPE_USER) {
                 self->adjust_symbols = (ehdr.e_type == ET_EXEC ||
                                 elf_section_by_name(elf, &ehdr, &shdr,
                                                      ".gnu.prelink_undo",
@@ -933,14 +1067,35 @@ static int dso__load_sym(struct dso *self, struct map *map,
 
         elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
                 struct symbol *f;
-                const char *elf_name;
+                const char *elf_name = elf_sym__name(&sym, symstrs);
                 char *demangled = NULL;
                 int is_label = elf_sym__is_label(&sym);
                 const char *section_name;
 
+                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
+                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+
                 if (!is_label && !elf_sym__is_a(&sym, map->type))
                         continue;
 
+                /* Reject ARM ELF "mapping symbols": these aren't unique and
+                 * don't identify functions, so will confuse the profile
+                 * output: */
+                if (ehdr.e_machine == EM_ARM) {
+                        if (!strcmp(elf_name, "$a") ||
+                            !strcmp(elf_name, "$d") ||
+                            !strcmp(elf_name, "$t"))
+                                continue;
+                }
+
+                if (opdsec && sym.st_shndx == opdidx) {
+                        u32 offset = sym.st_value - opdshdr.sh_addr;
+                        u64 *opd = opddata->d_buf + offset;
+                        sym.st_value = *opd;
+                        sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
+                }
+
                 sec = elf_getscn(elf, sym.st_shndx);
                 if (!sec)
                         goto out_elf_end;
@@ -950,14 +1105,14 @@ static int dso__load_sym(struct dso *self, struct map *map,
                 if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
                         continue;
 
-                elf_name = elf_sym__name(&sym, symstrs);
                 section_name = elf_sec__name(&shdr, secstrs);
 
-                if (kernel || kmodule) {
+                if (self->kernel != DSO_TYPE_USER || kmodule) {
                         char dso_name[PATH_MAX];
 
                         if (strcmp(section_name,
-                                   curr_dso->short_name + dso_name_len) == 0)
+                                   (curr_dso->short_name +
+                                    self->short_name_len)) == 0)
                                 goto new_symbol;
 
                         if (strcmp(section_name, ".text") == 0) {
@@ -969,7 +1124,7 @@ static int dso__load_sym(struct dso *self, struct map *map,
                         snprintf(dso_name, sizeof(dso_name),
                                  "%s%s", self->short_name, section_name);
 
-                        curr_map = map_groups__find_by_name(&session->kmaps, map->type, dso_name);
+                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
                         if (curr_map == NULL) {
                                 u64 start = sym.st_value;
 
@@ -979,17 +1134,19 @@ static int dso__load_sym(struct dso *self, struct map *map,
                                 curr_dso = dso__new(dso_name);
                                 if (curr_dso == NULL)
                                         goto out_elf_end;
+                                curr_dso->kernel = self->kernel;
                                 curr_map = map__new2(start, curr_dso,
-                                                     MAP__FUNCTION);
+                                                     map->type);
                                 if (curr_map == NULL) {
                                         dso__delete(curr_dso);
                                         goto out_elf_end;
                                 }
                                 curr_map->map_ip = identity__map_ip;
                                 curr_map->unmap_ip = identity__map_ip;
-                                curr_dso->origin = DSO__ORIG_KERNEL;
-                                map_groups__insert(&session->kmaps, curr_map);
-                                dsos__add(&dsos__kernel, curr_dso);
+                                curr_dso->origin = self->origin;
+                                map_groups__insert(kmap->kmaps, curr_map);
+                                dsos__add(&self->node, curr_dso);
+                                dso__set_loaded(curr_dso, map->type);
                         } else
                                 curr_dso = curr_map->dso;
 
@@ -997,9 +1154,10 @@ static int dso__load_sym(struct dso *self, struct map *map,
                 }
 
                 if (curr_dso->adjust_symbols) {
-                        pr_debug2("adjusting symbol: st_value: %Lx sh_addr: "
-                                  "%Lx sh_offset: %Lx\n", (u64)sym.st_value,
-                                  (u64)shdr.sh_addr, (u64)shdr.sh_offset);
+                        pr_debug4("%s: adjusting symbol: st_value: %#Lx "
+                                  "sh_addr: %#Lx sh_offset: %#Lx\n", __func__,
+                                  (u64)sym.st_value, (u64)shdr.sh_addr,
+                                  (u64)shdr.sh_offset);
                         sym.st_value -= shdr.sh_addr - shdr.sh_offset;
                 }
                 /*
@@ -1011,7 +1169,8 @@ static int dso__load_sym(struct dso *self, struct map *map,
                 if (demangled != NULL)
                         elf_name = demangled;
 new_symbol:
-                f = symbol__new(sym.st_value, sym.st_size, elf_name);
+                f = symbol__new(sym.st_value, sym.st_size,
+                                GELF_ST_BIND(sym.st_info), elf_name);
                 free(demangled);
                 if (!f)
                         goto out_elf_end;
@@ -1027,8 +1186,16 @@ new_symbol:
         /*
          * For misannotated, zeroed, ASM function sizes.
          */
-        if (nr > 0)
+        if (nr > 0) {
                 symbols__fixup_end(&self->symbols[map->type]);
+                if (kmap) {
+                        /*
+                         * We need to fixup this here too because we create new
+                         * maps here, for things like vsyscall sections.
+                         */
+                        __map_groups__fixup_end(kmap->kmaps, map->type);
+                }
+        }
         err = nr;
 out_elf_end:
         elf_end(elf);
@@ -1041,64 +1208,53 @@ static bool dso__build_id_equal(const struct dso *self, u8 *build_id)
         return memcmp(self->build_id, build_id, sizeof(self->build_id)) == 0;
 }
 
-static bool __dsos__read_build_ids(struct list_head *head)
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 {
         bool have_build_id = false;
         struct dso *pos;
 
-        list_for_each_entry(pos, head, node)
+        list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
+                if (pos->has_build_id) {
+                        have_build_id = true;
+                        continue;
+                }
                 if (filename__read_build_id(pos->long_name, pos->build_id,
                                             sizeof(pos->build_id)) > 0) {
                         have_build_id     = true;
                         pos->has_build_id = true;
                 }
+        }
 
         return have_build_id;
 }
 
-bool dsos__read_build_ids(void)
-{
-        bool kbuildids = __dsos__read_build_ids(&dsos__kernel),
-             ubuildids = __dsos__read_build_ids(&dsos__user);
-        return kbuildids || ubuildids;
-}
-
 /*
  * Align offset to 4 bytes as needed for note name and descriptor data.
  */
 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
 
-int filename__read_build_id(const char *filename, void *bf, size_t size)
+static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 {
-        int fd, err = -1;
+        int err = -1;
         GElf_Ehdr ehdr;
         GElf_Shdr shdr;
         Elf_Data *data;
         Elf_Scn *sec;
         Elf_Kind ek;
         void *ptr;
-        Elf *elf;
 
         if (size < BUILD_ID_SIZE)
                 goto out;
 
-        fd = open(filename, O_RDONLY);
-        if (fd < 0)
-                goto out;
-
-        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-        if (elf == NULL) {
-                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
-                goto out_close;
-        }
-
         ek = elf_kind(elf);
         if (ek != ELF_K_ELF)
-                goto out_elf_end;
+                goto out;
 
         if (gelf_getehdr(elf, &ehdr) == NULL) {
                 pr_err("%s: cannot get elf header.\n", __func__);
-                goto out_elf_end;
+                goto out;
         }
 
         sec = elf_section_by_name(elf, &ehdr, &shdr,
@@ -1107,12 +1263,12 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                 sec = elf_section_by_name(elf, &ehdr, &shdr,
                                           ".notes", NULL);
                 if (sec == NULL)
-                        goto out_elf_end;
+                        goto out;
         }
 
         data = elf_getdata(sec, NULL);
         if (data == NULL)
-                goto out_elf_end;
+                goto out;
 
         ptr = data->d_buf;
         while (ptr < (data->d_buf + data->d_size)) {
@@ -1134,7 +1290,31 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                 }
                 ptr += descsz;
         }
-out_elf_end:
+
+out:
+        return err;
+}
+
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+        int fd, err = -1;
+        Elf *elf;
+
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL) {
+                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
+                goto out_close;
+        }
+
+        err = elf_read_build_id(elf, bf, size);
+
         elf_end(elf);
 out_close:
         close(fd);
@@ -1191,11 +1371,14 @@ char dso__symtab_origin(const struct dso *self)
         static const char origin[] = {
                 [DSO__ORIG_KERNEL] =   'k',
                 [DSO__ORIG_JAVA_JIT] = 'j',
+                [DSO__ORIG_BUILD_ID_CACHE] = 'B',
                 [DSO__ORIG_FEDORA] =   'f',
                 [DSO__ORIG_UBUNTU] =   'u',
                 [DSO__ORIG_BUILDID] =  'b',
                 [DSO__ORIG_DSO] =      'd',
                 [DSO__ORIG_KMODULE] =  'K',
+                [DSO__ORIG_GUEST_KERNEL] =  'g',
+                [DSO__ORIG_GUEST_KMODULE] =  'G',
         };
 
         if (self == NULL || self->origin == DSO__ORIG_NOT_FOUND)
@@ -1203,19 +1386,27 @@ char dso__symtab_origin(const struct dso *self)
         return origin[self->origin];
 }
 
-int dso__load(struct dso *self, struct map *map, struct perf_session *session,
-              symbol_filter_t filter)
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
         int size = PATH_MAX;
         char *name;
-        u8 build_id[BUILD_ID_SIZE];
         int ret = -1;
         int fd;
+        struct machine *machine;
+        const char *root_dir;
+        int want_symtab;
 
         dso__set_loaded(self, map->type);
 
-        if (self->kernel)
-                return dso__load_kernel_sym(self, map, session, filter);
+        if (self->kernel == DSO_TYPE_KERNEL)
+                return dso__load_kernel_sym(self, map, filter);
+        else if (self->kernel == DSO_TYPE_GUEST_KERNEL)
+                return dso__load_guest_kernel_sym(self, map, filter);
+
+        if (map->groups && map->groups->machine)
+                machine = map->groups->machine;
+        else
+                machine = NULL;
 
         name = malloc(size);
         if (!name)
@@ -1230,12 +1421,18 @@ int dso__load(struct dso *self, struct map *map, struct perf_session *session,
                 return ret;
         }
 
-        self->origin = DSO__ORIG_FEDORA - 1;
-
-more:
-        do {
-                self->origin++;
+        /* Iterate over candidate debug images.
+         * On the first pass, only load images if they have a full symtab.
+         * Failing that, do a second pass where we accept .dynsym also
+         */
+        for (self->origin = DSO__ORIG_BUILD_ID_CACHE, want_symtab = 1;
+             self->origin != DSO__ORIG_NOT_FOUND;
+             self->origin++) {
                 switch (self->origin) {
+                case DSO__ORIG_BUILD_ID_CACHE:
+                        if (dso__build_id_filename(self, name, size) == NULL)
+                                continue;
+                        break;
                 case DSO__ORIG_FEDORA:
                         snprintf(name, size, "/usr/lib/debug%s.debug",
                                  self->long_name);
@@ -1244,57 +1441,67 @@ more:
                         snprintf(name, size, "/usr/lib/debug%s",
                                  self->long_name);
                         break;
-                case DSO__ORIG_BUILDID:
-                        if (filename__read_build_id(self->long_name, build_id,
-                                                    sizeof(build_id))) {
-                                char build_id_hex[BUILD_ID_SIZE * 2 + 1];
-
-                                build_id__sprintf(build_id, sizeof(build_id),
-                                                  build_id_hex);
-                                snprintf(name, size,
-                                         "/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                        build_id_hex, build_id_hex + 2);
-                                if (self->has_build_id)
-                                        goto compare_build_id;
-                                break;
+                case DSO__ORIG_BUILDID: {
+                        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+
+                        if (!self->has_build_id)
+                                continue;
+
+                        build_id__sprintf(self->build_id,
+                                          sizeof(self->build_id),
+                                          build_id_hex);
+                        snprintf(name, size,
+                                 "/usr/lib/debug/.build-id/%.2s/%s.debug",
+                                 build_id_hex, build_id_hex + 2);
                         }
-                        self->origin++;
-                        /* Fall thru */
+                        break;
                 case DSO__ORIG_DSO:
                         snprintf(name, size, "%s", self->long_name);
                         break;
+                case DSO__ORIG_GUEST_KMODULE:
+                        if (map->groups && map->groups->machine)
+                                root_dir = map->groups->machine->root_dir;
+                        else
+                                root_dir = "";
+                        snprintf(name, size, "%s%s", root_dir, self->long_name);
+                        break;
 
                 default:
-                        goto out;
-                }
-
-                if (self->has_build_id) {
-                        if (filename__read_build_id(name, build_id,
-                                                    sizeof(build_id)) < 0)
-                                goto more;
-compare_build_id:
-                        if (!dso__build_id_equal(self, build_id))
-                                goto more;
+                        /*
+                         * If we wanted a full symtab but no image had one,
+                         * relax our requirements and repeat the search.
+                         */
+                        if (want_symtab) {
+                                want_symtab = 0;
+                                self->origin = DSO__ORIG_BUILD_ID_CACHE;
+                        } else
+                                continue;
                 }
 
+                /* Name is now the name of the next image to try */
                 fd = open(name, O_RDONLY);
-        } while (fd < 0);
+                if (fd < 0)
+                        continue;
 
-        ret = dso__load_sym(self, map, NULL, name, fd, filter, 0, 0);
-        close(fd);
+                ret = dso__load_sym(self, map, name, fd, filter, 0,
+                                    want_symtab);
+                close(fd);
 
-        /*
-         * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
-         */
-        if (!ret)
-                goto more;
+                /*
+                 * Some people seem to have debuginfo files _WITHOUT_ debug
+                 * info!?!?
+                 */
+                if (!ret)
+                        continue;
 
-        if (ret > 0) {
-                int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
-                if (nr_plt > 0)
-                        ret += nr_plt;
+                if (ret > 0) {
+                        int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
+                        if (nr_plt > 0)
+                                ret += nr_plt;
+                        break;
+                }
         }
-out:
+
         free(name);
         if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
                 return 0;
@@ -1309,35 +1516,65 @@ struct map *map_groups__find_by_name(struct map_groups *self,
         for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
                 struct map *map = rb_entry(nd, struct map, rb_node);
 
-                if (map->dso && strcmp(map->dso->name, name) == 0)
+                if (map->dso && strcmp(map->dso->short_name, name) == 0)
                         return map;
         }
 
         return NULL;
 }
 
-static int perf_session__set_modules_path_dir(struct perf_session *self, char *dirname)
+static int dso__kernel_module_get_build_id(struct dso *self,
+                                const char *root_dir)
+{
+        char filename[PATH_MAX];
+        /*
+         * kernel module short names are of the form "[module]" and
+         * we need just "module" here.
+         */
+        const char *name = self->short_name + 1;
+
+        snprintf(filename, sizeof(filename),
+                 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
+                 root_dir, (int)strlen(name) - 1, name);
+
+        if (sysfs__read_build_id(filename, self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+
+        return 0;
+}
+
+static int map_groups__set_modules_path_dir(struct map_groups *self,
+                                const char *dir_name)
 {
         struct dirent *dent;
-        DIR *dir = opendir(dirname);
+        DIR *dir = opendir(dir_name);
+        int ret = 0;
 
         if (!dir) {
-                pr_debug("%s: cannot open %s dir\n", __func__, dirname);
+                pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
                 return -1;
         }
 
         while ((dent = readdir(dir)) != NULL) {
                 char path[PATH_MAX];
+                struct stat st;
 
-                if (dent->d_type == DT_DIR) {
+                /*sshfs might return bad dent->d_type, so we have to stat*/
+                sprintf(path, "%s/%s", dir_name, dent->d_name);
+                if (stat(path, &st))
+                        continue;
+
+                if (S_ISDIR(st.st_mode)) {
                         if (!strcmp(dent->d_name, ".") ||
                             !strcmp(dent->d_name, ".."))
                                 continue;
 
                         snprintf(path, sizeof(path), "%s/%s",
-                                 dirname, dent->d_name);
-                        if (perf_session__set_modules_path_dir(self, path) < 0)
-                                goto failure;
+                                 dir_name, dent->d_name);
+                        ret = map_groups__set_modules_path_dir(self, path);
+                        if (ret < 0)
+                                goto out;
                 } else {
                         char *dot = strrchr(dent->d_name, '.'),
                              dso_name[PATH_MAX];
@@ -1350,38 +1587,70 @@ static int perf_session__set_modules_path_dir(struct perf_session *self, char *d
                                  (int)(dot - dent->d_name), dent->d_name);
 
                         strxfrchar(dso_name, '-', '_');
-                        map = map_groups__find_by_name(&self->kmaps, MAP__FUNCTION, dso_name);
+                        map = map_groups__find_by_name(self, MAP__FUNCTION, dso_name);
                         if (map == NULL)
                                 continue;
 
                         snprintf(path, sizeof(path), "%s/%s",
-                                 dirname, dent->d_name);
+                                 dir_name, dent->d_name);
 
                         long_name = strdup(path);
-                        if (long_name == NULL)
-                                goto failure;
+                        if (long_name == NULL) {
+                                ret = -1;
+                                goto out;
+                        }
                         dso__set_long_name(map->dso, long_name);
+                        map->dso->lname_alloc = 1;
+                        dso__kernel_module_get_build_id(map->dso, "");
                 }
         }
 
-        return 0;
-failure:
+out:
         closedir(dir);
-        return -1;
+        return ret;
 }
 
-static int perf_session__set_modules_path(struct perf_session *self)
+static char *get_kernel_version(const char *root_dir)
 {
-        struct utsname uts;
+        char version[PATH_MAX];
+        FILE *file;
+        char *name, *tmp;
+        const char *prefix = "Linux version ";
+
+        sprintf(version, "%s/proc/version", root_dir);
+        file = fopen(version, "r");
+        if (!file)
+                return NULL;
+
+        version[0] = '\0';
+        tmp = fgets(version, sizeof(version), file);
+        fclose(file);
+
+        name = strstr(version, prefix);
+        if (!name)
+                return NULL;
+        name += strlen(prefix);
+        tmp = strchr(name, ' ');
+        if (tmp)
+                *tmp = '\0';
+
+        return strdup(name);
+}
+
+static int machine__set_modules_path(struct machine *self)
+{
+        char *version;
         char modules_path[PATH_MAX];
 
-        if (uname(&uts) < 0)
+        version = get_kernel_version(self->root_dir);
+        if (!version)
                 return -1;
 
-        snprintf(modules_path, sizeof(modules_path), "/lib/modules/%s/kernel",
-                 uts.release);
+        snprintf(modules_path, sizeof(modules_path), "%s/lib/modules/%s/kernel",
+                 self->root_dir, version);
+        free(version);
 
-        return perf_session__set_modules_path_dir(self, modules_path);
+        return map_groups__set_modules_path_dir(&self->kmaps, modules_path);
 }
 
 /*
@@ -1391,8 +1660,8 @@ static int perf_session__set_modules_path(struct perf_session *self)
  */
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
 {
-        struct map *self = malloc(sizeof(*self));
-
+        struct map *self = calloc(1, (sizeof(*self) +
+                                      (dso->kernel ? sizeof(struct kmap) : 0)));
         if (self != NULL) {
                 /*
                  * ->end will be filled after we load all the symbols
@@ -1403,20 +1672,50 @@ static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
         return self;
 }
 
-static int perf_session__create_module_maps(struct perf_session *self)
+struct map *machine__new_module(struct machine *self, u64 start,
+                                const char *filename)
+{
+        struct map *map;
+        struct dso *dso = __dsos__findnew(&self->kernel_dsos, filename);
+
+        if (dso == NULL)
+                return NULL;
+
+        map = map__new2(start, dso, MAP__FUNCTION);
+        if (map == NULL)
+                return NULL;
+
+        if (machine__is_host(self))
+                dso->origin = DSO__ORIG_KMODULE;
+        else
+                dso->origin = DSO__ORIG_GUEST_KMODULE;
+        map_groups__insert(&self->kmaps, map);
+        return map;
+}
+
+static int machine__create_modules(struct machine *self)
 {
         char *line = NULL;
         size_t n;
-        FILE *file = fopen("/proc/modules", "r");
+        FILE *file;
         struct map *map;
+        const char *modules;
+        char path[PATH_MAX];
+
+        if (machine__is_default_guest(self))
+                modules = symbol_conf.default_guest_modules;
+        else {
+                sprintf(path, "%s/proc/modules", self->root_dir);
+                modules = path;
+        }
 
+        file = fopen(modules, "r");
         if (file == NULL)
                 return -1;
 
         while (!feof(file)) {
                 char name[PATH_MAX];
                 u64 start;
-                struct dso *dso;
                 char *sep;
                 int line_len;
 
@@ -1442,32 +1741,16 @@ static int perf_session__create_module_maps(struct perf_session *self)
                 *sep = '\0';
 
                 snprintf(name, sizeof(name), "[%s]", line);
-                dso = dso__new(name);
-
-                if (dso == NULL)
-                        goto out_delete_line;
-
-                map = map__new2(start, dso, MAP__FUNCTION);
-                if (map == NULL) {
-                        dso__delete(dso);
+                map = machine__new_module(self, start, name);
+                if (map == NULL)
                         goto out_delete_line;
-                }
-
-                snprintf(name, sizeof(name),
-                         "/sys/module/%s/notes/.note.gnu.build-id", line);
-                if (sysfs__read_build_id(name, dso->build_id,
-                                         sizeof(dso->build_id)) == 0)
-                        dso->has_build_id = true;
-
-                dso->origin = DSO__ORIG_KMODULE;
-                map_groups__insert(&self->kmaps, map);
-                dsos__add(&dsos__kernel, dso);
+                dso__kernel_module_get_build_id(map->dso, self->root_dir);
         }
 
         free(line);
         fclose(file);
 
-        return perf_session__set_modules_path(self);
+        return machine__set_modules_path(self);
 
 out_delete_line:
         free(line);
@@ -1476,85 +1759,148 @@ out_failure:
 }
 
 static int dso__load_vmlinux(struct dso *self, struct map *map,
-                             struct perf_session *session,
                              const char *vmlinux, symbol_filter_t filter)
 {
         int err = -1, fd;
 
-        if (self->has_build_id) {
-                u8 build_id[BUILD_ID_SIZE];
-
-                if (filename__read_build_id(vmlinux, build_id,
-                                            sizeof(build_id)) < 0) {
-                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
-                        return -1;
-                }
-                if (!dso__build_id_equal(self, build_id)) {
-                        char expected_build_id[BUILD_ID_SIZE * 2 + 1],
-                             vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
-
-                        build_id__sprintf(self->build_id,
-                                          sizeof(self->build_id),
-                                          expected_build_id);
-                        build_id__sprintf(build_id, sizeof(build_id),
-                                          vmlinux_build_id);
-                        pr_debug("build_id in %s is %s while expected is %s, "
-                                 "ignoring it\n", vmlinux, vmlinux_build_id,
-                                 expected_build_id);
-                        return -1;
-                }
-        }
-
         fd = open(vmlinux, O_RDONLY);
         if (fd < 0)
                 return -1;
 
         dso__set_loaded(self, map->type);
-        err = dso__load_sym(self, map, session, self->long_name, fd, filter, 1, 0);
+        err = dso__load_sym(self, map, vmlinux, fd, filter, 0, 0);
         close(fd);
 
+        if (err > 0)
+                pr_debug("Using %s for symbols\n", vmlinux);
+
+        return err;
+}
+
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                           symbol_filter_t filter)
+{
+        int i, err = 0;
+        char *filename;
+
+        pr_debug("Looking at the vmlinux_path (%d entries long)\n",
+                 vmlinux_path__nr_entries + 1);
+
+        filename = dso__build_id_filename(self, NULL, 0);
+        if (filename != NULL) {
+                err = dso__load_vmlinux(self, map, filename, filter);
+                if (err > 0) {
+                        dso__set_long_name(self, filename);
+                        goto out;
+                }
+                free(filename);
+        }
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i) {
+                err = dso__load_vmlinux(self, map, vmlinux_path[i], filter);
+                if (err > 0) {
+                        dso__set_long_name(self, strdup(vmlinux_path[i]));
+                        break;
+                }
+        }
+out:
         return err;
 }
 
 static int dso__load_kernel_sym(struct dso *self, struct map *map,
-                                struct perf_session *session, symbol_filter_t filter)
+                                symbol_filter_t filter)
 {
         int err;
-        bool is_kallsyms;
+        const char *kallsyms_filename = NULL;
+        char *kallsyms_allocated_filename = NULL;
+        /*
+         * Step 1: if the user specified a vmlinux filename, use it and only
+         * it, reporting errors to the user if it cannot be used.
+         *
+         * For instance, try to analyse an ARM perf.data file _without_ a
+         * build-id, or if the user specifies the wrong path to the right
+         * vmlinux file, obviously we can't fallback to another vmlinux (a
+         * x86_86 one, on the machine where analysis is being performed, say),
+         * or worse, /proc/kallsyms.
+         *
+         * If the specified file _has_ a build-id and there is a build-id
+         * section in the perf.data file, we will still do the expected
+         * validation in dso__load_vmlinux and will bail out if they don't
+         * match.
+         */
+        if (symbol_conf.vmlinux_name != NULL) {
+                err = dso__load_vmlinux(self, map,
+                                        symbol_conf.vmlinux_name, filter);
+                if (err > 0) {
+                        dso__set_long_name(self,
+                                           strdup(symbol_conf.vmlinux_name));
+                        goto out_fixup;
+                }
+                return err;
+        }
 
         if (vmlinux_path != NULL) {
-                int i;
-                pr_debug("Looking at the vmlinux_path (%d entries long)\n",
-                         vmlinux_path__nr_entries);
-                for (i = 0; i < vmlinux_path__nr_entries; ++i) {
-                        err = dso__load_vmlinux(self, map, session,
-                                                vmlinux_path[i], filter);
-                        if (err > 0) {
-                                pr_debug("Using %s for symbols\n",
-                                         vmlinux_path[i]);
-                                dso__set_long_name(self,
-                                                   strdup(vmlinux_path[i]));
-                                goto out_fixup;
+                err = dso__load_vmlinux_path(self, map, filter);
+                if (err > 0)
+                        goto out_fixup;
+        }
+
+        /*
+         * Say the kernel DSO was created when processing the build-id header table,
+         * we have a build-id, so check if it is the same as the running kernel,
+         * using it if it is.
+         */
+        if (self->has_build_id) {
+                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) {
+                        if (dso__build_id_equal(self, kallsyms_build_id)) {
+                                kallsyms_filename = "/proc/kallsyms";
+                                goto do_kallsyms;
                         }
                 }
-        }
+                /*
+                 * Now look if we have it on the build-id cache in
+                 * $HOME/.debug/[kernel.kallsyms].
+                 */
+                build_id__sprintf(self->build_id, sizeof(self->build_id),
+                                  sbuild_id);
 
-        is_kallsyms = self->long_name[0] == '[';
-        if (is_kallsyms)
-                goto do_kallsyms;
+                if (asprintf(&kallsyms_allocated_filename,
+                             "%s/.debug/[kernel.kallsyms]/%s",
+                             getenv("HOME"), sbuild_id) == -1) {
+                        pr_err("Not enough memory for kallsyms file lookup\n");
+                        return -1;
+                }
 
-        err = dso__load_vmlinux(self, map, session, self->long_name, filter);
-        if (err <= 0) {
-                pr_info("The file %s cannot be used, "
-                        "trying to use /proc/kallsyms...", self->long_name);
-do_kallsyms:
-                err = dso__load_kallsyms(self, map, session, filter);
-                if (err > 0 && !is_kallsyms)
-                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
+                kallsyms_filename = kallsyms_allocated_filename;
+
+                if (access(kallsyms_filename, F_OK)) {
+                        pr_err("No kallsyms or vmlinux with build-id %s "
+                               "was found\n", sbuild_id);
+                        free(kallsyms_allocated_filename);
+                        return -1;
+                }
+        } else {
+                /*
+                 * Last resort, if we don't have a build-id and couldn't find
+                 * any vmlinux file, try the running kernel kallsyms table.
+                 */
+                kallsyms_filename = "/proc/kallsyms";
         }
 
+do_kallsyms:
+        err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
+        if (err > 0)
+                pr_debug("Using %s for symbols\n", kallsyms_filename);
+        free(kallsyms_allocated_filename);
+
         if (err > 0) {
 out_fixup:
+                if (kallsyms_filename != NULL)
+                        dso__set_long_name(self, strdup("[kernel.kallsyms]"));
                 map__fixup_start(map);
                 map__fixup_end(map);
         }
@@ -1562,9 +1908,56 @@ out_fixup:
         return err;
 }
 
-LIST_HEAD(dsos__user);
-LIST_HEAD(dsos__kernel);
-struct dso *vdso;
+static int dso__load_guest_kernel_sym(struct dso *self, struct map *map,
+                                symbol_filter_t filter)
+{
+        int err;
+        const char *kallsyms_filename = NULL;
+        struct machine *machine;
+        char path[PATH_MAX];
+
+        if (!map->groups) {
+                pr_debug("Guest kernel map hasn't the point to groups\n");
+                return -1;
+        }
+        machine = map->groups->machine;
+
+        if (machine__is_default_guest(machine)) {
+                /*
+                 * if the user specified a vmlinux filename, use it and only
+                 * it, reporting errors to the user if it cannot be used.
+                 * Or use file guest_kallsyms inputted by user on commandline
+                 */
+                if (symbol_conf.default_guest_vmlinux_name != NULL) {
+                        err = dso__load_vmlinux(self, map,
+                                symbol_conf.default_guest_vmlinux_name, filter);
+                        goto out_try_fixup;
+                }
+
+                kallsyms_filename = symbol_conf.default_guest_kallsyms;
+                if (!kallsyms_filename)
+                        return -1;
+        } else {
+                sprintf(path, "%s/proc/kallsyms", machine->root_dir);
+                kallsyms_filename = path;
+        }
+
+        err = dso__load_kallsyms(self, kallsyms_filename, map, filter);
+        if (err > 0)
+                pr_debug("Using %s for symbols\n", kallsyms_filename);
+
+out_try_fixup:
+        if (err > 0) {
+                if (kallsyms_filename != NULL) {
+                        machine__mmap_name(machine, path, sizeof(path));
+                        dso__set_long_name(self, strdup(path));
+                }
+                map__fixup_start(map);
+                map__fixup_end(map);
+        }
+
+        return err;
+}
 
 static void dsos__add(struct list_head *head, struct dso *dso)
 {
@@ -1576,19 +1969,19 @@ static struct dso *dsos__find(struct list_head *head, const char *name)
         struct dso *pos;
 
         list_for_each_entry(pos, head, node)
-                if (strcmp(pos->name, name) == 0)
+                if (strcmp(pos->long_name, name) == 0)
                         return pos;
         return NULL;
 }
 
-struct dso *dsos__findnew(const char *name)
+struct dso *__dsos__findnew(struct list_head *head, const char *name)
 {
-        struct dso *dso = dsos__find(&dsos__user, name);
+        struct dso *dso = dsos__find(head, name);
 
         if (!dso) {
                 dso = dso__new(name);
                 if (dso != NULL) {
-                        dsos__add(&dsos__user, dso);
+                        dsos__add(head, dso);
                         dso__set_basename(dso);
                 }
         }
@@ -1596,93 +1989,192 @@ struct dso *dsos__findnew(const char *name)
         return dso;
 }
 
-static void __dsos__fprintf(struct list_head *head, FILE *fp)
+size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 {
         struct dso *pos;
+        size_t ret = 0;
 
         list_for_each_entry(pos, head, node) {
                 int i;
                 for (i = 0; i < MAP__NR_TYPES; ++i)
-                        dso__fprintf(pos, i, fp);
+                        ret += dso__fprintf(pos, i, fp);
         }
+
+        return ret;
 }
 
-void dsos__fprintf(FILE *fp)
+size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp)
 {
-        __dsos__fprintf(&dsos__kernel, fp);
-        __dsos__fprintf(&dsos__user, fp);
+        struct rb_node *nd;
+        size_t ret = 0;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += __dsos__fprintf(&pos->kernel_dsos, fp);
+                ret += __dsos__fprintf(&pos->user_dsos, fp);
+        }
+
+        return ret;
 }
 
-static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp)
+static size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
+                                      bool with_hits)
 {
         struct dso *pos;
         size_t ret = 0;
 
         list_for_each_entry(pos, head, node) {
+                if (with_hits && !pos->hit)
+                        continue;
                 ret += dso__fprintf_buildid(pos, fp);
                 ret += fprintf(fp, " %s\n", pos->long_name);
         }
         return ret;
 }
 
-size_t dsos__fprintf_buildid(FILE *fp)
+size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits)
 {
-        return (__dsos__fprintf_buildid(&dsos__kernel, fp) +
-                __dsos__fprintf_buildid(&dsos__user, fp));
+        return __dsos__fprintf_buildid(&self->kernel_dsos, fp, with_hits) +
+               __dsos__fprintf_buildid(&self->user_dsos, fp, with_hits);
 }
 
-static struct dso *dsos__create_kernel( const char *vmlinux)
+size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits)
 {
-        struct dso *kernel = dso__new(vmlinux ?: "[kernel.kallsyms]");
+        struct rb_node *nd;
+        size_t ret = 0;
 
-        if (kernel == NULL)
-                return NULL;
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct machine *pos = rb_entry(nd, struct machine, rb_node);
+                ret += machine__fprintf_dsos_buildid(pos, fp, with_hits);
+        }
+        return ret;
+}
+
+struct dso *dso__new_kernel(const char *name)
+{
+        struct dso *self = dso__new(name ?: "[kernel.kallsyms]");
+
+        if (self != NULL) {
+                dso__set_short_name(self, "[kernel]");
+                self->kernel = DSO_TYPE_KERNEL;
+        }
+
+        return self;
+}
+
+static struct dso *dso__new_guest_kernel(struct machine *machine,
+                                        const char *name)
+{
+        char bf[PATH_MAX];
+        struct dso *self = dso__new(name ?: machine__mmap_name(machine, bf, sizeof(bf)));
+
+        if (self != NULL) {
+                dso__set_short_name(self, "[guest.kernel]");
+                self->kernel = DSO_TYPE_GUEST_KERNEL;
+        }
+
+        return self;
+}
 
-        kernel->short_name = "[kernel]";
-        kernel->kernel     = 1;
+void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine)
+{
+        char path[PATH_MAX];
 
-        vdso = dso__new("[vdso]");
-        if (vdso == NULL)
-                goto out_delete_kernel_dso;
-        dso__set_loaded(vdso, MAP__FUNCTION);
+        if (machine__is_default_guest(machine))
+                return;
+        sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
+        if (sysfs__read_build_id(path, self->build_id,
+                                 sizeof(self->build_id)) == 0)
+                self->has_build_id = true;
+}
 
-        if (sysfs__read_build_id("/sys/kernel/notes", kernel->build_id,
-                                 sizeof(kernel->build_id)) == 0)
-                kernel->has_build_id = true;
+static struct dso *machine__create_kernel(struct machine *self)
+{
+        const char *vmlinux_name = NULL;
+        struct dso *kernel;
 
-        dsos__add(&dsos__kernel, kernel);
-        dsos__add(&dsos__user, vdso);
+        if (machine__is_host(self)) {
+                vmlinux_name = symbol_conf.vmlinux_name;
+                kernel = dso__new_kernel(vmlinux_name);
+        } else {
+                if (machine__is_default_guest(self))
+                        vmlinux_name = symbol_conf.default_guest_vmlinux_name;
+                kernel = dso__new_guest_kernel(self, vmlinux_name);
+        }
 
+        if (kernel != NULL) {
+                dso__read_running_kernel_build_id(kernel, self);
+                dsos__add(&self->kernel_dsos, kernel);
+        }
         return kernel;
+}
 
-out_delete_kernel_dso:
-        dso__delete(kernel);
-        return NULL;
+int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
+{
+        enum map_type type;
+
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
+
+                self->vmlinux_maps[type] = map__new2(0, kernel, type);
+                if (self->vmlinux_maps[type] == NULL)
+                        return -1;
+
+                self->vmlinux_maps[type]->map_ip =
+                        self->vmlinux_maps[type]->unmap_ip = identity__map_ip;
+
+                kmap = map__kmap(self->vmlinux_maps[type]);
+                kmap->kmaps = &self->kmaps;
+                map_groups__insert(&self->kmaps, self->vmlinux_maps[type]);
+        }
+
+        return 0;
 }
 
-static int map_groups__create_kernel_maps(struct map_groups *self, const char *vmlinux)
+void machine__destroy_kernel_maps(struct machine *self)
 {
-        struct map *functions, *variables;
-        struct dso *kernel = dsos__create_kernel(vmlinux);
+        enum map_type type;
 
-        if (kernel == NULL)
-                return -1;
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
 
-        functions = map__new2(0, kernel, MAP__FUNCTION);
-        if (functions == NULL)
-                return -1;
+                if (self->vmlinux_maps[type] == NULL)
+                        continue;
 
-        variables = map__new2(0, kernel, MAP__VARIABLE);
-        if (variables == NULL) {
-                map__delete(functions);
-                return -1;
+                kmap = map__kmap(self->vmlinux_maps[type]);
+                map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
+                if (kmap->ref_reloc_sym) {
+                        /*
+                         * ref_reloc_sym is shared among all maps, so free just
+                         * on one of them.
+                         */
+                        if (type == MAP__FUNCTION) {
+                                free((char *)kmap->ref_reloc_sym->name);
+                                kmap->ref_reloc_sym->name = NULL;
+                                free(kmap->ref_reloc_sym);
+                        }
+                        kmap->ref_reloc_sym = NULL;
+                }
+
+                map__delete(self->vmlinux_maps[type]);
+                self->vmlinux_maps[type] = NULL;
         }
+}
 
-        functions->map_ip = functions->unmap_ip =
-                variables->map_ip = variables->unmap_ip = identity__map_ip;
-        map_groups__insert(self, functions);
-        map_groups__insert(self, variables);
+int machine__create_kernel_maps(struct machine *self)
+{
+        struct dso *kernel = machine__create_kernel(self);
+
+        if (kernel == NULL ||
+            __machine__create_kernel_maps(self, kernel) < 0)
+                return -1;
 
+        if (symbol_conf.use_modules && machine__create_modules(self) < 0)
+                pr_debug("Problems creating module maps, continuing anyway...\n");
+        /*
+         * Now that we have all the maps created, just set the ->end of them:
+         */
+        map_groups__fixup_end(&self->kmaps);
         return 0;
 }
 
@@ -1741,6 +2233,25 @@ out_fail:
         return -1;
 }
 
+size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp)
+{
+        int i;
+        size_t printed = 0;
+        struct dso *kdso = self->vmlinux_maps[MAP__FUNCTION]->dso;
+
+        if (kdso->has_build_id) {
+                char filename[PATH_MAX];
+                if (dso__build_id_filename(kdso, filename, sizeof(filename)))
+                        printed += fprintf(fp, "[0] %s\n", filename);
+        }
+
+        for (i = 0; i < vmlinux_path__nr_entries; ++i)
+                printed += fprintf(fp, "[%d] %s\n",
+                                   i + kdso->has_build_id, vmlinux_path[i]);
+
+        return printed;
+}
+
 static int setup_list(struct strlist **list, const char *list_str,
                       const char *list_name)
 {
@@ -1757,6 +2268,9 @@ static int setup_list(struct strlist **list, const char *list_str,
 
 int symbol__init(void)
 {
+        if (symbol_conf.initialized)
+                return 0;
+
         elf_version(EV_CURRENT);
         if (symbol_conf.sort_by_name)
                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
@@ -1782,6 +2296,7 @@ int symbol__init(void)
                        symbol_conf.sym_list_str, "symbol") < 0)
                 goto out_free_comm_list;
 
+        symbol_conf.initialized = true;
         return 0;
 
 out_free_dso_list:
@@ -1791,19 +2306,154 @@ out_free_comm_list:
         return -1;
 }
 
-int perf_session__create_kernel_maps(struct perf_session *self)
+void symbol__exit(void)
+{
+        if (!symbol_conf.initialized)
+                return;
+        strlist__delete(symbol_conf.sym_list);
+        strlist__delete(symbol_conf.dso_list);
+        strlist__delete(symbol_conf.comm_list);
+        vmlinux_path__exit();
+        symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
+        symbol_conf.initialized = false;
+}
+
+int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
 {
-        if (map_groups__create_kernel_maps(&self->kmaps,
-                                           symbol_conf.vmlinux_name) < 0)
+        struct machine *machine = machines__findnew(self, pid);
+
+        if (machine == NULL)
                 return -1;
 
-        if (symbol_conf.use_modules &&
-            perf_session__create_module_maps(self) < 0)
-                pr_debug("Failed to load list of modules for session %s, "
-                         "continuing...\n", self->filename);
-        /*
-         * Now that we have all the maps created, just set the ->end of them:
-         */
-        map_groups__fixup_end(&self->kmaps);
-        return 0;
+        return machine__create_kernel_maps(machine);
+}
+
+static int hex(char ch)
+{
+        if ((ch >= '0') && (ch <= '9'))
+                return ch - '0';
+        if ((ch >= 'a') && (ch <= 'f'))
+                return ch - 'a' + 10;
+        if ((ch >= 'A') && (ch <= 'F'))
+                return ch - 'A' + 10;
+        return -1;
+}
+
+/*
+ * While we find nice hex chars, build a long_val.
+ * Return number of chars processed.
+ */
+int hex2u64(const char *ptr, u64 *long_val)
+{
+        const char *p = ptr;
+        *long_val = 0;
+
+        while (*p) {
+                const int hex_val = hex(*p);
+
+                if (hex_val < 0)
+                        break;
+
+                *long_val = (*long_val << 4) | hex_val;
+                p++;
+        }
+
+        return p - ptr;
+}
+
+char *strxfrchar(char *s, char from, char to)
+{
+        char *p = s;
+
+        while ((p = strchr(p, from)) != NULL)
+                *p++ = to;
+
+        return s;
+}
+
+int machines__create_guest_kernel_maps(struct rb_root *self)
+{
+        int ret = 0;
+        struct dirent **namelist = NULL;
+        int i, items = 0;
+        char path[PATH_MAX];
+        pid_t pid;
+
+        if (symbol_conf.default_guest_vmlinux_name ||
+            symbol_conf.default_guest_modules ||
+            symbol_conf.default_guest_kallsyms) {
+                machines__create_kernel_maps(self, DEFAULT_GUEST_KERNEL_ID);
+        }
+
+        if (symbol_conf.guestmount) {
+                items = scandir(symbol_conf.guestmount, &namelist, NULL, NULL);
+                if (items <= 0)
+                        return -ENOENT;
+                for (i = 0; i < items; i++) {
+                        if (!isdigit(namelist[i]->d_name[0])) {
+                                /* Filter out . and .. */
+                                continue;
+                        }
+                        pid = atoi(namelist[i]->d_name);
+                        sprintf(path, "%s/%s/proc/kallsyms",
+                                symbol_conf.guestmount,
+                                namelist[i]->d_name);
+                        ret = access(path, R_OK);
+                        if (ret) {
+                                pr_debug("Can't access file %s\n", path);
+                                goto failure;
+                        }
+                        machines__create_kernel_maps(self, pid);
+                }
+failure:
+                free(namelist);
+        }
+
+        return ret;
+}
+
+void machines__destroy_guest_kernel_maps(struct rb_root *self)
+{
+        struct rb_node *next = rb_first(self);
+
+        while (next) {
+                struct machine *pos = rb_entry(next, struct machine, rb_node);
+
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, self);
+                machine__delete(pos);
+        }
+}
+
+int machine__load_kallsyms(struct machine *self, const char *filename,
+                           enum map_type type, symbol_filter_t filter)
+{
+        struct map *map = self->vmlinux_maps[type];
+        int ret = dso__load_kallsyms(map->dso, filename, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                /*
+                 * Since /proc/kallsyms will have multiple sessions for the
+                 * kernel, with modules between them, fixup the end of all
+                 * sections.
+                 */
+                __map_groups__fixup_end(&self->kmaps, type);
+        }
+
+        return ret;
+}
+
+int machine__load_vmlinux_path(struct machine *self, enum map_type type,
+                               symbol_filter_t filter)
+{
+        struct map *map = self->vmlinux_maps[type];
+        int ret = dso__load_vmlinux_path(map->dso, map, filter);
+
+        if (ret > 0) {
+                dso__set_loaded(map->dso, type);
+                map__reloc_vmlinux(map);
+        }
+
+        return ret;
 }
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 8aded2356f79..ea95c2756f05 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -3,10 +3,11 @@
 
 #include <linux/types.h>
 #include <stdbool.h>
-#include "types.h"
+#include <stdint.h>
+#include "map.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
-#include "event.h"
+#include <stdio.h>
 
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
@@ -27,6 +28,9 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
 #endif
 #endif
 
+int hex2u64(const char *ptr, u64 *val);
+char *strxfrchar(char *s, char from, char to);
+
 /*
  * libelf 0.8.x and earlier do not support ELF_C_READ_MMAP;
  * for newer versions we can use mmap to reduce memory usage:
@@ -42,13 +46,19 @@ static inline char *bfd_demangle(void __used *v, const char __used *c,
 #define DMGL_ANSI        (1 << 1)       /* Include const, volatile, etc */
 #endif
 
+#define BUILD_ID_SIZE 20
+
 struct symbol {
         struct rb_node  rb_node;
         u64             start;
         u64             end;
+        u16             namelen;
+        u8              binding;
         char            name[0];
 };
 
+void symbol__delete(struct symbol *self);
+
 struct strlist;
 
 struct symbol_conf {
@@ -58,10 +68,17 @@ struct symbol_conf {
                         sort_by_name,
                         show_nr_samples,
                         use_callchain,
-                        exclude_other;
+                        exclude_other,
+                        show_cpu_utilization,
+                        initialized;
         const char      *vmlinux_name,
+                        *source_prefix,
                         *field_sep;
-        char            *dso_list_str,
+        const char      *default_guest_vmlinux_name,
+                        *default_guest_kallsyms,
+                        *default_guest_modules;
+        const char      *guestmount;
+        const char      *dso_list_str,
                         *comm_list_str,
                         *sym_list_str,
                         *col_width_list_str;
@@ -77,6 +94,19 @@ static inline void *symbol__priv(struct symbol *self)
         return ((void *)self) - symbol_conf.priv_size;
 }
 
+struct ref_reloc_sym {
+        const char      *name;
+        u64             addr;
+        u64             unrelocated_addr;
+};
+
+struct map_symbol {
+        struct map    *map;
+        struct symbol *sym;
+        bool          unfolded;
+        bool          has_children;
+};
+
 struct addr_location {
         struct thread *thread;
         struct map    *map;
@@ -84,58 +114,118 @@ struct addr_location {
         u64           addr;
         char          level;
         bool          filtered;
+        u8            cpumode;
+        s32           cpu;
+};
+
+enum dso_kernel_type {
+        DSO_TYPE_USER = 0,
+        DSO_TYPE_KERNEL,
+        DSO_TYPE_GUEST_KERNEL
 };
 
 struct dso {
         struct list_head node;
         struct rb_root   symbols[MAP__NR_TYPES];
         struct rb_root   symbol_names[MAP__NR_TYPES];
+        enum dso_kernel_type    kernel;
         u8               adjust_symbols:1;
         u8               slen_calculated:1;
         u8               has_build_id:1;
-        u8               kernel:1;
+        u8               hit:1;
+        u8               annotate_warned:1;
+        u8               sname_alloc:1;
+        u8               lname_alloc:1;
         unsigned char    origin;
         u8               sorted_by_name;
         u8               loaded;
         u8               build_id[BUILD_ID_SIZE];
-        u16              long_name_len;
         const char       *short_name;
         char             *long_name;
+        u16              long_name_len;
+        u16              short_name_len;
         char             name[0];
 };
 
 struct dso *dso__new(const char *name);
+struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *self);
 
+int dso__name_len(const struct dso *self);
+
 bool dso__loaded(const struct dso *self, enum map_type type);
 bool dso__sorted_by_name(const struct dso *self, enum map_type type);
 
+static inline void dso__set_loaded(struct dso *self, enum map_type type)
+{
+        self->loaded |= (1 << type);
+}
+
 void dso__sort_by_name(struct dso *self, enum map_type type);
 
-struct perf_session;
+struct dso *__dsos__findnew(struct list_head *head, const char *name);
+
+int dso__load(struct dso *self, struct map *map, symbol_filter_t filter);
+int dso__load_vmlinux_path(struct dso *self, struct map *map,
+                           symbol_filter_t filter);
+int dso__load_kallsyms(struct dso *self, const char *filename, struct map *map,
+                       symbol_filter_t filter);
+int machine__load_kallsyms(struct machine *self, const char *filename,
+                           enum map_type type, symbol_filter_t filter);
+int machine__load_vmlinux_path(struct machine *self, enum map_type type,
+                               symbol_filter_t filter);
+
+size_t __dsos__fprintf(struct list_head *head, FILE *fp);
 
-struct dso *dsos__findnew(const char *name);
-int dso__load(struct dso *self, struct map *map, struct perf_session *session,
-              symbol_filter_t filter);
-void dsos__fprintf(FILE *fp);
-size_t dsos__fprintf_buildid(FILE *fp);
+size_t machine__fprintf_dsos_buildid(struct machine *self, FILE *fp, bool with_hits);
+size_t machines__fprintf_dsos(struct rb_root *self, FILE *fp);
+size_t machines__fprintf_dsos_buildid(struct rb_root *self, FILE *fp, bool with_hits);
 
 size_t dso__fprintf_buildid(struct dso *self, FILE *fp);
 size_t dso__fprintf(struct dso *self, enum map_type type, FILE *fp);
+
+enum dso_origin {
+        DSO__ORIG_KERNEL = 0,
+        DSO__ORIG_GUEST_KERNEL,
+        DSO__ORIG_JAVA_JIT,
+        DSO__ORIG_BUILD_ID_CACHE,
+        DSO__ORIG_FEDORA,
+        DSO__ORIG_UBUNTU,
+        DSO__ORIG_BUILDID,
+        DSO__ORIG_DSO,
+        DSO__ORIG_GUEST_KMODULE,
+        DSO__ORIG_KMODULE,
+        DSO__ORIG_NOT_FOUND,
+};
+
 char dso__symtab_origin(const struct dso *self);
+void dso__set_long_name(struct dso *self, char *name);
 void dso__set_build_id(struct dso *self, void *build_id);
+void dso__read_running_kernel_build_id(struct dso *self, struct machine *machine);
 struct symbol *dso__find_symbol(struct dso *self, enum map_type type, u64 addr);
 struct symbol *dso__find_symbol_by_name(struct dso *self, enum map_type type,
                                         const char *name);
 
 int filename__read_build_id(const char *filename, void *bf, size_t size);
 int sysfs__read_build_id(const char *filename, void *bf, size_t size);
-bool dsos__read_build_ids(void);
-int build_id__sprintf(u8 *self, int len, char *bf);
+bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
+int build_id__sprintf(const u8 *self, int len, char *bf);
+int kallsyms__parse(const char *filename, void *arg,
+                    int (*process_symbol)(void *arg, const char *name,
+                                          char type, u64 start));
+
+void machine__destroy_kernel_maps(struct machine *self);
+int __machine__create_kernel_maps(struct machine *self, struct dso *kernel);
+int machine__create_kernel_maps(struct machine *self);
+
+int machines__create_kernel_maps(struct rb_root *self, pid_t pid);
+int machines__create_guest_kernel_maps(struct rb_root *self);
+void machines__destroy_guest_kernel_maps(struct rb_root *self);
 
 int symbol__init(void);
-int perf_session__create_kernel_maps(struct perf_session *self);
+void symbol__exit(void);
+bool symbol_type__is_a(char symbol_type, enum map_type map_type);
+
+size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp);
 
-extern struct list_head dsos__user, dsos__kernel;
-extern struct dso *vdso;
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 4a08dcf50b68..8c72d888e449 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -7,13 +7,44 @@
 #include "util.h"
 #include "debug.h"
 
-void map_groups__init(struct map_groups *self)
+/* Skip "." and ".." directories */
+static int filter(const struct dirent *dir)
 {
+        if (dir->d_name[0] == '.')
+                return 0;
+        else
+                return 1;
+}
+
+int find_all_tid(int pid, pid_t ** all_tid)
+{
+        char name[256];
+        int items;
+        struct dirent **namelist = NULL;
+        int ret = 0;
         int i;
-        for (i = 0; i < MAP__NR_TYPES; ++i) {
-                self->maps[i] = RB_ROOT;
-                INIT_LIST_HEAD(&self->removed_maps[i]);
+
+        sprintf(name, "/proc/%d/task", pid);
+        items = scandir(name, &namelist, filter, NULL);
+        if (items <= 0)
+                return -ENOENT;
+        *all_tid = malloc(sizeof(pid_t) * items);
+        if (!*all_tid) {
+                ret = -ENOMEM;
+                goto failure;
         }
+
+        for (i = 0; i < items; i++)
+                (*all_tid)[i] = atoi(namelist[i]->d_name);
+
+        ret = items;
+
+failure:
+        for (i=0; i<items; i++)
+                free(namelist[i]);
+        free(namelist);
+
+        return ret;
 }
 
 static struct thread *thread__new(pid_t pid)
@@ -31,12 +62,26 @@ static struct thread *thread__new(pid_t pid)
         return self;
 }
 
+void thread__delete(struct thread *self)
+{
+        map_groups__exit(&self->mg);
+        free(self->comm);
+        free(self);
+}
+
 int thread__set_comm(struct thread *self, const char *comm)
 {
+        int err;
+
         if (self->comm)
                 free(self->comm);
         self->comm = strdup(comm);
-        return self->comm ? 0 : -ENOMEM;
+        err = self->comm == NULL ? -ENOMEM : 0;
+        if (!err) {
+                self->comm_set = true;
+                map_groups__flush(&self->mg);
+        }
+        return err;
 }
 
 int thread__comm_len(struct thread *self)
@@ -50,74 +95,10 @@ int thread__comm_len(struct thread *self)
         return self->comm_len;
 }
 
-static const char *map_type__name[MAP__NR_TYPES] = {
-        [MAP__FUNCTION] = "Functions",
-        [MAP__VARIABLE] = "Variables",
-};
-
-static size_t __map_groups__fprintf_maps(struct map_groups *self,
-                                         enum map_type type, FILE *fp)
-{
-        size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
-        struct rb_node *nd;
-
-        for (nd = rb_first(&self->maps[type]); nd; nd = rb_next(nd)) {
-                struct map *pos = rb_entry(nd, struct map, rb_node);
-                printed += fprintf(fp, "Map:");
-                printed += map__fprintf(pos, fp);
-                if (verbose > 1) {
-                        printed += dso__fprintf(pos->dso, type, fp);
-                        printed += fprintf(fp, "--\n");
-                }
-        }
-
-        return printed;
-}
-
-size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
-{
-        size_t printed = 0, i;
-        for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_maps(self, i, fp);
-        return printed;
-}
-
-static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
-                                                 enum map_type type, FILE *fp)
-{
-        struct map *pos;
-        size_t printed = 0;
-
-        list_for_each_entry(pos, &self->removed_maps[type], node) {
-                printed += fprintf(fp, "Map:");
-                printed += map__fprintf(pos, fp);
-                if (verbose > 1) {
-                        printed += dso__fprintf(pos->dso, type, fp);
-                        printed += fprintf(fp, "--\n");
-                }
-        }
-        return printed;
-}
-
-static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
-{
-        size_t printed = 0, i;
-        for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __map_groups__fprintf_removed_maps(self, i, fp);
-        return printed;
-}
-
-static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
-{
-        size_t printed = map_groups__fprintf_maps(self, fp);
-        printed += fprintf(fp, "Removed maps:\n");
-        return printed + map_groups__fprintf_removed_maps(self, fp);
-}
-
 static size_t thread__fprintf(struct thread *self, FILE *fp)
 {
         return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
-               map_groups__fprintf(&self->mg, fp);
+               map_groups__fprintf(&self->mg, verbose, fp);
 }
 
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
@@ -159,107 +140,24 @@ struct thread *perf_session__findnew(struct perf_session *self, pid_t pid)
         return th;
 }
 
-static void map_groups__remove_overlappings(struct map_groups *self,
-                                            struct map *map)
-{
-        struct rb_root *root = &self->maps[map->type];
-        struct rb_node *next = rb_first(root);
-
-        while (next) {
-                struct map *pos = rb_entry(next, struct map, rb_node);
-                next = rb_next(&pos->rb_node);
-
-                if (!map__overlap(pos, map))
-                        continue;
-
-                if (verbose >= 2) {
-                        fputs("overlapping maps:\n", stderr);
-                        map__fprintf(map, stderr);
-                        map__fprintf(pos, stderr);
-                }
-
-                rb_erase(&pos->rb_node, root);
-                /*
-                 * We may have references to this map, for instance in some
-                 * hist_entry instances, so just move them to a separate
-                 * list.
-                 */
-                list_add_tail(&pos->node, &self->removed_maps[map->type]);
-        }
-}
-
-void maps__insert(struct rb_root *maps, struct map *map)
-{
-        struct rb_node **p = &maps->rb_node;
-        struct rb_node *parent = NULL;
-        const u64 ip = map->start;
-        struct map *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct map, rb_node);
-                if (ip < m->start)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-
-        rb_link_node(&map->rb_node, parent, p);
-        rb_insert_color(&map->rb_node, maps);
-}
-
-struct map *maps__find(struct rb_root *maps, u64 ip)
-{
-        struct rb_node **p = &maps->rb_node;
-        struct rb_node *parent = NULL;
-        struct map *m;
-
-        while (*p != NULL) {
-                parent = *p;
-                m = rb_entry(parent, struct map, rb_node);
-                if (ip < m->start)
-                        p = &(*p)->rb_left;
-                else if (ip > m->end)
-                        p = &(*p)->rb_right;
-                else
-                        return m;
-        }
-
-        return NULL;
-}
-
 void thread__insert_map(struct thread *self, struct map *map)
 {
-        map_groups__remove_overlappings(&self->mg, map);
+        map_groups__fixup_overlappings(&self->mg, map, verbose, stderr);
         map_groups__insert(&self->mg, map);
 }
 
-/*
- * XXX This should not really _copy_ te maps, but refcount them.
- */
-static int map_groups__clone(struct map_groups *self,
-                             struct map_groups *parent, enum map_type type)
-{
-        struct rb_node *nd;
-        for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
-                struct map *map = rb_entry(nd, struct map, rb_node);
-                struct map *new = map__clone(map);
-                if (new == NULL)
-                        return -ENOMEM;
-                map_groups__insert(self, new);
-        }
-        return 0;
-}
-
 int thread__fork(struct thread *self, struct thread *parent)
 {
         int i;
 
-        if (self->comm)
-                free(self->comm);
-        self->comm = strdup(parent->comm);
-        if (!self->comm)
-                return -ENOMEM;
+        if (parent->comm_set) {
+                if (self->comm)
+                        free(self->comm);
+                self->comm = strdup(parent->comm);
+                if (!self->comm)
+                        return -ENOMEM;
+                self->comm_set = true;
+        }
 
         for (i = 0; i < MAP__NR_TYPES; ++i)
                 if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
@@ -280,16 +178,3 @@ size_t perf_session__fprintf(struct perf_session *self, FILE *fp)
 
         return ret;
 }
-
-struct symbol *map_groups__find_symbol(struct map_groups *self,
-                                       struct perf_session *session,
-                                       enum map_type type, u64 addr,
-                                       symbol_filter_t filter)
-{
-        struct map *map = map_groups__find(self, type, addr);
-
-        if (map != NULL)
-                return map__find_symbol(map, session, map->map_ip(map, addr), filter);
-
-        return NULL;
-}
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index c206f72c8881..688500ff826f 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -5,66 +5,45 @@
 #include <unistd.h>
 #include "symbol.h"
 
-struct map_groups {
-        struct rb_root          maps[MAP__NR_TYPES];
-        struct list_head        removed_maps[MAP__NR_TYPES];
-};
-
 struct thread {
-        struct rb_node          rb_node;
+        union {
+                struct rb_node   rb_node;
+                struct list_head node;
+        };
         struct map_groups       mg;
         pid_t                   pid;
         char                    shortname[3];
+        bool                    comm_set;
         char                    *comm;
         int                     comm_len;
 };
 
-void map_groups__init(struct map_groups *self);
+struct perf_session;
+
+void thread__delete(struct thread *self);
+
+int find_all_tid(int pid, pid_t ** all_tid);
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
 void thread__insert_map(struct thread *self, struct map *map);
 int thread__fork(struct thread *self, struct thread *parent);
-size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp);
 size_t perf_session__fprintf(struct perf_session *self, FILE *fp);
 
-void maps__insert(struct rb_root *maps, struct map *map);
-struct map *maps__find(struct rb_root *maps, u64 addr);
-
-static inline void map_groups__insert(struct map_groups *self, struct map *map)
-{
-         maps__insert(&self->maps[map->type], map);
-}
-
-static inline struct map *map_groups__find(struct map_groups *self,
-                                           enum map_type type, u64 addr)
-{
-        return maps__find(&self->maps[type], addr);
-}
-
 static inline struct map *thread__find_map(struct thread *self,
                                            enum map_type type, u64 addr)
 {
         return self ? map_groups__find(&self->mg, type, addr) : NULL;
 }
 
+void thread__find_addr_map(struct thread *self,
+                           struct perf_session *session, u8 cpumode,
+                           enum map_type type, pid_t pid, u64 addr,
+                           struct addr_location *al);
+
 void thread__find_addr_location(struct thread *self,
                                 struct perf_session *session, u8 cpumode,
-                                enum map_type type, u64 addr,
+                                enum map_type type, pid_t pid, u64 addr,
                                 struct addr_location *al,
                                 symbol_filter_t filter);
-struct symbol *map_groups__find_symbol(struct map_groups *self,
-                                       struct perf_session *session,
-                                       enum map_type type, u64 addr,
-                                       symbol_filter_t filter);
-
-static inline struct symbol *
-map_groups__find_function(struct map_groups *self, struct perf_session *session,
-                          u64 addr, symbol_filter_t filter)
-{
-        return map_groups__find_symbol(self, session, MAP__FUNCTION, addr, filter);
-}
-
-struct map *map_groups__find_by_name(struct map_groups *self,
-                                     enum map_type type, const char *name);
 #endif  /* __PERF_THREAD_H */
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index cace35595530..b1572601286c 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -20,6 +20,7 @@
  */
 #define _GNU_SOURCE
 #include <dirent.h>
+#include <mntent.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -37,6 +38,7 @@
 
 #include "../perf.h"
 #include "trace-event.h"
+#include "debugfs.h"
 
 #define VERSION "0.5"
 
@@ -101,32 +103,12 @@ void *malloc_or_die(unsigned int size)
 
 static const char *find_debugfs(void)
 {
-        static char debugfs[MAX_PATH+1];
-        static int debugfs_found;
-        char type[100];
-        FILE *fp;
-
-        if (debugfs_found)
-                return debugfs;
-
-        if ((fp = fopen("/proc/mounts","r")) == NULL)
-                die("Can't open /proc/mounts for read");
-
-        while (fscanf(fp, "%*s %"
-                      STR(MAX_PATH)
-                      "s %99s %*s %*d %*d\n",
-                      debugfs, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
-
-        if (strcmp(type, "debugfs") != 0)
-                die("debugfs not mounted, please mount");
+        const char *path = debugfs_mount(NULL);
 
-        debugfs_found = 1;
+        if (!path)
+                die("Your kernel not support debugfs filesystem");
 
-        return debugfs;
+        return path;
 }
 
 /*
@@ -172,10 +154,17 @@ static void put_tracing_file(char *file)
         free(file);
 }
 
+static ssize_t calc_data_size;
+
 static ssize_t write_or_die(const void *buf, size_t len)
 {
         int ret;
 
+        if (calc_data_size) {
+                calc_data_size += len;
+                return len;
+        }
+
         ret = write(output_fd, buf, len);
         if (ret < 0)
                 die("writing to '%s'", output_file);
@@ -271,6 +260,8 @@ static void read_header_files(void)
         write_or_die("header_page", 12);
         write_or_die(&size, 8);
         check_size = copy_file_fd(fd);
+        close(fd);
+
         if (size != check_size)
                 die("wrong size for '%s' size=%lld read=%lld",
                     path, size, check_size);
@@ -289,6 +280,7 @@ static void read_header_files(void)
         if (size != check_size)
                 die("wrong size for '%s'", path);
         put_tracing_file(path);
+        close(fd);
 }
 
 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
@@ -317,7 +309,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
                 die("can't read directory '%s'", sys);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -334,7 +327,8 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     !name_in_tp_list(dent->d_name, tps))
                         continue;
@@ -353,6 +347,7 @@ static void copy_event_system(const char *sys, struct tracepoint_path *tps)
 
                 free(format);
         }
+        closedir(dir);
 }
 
 static void read_ftrace_files(struct tracepoint_path *tps)
@@ -394,26 +389,21 @@ static void read_event_files(struct tracepoint_path *tps)
                 die("can't read directory '%s'", path);
 
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
                         continue;
-                sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
-                sprintf(sys, "%s/%s", path, dent->d_name);
-                ret = stat(sys, &st);
-                free(sys);
-                if (ret < 0)
-                        continue;
-                if (S_ISDIR(st.st_mode))
-                        count++;
+                count++;
         }
 
         write_or_die(&count, 4);
 
         rewinddir(dir);
         while ((dent = readdir(dir))) {
-                if (strcmp(dent->d_name, ".") == 0 ||
+                if (dent->d_type != DT_DIR ||
+                    strcmp(dent->d_name, ".") == 0 ||
                     strcmp(dent->d_name, "..") == 0 ||
                     strcmp(dent->d_name, "ftrace") == 0 ||
                     !system_in_tp_list(dent->d_name, tps))
@@ -422,14 +412,13 @@ static void read_event_files(struct tracepoint_path *tps)
                 sprintf(sys, "%s/%s", path, dent->d_name);
                 ret = stat(sys, &st);
                 if (ret >= 0) {
-                        if (S_ISDIR(st.st_mode)) {
-                                write_or_die(dent->d_name, strlen(dent->d_name) + 1);
-                                copy_event_system(sys, tps);
-                        }
+                        write_or_die(dent->d_name, strlen(dent->d_name) + 1);
+                        copy_event_system(sys, tps);
                 }
                 free(sys);
         }
 
+        closedir(dir);
         put_tracing_file(path);
 }
 
@@ -498,6 +487,17 @@ get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
+bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
+{
+        int i;
+
+        for (i = 0; i < nb_events; i++)
+                if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
+                        return true;
+
+        return false;
+}
+
 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 {
         char buf[BUFSIZ];
@@ -533,7 +533,7 @@ int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
         write_or_die(buf, 1);
 
         /* save page_size */
-        page_size = getpagesize();
+        page_size = sysconf(_SC_PAGESIZE);
         write_or_die(&page_size, 4);
 
         read_header_files();
@@ -544,3 +544,20 @@ int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
 
         return 0;
 }
+
+ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
+                               int nb_events)
+{
+        ssize_t size;
+        int err = 0;
+
+        calc_data_size = 1;
+        err = read_tracing_data(fd, pattrs, nb_events);
+        size = calc_data_size - 1;
+        calc_data_size = 0;
+
+        if (err < 0)
+                return err;
+
+        return size;
+}
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index c5c32be040bf..73a02223c629 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -37,10 +37,12 @@ int header_page_ts_offset;
 int header_page_ts_size;
 int header_page_size_offset;
 int header_page_size_size;
+int header_page_overwrite_offset;
+int header_page_overwrite_size;
 int header_page_data_offset;
 int header_page_data_size;
 
-int latency_format;
+bool latency_format;
 
 static char *input_buf;
 static unsigned long long input_buf_ptr;
@@ -628,23 +630,32 @@ static int test_type(enum event_type type, enum event_type expect)
         return 0;
 }
 
-static int test_type_token(enum event_type type, char *token,
-                    enum event_type expect, const char *expect_tok)
+static int __test_type_token(enum event_type type, char *token,
+                             enum event_type expect, const char *expect_tok,
+                             bool warn)
 {
         if (type != expect) {
-                warning("Error: expected type %d but read %d",
-                    expect, type);
+                if (warn)
+                        warning("Error: expected type %d but read %d",
+                                expect, type);
                 return -1;
         }
 
         if (strcmp(token, expect_tok) != 0) {
-                warning("Error: expected '%s' but read '%s'",
-                    expect_tok, token);
+                if (warn)
+                        warning("Error: expected '%s' but read '%s'",
+                                expect_tok, token);
                 return -1;
         }
         return 0;
 }
 
+static int test_type_token(enum event_type type, char *token,
+                           enum event_type expect, const char *expect_tok)
+{
+        return __test_type_token(type, token, expect, expect_tok, true);
+}
+
 static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
 {
         enum event_type type;
@@ -661,7 +672,8 @@ static int read_expect_type(enum event_type expect, char **tok)
         return __read_expect_type(expect, tok, 1);
 }
 
-static int __read_expected(enum event_type expect, const char *str, int newline_ok)
+static int __read_expected(enum event_type expect, const char *str,
+                           int newline_ok, bool warn)
 {
         enum event_type type;
         char *token;
@@ -672,7 +684,7 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
         else
                 type = read_token_item(&token);
 
-        ret = test_type_token(type, token, expect, str);
+        ret = __test_type_token(type, token, expect, str, warn);
 
         free_token(token);
 
@@ -681,12 +693,12 @@ static int __read_expected(enum event_type expect, const char *str, int newline_
 
 static int read_expected(enum event_type expect, const char *str)
 {
-        return __read_expected(expect, str, 1);
+        return __read_expected(expect, str, 1, true);
 }
 
 static int read_expected_item(enum event_type expect, const char *str)
 {
-        return __read_expected(expect, str, 0);
+        return __read_expected(expect, str, 0, true);
 }
 
 static char *event_read_name(void)
@@ -744,7 +756,7 @@ static int field_is_string(struct format_field *field)
 
 static int field_is_dynamic(struct format_field *field)
 {
-        if (!strcmp(field->type, "__data_loc"))
+        if (!strncmp(field->type, "__data_loc", 10))
                 return 1;
 
         return 0;
@@ -1925,6 +1937,15 @@ void *raw_field_ptr(struct event *event, const char *name, void *data)
         if (!field)
                 return NULL;
 
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                int offset;
+
+                offset = *(int *)(data + field->offset);
+                offset &= 0xffff;
+
+                return data + offset;
+        }
+
         return data + field->offset;
 }
 
@@ -3078,88 +3099,6 @@ static void print_args(struct print_arg *args)
         }
 }
 
-static void parse_header_field(const char *field,
-                               int *offset, int *size)
-{
-        char *token;
-        int type;
-
-        if (read_expected(EVENT_ITEM, "field") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-
-        /* type */
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        free_token(token);
-
-        if (read_expected(EVENT_ITEM, field) < 0)
-                return;
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        if (read_expected(EVENT_ITEM, "offset") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        *offset = atoi(token);
-        free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        if (read_expected(EVENT_ITEM, "size") < 0)
-                return;
-        if (read_expected(EVENT_OP, ":") < 0)
-                return;
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        *size = atoi(token);
-        free_token(token);
-        if (read_expected(EVENT_OP, ";") < 0)
-                return;
-        type = read_token(&token);
-        if (type != EVENT_NEWLINE) {
-                /* newer versions of the kernel have a "signed" type */
-                if (type != EVENT_ITEM)
-                        goto fail;
-
-                if (strcmp(token, "signed") != 0)
-                        goto fail;
-
-                free_token(token);
-
-                if (read_expected(EVENT_OP, ":") < 0)
-                        return;
-
-                if (read_expect_type(EVENT_ITEM, &token))
-                        goto fail;
-
-                free_token(token);
-                if (read_expected(EVENT_OP, ";") < 0)
-                        return;
-
-                if (read_expect_type(EVENT_NEWLINE, &token))
-                        goto fail;
-        }
- fail:
-        free_token(token);
-}
-
-int parse_header_page(char *buf, unsigned long size)
-{
-        init_input_buf(buf, size);
-
-        parse_header_field("timestamp", &header_page_ts_offset,
-                           &header_page_ts_size);
-        parse_header_field("commit", &header_page_size_offset,
-                           &header_page_size_size);
-        parse_header_field("data", &header_page_data_offset,
-                           &header_page_data_size);
-
-        return 0;
-}
-
 int parse_ftrace_file(char *buf, unsigned long size)
 {
         struct format_field *field;
@@ -3277,3 +3216,18 @@ void parse_set_info(int nr_cpus, int long_sz)
         cpus = nr_cpus;
         long_size = long_sz;
 }
+
+int common_pc(struct scripting_context *context)
+{
+        return parse_common_pc(context->event_data);
+}
+
+int common_flags(struct scripting_context *context)
+{
+        return parse_common_flags(context->event_data);
+}
+
+int common_lock_depth(struct scripting_context *context)
+{
+        return parse_common_lock_depth(context->event_data);
+}
diff --git a/tools/perf/util/trace-event-perl.h b/tools/perf/util/trace-event-perl.h
deleted file mode 100644
index e88fb26137bb..000000000000
--- a/tools/perf/util/trace-event-perl.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef __PERF_TRACE_EVENT_PERL_H
-#define __PERF_TRACE_EVENT_PERL_H
-#ifdef NO_LIBPERL
-typedef int INTERP;
-#define dSP
-#define ENTER
-#define SAVETMPS
-#define PUTBACK
-#define SPAGAIN
-#define FREETMPS
-#define LEAVE
-#define SP
-#define ERRSV
-#define G_SCALAR                (0)
-#define G_DISCARD               (0)
-#define G_NOARGS                (0)
-#define PUSHMARK(a)
-#define SvTRUE(a)               (0)
-#define XPUSHs(s)
-#define sv_2mortal(a)
-#define newSVpv(a,b)
-#define newSVuv(a)
-#define newSViv(a)
-#define get_cv(a,b)             (0)
-#define call_pv(a,b)            (0)
-#define perl_alloc()            (0)
-#define perl_construct(a)       (0)
-#define perl_parse(a,b,c,d,e)   (0)
-#define perl_run(a)             (0)
-#define perl_destruct(a)        (0)
-#define perl_free(a)            (0)
-#define pTHX                    void
-#define CV                      void
-#define dXSUB_SYS
-#define pTHX_
-static inline void newXS(const char *a, void *b, const char *c) {}
-static void boot_Perf__Trace__Context(pTHX_ CV *cv) {}
-static void boot_DynaLoader(pTHX_ CV *cv) {}
-#else
-#include <EXTERN.h>
-#include <perl.h>
-void boot_Perf__Trace__Context(pTHX_ CV *cv);
-void boot_DynaLoader(pTHX_ CV *cv);
-typedef PerlInterpreter * INTERP;
-#endif
-
-struct scripting_context {
-        void *event_data;
-};
-
-int common_pc(struct scripting_context *context);
-int common_flags(struct scripting_context *context);
-int common_lock_depth(struct scripting_context *context);
-
-#endif /* __PERF_TRACE_EVENT_PERL_H */
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index 1744422cafcb..f55cc3a765a1 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -18,7 +18,7 @@
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
-#define _LARGEFILE64_SOURCE
+#define _FILE_OFFSET_BITS 64
 
 #include <dirent.h>
 #include <stdio.h>
@@ -50,17 +50,61 @@ static int long_size;
 
 static unsigned long    page_size;
 
+static ssize_t calc_data_size;
+static bool repipe;
+
+static int do_read(int fd, void *buf, int size)
+{
+        int rsize = size;
+
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret <= 0)
+                        return -1;
+
+                if (repipe) {
+                        int retw = write(STDOUT_FILENO, buf, ret);
+
+                        if (retw <= 0 || retw != ret)
+                                die("repiping input file");
+                }
+
+                size -= ret;
+                buf += ret;
+        }
+
+        return rsize;
+}
+
 static int read_or_die(void *data, int size)
 {
         int r;
 
-        r = read(input_fd, data, size);
-        if (r != size)
+        r = do_read(input_fd, data, size);
+        if (r <= 0)
                 die("reading input file (size expected=%d received=%d)",
                     size, r);
+
+        if (calc_data_size)
+                calc_data_size += r;
+
         return r;
 }
 
+/* If it fails, the next read will report it */
+static void skip(int size)
+{
+        char buf[BUFSIZ];
+        int r;
+
+        while (size) {
+                r = size > BUFSIZ ? BUFSIZ : size;
+                read_or_die(buf, r);
+                size -= r;
+        };
+}
+
 static unsigned int read4(void)
 {
         unsigned int data;
@@ -82,57 +126,36 @@ static char *read_string(void)
         char buf[BUFSIZ];
         char *str = NULL;
         int size = 0;
-        int i;
-        int r;
+        off_t r;
+        char c;
 
         for (;;) {
-                r = read(input_fd, buf, BUFSIZ);
+                r = read(input_fd, &c, 1);
                 if (r < 0)
                         die("reading input file");
 
                 if (!r)
                         die("no data");
 
-                for (i = 0; i < r; i++) {
-                        if (!buf[i])
-                                break;
-                }
-                if (i < r)
-                        break;
+                if (repipe) {
+                        int retw = write(STDOUT_FILENO, &c, 1);
 
-                if (str) {
-                        size += BUFSIZ;
-                        str = realloc(str, size);
-                        if (!str)
-                                die("malloc of size %d", size);
-                        memcpy(str + (size - BUFSIZ), buf, BUFSIZ);
-                } else {
-                        size = BUFSIZ;
-                        str = malloc_or_die(size);
-                        memcpy(str, buf, size);
+                        if (retw <= 0 || retw != r)
+                                die("repiping input file string");
                 }
-        }
 
-        /* trailing \0: */
-        i++;
-
-        /* move the file descriptor to the end of the string */
-        r = lseek(input_fd, -(r - i), SEEK_CUR);
-        if (r < 0)
-                die("lseek");
-
-        if (str) {
-                size += i;
-                str = realloc(str, size);
-                if (!str)
-                        die("malloc of size %d", size);
-                memcpy(str + (size - i), buf, i);
-        } else {
-                size = i;
-                str = malloc_or_die(i);
-                memcpy(str, buf, i);
+                buf[size++] = c;
+
+                if (!c)
+                        break;
         }
 
+        if (calc_data_size)
+                calc_data_size += size;
+
+        str = malloc_or_die(size);
+        memcpy(str, buf, size);
+
         return str;
 }
 
@@ -174,7 +197,6 @@ static void read_ftrace_printk(void)
 static void read_header_files(void)
 {
         unsigned long long size;
-        char *header_page;
         char *header_event;
         char buf[BUFSIZ];
 
@@ -184,10 +206,7 @@ static void read_header_files(void)
                 die("did not read header page");
 
         size = read8();
-        header_page = malloc_or_die(size);
-        read_or_die(header_page, size);
-        parse_header_page(header_page, size);
-        free(header_page);
+        skip(size);
 
         /*
          * The size field in the page is of type long,
@@ -282,8 +301,8 @@ static void update_cpu_data_index(int cpu)
 
 static void get_next_page(int cpu)
 {
-        off64_t save_seek;
-        off64_t ret;
+        off_t save_seek;
+        off_t ret;
 
         if (!cpu_data[cpu].page)
                 return;
@@ -298,17 +317,17 @@ static void get_next_page(int cpu)
                 update_cpu_data_index(cpu);
 
                 /* other parts of the code may expect the pointer to not move */
-                save_seek = lseek64(input_fd, 0, SEEK_CUR);
+                save_seek = lseek(input_fd, 0, SEEK_CUR);
 
-                ret = lseek64(input_fd, cpu_data[cpu].offset, SEEK_SET);
-                if (ret < 0)
+                ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
+                if (ret == (off_t)-1)
                         die("failed to lseek");
                 ret = read(input_fd, cpu_data[cpu].page, page_size);
                 if (ret < 0)
                         die("failed to read page");
 
                 /* reset the file pointer back */
-                lseek64(input_fd, save_seek, SEEK_SET);
+                lseek(input_fd, save_seek, SEEK_SET);
 
                 return;
         }
@@ -459,7 +478,7 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report(int fd)
+ssize_t trace_report(int fd, bool __repipe)
 {
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
@@ -467,6 +486,10 @@ void trace_report(int fd)
         int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
+        ssize_t size;
+
+        calc_data_size = 1;
+        repipe = __repipe;
 
         input_fd = fd;
 
@@ -499,14 +522,18 @@ void trace_report(int fd)
         read_proc_kallsyms();
         read_ftrace_printk();
 
+        size = calc_data_size - 1;
+        calc_data_size = 0;
+        repipe = false;
+
         if (show_funcs) {
                 print_funcs();
-                return;
+                return size;
         }
         if (show_printk) {
                 print_printk();
-                return;
+                return size;
         }
 
-        return;
+        return size;
 }
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
new file mode 100644
index 000000000000..f7af2fca965d
--- /dev/null
+++ b/tools/perf/util/trace-event-scripting.c
@@ -0,0 +1,167 @@
+/*
+ * trace-event-scripting.  Scripting engine common and initialization code.
+ *
+ * Copyright (C) 2009-2010 Tom Zanussi <tzanussi@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "../perf.h"
+#include "util.h"
+#include "trace-event.h"
+
+struct scripting_context *scripting_context;
+
+static int stop_script_unsupported(void)
+{
+        return 0;
+}
+
+static void process_event_unsupported(int cpu __unused,
+                                      void *data __unused,
+                                      int size __unused,
+                                      unsigned long long nsecs __unused,
+                                      char *comm __unused)
+{
+}
+
+static void print_python_unsupported_msg(void)
+{
+        fprintf(stderr, "Python scripting not supported."
+                "  Install libpython and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install python-dev (ubuntu)"
+                "\n  # yum install python-devel (Fedora)"
+                "\n  etc.\n");
+}
+
+static int python_start_script_unsupported(const char *script __unused,
+                                           int argc __unused,
+                                           const char **argv __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+static int python_generate_script_unsupported(const char *outfile __unused)
+{
+        print_python_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops python_scripting_unsupported_ops = {
+        .name = "Python",
+        .start_script = python_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = python_generate_script_unsupported,
+};
+
+static void register_python_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Python", scripting_ops);
+        if (err)
+                die("error registering Python script extension");
+
+        err = script_spec_register("py", scripting_ops);
+        if (err)
+                die("error registering py script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPYTHON
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_unsupported_ops);
+}
+#else
+extern struct scripting_ops python_scripting_ops;
+
+void setup_python_scripting(void)
+{
+        register_python_scripting(&python_scripting_ops);
+}
+#endif
+
+static void print_perl_unsupported_msg(void)
+{
+        fprintf(stderr, "Perl scripting not supported."
+                "  Install libperl and rebuild perf to enable it.\n"
+                "For example:\n  # apt-get install libperl-dev (ubuntu)"
+                "\n  # yum install 'perl(ExtUtils::Embed)' (Fedora)"
+                "\n  etc.\n");
+}
+
+static int perl_start_script_unsupported(const char *script __unused,
+                                         int argc __unused,
+                                         const char **argv __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+static int perl_generate_script_unsupported(const char *outfile __unused)
+{
+        print_perl_unsupported_msg();
+
+        return -1;
+}
+
+struct scripting_ops perl_scripting_unsupported_ops = {
+        .name = "Perl",
+        .start_script = perl_start_script_unsupported,
+        .stop_script = stop_script_unsupported,
+        .process_event = process_event_unsupported,
+        .generate_script = perl_generate_script_unsupported,
+};
+
+static void register_perl_scripting(struct scripting_ops *scripting_ops)
+{
+        int err;
+        err = script_spec_register("Perl", scripting_ops);
+        if (err)
+                die("error registering Perl script extension");
+
+        err = script_spec_register("pl", scripting_ops);
+        if (err)
+                die("error registering pl script extension");
+
+        scripting_context = malloc(sizeof(struct scripting_context));
+}
+
+#ifdef NO_LIBPERL
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_unsupported_ops);
+}
+#else
+extern struct scripting_ops perl_scripting_ops;
+
+void setup_perl_scripting(void)
+{
+        register_perl_scripting(&perl_scripting_ops);
+}
+#endif
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 6ad405620c9b..b3e86b1e4444 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,6 +1,7 @@
 #ifndef __PERF_TRACE_EVENTS_H
 #define __PERF_TRACE_EVENTS_H
 
+#include <stdbool.h>
 #include "parse-events.h"
 
 #define __unused __attribute__((unused))
@@ -162,7 +163,7 @@ struct record *trace_read_data(int cpu);
 
 void parse_set_info(int nr_cpus, int long_sz);
 
-void trace_report(int fd);
+ssize_t trace_report(int fd, bool repipe);
 
 void *malloc_or_die(unsigned int size);
 
@@ -232,7 +233,12 @@ static inline unsigned long long __data2host8(unsigned long long data)
 
 #define data2host2(ptr)         __data2host2(*(unsigned short *)ptr)
 #define data2host4(ptr)         __data2host4(*(unsigned int *)ptr)
-#define data2host8(ptr)         __data2host8(*(unsigned long long *)ptr)
+#define data2host8(ptr)         ({                              \
+        unsigned long long __val;                               \
+                                                                \
+        memcpy(&__val, (ptr), sizeof(unsigned long long));      \
+        __data2host8(__val);                                    \
+})
 
 extern int header_page_ts_offset;
 extern int header_page_ts_size;
@@ -241,9 +247,8 @@ extern int header_page_size_size;
 extern int header_page_data_offset;
 extern int header_page_data_size;
 
-extern int latency_format;
+extern bool latency_format;
 
-int parse_header_page(char *buf, unsigned long size);
 int trace_parse_common_type(void *data);
 int trace_parse_common_pid(void *data);
 int parse_common_pc(void *data);
@@ -258,6 +263,8 @@ void *raw_field_ptr(struct event *event, const char *name, void *data);
 unsigned long long eval_flag(const char *flag);
 
 int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
+ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
+                               int nb_events);
 
 /* taken from kernel/trace/trace.h */
 enum trace_flag_type {
@@ -279,7 +286,15 @@ struct scripting_ops {
 
 int script_spec_register(const char *spec, struct scripting_ops *ops);
 
-extern struct scripting_ops perl_scripting_ops;
 void setup_perl_scripting(void);
+void setup_python_scripting(void);
+
+struct scripting_context {
+        void *event_data;
+};
+
+int common_pc(struct scripting_context *context);
+int common_flags(struct scripting_context *context);
+int common_lock_depth(struct scripting_context *context);
 
 #endif /* __PERF_TRACE_EVENTS_H */
diff --git a/tools/perf/util/ui/browser.c b/tools/perf/util/ui/browser.c
new file mode 100644
index 000000000000..66f2d583d8c4
--- /dev/null
+++ b/tools/perf/util/ui/browser.c
@@ -0,0 +1,329 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+/*
+ * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
+ * the build if it isn't defined. Use the equivalent one that glibc
+ * has on features.h.
+ */
+#include <features.h>
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
+#endif
+#include <slang.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <stdlib.h>
+#include <sys/ttydefaults.h>
+#include "browser.h"
+#include "helpline.h"
+#include "../color.h"
+#include "../util.h"
+
+#if SLANG_VERSION < 20104
+#define sltt_set_color(obj, name, fg, bg) \
+        SLtt_set_color(obj,(char *)name, (char *)fg, (char *)bg)
+#else
+#define sltt_set_color SLtt_set_color
+#endif
+
+newtComponent newt_form__new(void);
+
+int ui_browser__percent_color(double percent, bool current)
+{
+        if (current)
+                return HE_COLORSET_SELECTED;
+        if (percent >= MIN_RED)
+                return HE_COLORSET_TOP;
+        if (percent >= MIN_GREEN)
+                return HE_COLORSET_MEDIUM;
+        return HE_COLORSET_NORMAL;
+}
+
+void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
+{
+        struct list_head *head = self->entries;
+        struct list_head *pos;
+
+        switch (whence) {
+        case SEEK_SET:
+                pos = head->next;
+                break;
+        case SEEK_CUR:
+                pos = self->top;
+                break;
+        case SEEK_END:
+                pos = head->prev;
+                break;
+        default:
+                return;
+        }
+
+        if (offset > 0) {
+                while (offset-- != 0)
+                        pos = pos->next;
+        } else {
+                while (offset++ != 0)
+                        pos = pos->prev;
+        }
+
+        self->top = pos;
+}
+
+void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
+{
+        struct rb_root *root = self->entries;
+        struct rb_node *nd;
+
+        switch (whence) {
+        case SEEK_SET:
+                nd = rb_first(root);
+                break;
+        case SEEK_CUR:
+                nd = self->top;
+                break;
+        case SEEK_END:
+                nd = rb_last(root);
+                break;
+        default:
+                return;
+        }
+
+        if (offset > 0) {
+                while (offset-- != 0)
+                        nd = rb_next(nd);
+        } else {
+                while (offset++ != 0)
+                        nd = rb_prev(nd);
+        }
+
+        self->top = nd;
+}
+
+unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
+{
+        struct rb_node *nd;
+        int row = 0;
+
+        if (self->top == NULL)
+                self->top = rb_first(self->entries);
+
+        nd = self->top;
+
+        while (nd != NULL) {
+                SLsmg_gotorc(self->y + row, self->x);
+                self->write(self, nd, row);
+                if (++row == self->height)
+                        break;
+                nd = rb_next(nd);
+        }
+
+        return row;
+}
+
+bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
+{
+        return self->top_idx + row == self->index;
+}
+
+void ui_browser__refresh_dimensions(struct ui_browser *self)
+{
+        int cols, rows;
+        newtGetScreenSize(&cols, &rows);
+
+        if (self->width > cols - 4)
+                self->width = cols - 4;
+        self->height = rows - 5;
+        if (self->height > self->nr_entries)
+                self->height = self->nr_entries;
+        self->y  = (rows - self->height) / 2;
+        self->x = (cols - self->width) / 2;
+}
+
+void ui_browser__reset_index(struct ui_browser *self)
+{
+        self->index = self->top_idx = 0;
+        self->seek(self, 0, SEEK_SET);
+}
+
+int ui_browser__show(struct ui_browser *self, const char *title,
+                     const char *helpline, ...)
+{
+        va_list ap;
+
+        if (self->form != NULL) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+        ui_browser__refresh_dimensions(self);
+        newtCenteredWindow(self->width, self->height, title);
+        self->form = newt_form__new();
+        if (self->form == NULL)
+                return -1;
+
+        self->sb = newtVerticalScrollbar(self->width, 0, self->height,
+                                         HE_COLORSET_NORMAL,
+                                         HE_COLORSET_SELECTED);
+        if (self->sb == NULL)
+                return -1;
+
+        newtFormAddHotKey(self->form, NEWT_KEY_UP);
+        newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
+        newtFormAddHotKey(self->form, NEWT_KEY_HOME);
+        newtFormAddHotKey(self->form, NEWT_KEY_END);
+        newtFormAddHotKey(self->form, ' ');
+        newtFormAddComponent(self->form, self->sb);
+
+        va_start(ap, helpline);
+        ui_helpline__vpush(helpline, ap);
+        va_end(ap);
+        return 0;
+}
+
+void ui_browser__hide(struct ui_browser *self)
+{
+        newtFormDestroy(self->form);
+        newtPopWindow();
+        self->form = NULL;
+        ui_helpline__pop();
+}
+
+int ui_browser__refresh(struct ui_browser *self)
+{
+        int row;
+
+        newtScrollbarSet(self->sb, self->index, self->nr_entries - 1);
+        row = self->refresh(self);
+        SLsmg_set_color(HE_COLORSET_NORMAL);
+        SLsmg_fill_region(self->y + row, self->x,
+                          self->height - row, self->width, ' ');
+
+        return 0;
+}
+
+int ui_browser__run(struct ui_browser *self, struct newtExitStruct *es)
+{
+        if (ui_browser__refresh(self) < 0)
+                return -1;
+
+        while (1) {
+                off_t offset;
+
+                newtFormRun(self->form, es);
+
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                if (is_exit_key(es->u.key))
+                        return es->u.key;
+                switch (es->u.key) {
+                case NEWT_KEY_DOWN:
+                        if (self->index == self->nr_entries - 1)
+                                break;
+                        ++self->index;
+                        if (self->index == self->top_idx + self->height) {
+                                ++self->top_idx;
+                                self->seek(self, +1, SEEK_CUR);
+                        }
+                        break;
+                case NEWT_KEY_UP:
+                        if (self->index == 0)
+                                break;
+                        --self->index;
+                        if (self->index < self->top_idx) {
+                                --self->top_idx;
+                                self->seek(self, -1, SEEK_CUR);
+                        }
+                        break;
+                case NEWT_KEY_PGDN:
+                case ' ':
+                        if (self->top_idx + self->height > self->nr_entries - 1)
+                                break;
+
+                        offset = self->height;
+                        if (self->index + offset > self->nr_entries - 1)
+                                offset = self->nr_entries - 1 - self->index;
+                        self->index += offset;
+                        self->top_idx += offset;
+                        self->seek(self, +offset, SEEK_CUR);
+                        break;
+                case NEWT_KEY_PGUP:
+                        if (self->top_idx == 0)
+                                break;
+
+                        if (self->top_idx < self->height)
+                                offset = self->top_idx;
+                        else
+                                offset = self->height;
+
+                        self->index -= offset;
+                        self->top_idx -= offset;
+                        self->seek(self, -offset, SEEK_CUR);
+                        break;
+                case NEWT_KEY_HOME:
+                        ui_browser__reset_index(self);
+                        break;
+                case NEWT_KEY_END:
+                        offset = self->height - 1;
+                        if (offset >= self->nr_entries)
+                                offset = self->nr_entries - 1;
+
+                        self->index = self->nr_entries - 1;
+                        self->top_idx = self->index - offset;
+                        self->seek(self, -offset, SEEK_END);
+                        break;
+                default:
+                        return es->u.key;
+                }
+                if (ui_browser__refresh(self) < 0)
+                        return -1;
+        }
+        return 0;
+}
+
+unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
+{
+        struct list_head *pos;
+        struct list_head *head = self->entries;
+        int row = 0;
+
+        if (self->top == NULL || self->top == self->entries)
+                self->top = head->next;
+
+        pos = self->top;
+
+        list_for_each_from(pos, head) {
+                SLsmg_gotorc(self->y + row, self->x);
+                self->write(self, pos, row);
+                if (++row == self->height)
+                        break;
+        }
+
+        return row;
+}
+
+static struct newtPercentTreeColors {
+        const char *topColorFg, *topColorBg;
+        const char *mediumColorFg, *mediumColorBg;
+        const char *normalColorFg, *normalColorBg;
+        const char *selColorFg, *selColorBg;
+        const char *codeColorFg, *codeColorBg;
+} defaultPercentTreeColors = {
+        "red",       "lightgray",
+        "green",     "lightgray",
+        "black",     "lightgray",
+        "lightgray", "magenta",
+        "blue",      "lightgray",
+};
+
+void ui_browser__init(void)
+{
+        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
+
+        sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
+        sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
+        sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
+        sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
+        sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
+}
diff --git a/tools/perf/util/ui/browser.h b/tools/perf/util/ui/browser.h
new file mode 100644
index 000000000000..0b9f829214f7
--- /dev/null
+++ b/tools/perf/util/ui/browser.h
@@ -0,0 +1,46 @@
+#ifndef _PERF_UI_BROWSER_H_
+#define _PERF_UI_BROWSER_H_ 1
+
+#include <stdbool.h>
+#include <newt.h>
+#include <sys/types.h>
+#include "../types.h"
+
+#define HE_COLORSET_TOP         50
+#define HE_COLORSET_MEDIUM      51
+#define HE_COLORSET_NORMAL      52
+#define HE_COLORSET_SELECTED    53
+#define HE_COLORSET_CODE        54
+
+struct ui_browser {
+        newtComponent form, sb;
+        u64           index, top_idx;
+        void          *top, *entries;
+        u16           y, x, width, height;
+        void          *priv;
+        unsigned int  (*refresh)(struct ui_browser *self);
+        void          (*write)(struct ui_browser *self, void *entry, int row);
+        void          (*seek)(struct ui_browser *self, off_t offset, int whence);
+        u32           nr_entries;
+};
+
+
+int ui_browser__percent_color(double percent, bool current);
+bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row);
+void ui_browser__refresh_dimensions(struct ui_browser *self);
+void ui_browser__reset_index(struct ui_browser *self);
+
+int ui_browser__show(struct ui_browser *self, const char *title,
+                     const char *helpline, ...);
+void ui_browser__hide(struct ui_browser *self);
+int ui_browser__refresh(struct ui_browser *self);
+int ui_browser__run(struct ui_browser *self, struct newtExitStruct *es);
+
+void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence);
+unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self);
+
+void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence);
+unsigned int ui_browser__list_head_refresh(struct ui_browser *self);
+
+void ui_browser__init(void);
+#endif /* _PERF_UI_BROWSER_H_ */
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
new file mode 100644
index 000000000000..a90273e63f4f
--- /dev/null
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -0,0 +1,241 @@
+#include "../browser.h"
+#include "../helpline.h"
+#include "../libslang.h"
+#include "../../hist.h"
+#include "../../sort.h"
+#include "../../symbol.h"
+
+static void ui__error_window(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        newtWinMessagev((char *)"Error", (char *)"Ok", (char *)fmt, ap);
+        va_end(ap);
+}
+
+struct annotate_browser {
+        struct ui_browser b;
+        struct rb_root    entries;
+        struct rb_node    *curr_hot;
+};
+
+struct objdump_line_rb_node {
+        struct rb_node  rb_node;
+        double          percent;
+        u32             idx;
+};
+
+static inline
+struct objdump_line_rb_node *objdump_line__rb(struct objdump_line *self)
+{
+        return (struct objdump_line_rb_node *)(self + 1);
+}
+
+static void annotate_browser__write(struct ui_browser *self, void *entry, int row)
+{
+        struct objdump_line *ol = rb_entry(entry, struct objdump_line, node);
+        bool current_entry = ui_browser__is_current_entry(self, row);
+        int width = self->width;
+
+        if (ol->offset != -1) {
+                struct objdump_line_rb_node *olrb = objdump_line__rb(ol);
+                int color = ui_browser__percent_color(olrb->percent, current_entry);
+                SLsmg_set_color(color);
+                slsmg_printf(" %7.2f ", olrb->percent);
+                if (!current_entry)
+                        SLsmg_set_color(HE_COLORSET_CODE);
+        } else {
+                int color = ui_browser__percent_color(0, current_entry);
+                SLsmg_set_color(color);
+                slsmg_write_nstring(" ", 9);
+        }
+
+        SLsmg_write_char(':');
+        slsmg_write_nstring(" ", 8);
+        if (!*ol->line)
+                slsmg_write_nstring(" ", width - 18);
+        else
+                slsmg_write_nstring(ol->line, width - 18);
+}
+
+static double objdump_line__calc_percent(struct objdump_line *self,
+                                         struct list_head *head,
+                                         struct symbol *sym)
+{
+        double percent = 0.0;
+
+        if (self->offset != -1) {
+                int len = sym->end - sym->start;
+                unsigned int hits = 0;
+                struct sym_priv *priv = symbol__priv(sym);
+                struct sym_ext *sym_ext = priv->ext;
+                struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+
+
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+
+                        ++offset;
+                }
+
+                if (sym_ext == NULL && h->sum)
+                        percent = 100.0 * hits / h->sum;
+        }
+
+        return percent;
+}
+
+static void objdump__insert_line(struct rb_root *self,
+                                 struct objdump_line_rb_node *line)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct objdump_line_rb_node *l;
+
+        while (*p != NULL) {
+                parent = *p;
+                l = rb_entry(parent, struct objdump_line_rb_node, rb_node);
+                if (line->percent < l->percent)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&line->rb_node, parent, p);
+        rb_insert_color(&line->rb_node, self);
+}
+
+static void annotate_browser__set_top(struct annotate_browser *self,
+                                      struct rb_node *nd)
+{
+        struct objdump_line_rb_node *rbpos;
+        struct objdump_line *pos;
+        unsigned back;
+
+        ui_browser__refresh_dimensions(&self->b);
+        back = self->b.height / 2;
+        rbpos = rb_entry(nd, struct objdump_line_rb_node, rb_node);
+        pos = ((struct objdump_line *)rbpos) - 1;
+        self->b.top_idx = self->b.index = rbpos->idx;
+
+        while (self->b.top_idx != 0 && back != 0) {
+                pos = list_entry(pos->node.prev, struct objdump_line, node);
+
+                --self->b.top_idx;
+                --back;
+        }
+
+        self->b.top = pos;
+        self->curr_hot = nd;
+}
+
+static int annotate_browser__run(struct annotate_browser *self,
+                                 struct newtExitStruct *es)
+{
+        struct rb_node *nd;
+        struct hist_entry *he = self->b.priv;
+
+        if (ui_browser__show(&self->b, he->ms.sym->name,
+                             "<- or ESC: exit, TAB/shift+TAB: cycle thru samples") < 0)
+                return -1;
+
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_RIGHT);
+
+        nd = self->curr_hot;
+        if (nd) {
+                newtFormAddHotKey(self->b.form, NEWT_KEY_TAB);
+                newtFormAddHotKey(self->b.form, NEWT_KEY_UNTAB);
+        }
+
+        while (1) {
+                ui_browser__run(&self->b, es);
+
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+
+                switch (es->u.key) {
+                case NEWT_KEY_TAB:
+                        nd = rb_prev(nd);
+                        if (nd == NULL)
+                                nd = rb_last(&self->entries);
+                        annotate_browser__set_top(self, nd);
+                        break;
+                case NEWT_KEY_UNTAB:
+                        nd = rb_next(nd);
+                        if (nd == NULL)
+                                nd = rb_first(&self->entries);
+                        annotate_browser__set_top(self, nd);
+                        break;
+                default:
+                        goto out;
+                }
+        }
+out:
+        ui_browser__hide(&self->b);
+        return es->u.key;
+}
+
+int hist_entry__tui_annotate(struct hist_entry *self)
+{
+        struct newtExitStruct es;
+        struct objdump_line *pos, *n;
+        struct objdump_line_rb_node *rbpos;
+        LIST_HEAD(head);
+        struct annotate_browser browser = {
+                .b = {
+                        .entries = &head,
+                        .refresh = ui_browser__list_head_refresh,
+                        .seek    = ui_browser__list_head_seek,
+                        .write   = annotate_browser__write,
+                        .priv    = self,
+                },
+        };
+        int ret;
+
+        if (self->ms.sym == NULL)
+                return -1;
+
+        if (self->ms.map->dso->annotate_warned)
+                return -1;
+
+        if (hist_entry__annotate(self, &head, sizeof(*rbpos)) < 0) {
+                ui__error_window(ui_helpline__last_msg);
+                return -1;
+        }
+
+        ui_helpline__push("Press <- or ESC to exit");
+
+        list_for_each_entry(pos, &head, node) {
+                size_t line_len = strlen(pos->line);
+                if (browser.b.width < line_len)
+                        browser.b.width = line_len;
+                rbpos = objdump_line__rb(pos);
+                rbpos->idx = browser.b.nr_entries++;
+                rbpos->percent = objdump_line__calc_percent(pos, &head, self->ms.sym);
+                if (rbpos->percent < 0.01)
+                        continue;
+                objdump__insert_line(&browser.entries, rbpos);
+        }
+
+        /*
+         * Position the browser at the hottest line.
+         */
+        browser.curr_hot = rb_last(&browser.entries);
+        if (browser.curr_hot)
+                annotate_browser__set_top(&browser, browser.curr_hot);
+
+        browser.b.width += 18; /* Percentage */
+        ret = annotate_browser__run(&browser, &es);
+        list_for_each_entry_safe(pos, n, &head, node) {
+                list_del(&pos->node);
+                objdump_line__free(pos);
+        }
+        return ret;
+}
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
new file mode 100644
index 000000000000..6866aa4c41e0
--- /dev/null
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -0,0 +1,948 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+#include "../libslang.h"
+#include <stdlib.h>
+#include <string.h>
+#include <newt.h>
+#include <linux/rbtree.h>
+
+#include "../../hist.h"
+#include "../../pstack.h"
+#include "../../sort.h"
+#include "../../util.h"
+
+#include "../browser.h"
+#include "../helpline.h"
+#include "../util.h"
+#include "map.h"
+
+struct hist_browser {
+        struct ui_browser   b;
+        struct hists        *hists;
+        struct hist_entry   *he_selection;
+        struct map_symbol   *selection;
+};
+
+static void hist_browser__refresh_dimensions(struct hist_browser *self)
+{
+        /* 3 == +/- toggle symbol before actual hist_entry rendering */
+        self->b.width = 3 + (hists__sort_list_width(self->hists) +
+                             sizeof("[k]"));
+}
+
+static void hist_browser__reset(struct hist_browser *self)
+{
+        self->b.nr_entries = self->hists->nr_entries;
+        hist_browser__refresh_dimensions(self);
+        ui_browser__reset_index(&self->b);
+}
+
+static char tree__folded_sign(bool unfolded)
+{
+        return unfolded ? '-' : '+';
+}
+
+static char map_symbol__folded(const struct map_symbol *self)
+{
+        return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
+}
+
+static char hist_entry__folded(const struct hist_entry *self)
+{
+        return map_symbol__folded(&self->ms);
+}
+
+static char callchain_list__folded(const struct callchain_list *self)
+{
+        return map_symbol__folded(&self->ms);
+}
+
+static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
+{
+        int n = 0;
+        struct rb_node *nd;
+
+        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+                struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
+                struct callchain_list *chain;
+                char folded_sign = ' '; /* No children */
+
+                list_for_each_entry(chain, &child->val, list) {
+                        ++n;
+                        /* We need this because we may not have children */
+                        folded_sign = callchain_list__folded(chain);
+                        if (folded_sign == '+')
+                                break;
+                }
+
+                if (folded_sign == '-') /* Have children and they're unfolded */
+                        n += callchain_node__count_rows_rb_tree(child);
+        }
+
+        return n;
+}
+
+static int callchain_node__count_rows(struct callchain_node *node)
+{
+        struct callchain_list *chain;
+        bool unfolded = false;
+        int n = 0;
+
+        list_for_each_entry(chain, &node->val, list) {
+                ++n;
+                unfolded = chain->ms.unfolded;
+        }
+
+        if (unfolded)
+                n += callchain_node__count_rows_rb_tree(node);
+
+        return n;
+}
+
+static int callchain__count_rows(struct rb_root *chain)
+{
+        struct rb_node *nd;
+        int n = 0;
+
+        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+                n += callchain_node__count_rows(node);
+        }
+
+        return n;
+}
+
+static bool map_symbol__toggle_fold(struct map_symbol *self)
+{
+        if (!self->has_children)
+                return false;
+
+        self->unfolded = !self->unfolded;
+        return true;
+}
+
+static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
+{
+        struct rb_node *nd = rb_first(&self->rb_root);
+
+        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+                struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
+                struct callchain_list *chain;
+                int first = true;
+
+                list_for_each_entry(chain, &child->val, list) {
+                        if (first) {
+                                first = false;
+                                chain->ms.has_children = chain->list.next != &child->val ||
+                                                         rb_first(&child->rb_root) != NULL;
+                        } else
+                                chain->ms.has_children = chain->list.next == &child->val &&
+                                                         rb_first(&child->rb_root) != NULL;
+                }
+
+                callchain_node__init_have_children_rb_tree(child);
+        }
+}
+
+static void callchain_node__init_have_children(struct callchain_node *self)
+{
+        struct callchain_list *chain;
+
+        list_for_each_entry(chain, &self->val, list)
+                chain->ms.has_children = rb_first(&self->rb_root) != NULL;
+
+        callchain_node__init_have_children_rb_tree(self);
+}
+
+static void callchain__init_have_children(struct rb_root *self)
+{
+        struct rb_node *nd;
+
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+                callchain_node__init_have_children(node);
+        }
+}
+
+static void hist_entry__init_have_children(struct hist_entry *self)
+{
+        if (!self->init_have_children) {
+                callchain__init_have_children(&self->sorted_chain);
+                self->init_have_children = true;
+        }
+}
+
+static bool hist_browser__toggle_fold(struct hist_browser *self)
+{
+        if (map_symbol__toggle_fold(self->selection)) {
+                struct hist_entry *he = self->he_selection;
+
+                hist_entry__init_have_children(he);
+                self->hists->nr_entries -= he->nr_rows;
+
+                if (he->ms.unfolded)
+                        he->nr_rows = callchain__count_rows(&he->sorted_chain);
+                else
+                        he->nr_rows = 0;
+                self->hists->nr_entries += he->nr_rows;
+                self->b.nr_entries = self->hists->nr_entries;
+
+                return true;
+        }
+
+        /* If it doesn't have children, no toggling performed */
+        return false;
+}
+
+static int hist_browser__run(struct hist_browser *self, const char *title,
+                             struct newtExitStruct *es)
+{
+        char str[256], unit;
+        unsigned long nr_events = self->hists->stats.nr_events[PERF_RECORD_SAMPLE];
+
+        self->b.entries = &self->hists->entries;
+        self->b.nr_entries = self->hists->nr_entries;
+
+        hist_browser__refresh_dimensions(self);
+
+        nr_events = convert_unit(nr_events, &unit);
+        snprintf(str, sizeof(str), "Events: %lu%c                            ",
+                 nr_events, unit);
+        newtDrawRootText(0, 0, str);
+
+        if (ui_browser__show(&self->b, title,
+                             "Press '?' for help on key bindings") < 0)
+                return -1;
+
+        newtFormAddHotKey(self->b.form, 'a');
+        newtFormAddHotKey(self->b.form, '?');
+        newtFormAddHotKey(self->b.form, 'h');
+        newtFormAddHotKey(self->b.form, 'd');
+        newtFormAddHotKey(self->b.form, 'D');
+        newtFormAddHotKey(self->b.form, 't');
+
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_RIGHT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_ENTER);
+
+        while (1) {
+                ui_browser__run(&self->b, es);
+
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                switch (es->u.key) {
+                case 'D': { /* Debug */
+                        static int seq;
+                        struct hist_entry *h = rb_entry(self->b.top,
+                                                        struct hist_entry, rb_node);
+                        ui_helpline__pop();
+                        ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
+                                           seq++, self->b.nr_entries,
+                                           self->hists->nr_entries,
+                                           self->b.height,
+                                           self->b.index,
+                                           self->b.top_idx,
+                                           h->row_offset, h->nr_rows);
+                }
+                        continue;
+                case NEWT_KEY_ENTER:
+                        if (hist_browser__toggle_fold(self))
+                                break;
+                        /* fall thru */
+                default:
+                        return 0;
+                }
+        }
+
+        ui_browser__hide(&self->b);
+        return 0;
+}
+
+static char *callchain_list__sym_name(struct callchain_list *self,
+                                      char *bf, size_t bfsize)
+{
+        if (self->ms.sym)
+                return self->ms.sym->name;
+
+        snprintf(bf, bfsize, "%#Lx", self->ip);
+        return bf;
+}
+
+#define LEVEL_OFFSET_STEP 3
+
+static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
+                                                     struct callchain_node *chain_node,
+                                                     u64 total, int level,
+                                                     unsigned short row,
+                                                     off_t *row_offset,
+                                                     bool *is_current_entry)
+{
+        struct rb_node *node;
+        int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
+        u64 new_total, remaining;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = chain_node->children_hit;
+        else
+                new_total = total;
+
+        remaining = new_total;
+        node = rb_first(&chain_node->rb_root);
+        while (node) {
+                struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
+                struct rb_node *next = rb_next(node);
+                u64 cumul = cumul_hits(child);
+                struct callchain_list *chain;
+                char folded_sign = ' ';
+                int first = true;
+                int extra_offset = 0;
+
+                remaining -= cumul;
+
+                list_for_each_entry(chain, &child->val, list) {
+                        char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
+                        const char *str;
+                        int color;
+                        bool was_first = first;
+
+                        if (first) {
+                                first = false;
+                                chain->ms.has_children = chain->list.next != &child->val ||
+                                                         rb_first(&child->rb_root) != NULL;
+                        } else {
+                                extra_offset = LEVEL_OFFSET_STEP;
+                                chain->ms.has_children = chain->list.next == &child->val &&
+                                                         rb_first(&child->rb_root) != NULL;
+                        }
+
+                        folded_sign = callchain_list__folded(chain);
+                        if (*row_offset != 0) {
+                                --*row_offset;
+                                goto do_next;
+                        }
+
+                        alloc_str = NULL;
+                        str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                        if (was_first) {
+                                double percent = cumul * 100.0 / new_total;
+
+                                if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
+                                        str = "Not enough memory!";
+                                else
+                                        str = alloc_str;
+                        }
+
+                        color = HE_COLORSET_NORMAL;
+                        width = self->b.width - (offset + extra_offset + 2);
+                        if (ui_browser__is_current_entry(&self->b, row)) {
+                                self->selection = &chain->ms;
+                                color = HE_COLORSET_SELECTED;
+                                *is_current_entry = true;
+                        }
+
+                        SLsmg_set_color(color);
+                        SLsmg_gotorc(self->b.y + row, self->b.x);
+                        slsmg_write_nstring(" ", offset + extra_offset);
+                        slsmg_printf("%c ", folded_sign);
+                        slsmg_write_nstring(str, width);
+                        free(alloc_str);
+
+                        if (++row == self->b.height)
+                                goto out;
+do_next:
+                        if (folded_sign == '+')
+                                break;
+                }
+
+                if (folded_sign == '-') {
+                        const int new_level = level + (extra_offset ? 2 : 1);
+                        row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
+                                                                         new_level, row, row_offset,
+                                                                         is_current_entry);
+                }
+                if (row == self->b.height)
+                        goto out;
+                node = next;
+        }
+out:
+        return row - first_row;
+}
+
+static int hist_browser__show_callchain_node(struct hist_browser *self,
+                                             struct callchain_node *node,
+                                             int level, unsigned short row,
+                                             off_t *row_offset,
+                                             bool *is_current_entry)
+{
+        struct callchain_list *chain;
+        int first_row = row,
+             offset = level * LEVEL_OFFSET_STEP,
+             width = self->b.width - offset;
+        char folded_sign = ' ';
+
+        list_for_each_entry(chain, &node->val, list) {
+                char ipstr[BITS_PER_LONG / 4 + 1], *s;
+                int color;
+                /*
+                 * FIXME: This should be moved to somewhere else,
+                 * probably when the callchain is created, so as not to
+                 * traverse it all over again
+                 */
+                chain->ms.has_children = rb_first(&node->rb_root) != NULL;
+                folded_sign = callchain_list__folded(chain);
+
+                if (*row_offset != 0) {
+                        --*row_offset;
+                        continue;
+                }
+
+                color = HE_COLORSET_NORMAL;
+                if (ui_browser__is_current_entry(&self->b, row)) {
+                        self->selection = &chain->ms;
+                        color = HE_COLORSET_SELECTED;
+                        *is_current_entry = true;
+                }
+
+                s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                SLsmg_gotorc(self->b.y + row, self->b.x);
+                SLsmg_set_color(color);
+                slsmg_write_nstring(" ", offset);
+                slsmg_printf("%c ", folded_sign);
+                slsmg_write_nstring(s, width - 2);
+
+                if (++row == self->b.height)
+                        goto out;
+        }
+
+        if (folded_sign == '-')
+                row += hist_browser__show_callchain_node_rb_tree(self, node,
+                                                                 self->hists->stats.total_period,
+                                                                 level + 1, row,
+                                                                 row_offset,
+                                                                 is_current_entry);
+out:
+        return row - first_row;
+}
+
+static int hist_browser__show_callchain(struct hist_browser *self,
+                                        struct rb_root *chain,
+                                        int level, unsigned short row,
+                                        off_t *row_offset,
+                                        bool *is_current_entry)
+{
+        struct rb_node *nd;
+        int first_row = row;
+
+        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+
+                row += hist_browser__show_callchain_node(self, node, level,
+                                                         row, row_offset,
+                                                         is_current_entry);
+                if (row == self->b.height)
+                        break;
+        }
+
+        return row - first_row;
+}
+
+static int hist_browser__show_entry(struct hist_browser *self,
+                                    struct hist_entry *entry,
+                                    unsigned short row)
+{
+        char s[256];
+        double percent;
+        int printed = 0;
+        int color, width = self->b.width;
+        char folded_sign = ' ';
+        bool current_entry = ui_browser__is_current_entry(&self->b, row);
+        off_t row_offset = entry->row_offset;
+
+        if (current_entry) {
+                self->he_selection = entry;
+                self->selection = &entry->ms;
+        }
+
+        if (symbol_conf.use_callchain) {
+                entry->ms.has_children = !RB_EMPTY_ROOT(&entry->sorted_chain);
+                folded_sign = hist_entry__folded(entry);
+        }
+
+        if (row_offset == 0) {
+                hist_entry__snprintf(entry, s, sizeof(s), self->hists, NULL, false,
+                                     0, false, self->hists->stats.total_period);
+                percent = (entry->period * 100.0) / self->hists->stats.total_period;
+
+                color = HE_COLORSET_SELECTED;
+                if (!current_entry) {
+                        if (percent >= MIN_RED)
+                                color = HE_COLORSET_TOP;
+                        else if (percent >= MIN_GREEN)
+                                color = HE_COLORSET_MEDIUM;
+                        else
+                                color = HE_COLORSET_NORMAL;
+                }
+
+                SLsmg_set_color(color);
+                SLsmg_gotorc(self->b.y + row, self->b.x);
+                if (symbol_conf.use_callchain) {
+                        slsmg_printf("%c ", folded_sign);
+                        width -= 2;
+                }
+                slsmg_write_nstring(s, width);
+                ++row;
+                ++printed;
+        } else
+                --row_offset;
+
+        if (folded_sign == '-' && row != self->b.height) {
+                printed += hist_browser__show_callchain(self, &entry->sorted_chain,
+                                                        1, row, &row_offset,
+                                                        &current_entry);
+                if (current_entry)
+                        self->he_selection = entry;
+        }
+
+        return printed;
+}
+
+static unsigned int hist_browser__refresh(struct ui_browser *self)
+{
+        unsigned row = 0;
+        struct rb_node *nd;
+        struct hist_browser *hb = container_of(self, struct hist_browser, b);
+
+        if (self->top == NULL)
+                self->top = rb_first(&hb->hists->entries);
+
+        for (nd = self->top; nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (h->filtered)
+                        continue;
+
+                row += hist_browser__show_entry(hb, h, row);
+                if (row == self->height)
+                        break;
+        }
+
+        return row;
+}
+
+static struct rb_node *hists__filter_entries(struct rb_node *nd)
+{
+        while (nd != NULL) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                if (!h->filtered)
+                        return nd;
+
+                nd = rb_next(nd);
+        }
+
+        return NULL;
+}
+
+static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
+{
+        while (nd != NULL) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                if (!h->filtered)
+                        return nd;
+
+                nd = rb_prev(nd);
+        }
+
+        return NULL;
+}
+
+static void ui_browser__hists_seek(struct ui_browser *self,
+                                   off_t offset, int whence)
+{
+        struct hist_entry *h;
+        struct rb_node *nd;
+        bool first = true;
+
+        switch (whence) {
+        case SEEK_SET:
+                nd = hists__filter_entries(rb_first(self->entries));
+                break;
+        case SEEK_CUR:
+                nd = self->top;
+                goto do_offset;
+        case SEEK_END:
+                nd = hists__filter_prev_entries(rb_last(self->entries));
+                first = false;
+                break;
+        default:
+                return;
+        }
+
+        /*
+         * Moves not relative to the first visible entry invalidates its
+         * row_offset:
+         */
+        h = rb_entry(self->top, struct hist_entry, rb_node);
+        h->row_offset = 0;
+
+        /*
+         * Here we have to check if nd is expanded (+), if it is we can't go
+         * the next top level hist_entry, instead we must compute an offset of
+         * what _not_ to show and not change the first visible entry.
+         *
+         * This offset increments when we are going from top to bottom and
+         * decreases when we're going from bottom to top.
+         *
+         * As we don't have backpointers to the top level in the callchains
+         * structure, we need to always print the whole hist_entry callchain,
+         * skipping the first ones that are before the first visible entry
+         * and stop when we printed enough lines to fill the screen.
+         */
+do_offset:
+        if (offset > 0) {
+                do {
+                        h = rb_entry(nd, struct hist_entry, rb_node);
+                        if (h->ms.unfolded) {
+                                u16 remaining = h->nr_rows - h->row_offset;
+                                if (offset > remaining) {
+                                        offset -= remaining;
+                                        h->row_offset = 0;
+                                } else {
+                                        h->row_offset += offset;
+                                        offset = 0;
+                                        self->top = nd;
+                                        break;
+                                }
+                        }
+                        nd = hists__filter_entries(rb_next(nd));
+                        if (nd == NULL)
+                                break;
+                        --offset;
+                        self->top = nd;
+                } while (offset != 0);
+        } else if (offset < 0) {
+                while (1) {
+                        h = rb_entry(nd, struct hist_entry, rb_node);
+                        if (h->ms.unfolded) {
+                                if (first) {
+                                        if (-offset > h->row_offset) {
+                                                offset += h->row_offset;
+                                                h->row_offset = 0;
+                                        } else {
+                                                h->row_offset += offset;
+                                                offset = 0;
+                                                self->top = nd;
+                                                break;
+                                        }
+                                } else {
+                                        if (-offset > h->nr_rows) {
+                                                offset += h->nr_rows;
+                                                h->row_offset = 0;
+                                        } else {
+                                                h->row_offset = h->nr_rows + offset;
+                                                offset = 0;
+                                                self->top = nd;
+                                                break;
+                                        }
+                                }
+                        }
+
+                        nd = hists__filter_prev_entries(rb_prev(nd));
+                        if (nd == NULL)
+                                break;
+                        ++offset;
+                        self->top = nd;
+                        if (offset == 0) {
+                                /*
+                                 * Last unfiltered hist_entry, check if it is
+                                 * unfolded, if it is then we should have
+                                 * row_offset at its last entry.
+                                 */
+                                h = rb_entry(nd, struct hist_entry, rb_node);
+                                if (h->ms.unfolded)
+                                        h->row_offset = h->nr_rows;
+                                break;
+                        }
+                        first = false;
+                }
+        } else {
+                self->top = nd;
+                h = rb_entry(nd, struct hist_entry, rb_node);
+                h->row_offset = 0;
+        }
+}
+
+static struct hist_browser *hist_browser__new(struct hists *hists)
+{
+        struct hist_browser *self = zalloc(sizeof(*self));
+
+        if (self) {
+                self->hists = hists;
+                self->b.refresh = hist_browser__refresh;
+                self->b.seek = ui_browser__hists_seek;
+        }
+
+        return self;
+}
+
+static void hist_browser__delete(struct hist_browser *self)
+{
+        newtFormDestroy(self->b.form);
+        newtPopWindow();
+        free(self);
+}
+
+static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
+{
+        return self->he_selection;
+}
+
+static struct thread *hist_browser__selected_thread(struct hist_browser *self)
+{
+        return self->he_selection->thread;
+}
+
+static int hist_browser__title(char *bf, size_t size, const char *ev_name,
+                               const struct dso *dso, const struct thread *thread)
+{
+        int printed = 0;
+
+        if (thread)
+                printed += snprintf(bf + printed, size - printed,
+                                    "Thread: %s(%d)",
+                                    (thread->comm_set ?  thread->comm : ""),
+                                    thread->pid);
+        if (dso)
+                printed += snprintf(bf + printed, size - printed,
+                                    "%sDSO: %s", thread ? " " : "",
+                                    dso->short_name);
+        return printed ?: snprintf(bf, size, "Event: %s", ev_name);
+}
+
+int hists__browse(struct hists *self, const char *helpline, const char *ev_name)
+{
+        struct hist_browser *browser = hist_browser__new(self);
+        struct pstack *fstack;
+        const struct thread *thread_filter = NULL;
+        const struct dso *dso_filter = NULL;
+        struct newtExitStruct es;
+        char msg[160];
+        int key = -1;
+
+        if (browser == NULL)
+                return -1;
+
+        fstack = pstack__new(2);
+        if (fstack == NULL)
+                goto out;
+
+        ui_helpline__push(helpline);
+
+        hist_browser__title(msg, sizeof(msg), ev_name,
+                            dso_filter, thread_filter);
+
+        while (1) {
+                const struct thread *thread;
+                const struct dso *dso;
+                char *options[16];
+                int nr_options = 0, choice = 0, i,
+                    annotate = -2, zoom_dso = -2, zoom_thread = -2,
+                    browse_map = -2;
+
+                if (hist_browser__run(browser, msg, &es))
+                        break;
+
+                thread = hist_browser__selected_thread(browser);
+                dso = browser->selection->map ? browser->selection->map->dso : NULL;
+
+                if (es.reason == NEWT_EXIT_HOTKEY) {
+                        key = es.u.key;
+
+                        switch (key) {
+                        case NEWT_KEY_F1:
+                                goto do_help;
+                        case NEWT_KEY_TAB:
+                        case NEWT_KEY_UNTAB:
+                                /*
+                                 * Exit the browser, let hists__browser_tree
+                                 * go to the next or previous
+                                 */
+                                goto out_free_stack;
+                        default:;
+                        }
+
+                        switch (key) {
+                        case 'a':
+                                if (browser->selection->map == NULL ||
+                                    browser->selection->map->dso->annotate_warned)
+                                        continue;
+                                goto do_annotate;
+                        case 'd':
+                                goto zoom_dso;
+                        case 't':
+                                goto zoom_thread;
+                        case 'h':
+                        case '?':
+do_help:
+                                ui__help_window("->        Zoom into DSO/Threads & Annotate current symbol\n"
+                                                "<-        Zoom out\n"
+                                                "a         Annotate current symbol\n"
+                                                "h/?/F1    Show this window\n"
+                                                "d         Zoom into current DSO\n"
+                                                "t         Zoom into current Thread\n"
+                                                "q/CTRL+C  Exit browser");
+                                continue;
+                        default:;
+                        }
+                        if (is_exit_key(key)) {
+                                if (key == NEWT_KEY_ESCAPE &&
+                                    !ui__dialog_yesno("Do you really want to exit?"))
+                                        continue;
+                                break;
+                        }
+
+                        if (es.u.key == NEWT_KEY_LEFT) {
+                                const void *top;
+
+                                if (pstack__empty(fstack))
+                                        continue;
+                                top = pstack__pop(fstack);
+                                if (top == &dso_filter)
+                                        goto zoom_out_dso;
+                                if (top == &thread_filter)
+                                        goto zoom_out_thread;
+                                continue;
+                        }
+                }
+
+                if (browser->selection->sym != NULL &&
+                    !browser->selection->map->dso->annotate_warned &&
+                    asprintf(&options[nr_options], "Annotate %s",
+                             browser->selection->sym->name) > 0)
+                        annotate = nr_options++;
+
+                if (thread != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
+                             (thread_filter ? "out of" : "into"),
+                             (thread->comm_set ? thread->comm : ""),
+                             thread->pid) > 0)
+                        zoom_thread = nr_options++;
+
+                if (dso != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s DSO",
+                             (dso_filter ? "out of" : "into"),
+                             (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
+                        zoom_dso = nr_options++;
+
+                if (browser->selection->map != NULL &&
+                    asprintf(&options[nr_options], "Browse map details") > 0)
+                        browse_map = nr_options++;
+
+                options[nr_options++] = (char *)"Exit";
+
+                choice = ui__popup_menu(nr_options, options);
+
+                for (i = 0; i < nr_options - 1; ++i)
+                        free(options[i]);
+
+                if (choice == nr_options - 1)
+                        break;
+
+                if (choice == -1)
+                        continue;
+
+                if (choice == annotate) {
+                        struct hist_entry *he;
+do_annotate:
+                        if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
+                                browser->selection->map->dso->annotate_warned = 1;
+                                ui_helpline__puts("No vmlinux file found, can't "
+                                                 "annotate with just a "
+                                                 "kallsyms file");
+                                continue;
+                        }
+
+                        he = hist_browser__selected_entry(browser);
+                        if (he == NULL)
+                                continue;
+
+                        hist_entry__tui_annotate(he);
+                } else if (choice == browse_map)
+                        map__browse(browser->selection->map);
+                else if (choice == zoom_dso) {
+zoom_dso:
+                        if (dso_filter) {
+                                pstack__remove(fstack, &dso_filter);
+zoom_out_dso:
+                                ui_helpline__pop();
+                                dso_filter = NULL;
+                        } else {
+                                if (dso == NULL)
+                                        continue;
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
+                                                   dso->kernel ? "the Kernel" : dso->short_name);
+                                dso_filter = dso;
+                                pstack__push(fstack, &dso_filter);
+                        }
+                        hists__filter_by_dso(self, dso_filter);
+                        hist_browser__title(msg, sizeof(msg), ev_name,
+                                            dso_filter, thread_filter);
+                        hist_browser__reset(browser);
+                } else if (choice == zoom_thread) {
+zoom_thread:
+                        if (thread_filter) {
+                                pstack__remove(fstack, &thread_filter);
+zoom_out_thread:
+                                ui_helpline__pop();
+                                thread_filter = NULL;
+                        } else {
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
+                                                   thread->comm_set ? thread->comm : "",
+                                                   thread->pid);
+                                thread_filter = thread;
+                                pstack__push(fstack, &thread_filter);
+                        }
+                        hists__filter_by_thread(self, thread_filter);
+                        hist_browser__title(msg, sizeof(msg), ev_name,
+                                            dso_filter, thread_filter);
+                        hist_browser__reset(browser);
+                }
+        }
+out_free_stack:
+        pstack__delete(fstack);
+out:
+        hist_browser__delete(browser);
+        return key;
+}
+
+int hists__tui_browse_tree(struct rb_root *self, const char *help)
+{
+        struct rb_node *first = rb_first(self), *nd = first, *next;
+        int key = 0;
+
+        while (nd) {
+                struct hists *hists = rb_entry(nd, struct hists, rb_node);
+                const char *ev_name = __event_name(hists->type, hists->config);
+
+                key = hists__browse(hists, help, ev_name);
+
+                if (is_exit_key(key))
+                        break;
+
+                switch (key) {
+                case NEWT_KEY_TAB:
+                        next = rb_next(nd);
+                        if (next)
+                                nd = next;
+                        break;
+                case NEWT_KEY_UNTAB:
+                        if (nd == first)
+                                continue;
+                        nd = rb_prev(nd);
+                default:
+                        break;
+                }
+        }
+
+        return key;
+}
diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/util/ui/browsers/map.c
new file mode 100644
index 000000000000..142b825b42bf
--- /dev/null
+++ b/tools/perf/util/ui/browsers/map.c
@@ -0,0 +1,161 @@
+#include "../libslang.h"
+#include <elf.h>
+#include <newt.h>
+#include <sys/ttydefaults.h>
+#include <ctype.h>
+#include <string.h>
+#include <linux/bitops.h>
+#include "../../debug.h"
+#include "../../symbol.h"
+#include "../browser.h"
+#include "../helpline.h"
+#include "map.h"
+
+static int ui_entry__read(const char *title, char *bf, size_t size, int width)
+{
+        struct newtExitStruct es;
+        newtComponent form, entry;
+        const char *result;
+        int err = -1;
+
+        newtCenteredWindow(width, 1, title);
+        form = newtForm(NULL, NULL, 0);
+        if (form == NULL)
+                return -1;
+
+        entry = newtEntry(0, 0, "0x", width, &result, NEWT_FLAG_SCROLL);
+        if (entry == NULL)
+                goto out_free_form;
+
+        newtFormAddComponent(form, entry);
+        newtFormAddHotKey(form, NEWT_KEY_ENTER);
+        newtFormAddHotKey(form, NEWT_KEY_ESCAPE);
+        newtFormAddHotKey(form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(form, CTRL('c'));
+        newtFormRun(form, &es);
+
+        if (result != NULL) {
+                strncpy(bf, result, size);
+                err = 0;
+        }
+out_free_form:
+        newtPopWindow();
+        newtFormDestroy(form);
+        return 0;
+}
+
+struct map_browser {
+        struct ui_browser b;
+        struct map        *map;
+        u16               namelen;
+        u8                addrlen;
+};
+
+static void map_browser__write(struct ui_browser *self, void *nd, int row)
+{
+        struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+        struct map_browser *mb = container_of(self, struct map_browser, b);
+        bool current_entry = ui_browser__is_current_entry(self, row);
+        int color = ui_browser__percent_color(0, current_entry);
+
+        SLsmg_set_color(color);
+        slsmg_printf("%*llx %*llx %c ",
+                     mb->addrlen, sym->start, mb->addrlen, sym->end,
+                     sym->binding == STB_GLOBAL ? 'g' :
+                     sym->binding == STB_LOCAL  ? 'l' : 'w');
+        slsmg_write_nstring(sym->name, mb->namelen);
+}
+
+/* FIXME uber-kludgy, see comment on cmd_report... */
+static u32 *symbol__browser_index(struct symbol *self)
+{
+        return ((void *)self) - sizeof(struct rb_node) - sizeof(u32);
+}
+
+static int map_browser__search(struct map_browser *self)
+{
+        char target[512];
+        struct symbol *sym;
+        int err = ui_entry__read("Search by name/addr", target, sizeof(target), 40);
+
+        if (err)
+                return err;
+
+        if (target[0] == '0' && tolower(target[1]) == 'x') {
+                u64 addr = strtoull(target, NULL, 16);
+                sym = map__find_symbol(self->map, addr, NULL);
+        } else
+                sym = map__find_symbol_by_name(self->map, target, NULL);
+
+        if (sym != NULL) {
+                u32 *idx = symbol__browser_index(sym);
+
+                self->b.top = &sym->rb_node;
+                self->b.index = self->b.top_idx = *idx;
+        } else
+                ui_helpline__fpush("%s not found!", target);
+
+        return 0;
+}
+
+static int map_browser__run(struct map_browser *self, struct newtExitStruct *es)
+{
+        if (ui_browser__show(&self->b, self->map->dso->long_name,
+                             "Press <- or ESC to exit, %s / to search",
+                             verbose ? "" : "restart with -v to use") < 0)
+                return -1;
+
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_ENTER);
+        if (verbose)
+                newtFormAddHotKey(self->b.form, '/');
+
+        while (1) {
+                ui_browser__run(&self->b, es);
+
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                if (verbose && es->u.key == '/')
+                        map_browser__search(self);
+                else
+                        break;
+        }
+
+        ui_browser__hide(&self->b);
+        return 0;
+}
+
+int map__browse(struct map *self)
+{
+        struct map_browser mb = {
+                .b = {
+                        .entries = &self->dso->symbols[self->type],
+                        .refresh = ui_browser__rb_tree_refresh,
+                        .seek    = ui_browser__rb_tree_seek,
+                        .write   = map_browser__write,
+                },
+                .map = self,
+        };
+        struct newtExitStruct es;
+        struct rb_node *nd;
+        char tmp[BITS_PER_LONG / 4];
+        u64 maxaddr = 0;
+
+        for (nd = rb_first(mb.b.entries); nd; nd = rb_next(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+
+                if (mb.namelen < pos->namelen)
+                        mb.namelen = pos->namelen;
+                if (maxaddr < pos->end)
+                        maxaddr = pos->end;
+                if (verbose) {
+                        u32 *idx = symbol__browser_index(pos);
+                        *idx = mb.b.nr_entries;
+                }
+                ++mb.b.nr_entries;
+        }
+
+        mb.addrlen = snprintf(tmp, sizeof(tmp), "%llx", maxaddr);
+        mb.b.width += mb.addrlen * 2 + 4 + mb.namelen;
+        return map_browser__run(&mb, &es);
+}
diff --git a/tools/perf/util/ui/browsers/map.h b/tools/perf/util/ui/browsers/map.h
new file mode 100644
index 000000000000..df8581a43e17
--- /dev/null
+++ b/tools/perf/util/ui/browsers/map.h
@@ -0,0 +1,6 @@
+#ifndef _PERF_UI_MAP_BROWSER_H_
+#define _PERF_UI_MAP_BROWSER_H_ 1
+struct map;
+
+int map__browse(struct map *self);
+#endif /* _PERF_UI_MAP_BROWSER_H_ */
diff --git a/tools/perf/util/ui/helpline.c b/tools/perf/util/ui/helpline.c
new file mode 100644
index 000000000000..8d79daa4458a
--- /dev/null
+++ b/tools/perf/util/ui/helpline.c
@@ -0,0 +1,69 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <newt.h>
+
+#include "../debug.h"
+#include "helpline.h"
+
+void ui_helpline__pop(void)
+{
+        newtPopHelpLine();
+}
+
+void ui_helpline__push(const char *msg)
+{
+        newtPushHelpLine(msg);
+}
+
+void ui_helpline__vpush(const char *fmt, va_list ap)
+{
+        char *s;
+
+        if (vasprintf(&s, fmt, ap) < 0)
+                vfprintf(stderr, fmt, ap);
+        else {
+                ui_helpline__push(s);
+                free(s);
+        }
+}
+
+void ui_helpline__fpush(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        ui_helpline__vpush(fmt, ap);
+        va_end(ap);
+}
+
+void ui_helpline__puts(const char *msg)
+{
+        ui_helpline__pop();
+        ui_helpline__push(msg);
+}
+
+void ui_helpline__init(void)
+{
+        ui_helpline__puts(" ");
+}
+
+char ui_helpline__last_msg[1024];
+
+int ui_helpline__show_help(const char *format, va_list ap)
+{
+        int ret;
+        static int backlog;
+
+        ret = vsnprintf(ui_helpline__last_msg + backlog,
+                        sizeof(ui_helpline__last_msg) - backlog, format, ap);
+        backlog += ret;
+
+        if (ui_helpline__last_msg[backlog - 1] == '\n') {
+                ui_helpline__puts(ui_helpline__last_msg);
+                newtRefresh();
+                backlog = 0;
+        }
+
+        return ret;
+}
diff --git a/tools/perf/util/ui/helpline.h b/tools/perf/util/ui/helpline.h
new file mode 100644
index 000000000000..ab6028d0c401
--- /dev/null
+++ b/tools/perf/util/ui/helpline.h
@@ -0,0 +1,11 @@
+#ifndef _PERF_UI_HELPLINE_H_
+#define _PERF_UI_HELPLINE_H_ 1
+
+void ui_helpline__init(void);
+void ui_helpline__pop(void);
+void ui_helpline__push(const char *msg);
+void ui_helpline__vpush(const char *fmt, va_list ap);
+void ui_helpline__fpush(const char *fmt, ...);
+void ui_helpline__puts(const char *msg);
+
+#endif /* _PERF_UI_HELPLINE_H_ */
diff --git a/tools/perf/util/ui/libslang.h b/tools/perf/util/ui/libslang.h
new file mode 100644
index 000000000000..5623da8e8080
--- /dev/null
+++ b/tools/perf/util/ui/libslang.h
@@ -0,0 +1,27 @@
+#ifndef _PERF_UI_SLANG_H_
+#define _PERF_UI_SLANG_H_ 1
+/*
+ * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
+ * the build if it isn't defined. Use the equivalent one that glibc
+ * has on features.h.
+ */
+#include <features.h>
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
+#endif
+#include <slang.h>
+
+#if SLANG_VERSION < 20104
+#define slsmg_printf(msg, args...) \
+        SLsmg_printf((char *)msg, ##args)
+#define slsmg_write_nstring(msg, len) \
+        SLsmg_write_nstring((char *)msg, len)
+#define sltt_set_color(obj, name, fg, bg) \
+        SLtt_set_color(obj,(char *)name, (char *)fg, (char *)bg)
+#else
+#define slsmg_printf SLsmg_printf
+#define slsmg_write_nstring SLsmg_write_nstring
+#define sltt_set_color SLtt_set_color
+#endif
+
+#endif /* _PERF_UI_SLANG_H_ */
diff --git a/tools/perf/util/ui/progress.c b/tools/perf/util/ui/progress.c
new file mode 100644
index 000000000000..d7fc399d36b3
--- /dev/null
+++ b/tools/perf/util/ui/progress.c
@@ -0,0 +1,60 @@
+#include <stdlib.h>
+#include <newt.h>
+#include "../cache.h"
+#include "progress.h"
+
+struct ui_progress {
+        newtComponent form, scale;
+};
+
+struct ui_progress *ui_progress__new(const char *title, u64 total)
+{
+        struct ui_progress *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                int cols;
+
+                if (use_browser <= 0)
+                        return self;
+                newtGetScreenSize(&cols, NULL);
+                cols -= 4;
+                newtCenteredWindow(cols, 1, title);
+                self->form  = newtForm(NULL, NULL, 0);
+                if (self->form == NULL)
+                        goto out_free_self;
+                self->scale = newtScale(0, 0, cols, total);
+                if (self->scale == NULL)
+                        goto out_free_form;
+                newtFormAddComponent(self->form, self->scale);
+                newtRefresh();
+        }
+
+        return self;
+
+out_free_form:
+        newtFormDestroy(self->form);
+out_free_self:
+        free(self);
+        return NULL;
+}
+
+void ui_progress__update(struct ui_progress *self, u64 curr)
+{
+        /*
+         * FIXME: We should have a per UI backend way of showing progress,
+         * stdio will just show a percentage as NN%, etc.
+         */
+        if (use_browser <= 0)
+                return;
+        newtScaleSet(self->scale, curr);
+        newtRefresh();
+}
+
+void ui_progress__delete(struct ui_progress *self)
+{
+        if (use_browser > 0) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+        free(self);
+}
diff --git a/tools/perf/util/ui/progress.h b/tools/perf/util/ui/progress.h
new file mode 100644
index 000000000000..a3820a0beb5b
--- /dev/null
+++ b/tools/perf/util/ui/progress.h
@@ -0,0 +1,11 @@
+#ifndef _PERF_UI_PROGRESS_H_
+#define _PERF_UI_PROGRESS_H_ 1
+
+struct ui_progress;
+
+struct ui_progress *ui_progress__new(const char *title, u64 total);
+void ui_progress__delete(struct ui_progress *self);
+
+void ui_progress__update(struct ui_progress *self, u64 curr);
+
+#endif
diff --git a/tools/perf/util/ui/setup.c b/tools/perf/util/ui/setup.c
new file mode 100644
index 000000000000..662085032eb7
--- /dev/null
+++ b/tools/perf/util/ui/setup.c
@@ -0,0 +1,42 @@
+#include <newt.h>
+#include <signal.h>
+#include <stdbool.h>
+
+#include "../cache.h"
+#include "../debug.h"
+#include "browser.h"
+#include "helpline.h"
+
+static void newt_suspend(void *d __used)
+{
+        newtSuspend();
+        raise(SIGTSTP);
+        newtResume();
+}
+
+void setup_browser(void)
+{
+        if (!isatty(1) || !use_browser || dump_trace) {
+                use_browser = 0;
+                setup_pager();
+                return;
+        }
+
+        use_browser = 1;
+        newtInit();
+        newtCls();
+        newtSetSuspendCallback(newt_suspend, NULL);
+        ui_helpline__init();
+        ui_browser__init();
+}
+
+void exit_browser(bool wait_for_ok)
+{
+        if (use_browser > 0) {
+                if (wait_for_ok) {
+                        char title[] = "Fatal Error", ok[] = "Ok";
+                        newtWinMessage(title, ok, ui_helpline__last_msg);
+                }
+                newtFinished();
+        }
+}
diff --git a/tools/perf/util/ui/util.c b/tools/perf/util/ui/util.c
new file mode 100644
index 000000000000..04600e26ceea
--- /dev/null
+++ b/tools/perf/util/ui/util.c
@@ -0,0 +1,114 @@
+#include <newt.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/ttydefaults.h>
+
+#include "../cache.h"
+#include "../debug.h"
+#include "browser.h"
+#include "helpline.h"
+#include "util.h"
+
+newtComponent newt_form__new(void);
+
+static void newt_form__set_exit_keys(newtComponent self)
+{
+        newtFormAddHotKey(self, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
+        newtFormAddHotKey(self, 'Q');
+        newtFormAddHotKey(self, 'q');
+        newtFormAddHotKey(self, CTRL('c'));
+}
+
+newtComponent newt_form__new(void)
+{
+        newtComponent self = newtForm(NULL, NULL, 0);
+        if (self)
+                newt_form__set_exit_keys(self);
+        return self;
+}
+
+int ui__popup_menu(int argc, char * const argv[])
+{
+        struct newtExitStruct es;
+        int i, rc = -1, max_len = 5;
+        newtComponent listbox, form = newt_form__new();
+
+        if (form == NULL)
+                return -1;
+
+        listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
+        if (listbox == NULL)
+                goto out_destroy_form;
+
+        newtFormAddComponent(form, listbox);
+
+        for (i = 0; i < argc; ++i) {
+                int len = strlen(argv[i]);
+                if (len > max_len)
+                        max_len = len;
+                if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
+                        goto out_destroy_form;
+        }
+
+        newtCenteredWindow(max_len, argc, NULL);
+        newtFormRun(form, &es);
+        rc = newtListboxGetCurrent(listbox) - NULL;
+        if (es.reason == NEWT_EXIT_HOTKEY)
+                rc = -1;
+        newtPopWindow();
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+
+int ui__help_window(const char *text)
+{
+        struct newtExitStruct es;
+        newtComponent tb, form = newt_form__new();
+        int rc = -1;
+        int max_len = 0, nr_lines = 0;
+        const char *t;
+
+        if (form == NULL)
+                return -1;
+
+        t = text;
+        while (1) {
+                const char *sep = strchr(t, '\n');
+                int len;
+
+                if (sep == NULL)
+                        sep = strchr(t, '\0');
+                len = sep - t;
+                if (max_len < len)
+                        max_len = len;
+                ++nr_lines;
+                if (*sep == '\0')
+                        break;
+                t = sep + 1;
+        }
+
+        tb = newtTextbox(0, 0, max_len, nr_lines, 0);
+        if (tb == NULL)
+                goto out_destroy_form;
+
+        newtTextboxSetText(tb, text);
+        newtFormAddComponent(form, tb);
+        newtCenteredWindow(max_len, nr_lines, NULL);
+        newtFormRun(form, &es);
+        newtPopWindow();
+        rc = 0;
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+
+bool ui__dialog_yesno(const char *msg)
+{
+        /* newtWinChoice should really be accepting const char pointers... */
+        char yes[] = "Yes", no[] = "No";
+        return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
+}
diff --git a/tools/perf/util/ui/util.h b/tools/perf/util/ui/util.h
new file mode 100644
index 000000000000..afcbc1d99531
--- /dev/null
+++ b/tools/perf/util/ui/util.h
@@ -0,0 +1,10 @@
+#ifndef _PERF_UI_UTIL_H_
+#define _PERF_UI_UTIL_H_ 1
+
+#include <stdbool.h>
+
+int ui__popup_menu(int argc, char * const argv[]);
+int ui__help_window(const char *text);
+bool ui__dialog_yesno(const char *msg);
+
+#endif /* _PERF_UI_UTIL_H_ */
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
new file mode 100644
index 000000000000..214265674ddd
--- /dev/null
+++ b/tools/perf/util/util.c
@@ -0,0 +1,116 @@
+#include "util.h"
+#include <sys/mman.h>
+
+int mkdir_p(char *path, mode_t mode)
+{
+        struct stat st;
+        int err;
+        char *d = path;
+
+        if (*d != '/')
+                return -1;
+
+        if (stat(path, &st) == 0)
+                return 0;
+
+        while (*++d == '/');
+
+        while ((d = strchr(d, '/'))) {
+                *d = '\0';
+                err = stat(path, &st) && mkdir(path, mode);
+                *d++ = '/';
+                if (err)
+                        return -1;
+                while (*d == '/')
+                        ++d;
+        }
+        return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
+}
+
+static int slow_copyfile(const char *from, const char *to)
+{
+        int err = 0;
+        char *line = NULL;
+        size_t n;
+        FILE *from_fp = fopen(from, "r"), *to_fp;
+
+        if (from_fp == NULL)
+                goto out;
+
+        to_fp = fopen(to, "w");
+        if (to_fp == NULL)
+                goto out_fclose_from;
+
+        while (getline(&line, &n, from_fp) > 0)
+                if (fputs(line, to_fp) == EOF)
+                        goto out_fclose_to;
+        err = 0;
+out_fclose_to:
+        fclose(to_fp);
+        free(line);
+out_fclose_from:
+        fclose(from_fp);
+out:
+        return err;
+}
+
+int copyfile(const char *from, const char *to)
+{
+        int fromfd, tofd;
+        struct stat st;
+        void *addr;
+        int err = -1;
+
+        if (stat(from, &st))
+                goto out;
+
+        if (st.st_size == 0) /* /proc? do it slowly... */
+                return slow_copyfile(from, to);
+
+        fromfd = open(from, O_RDONLY);
+        if (fromfd < 0)
+                goto out;
+
+        tofd = creat(to, 0755);
+        if (tofd < 0)
+                goto out_close_from;
+
+        addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fromfd, 0);
+        if (addr == MAP_FAILED)
+                goto out_close_to;
+
+        if (write(tofd, addr, st.st_size) == st.st_size)
+                err = 0;
+
+        munmap(addr, st.st_size);
+out_close_to:
+        close(tofd);
+        if (err)
+                unlink(to);
+out_close_from:
+        close(fromfd);
+out:
+        return err;
+}
+
+unsigned long convert_unit(unsigned long value, char *unit)
+{
+        *unit = ' ';
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'K';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'M';
+        }
+
+        if (value > 1000) {
+                value /= 1000;
+                *unit = 'G';
+        }
+
+        return value;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index c673d8825883..f380fed74359 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -42,12 +42,14 @@
 #define _ALL_SOURCE 1
 #define _GNU_SOURCE 1
 #define _BSD_SOURCE 1
+#define HAS_BOOL
 
 #include <unistd.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/statfs.h>
 #include <fcntl.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -78,7 +80,8 @@
 #include <pwd.h>
 #include <inttypes.h>
 #include "../../../include/linux/magic.h"
-
+#include "types.h"
+#include <sys/ttydefaults.h>
 
 #ifndef NO_ICONV
 #include <iconv.h>
@@ -86,6 +89,7 @@
 
 extern const char *graph_line;
 extern const char *graph_dotted_line;
+extern char buildid_dir[];
 
 /* On most systems <limits.h> would have given us this, but
  * not on some systems (e.g. GNU/Hurd).
@@ -149,7 +153,8 @@ extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)))
 extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
 
 extern int prefixcmp(const char *str, const char *prefix);
-extern time_t tm_to_time_t(const struct tm *tm);
+extern void set_buildid_dir(void);
+extern void disable_buildid_cache(void);
 
 static inline const char *skip_prefix(const char *str, const char *prefix)
 {
@@ -157,119 +162,6 @@ static inline const char *skip_prefix(const char *str, const char *prefix)
         return strncmp(str, prefix, len) ? NULL : str + len;
 }
 
-#if defined(NO_MMAP) || defined(USE_WIN32_MMAP)
-
-#ifndef PROT_READ
-#define PROT_READ 1
-#define PROT_WRITE 2
-#define MAP_PRIVATE 1
-#define MAP_FAILED ((void*)-1)
-#endif
-
-#define mmap git_mmap
-#define munmap git_munmap
-extern void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
-extern int git_munmap(void *start, size_t length);
-
-#else /* NO_MMAP || USE_WIN32_MMAP */
-
-#include <sys/mman.h>
-
-#endif /* NO_MMAP || USE_WIN32_MMAP */
-
-#ifdef NO_MMAP
-
-/* This value must be multiple of (pagesize * 2) */
-#define DEFAULT_PACKED_GIT_WINDOW_SIZE (1 * 1024 * 1024)
-
-#else /* NO_MMAP */
-
-/* This value must be multiple of (pagesize * 2) */
-#define DEFAULT_PACKED_GIT_WINDOW_SIZE \
-        (sizeof(void*) >= 8 \
-                ?  1 * 1024 * 1024 * 1024 \
-                : 32 * 1024 * 1024)
-
-#endif /* NO_MMAP */
-
-#ifdef NO_ST_BLOCKS_IN_STRUCT_STAT
-#define on_disk_bytes(st) ((st).st_size)
-#else
-#define on_disk_bytes(st) ((st).st_blocks * 512)
-#endif
-
-#define DEFAULT_PACKED_GIT_LIMIT \
-        ((1024L * 1024L) * (sizeof(void*) >= 8 ? 8192 : 256))
-
-#ifdef NO_PREAD
-#define pread git_pread
-extern ssize_t git_pread(int fd, void *buf, size_t count, off_t offset);
-#endif
-/*
- * Forward decl that will remind us if its twin in cache.h changes.
- * This function is used in compat/pread.c.  But we can't include
- * cache.h there.
- */
-extern ssize_t read_in_full(int fd, void *buf, size_t count);
-
-#ifdef NO_SETENV
-#define setenv gitsetenv
-extern int gitsetenv(const char *, const char *, int);
-#endif
-
-#ifdef NO_MKDTEMP
-#define mkdtemp gitmkdtemp
-extern char *gitmkdtemp(char *);
-#endif
-
-#ifdef NO_UNSETENV
-#define unsetenv gitunsetenv
-extern void gitunsetenv(const char *);
-#endif
-
-#ifdef NO_STRCASESTR
-#define strcasestr gitstrcasestr
-extern char *gitstrcasestr(const char *haystack, const char *needle);
-#endif
-
-#ifdef NO_STRLCPY
-#define strlcpy gitstrlcpy
-extern size_t gitstrlcpy(char *, const char *, size_t);
-#endif
-
-#ifdef NO_STRTOUMAX
-#define strtoumax gitstrtoumax
-extern uintmax_t gitstrtoumax(const char *, char **, int);
-#endif
-
-#ifdef NO_HSTRERROR
-#define hstrerror githstrerror
-extern const char *githstrerror(int herror);
-#endif
-
-#ifdef NO_MEMMEM
-#define memmem gitmemmem
-void *gitmemmem(const void *haystack, size_t haystacklen,
-                const void *needle, size_t needlelen);
-#endif
-
-#ifdef FREAD_READS_DIRECTORIES
-#ifdef fopen
-#undef fopen
-#endif
-#define fopen(a,b) git_fopen(a,b)
-extern FILE *git_fopen(const char*, const char*);
-#endif
-
-#ifdef SNPRINTF_RETURNS_BOGUS
-#define snprintf git_snprintf
-extern int git_snprintf(char *str, size_t maxsize,
-                        const char *format, ...);
-#define vsnprintf git_vsnprintf
-extern int git_vsnprintf(char *str, size_t maxsize,
-                         const char *format, va_list ap);
-#endif
-
 #ifdef __GLIBC_PREREQ
 #if __GLIBC_PREREQ(2, 1)
 #define HAVE_STRCHRNUL
@@ -290,25 +182,19 @@ static inline char *gitstrchrnul(const char *s, int c)
  * Wrappers:
  */
 extern char *xstrdup(const char *str);
-extern void *xmalloc(size_t size) __attribute__((weak));
-extern void *xmemdupz(const void *data, size_t len);
-extern char *xstrndup(const char *str, size_t len);
 extern void *xrealloc(void *ptr, size_t size) __attribute__((weak));
 
+
 static inline void *zalloc(size_t size)
 {
         return calloc(1, size);
 }
 
-static inline size_t xsize_t(off_t len)
-{
-        return (size_t)len;
-}
-
 static inline int has_extension(const char *filename, const char *ext)
 {
         size_t len = strlen(filename);
         size_t extlen = strlen(ext);
+
         return len > extlen && !memcmp(filename + len - extlen, ext, extlen);
 }
 
@@ -322,6 +208,7 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isalnum
 #undef tolower
 #undef toupper
+
 extern unsigned char sane_ctype[256];
 #define GIT_SPACE               0x01
 #define GIT_DIGIT               0x02
@@ -339,8 +226,6 @@ extern unsigned char sane_ctype[256];
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
-#define is_glob_special(x) sane_istest(x,GIT_GLOB_SPECIAL)
-#define is_regex_special(x) sane_istest(x,GIT_GLOB_SPECIAL | GIT_REGEX_SPECIAL)
 #define tolower(x) sane_case((unsigned char)(x), 0x20)
 #define toupper(x) sane_case((unsigned char)(x), 0)
 
@@ -351,38 +236,6 @@ static inline int sane_case(int x, int high)
         return x;
 }
 
-static inline int strtoul_ui(char const *s, int base, unsigned int *result)
-{
-        unsigned long ul;
-        char *p;
-
-        errno = 0;
-        ul = strtoul(s, &p, base);
-        if (errno || *p || p == s || (unsigned int) ul != ul)
-                return -1;
-        *result = ul;
-        return 0;
-}
-
-static inline int strtol_i(char const *s, int base, int *result)
-{
-        long ul;
-        char *p;
-
-        errno = 0;
-        ul = strtol(s, &p, base);
-        if (errno || *p || p == s || (int) ul != ul)
-                return -1;
-        *result = ul;
-        return 0;
-}
-
-#ifdef INTERNAL_QSORT
-void git_qsort(void *base, size_t nmemb, size_t size,
-               int(*compar)(const void *, const void *));
-#define qsort git_qsort
-#endif
-
 #ifndef DIR_HAS_BSD_GROUP_SEMANTICS
 # define FORCE_DIR_SET_GID S_ISGID
 #else
@@ -403,4 +256,30 @@ void git_qsort(void *base, size_t nmemb, size_t size,
 #endif
 #endif
 
+int mkdir_p(char *path, mode_t mode);
+int copyfile(const char *from, const char *to);
+
+s64 perf_atoll(const char *str);
+char **argv_split(const char *str, int *argcp);
+void argv_free(char **argv);
+bool strglobmatch(const char *str, const char *pat);
+bool strlazymatch(const char *str, const char *pat);
+unsigned long convert_unit(unsigned long value, char *unit);
+
+#ifndef ESC
+#define ESC 27
+#endif
+
+static inline bool is_exit_key(int key)
+{
+        char up;
+        if (key == CTRL('c') || key == ESC)
+                return true;
+        up = toupper(key);
+        return up == 'Q';
+}
+
+#define _STR(x) #x
+#define STR(x) _STR(x)
+
 #endif
diff --git a/tools/perf/util/values.c b/tools/perf/util/values.c
index 1c15e39f99e3..cfa55d686e3b 100644
--- a/tools/perf/util/values.c
+++ b/tools/perf/util/values.c
@@ -169,6 +169,7 @@ static void perf_read_values__display_pretty(FILE *fp,
                                 counterwidth[j], values->value[i][j]);
                 fprintf(fp, "\n");
         }
+        free(counterwidth);
 }
 
 static void perf_read_values__display_raw(FILE *fp,
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
index bf44ca85d23b..73e900edb5a2 100644
--- a/tools/perf/util/wrapper.c
+++ b/tools/perf/util/wrapper.c
@@ -23,46 +23,6 @@ char *xstrdup(const char *str)
         return ret;
 }
 
-void *xmalloc(size_t size)
-{
-        void *ret = malloc(size);
-        if (!ret && !size)
-                ret = malloc(1);
-        if (!ret) {
-                release_pack_memory(size, -1);
-                ret = malloc(size);
-                if (!ret && !size)
-                        ret = malloc(1);
-                if (!ret)
-                        die("Out of memory, malloc failed");
-        }
-#ifdef XMALLOC_POISON
-        memset(ret, 0xA5, size);
-#endif
-        return ret;
-}
-
-/*
- * xmemdupz() allocates (len + 1) bytes of memory, duplicates "len" bytes of
- * "data" to the allocated memory, zero terminates the allocated memory,
- * and returns a pointer to the allocated memory. If the allocation fails,
- * the program dies.
- */
-void *xmemdupz(const void *data, size_t len)
-{
-        char *p = xmalloc(len + 1);
-        memcpy(p, data, len);
-        p[len] = '\0';
-        return p;
-}
-
-char *xstrndup(const char *str, size_t len)
-{
-        char *p = memchr(str, '\0', len);
-
-        return xmemdupz(str, p ? (size_t)(p - str) : len);
-}
-
 void *xrealloc(void *ptr, size_t size)
 {
         void *ret = realloc(ptr, size);
@@ -78,73 +38,3 @@ void *xrealloc(void *ptr, size_t size)
         }
         return ret;
 }
-
-/*
- * xread() is the same a read(), but it automatically restarts read()
- * operations with a recoverable error (EAGAIN and EINTR). xread()
- * DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
- */
-static ssize_t xread(int fd, void *buf, size_t len)
-{
-        ssize_t nr;
-        while (1) {
-                nr = read(fd, buf, len);
-                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
-                        continue;
-                return nr;
-        }
-}
-
-/*
- * xwrite() is the same a write(), but it automatically restarts write()
- * operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
- * GUARANTEE that "len" bytes is written even if the operation is successful.
- */
-static ssize_t xwrite(int fd, const void *buf, size_t len)
-{
-        ssize_t nr;
-        while (1) {
-                nr = write(fd, buf, len);
-                if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
-                        continue;
-                return nr;
-        }
-}
-
-ssize_t read_in_full(int fd, void *buf, size_t count)
-{
-        char *p = buf;
-        ssize_t total = 0;
-
-        while (count > 0) {
-                ssize_t loaded = xread(fd, p, count);
-                if (loaded <= 0)
-                        return total ? total : loaded;
-                count -= loaded;
-                p += loaded;
-                total += loaded;
-        }
-
-        return total;
-}
-
-ssize_t write_in_full(int fd, const void *buf, size_t count)
-{
-        const char *p = buf;
-        ssize_t total = 0;
-
-        while (count > 0) {
-                ssize_t written = xwrite(fd, p, count);
-                if (written < 0)
-                        return -1;
-                if (!written) {
-                        errno = ENOSPC;
-                        return -1;
-                }
-                count -= written;
-                p += written;
-                total += written;
-        }
-
-        return total;
-}
diff --git a/tools/usb/ffs-test.c b/tools/usb/ffs-test.c
new file mode 100644
index 000000000000..bbe2e3a2ea62
--- /dev/null
+++ b/tools/usb/ffs-test.c
@@ -0,0 +1,554 @@
+/*
+ * ffs-test.c.c -- user mode filesystem api for usb composite function
+ *
+ * Copyright (C) 2010 Samsung Electronics
+ *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* $(CROSS_COMPILE)cc -Wall -Wextra -g -o ffs-test ffs-test.c -lpthread */
+
+
+#define _BSD_SOURCE /* for endian.h */
+
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <linux/usb/functionfs.h>
+
+
+/******************** Little Endian Handling ********************************/
+
+#define cpu_to_le16(x)  htole16(x)
+#define cpu_to_le32(x)  htole32(x)
+#define le32_to_cpu(x)  le32toh(x)
+#define le16_to_cpu(x)  le16toh(x)
+
+static inline __u16 get_unaligned_le16(const void *_ptr)
+{
+        const __u8 *ptr = _ptr;
+        return ptr[0] | (ptr[1] << 8);
+}
+
+static inline __u32 get_unaligned_le32(const void *_ptr)
+{
+        const __u8 *ptr = _ptr;
+        return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
+}
+
+static inline void put_unaligned_le16(__u16 val, void *_ptr)
+{
+        __u8 *ptr = _ptr;
+        *ptr++ = val;
+        *ptr++ = val >> 8;
+}
+
+static inline void put_unaligned_le32(__u32 val, void *_ptr)
+{
+        __u8 *ptr = _ptr;
+        *ptr++ = val;
+        *ptr++ = val >>  8;
+        *ptr++ = val >> 16;
+        *ptr++ = val >> 24;
+}
+
+
+/******************** Messages and Errors ***********************************/
+
+static const char argv0[] = "ffs-test";
+
+static unsigned verbosity = 7;
+
+static void _msg(unsigned level, const char *fmt, ...)
+{
+        if (level < 2)
+                level = 2;
+        else if (level > 7)
+                level = 7;
+
+        if (level <= verbosity) {
+                static const char levels[8][6] = {
+                        [2] = "crit:",
+                        [3] = "err: ",
+                        [4] = "warn:",
+                        [5] = "note:",
+                        [6] = "info:",
+                        [7] = "dbg: "
+                };
+
+                int _errno = errno;
+                va_list ap;
+
+                fprintf(stderr, "%s: %s ", argv0, levels[level]);
+                va_start(ap, fmt);
+                vfprintf(stderr, fmt, ap);
+                va_end(ap);
+
+                if (fmt[strlen(fmt) - 1] != '\n') {
+                        char buffer[128];
+                        strerror_r(_errno, buffer, sizeof buffer);
+                        fprintf(stderr, ": (-%d) %s\n", _errno, buffer);
+                }
+
+                fflush(stderr);
+        }
+}
+
+#define die(...)  (_msg(2, __VA_ARGS__), exit(1))
+#define err(...)   _msg(3, __VA_ARGS__)
+#define warn(...)  _msg(4, __VA_ARGS__)
+#define note(...)  _msg(5, __VA_ARGS__)
+#define info(...)  _msg(6, __VA_ARGS__)
+#define debug(...) _msg(7, __VA_ARGS__)
+
+#define die_on(cond, ...) do { \
+        if (cond) \
+                die(__VA_ARGS__); \
+        } while (0)
+
+
+/******************** Descriptors and Strings *******************************/
+
+static const struct {
+        struct usb_functionfs_descs_head header;
+        struct {
+                struct usb_interface_descriptor intf;
+                struct usb_endpoint_descriptor_no_audio sink;
+                struct usb_endpoint_descriptor_no_audio source;
+        } __attribute__((packed)) fs_descs, hs_descs;
+} __attribute__((packed)) descriptors = {
+        .header = {
+                .magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC),
+                .length = cpu_to_le32(sizeof descriptors),
+                .fs_count = 3,
+                .hs_count = 3,
+        },
+        .fs_descs = {
+                .intf = {
+                        .bLength = sizeof descriptors.fs_descs.intf,
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .sink = {
+                        .bLength = sizeof descriptors.fs_descs.sink,
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        /* .wMaxPacketSize = autoconfiguration (kernel) */
+                },
+                .source = {
+                        .bLength = sizeof descriptors.fs_descs.source,
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        /* .wMaxPacketSize = autoconfiguration (kernel) */
+                },
+        },
+        .hs_descs = {
+                .intf = {
+                        .bLength = sizeof descriptors.fs_descs.intf,
+                        .bDescriptorType = USB_DT_INTERFACE,
+                        .bNumEndpoints = 2,
+                        .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
+                        .iInterface = 1,
+                },
+                .sink = {
+                        .bLength = sizeof descriptors.hs_descs.sink,
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 1 | USB_DIR_IN,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = cpu_to_le16(512),
+                },
+                .source = {
+                        .bLength = sizeof descriptors.hs_descs.source,
+                        .bDescriptorType = USB_DT_ENDPOINT,
+                        .bEndpointAddress = 2 | USB_DIR_OUT,
+                        .bmAttributes = USB_ENDPOINT_XFER_BULK,
+                        .wMaxPacketSize = cpu_to_le16(512),
+                        .bInterval = 1, /* NAK every 1 uframe */
+                },
+        },
+};
+
+
+#define STR_INTERFACE_ "Source/Sink"
+
+static const struct {
+        struct usb_functionfs_strings_head header;
+        struct {
+                __le16 code;
+                const char str1[sizeof STR_INTERFACE_];
+        } __attribute__((packed)) lang0;
+} __attribute__((packed)) strings = {
+        .header = {
+                .magic = cpu_to_le32(FUNCTIONFS_STRINGS_MAGIC),
+                .length = cpu_to_le32(sizeof strings),
+                .str_count = cpu_to_le32(1),
+                .lang_count = cpu_to_le32(1),
+        },
+        .lang0 = {
+                cpu_to_le16(0x0409), /* en-us */
+                STR_INTERFACE_,
+        },
+};
+
+#define STR_INTERFACE strings.lang0.str1
+
+
+/******************** Files and Threads Handling ****************************/
+
+struct thread;
+
+static ssize_t read_wrap(struct thread *t, void *buf, size_t nbytes);
+static ssize_t write_wrap(struct thread *t, const void *buf, size_t nbytes);
+static ssize_t ep0_consume(struct thread *t, const void *buf, size_t nbytes);
+static ssize_t fill_in_buf(struct thread *t, void *buf, size_t nbytes);
+static ssize_t empty_out_buf(struct thread *t, const void *buf, size_t nbytes);
+
+
+static struct thread {
+        const char *const filename;
+        size_t buf_size;
+
+        ssize_t (*in)(struct thread *, void *, size_t);
+        const char *const in_name;
+
+        ssize_t (*out)(struct thread *, const void *, size_t);
+        const char *const out_name;
+
+        int fd;
+        pthread_t id;
+        void *buf;
+        ssize_t status;
+} threads[] = {
+        {
+                "ep0", 4 * sizeof(struct usb_functionfs_event),
+                read_wrap, NULL,
+                ep0_consume, "<consume>",
+                0, 0, NULL, 0
+        },
+        {
+                "ep1", 8 * 1024,
+                fill_in_buf, "<in>",
+                write_wrap, NULL,
+                0, 0, NULL, 0
+        },
+        {
+                "ep2", 8 * 1024,
+                read_wrap, NULL,
+                empty_out_buf, "<out>",
+                0, 0, NULL, 0
+        },
+};
+
+
+static void init_thread(struct thread *t)
+{
+        t->buf = malloc(t->buf_size);
+        die_on(!t->buf, "malloc");
+
+        t->fd = open(t->filename, O_RDWR);
+        die_on(t->fd < 0, "%s", t->filename);
+}
+
+static void cleanup_thread(void *arg)
+{
+        struct thread *t = arg;
+        int ret, fd;
+
+        fd = t->fd;
+        if (t->fd < 0)
+                return;
+        t->fd = -1;
+
+        /* test the FIFO ioctls (non-ep0 code paths) */
+        if (t != threads) {
+                ret = ioctl(fd, FUNCTIONFS_FIFO_STATUS);
+                if (ret < 0) {
+                        /* ENODEV reported after disconnect */
+                        if (errno != ENODEV)
+                                err("%s: get fifo status", t->filename);
+                } else if (ret) {
+                        warn("%s: unclaimed = %d\n", t->filename, ret);
+                        if (ioctl(fd, FUNCTIONFS_FIFO_FLUSH) < 0)
+                                err("%s: fifo flush", t->filename);
+                }
+        }
+
+        if (close(fd) < 0)
+                err("%s: close", t->filename);
+
+        free(t->buf);
+        t->buf = NULL;
+}
+
+static void *start_thread_helper(void *arg)
+{
+        const char *name, *op, *in_name, *out_name;
+        struct thread *t = arg;
+        ssize_t ret;
+
+        info("%s: starts\n", t->filename);
+        in_name = t->in_name ? t->in_name : t->filename;
+        out_name = t->out_name ? t->out_name : t->filename;
+
+        pthread_cleanup_push(cleanup_thread, arg);
+
+        for (;;) {
+                pthread_testcancel();
+
+                ret = t->in(t, t->buf, t->buf_size);
+                if (ret > 0) {
+                        ret = t->out(t, t->buf, t->buf_size);
+                        name = out_name;
+                        op = "write";
+                } else {
+                        name = in_name;
+                        op = "read";
+                }
+
+                if (ret > 0) {
+                        /* nop */
+                } else if (!ret) {
+                        debug("%s: %s: EOF", name, op);
+                        break;
+                } else if (errno == EINTR || errno == EAGAIN) {
+                        debug("%s: %s", name, op);
+                } else {
+                        warn("%s: %s", name, op);
+                        break;
+                }
+        }
+
+        pthread_cleanup_pop(1);
+
+        t->status = ret;
+        info("%s: ends\n", t->filename);
+        return NULL;
+}
+
+static void start_thread(struct thread *t)
+{
+        debug("%s: starting\n", t->filename);
+
+        die_on(pthread_create(&t->id, NULL, start_thread_helper, t) < 0,
+               "pthread_create(%s)", t->filename);
+}
+
+static void join_thread(struct thread *t)
+{
+        int ret = pthread_join(t->id, NULL);
+
+        if (ret < 0)
+                err("%s: joining thread", t->filename);
+        else
+                debug("%s: joined\n", t->filename);
+}
+
+
+static ssize_t read_wrap(struct thread *t, void *buf, size_t nbytes)
+{
+        return read(t->fd, buf, nbytes);
+}
+
+static ssize_t write_wrap(struct thread *t, const void *buf, size_t nbytes)
+{
+        return write(t->fd, buf, nbytes);
+}
+
+
+/******************** Empty/Fill buffer routines ****************************/
+
+/* 0 -- stream of zeros, 1 -- i % 63, 2 -- pipe */
+enum pattern { PAT_ZERO, PAT_SEQ, PAT_PIPE };
+static enum pattern pattern;
+
+static ssize_t
+fill_in_buf(struct thread *ignore, void *buf, size_t nbytes)
+{
+        size_t i;
+        __u8 *p;
+
+        (void)ignore;
+
+        switch (pattern) {
+        case PAT_ZERO:
+                memset(buf, 0, nbytes);
+                break;
+
+        case PAT_SEQ:
+                for (p = buf, i = 0; i < nbytes; ++i, ++p)
+                        *p = i % 63;
+                break;
+
+        case PAT_PIPE:
+                return fread(buf, 1, nbytes, stdin);
+        }
+
+        return nbytes;
+}
+
+static ssize_t
+empty_out_buf(struct thread *ignore, const void *buf, size_t nbytes)
+{
+        const __u8 *p;
+        __u8 expected;
+        ssize_t ret;
+        size_t len;
+
+        (void)ignore;
+
+        switch (pattern) {
+        case PAT_ZERO:
+                expected = 0;
+                for (p = buf, len = 0; len < nbytes; ++p, ++len)
+                        if (*p)
+                                goto invalid;
+                break;
+
+        case PAT_SEQ:
+                for (p = buf, len = 0; len < nbytes; ++p, ++len)
+                        if (*p != len % 63) {
+                                expected = len % 63;
+                                goto invalid;
+                        }
+                break;
+
+        case PAT_PIPE:
+                ret = fwrite(buf, nbytes, 1, stdout);
+                if (ret > 0)
+                        fflush(stdout);
+                break;
+
+invalid:
+                err("bad OUT byte %zd, expected %02x got %02x\n",
+                    len, expected, *p);
+                for (p = buf, len = 0; len < nbytes; ++p, ++len) {
+                        if (0 == (len % 32))
+                                fprintf(stderr, "%4d:", len);
+                        fprintf(stderr, " %02x", *p);
+                        if (31 == (len % 32))
+                                fprintf(stderr, "\n");
+                }
+                fflush(stderr);
+                errno = EILSEQ;
+                return -1;
+        }
+
+        return len;
+}
+
+
+/******************** Endpoints routines ************************************/
+
+static void handle_setup(const struct usb_ctrlrequest *setup)
+{
+        printf("bRequestType = %d\n", setup->bRequestType);
+        printf("bRequest     = %d\n", setup->bRequest);
+        printf("wValue       = %d\n", le16_to_cpu(setup->wValue));
+        printf("wIndex       = %d\n", le16_to_cpu(setup->wIndex));
+        printf("wLength      = %d\n", le16_to_cpu(setup->wLength));
+}
+
+static ssize_t
+ep0_consume(struct thread *ignore, const void *buf, size_t nbytes)
+{
+        static const char *const names[] = {
+                [FUNCTIONFS_BIND] = "BIND",
+                [FUNCTIONFS_UNBIND] = "UNBIND",
+                [FUNCTIONFS_ENABLE] = "ENABLE",
+                [FUNCTIONFS_DISABLE] = "DISABLE",
+                [FUNCTIONFS_SETUP] = "SETUP",
+                [FUNCTIONFS_SUSPEND] = "SUSPEND",
+                [FUNCTIONFS_RESUME] = "RESUME",
+        };
+
+        const struct usb_functionfs_event *event = buf;
+        size_t n;
+
+        (void)ignore;
+
+        for (n = nbytes / sizeof *event; n; --n, ++event)
+                switch (event->type) {
+                case FUNCTIONFS_BIND:
+                case FUNCTIONFS_UNBIND:
+                case FUNCTIONFS_ENABLE:
+                case FUNCTIONFS_DISABLE:
+                case FUNCTIONFS_SETUP:
+                case FUNCTIONFS_SUSPEND:
+                case FUNCTIONFS_RESUME:
+                        printf("Event %s\n", names[event->type]);
+                        if (event->type == FUNCTIONFS_SETUP)
+                                handle_setup(&event->u.setup);
+                        break;
+
+                default:
+                        printf("Event %03u (unknown)\n", event->type);
+                }
+
+        return nbytes;
+}
+
+static void ep0_init(struct thread *t)
+{
+        ssize_t ret;
+
+        info("%s: writing descriptors\n", t->filename);
+        ret = write(t->fd, &descriptors, sizeof descriptors);
+        die_on(ret < 0, "%s: write: descriptors", t->filename);
+
+        info("%s: writing strings\n", t->filename);
+        ret = write(t->fd, &strings, sizeof strings);
+        die_on(ret < 0, "%s: write: strings", t->filename);
+}
+
+
+/******************** Main **************************************************/
+
+int main(void)
+{
+        unsigned i;
+
+        /* XXX TODO: Argument parsing missing */
+
+        init_thread(threads);
+        ep0_init(threads);
+
+        for (i = 1; i < sizeof threads / sizeof *threads; ++i)
+                init_thread(threads + i);
+
+        for (i = 1; i < sizeof threads / sizeof *threads; ++i)
+                start_thread(threads + i);
+
+        start_thread_helper(threads);
+
+        for (i = 1; i < sizeof threads / sizeof *threads; ++i)
+                join_thread(threads + i);
+
+        return 0;
+}
diff --git a/tools/usb/testusb.c b/tools/usb/testusb.c
new file mode 100644
index 000000000000..f08e89463842
--- /dev/null
+++ b/tools/usb/testusb.c
@@ -0,0 +1,547 @@
+/* $(CROSS_COMPILE)cc -Wall -Wextra -g -lpthread -o testusb testusb.c */
+
+/*
+ * Copyright (c) 2002 by David Brownell
+ * Copyright (c) 2010 by Samsung Electronics
+ * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/*
+ * This program issues ioctls to perform the tests implemented by the
+ * kernel driver.  It can generate a variety of transfer patterns; you
+ * should make sure to test both regular streaming and mixes of
+ * transfer sizes (including short transfers).
+ *
+ * For more information on how this can be used and on USB testing
+ * refer to <URL:http://www.linux-usb.org/usbtest/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <ftw.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
+#include <errno.h>
+#include <limits.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <sys/ioctl.h>
+#include <linux/usbdevice_fs.h>
+
+/*-------------------------------------------------------------------------*/
+
+#define TEST_CASES      30
+
+// FIXME make these public somewhere; usbdevfs.h?
+
+struct usbtest_param {
+        // inputs
+        unsigned                test_num;       /* 0..(TEST_CASES-1) */
+        unsigned                iterations;
+        unsigned                length;
+        unsigned                vary;
+        unsigned                sglen;
+
+        // outputs
+        struct timeval          duration;
+};
+#define USBTEST_REQUEST _IOWR('U', 100, struct usbtest_param)
+
+/*-------------------------------------------------------------------------*/
+
+/* #include <linux/usb_ch9.h> */
+
+#define USB_DT_DEVICE                   0x01
+#define USB_DT_INTERFACE                0x04
+
+#define USB_CLASS_PER_INTERFACE         0       /* for DeviceClass */
+#define USB_CLASS_VENDOR_SPEC           0xff
+
+
+struct usb_device_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+        __u16 bcdUSB;
+        __u8  bDeviceClass;
+        __u8  bDeviceSubClass;
+        __u8  bDeviceProtocol;
+        __u8  bMaxPacketSize0;
+        __u16 idVendor;
+        __u16 idProduct;
+        __u16 bcdDevice;
+        __u8  iManufacturer;
+        __u8  iProduct;
+        __u8  iSerialNumber;
+        __u8  bNumConfigurations;
+} __attribute__ ((packed));
+
+struct usb_interface_descriptor {
+        __u8  bLength;
+        __u8  bDescriptorType;
+
+        __u8  bInterfaceNumber;
+        __u8  bAlternateSetting;
+        __u8  bNumEndpoints;
+        __u8  bInterfaceClass;
+        __u8  bInterfaceSubClass;
+        __u8  bInterfaceProtocol;
+        __u8  iInterface;
+} __attribute__ ((packed));
+
+enum usb_device_speed {
+        USB_SPEED_UNKNOWN = 0,                  /* enumerating */
+        USB_SPEED_LOW, USB_SPEED_FULL,          /* usb 1.1 */
+        USB_SPEED_HIGH                          /* usb 2.0 */
+};
+
+/*-------------------------------------------------------------------------*/
+
+static char *speed (enum usb_device_speed s)
+{
+        switch (s) {
+        case USB_SPEED_UNKNOWN: return "unknown";
+        case USB_SPEED_LOW:     return "low";
+        case USB_SPEED_FULL:    return "full";
+        case USB_SPEED_HIGH:    return "high";
+        default:                return "??";
+        }
+}
+
+struct testdev {
+        struct testdev          *next;
+        char                    *name;
+        pthread_t               thread;
+        enum usb_device_speed   speed;
+        unsigned                ifnum : 8;
+        unsigned                forever : 1;
+        int                     test;
+
+        struct usbtest_param    param;
+};
+static struct testdev           *testdevs;
+
+static int testdev_ffs_ifnum(FILE *fd)
+{
+        union {
+                char buf[255];
+                struct usb_interface_descriptor intf;
+        } u;
+
+        for (;;) {
+                if (fread(u.buf, 1, 1, fd) != 1)
+                        return -1;
+                if (fread(u.buf + 1, (unsigned char)u.buf[0] - 1, 1, fd) != 1)
+                        return -1;
+
+                if (u.intf.bLength == sizeof u.intf
+                 && u.intf.bDescriptorType == USB_DT_INTERFACE
+                 && u.intf.bNumEndpoints == 2
+                 && u.intf.bInterfaceClass == USB_CLASS_VENDOR_SPEC
+                 && u.intf.bInterfaceSubClass == 0
+                 && u.intf.bInterfaceProtocol == 0)
+                        return (unsigned char)u.intf.bInterfaceNumber;
+        }
+}
+
+static int testdev_ifnum(FILE *fd)
+{
+        struct usb_device_descriptor dev;
+
+        if (fread(&dev, sizeof dev, 1, fd) != 1)
+                return -1;
+
+        if (dev.bLength != sizeof dev || dev.bDescriptorType != USB_DT_DEVICE)
+                return -1;
+
+        /* FX2 with (tweaked) bulksrc firmware */
+        if (dev.idVendor == 0x0547 && dev.idProduct == 0x1002)
+                return 0;
+
+        /*----------------------------------------------------*/
+
+        /* devices that start up using the EZ-USB default device and
+         * which we can use after loading simple firmware.  hotplug
+         * can fxload it, and then run this test driver.
+         *
+         * we return false positives in two cases:
+         * - the device has a "real" driver (maybe usb-serial) that
+         *   renumerates.  the device should vanish quickly.
+         * - the device doesn't have the test firmware installed.
+         */
+
+        /* generic EZ-USB FX controller */
+        if (dev.idVendor == 0x0547 && dev.idProduct == 0x2235)
+                return 0;
+
+        /* generic EZ-USB FX2 controller */
+        if (dev.idVendor == 0x04b4 && dev.idProduct == 0x8613)
+                return 0;
+
+        /* CY3671 development board with EZ-USB FX */
+        if (dev.idVendor == 0x0547 && dev.idProduct == 0x0080)
+                return 0;
+
+        /* Keyspan 19Qi uses an21xx (original EZ-USB) */
+        if (dev.idVendor == 0x06cd && dev.idProduct == 0x010b)
+                return 0;
+
+        /*----------------------------------------------------*/
+
+        /* "gadget zero", Linux-USB test software */
+        if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a0)
+                return 0;
+
+        /* user mode subset of that */
+        if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a4)
+                return testdev_ffs_ifnum(fd);
+                /* return 0; */
+
+        /* iso version of usermode code */
+        if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4a3)
+                return 0;
+
+        /* some GPL'd test firmware uses these IDs */
+
+        if (dev.idVendor == 0xfff0 && dev.idProduct == 0xfff0)
+                return 0;
+
+        /*----------------------------------------------------*/
+
+        /* iBOT2 high speed webcam */
+        if (dev.idVendor == 0x0b62 && dev.idProduct == 0x0059)
+                return 0;
+
+        /*----------------------------------------------------*/
+
+        /* the FunctionFS gadget can have the source/sink interface
+         * anywhere.  We look for an interface descriptor that match
+         * what we expect.  We ignore configuratiens thou. */
+
+        if (dev.idVendor == 0x0525 && dev.idProduct == 0xa4ac
+         && (dev.bDeviceClass == USB_CLASS_PER_INTERFACE
+          || dev.bDeviceClass == USB_CLASS_VENDOR_SPEC))
+                return testdev_ffs_ifnum(fd);
+
+        return -1;
+}
+
+static int find_testdev(const char *name, const struct stat *sb, int flag)
+{
+        FILE                            *fd;
+        int                             ifnum;
+        struct testdev                  *entry;
+
+        (void)sb; /* unused */
+
+        if (flag != FTW_F)
+                return 0;
+        /* ignore /proc/bus/usb/{devices,drivers} */
+        if (strrchr(name, '/')[1] == 'd')
+                return 0;
+
+        fd = fopen(name, "rb");
+        if (!fd) {
+                perror(name);
+                return 0;
+        }
+
+        ifnum = testdev_ifnum(fd);
+        fclose(fd);
+        if (ifnum < 0)
+                return 0;
+
+        entry = calloc(1, sizeof *entry);
+        if (!entry)
+                goto nomem;
+
+        entry->name = strdup(name);
+        if (!entry->name) {
+                free(entry);
+nomem:
+                perror("malloc");
+                return 0;
+        }
+
+        entry->ifnum = ifnum;
+
+        /* FIXME ask usbfs what speed; update USBDEVFS_CONNECTINFO so
+         * it tells about high speed etc */
+
+        fprintf(stderr, "%s speed\t%s\t%u\n",
+                speed(entry->speed), entry->name, entry->ifnum);
+
+        entry->next = testdevs;
+        testdevs = entry;
+        return 0;
+}
+
+static int
+usbdev_ioctl (int fd, int ifno, unsigned request, void *param)
+{
+        struct usbdevfs_ioctl   wrapper;
+
+        wrapper.ifno = ifno;
+        wrapper.ioctl_code = request;
+        wrapper.data = param;
+
+        return ioctl (fd, USBDEVFS_IOCTL, &wrapper);
+}
+
+static void *handle_testdev (void *arg)
+{
+        struct testdev          *dev = arg;
+        int                     fd, i;
+        int                     status;
+
+        if ((fd = open (dev->name, O_RDWR)) < 0) {
+                perror ("can't open dev file r/w");
+                return 0;
+        }
+
+restart:
+        for (i = 0; i < TEST_CASES; i++) {
+                if (dev->test != -1 && dev->test != i)
+                        continue;
+                dev->param.test_num = i;
+
+                status = usbdev_ioctl (fd, dev->ifnum,
+                                USBTEST_REQUEST, &dev->param);
+                if (status < 0 && errno == EOPNOTSUPP)
+                        continue;
+
+                /* FIXME need a "syslog it" option for background testing */
+
+                /* NOTE: each thread emits complete lines; no fragments! */
+                if (status < 0) {
+                        char    buf [80];
+                        int     err = errno;
+
+                        if (strerror_r (errno, buf, sizeof buf)) {
+                                snprintf (buf, sizeof buf, "error %d", err);
+                                errno = err;
+                        }
+                        printf ("%s test %d --> %d (%s)\n",
+                                dev->name, i, errno, buf);
+                } else
+                        printf ("%s test %d, %4d.%.06d secs\n", dev->name, i,
+                                (int) dev->param.duration.tv_sec,
+                                (int) dev->param.duration.tv_usec);
+
+                fflush (stdout);
+        }
+        if (dev->forever)
+                goto restart;
+
+        close (fd);
+        return arg;
+}
+
+static const char *usbfs_dir_find(void)
+{
+        static char usbfs_path_0[] = "/dev/usb/devices";
+        static char usbfs_path_1[] = "/proc/bus/usb/devices";
+
+        static char *const usbfs_paths[] = {
+                usbfs_path_0, usbfs_path_1
+        };
+
+        static char *const *
+                end = usbfs_paths + sizeof usbfs_paths / sizeof *usbfs_paths;
+
+        char *const *it = usbfs_paths;
+        do {
+                int fd = open(*it, O_RDONLY);
+                close(fd);
+                if (fd >= 0) {
+                        strrchr(*it, '/')[0] = '\0';
+                        return *it;
+                }
+        } while (++it != end);
+
+        return NULL;
+}
+
+static int parse_num(unsigned *num, const char *str)
+{
+        unsigned long val;
+        char *end;
+
+        errno = 0;
+        val = strtoul(str, &end, 0);
+        if (errno || *end || val > UINT_MAX)
+                return -1;
+        *num = val;
+        return 0;
+}
+
+int main (int argc, char **argv)
+{
+
+        int                     c;
+        struct testdev          *entry;
+        char                    *device;
+        const char              *usbfs_dir = NULL;
+        int                     all = 0, forever = 0, not = 0;
+        int                     test = -1 /* all */;
+        struct usbtest_param    param;
+
+        /* pick defaults that works with all speeds, without short packets.
+         *
+         * Best per-frame data rates:
+         *     high speed, bulk       512 * 13 * 8 = 53248
+         *                 interrupt 1024 *  3 * 8 = 24576
+         *     full speed, bulk/intr   64 * 19     =  1216
+         *                 interrupt   64 *  1     =    64
+         *      low speed, interrupt    8 *  1     =     8
+         */
+        param.iterations = 1000;
+        param.length = 512;
+        param.vary = 512;
+        param.sglen = 32;
+
+        /* for easy use when hotplugging */
+        device = getenv ("DEVICE");
+
+        while ((c = getopt (argc, argv, "D:aA:c:g:hns:t:v:")) != EOF)
+        switch (c) {
+        case 'D':       /* device, if only one */
+                device = optarg;
+                continue;
+        case 'A':       /* use all devices with specified usbfs dir */
+                usbfs_dir = optarg;
+                /* FALL THROUGH */
+        case 'a':       /* use all devices */
+                device = NULL;
+                all = 1;
+                continue;
+        case 'c':       /* count iterations */
+                if (parse_num(&param.iterations, optarg))
+                        goto usage;
+                continue;
+        case 'g':       /* scatter/gather entries */
+                if (parse_num(&param.sglen, optarg))
+                        goto usage;
+                continue;
+        case 'l':       /* loop forever */
+                forever = 1;
+                continue;
+        case 'n':       /* no test running! */
+                not = 1;
+                continue;
+        case 's':       /* size of packet */
+                if (parse_num(&param.length, optarg))
+                        goto usage;
+                continue;
+        case 't':       /* run just one test */
+                test = atoi (optarg);
+                if (test < 0)
+                        goto usage;
+                continue;
+        case 'v':       /* vary packet size by ... */
+                if (parse_num(&param.vary, optarg))
+                        goto usage;
+                continue;
+        case '?':
+        case 'h':
+        default:
+usage:
+                fprintf (stderr, "usage: %s [-n] [-D dev | -a | -A usbfs-dir]\n"
+                        "\t[-c iterations]  [-t testnum]\n"
+                        "\t[-s packetsize] [-g sglen] [-v vary]\n",
+                        argv [0]);
+                return 1;
+        }
+        if (optind != argc)
+                goto usage;
+        if (!all && !device) {
+                fprintf (stderr, "must specify '-a' or '-D dev', "
+                        "or DEVICE=/proc/bus/usb/BBB/DDD in env\n");
+                goto usage;
+        }
+
+        /* Find usbfs mount point */
+        if (!usbfs_dir) {
+                usbfs_dir = usbfs_dir_find();
+                if (!usbfs_dir) {
+                        fputs ("usbfs files are missing\n", stderr);
+                        return -1;
+                }
+        }
+
+        /* collect and list the test devices */
+        if (ftw (usbfs_dir, find_testdev, 3) != 0) {
+                fputs ("ftw failed; is usbfs missing?\n", stderr);
+                return -1;
+        }
+
+        /* quit, run single test, or create test threads */
+        if (!testdevs && !device) {
+                fputs ("no test devices recognized\n", stderr);
+                return -1;
+        }
+        if (not)
+                return 0;
+        if (testdevs && testdevs->next == 0 && !device)
+                device = testdevs->name;
+        for (entry = testdevs; entry; entry = entry->next) {
+                int     status;
+
+                entry->param = param;
+                entry->forever = forever;
+                entry->test = test;
+
+                if (device) {
+                        if (strcmp (entry->name, device))
+                                continue;
+                        return handle_testdev (entry) != entry;
+                }
+                status = pthread_create (&entry->thread, 0, handle_testdev, entry);
+                if (status) {
+                        perror ("pthread_create");
+                        continue;
+                }
+        }
+        if (device) {
+                struct testdev          dev;
+
+                /* kernel can recognize test devices we don't */
+                fprintf (stderr, "%s: %s may see only control tests\n",
+                                argv [0], device);
+
+                memset (&dev, 0, sizeof dev);
+                dev.name = device;
+                dev.param = param;
+                dev.forever = forever;
+                dev.test = test;
+                return handle_testdev (&dev) != &dev;
+        }
+
+        /* wait for tests to complete */
+        for (entry = testdevs; entry; entry = entry->next) {
+                void    *retval;
+
+                if (pthread_join (entry->thread, &retval))
+                        perror ("pthread_join");
+                /* testing errors discarded! */
+        }
+
+        return 0;
+}