Merge branch 'perfcounters-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'perfcounters-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (47 commits)
  perf report: Add --symbols parameter
  perf report: Add --comms parameter
  perf report: Add --dsos parameter
  perf_counter tools: Adjust only prelinked symbol's addresses
  perf_counter: Provide a way to enable counters on exec
  perf_counter tools: Reduce perf stat measurement overhead/skew
  perf stat: Use percentages for scaling output
  perf_counter, x86: Update x86_pmu after WARN()
  perf stat: Micro-optimize the code: memcpy is only required if no event is selected and !null_run
  perf stat: Improve output
  perf stat: Fix multi-run stats
  perf stat: Add -n/--null option to run without counters
  perf_counter tools: Remove dead code
  perf_counter: Complete counter swap
  perf report: Print sorted callchains per histogram entries
  perf_counter tools: Prepare a small callchain framework
  perf record: Fix unhandled io return value
  perf_counter tools: Add alias for 'l1d' and 'l1i'
  perf-report: Add bare minimum PERF_EVENT_READ parsing
  perf-report: Add modes for inherited stats and no-samples
  ...

17 files changed, 845 insertions, 187 deletions

diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
new file mode 100644
index 000000000000..ad3c28578961
--- /dev/null
+++ b/tools/perf/util/callchain.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2009, Frederic Weisbecker <fweisbec@gmail.com>
+ *
+ * Handle the callchains from the stream in an ad-hoc radix tree and then
+ * sort them in an rbtree.
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <errno.h>
+
+#include "callchain.h"
+
+
+static void rb_insert_callchain(struct rb_root *root, struct callchain_node *chain)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct callchain_node *rnode;
+
+        while (*p) {
+                parent = *p;
+                rnode = rb_entry(parent, struct callchain_node, rb_node);
+
+                if (rnode->hit < chain->hit)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&chain->rb_node, parent, p);
+        rb_insert_color(&chain->rb_node, root);
+}
+
+/*
+ * Once we get every callchains from the stream, we can now
+ * sort them by hit
+ */
+void sort_chain_to_rbtree(struct rb_root *rb_root, struct callchain_node *node)
+{
+        struct callchain_node *child;
+
+        list_for_each_entry(child, &node->children, brothers)
+                sort_chain_to_rbtree(rb_root, child);
+
+        if (node->hit)
+                rb_insert_callchain(rb_root, node);
+}
+
+static struct callchain_node *create_child(struct callchain_node *parent)
+{
+        struct callchain_node *new;
+
+        new = malloc(sizeof(*new));
+        if (!new) {
+                perror("not enough memory to create child for code path tree");
+                return NULL;
+        }
+        new->parent = parent;
+        INIT_LIST_HEAD(&new->children);
+        INIT_LIST_HEAD(&new->val);
+        list_add_tail(&new->brothers, &parent->children);
+
+        return new;
+}
+
+static void
+fill_node(struct callchain_node *node, struct ip_callchain *chain, int start)
+{
+        int i;
+
+        for (i = start; i < chain->nr; i++) {
+                struct callchain_list *call;
+
+                call = malloc(sizeof(*chain));
+                if (!call) {
+                        perror("not enough memory for the code path tree");
+                        return;
+                }
+                call->ip = chain->ips[i];
+                list_add_tail(&call->list, &node->val);
+        }
+        node->val_nr = i - start;
+}
+
+static void add_child(struct callchain_node *parent, struct ip_callchain *chain)
+{
+        struct callchain_node *new;
+
+        new = create_child(parent);
+        fill_node(new, chain, parent->val_nr);
+
+        new->hit = 1;
+}
+
+static void
+split_add_child(struct callchain_node *parent, struct ip_callchain *chain,
+                struct callchain_list *to_split, int idx)
+{
+        struct callchain_node *new;
+
+        /* split */
+        new = create_child(parent);
+        list_move_tail(&to_split->list, &new->val);
+        new->hit = parent->hit;
+        parent->hit = 0;
+        parent->val_nr = idx;
+
+        /* create the new one */
+        add_child(parent, chain);
+}
+
+static int
+__append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                int start);
+
+static int
+__append_chain_children(struct callchain_node *root, struct ip_callchain *chain)
+{
+        struct callchain_node *rnode;
+
+        /* lookup in childrens */
+        list_for_each_entry(rnode, &root->children, brothers) {
+                int ret = __append_chain(rnode, chain, root->val_nr);
+                if (!ret)
+                        return 0;
+        }
+        return -1;
+}
+
+static int
+__append_chain(struct callchain_node *root, struct ip_callchain *chain,
+                int start)
+{
+        struct callchain_list *cnode;
+        int i = start;
+        bool found = false;
+
+        /* lookup in the current node */
+        list_for_each_entry(cnode, &root->val, list) {
+                if (cnode->ip != chain->ips[i++])
+                        break;
+                if (!found)
+                        found = true;
+                if (i == chain->nr)
+                        break;
+        }
+
+        /* matches not, relay on the parent */
+        if (!found)
+                return -1;
+
+        /* we match only a part of the node. Split it and add the new chain */
+        if (i < root->val_nr) {
+                split_add_child(root, chain, cnode, i);
+                return 0;
+        }
+
+        /* we match 100% of the path, increment the hit */
+        if (i == root->val_nr) {
+                root->hit++;
+                return 0;
+        }
+
+        return __append_chain_children(root, chain);
+}
+
+void append_chain(struct callchain_node *root, struct ip_callchain *chain)
+{
+        if (__append_chain_children(root, chain) == -1)
+                add_child(root, chain);
+}
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
new file mode 100644
index 000000000000..fa1cd2f71fd3
--- /dev/null
+++ b/tools/perf/util/callchain.h
@@ -0,0 +1,33 @@
+#ifndef __PERF_CALLCHAIN_H
+#define __PERF_CALLCHAIN_H
+
+#include "../perf.h"
+#include "list.h"
+#include "rbtree.h"
+
+
+struct callchain_node {
+        struct callchain_node   *parent;
+        struct list_head        brothers;
+        struct list_head        children;
+        struct list_head        val;
+        struct rb_node          rb_node;
+        int                     val_nr;
+        int                     hit;
+};
+
+struct callchain_list {
+        unsigned long           ip;
+        struct list_head        list;
+};
+
+static inline void callchain_init(struct callchain_node *node)
+{
+        INIT_LIST_HEAD(&node->brothers);
+        INIT_LIST_HEAD(&node->children);
+        INIT_LIST_HEAD(&node->val);
+}
+
+void append_chain(struct callchain_node *root, struct ip_callchain *chain);
+void sort_chain_to_rbtree(struct rb_root *rb_root, struct callchain_node *node);
+#endif
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
new file mode 100644
index 000000000000..450384b3bbe5
--- /dev/null
+++ b/tools/perf/util/header.c
@@ -0,0 +1,242 @@
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "util.h"
+#include "header.h"
+
+/*
+ *
+ */
+
+struct perf_header_attr *perf_header_attr__new(struct perf_counter_attr *attr)
+{
+        struct perf_header_attr *self = malloc(sizeof(*self));
+
+        if (!self)
+                die("nomem");
+
+        self->attr = *attr;
+        self->ids = 0;
+        self->size = 1;
+        self->id = malloc(sizeof(u64));
+
+        if (!self->id)
+                die("nomem");
+
+        return self;
+}
+
+void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
+{
+        int pos = self->ids;
+
+        self->ids++;
+        if (self->ids > self->size) {
+                self->size *= 2;
+                self->id = realloc(self->id, self->size * sizeof(u64));
+                if (!self->id)
+                        die("nomem");
+        }
+        self->id[pos] = id;
+}
+
+/*
+ *
+ */
+
+struct perf_header *perf_header__new(void)
+{
+        struct perf_header *self = malloc(sizeof(*self));
+
+        if (!self)
+                die("nomem");
+
+        self->frozen = 0;
+
+        self->attrs = 0;
+        self->size = 1;
+        self->attr = malloc(sizeof(void *));
+
+        if (!self->attr)
+                die("nomem");
+
+        self->data_offset = 0;
+        self->data_size = 0;
+
+        return self;
+}
+
+void perf_header__add_attr(struct perf_header *self,
+                           struct perf_header_attr *attr)
+{
+        int pos = self->attrs;
+
+        if (self->frozen)
+                die("frozen");
+
+        self->attrs++;
+        if (self->attrs > self->size) {
+                self->size *= 2;
+                self->attr = realloc(self->attr, self->size * sizeof(void *));
+                if (!self->attr)
+                        die("nomem");
+        }
+        self->attr[pos] = attr;
+}
+
+static const char *__perf_magic = "PERFFILE";
+
+#define PERF_MAGIC      (*(u64 *)__perf_magic)
+
+struct perf_file_section {
+        u64 offset;
+        u64 size;
+};
+
+struct perf_file_attr {
+        struct perf_counter_attr        attr;
+        struct perf_file_section        ids;
+};
+
+struct perf_file_header {
+        u64                             magic;
+        u64                             size;
+        u64                             attr_size;
+        struct perf_file_section        attrs;
+        struct perf_file_section        data;
+};
+
+static void do_write(int fd, void *buf, size_t size)
+{
+        while (size) {
+                int ret = write(fd, buf, size);
+
+                if (ret < 0)
+                        die("failed to write");
+
+                size -= ret;
+                buf += ret;
+        }
+}
+
+void perf_header__write(struct perf_header *self, int fd)
+{
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        struct perf_header_attr *attr;
+        int i;
+
+        lseek(fd, sizeof(f_header), SEEK_SET);
+
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                attr->id_offset = lseek(fd, 0, SEEK_CUR);
+                do_write(fd, attr->id, attr->ids * sizeof(u64));
+        }
+
+
+        self->attr_offset = lseek(fd, 0, SEEK_CUR);
+
+        for (i = 0; i < self->attrs; i++) {
+                attr = self->attr[i];
+
+                f_attr = (struct perf_file_attr){
+                        .attr = attr->attr,
+                        .ids  = {
+                                .offset = attr->id_offset,
+                                .size   = attr->ids * sizeof(u64),
+                        }
+                };
+                do_write(fd, &f_attr, sizeof(f_attr));
+        }
+
+
+        self->data_offset = lseek(fd, 0, SEEK_CUR);
+
+        f_header = (struct perf_file_header){
+                .magic     = PERF_MAGIC,
+                .size      = sizeof(f_header),
+                .attr_size = sizeof(f_attr),
+                .attrs = {
+                        .offset = self->attr_offset,
+                        .size   = self->attrs * sizeof(f_attr),
+                },
+                .data = {
+                        .offset = self->data_offset,
+                        .size   = self->data_size,
+                },
+        };
+
+        lseek(fd, 0, SEEK_SET);
+        do_write(fd, &f_header, sizeof(f_header));
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        self->frozen = 1;
+}
+
+static void do_read(int fd, void *buf, size_t size)
+{
+        while (size) {
+                int ret = read(fd, buf, size);
+
+                if (ret < 0)
+                        die("failed to read");
+
+                size -= ret;
+                buf += ret;
+        }
+}
+
+struct perf_header *perf_header__read(int fd)
+{
+        struct perf_header      *self = perf_header__new();
+        struct perf_file_header f_header;
+        struct perf_file_attr   f_attr;
+        u64                     f_id;
+
+        int nr_attrs, nr_ids, i, j;
+
+        lseek(fd, 0, SEEK_SET);
+        do_read(fd, &f_header, sizeof(f_header));
+
+        if (f_header.magic      != PERF_MAGIC           ||
+            f_header.size       != sizeof(f_header)     ||
+            f_header.attr_size  != sizeof(f_attr))
+                die("incompatible file format");
+
+        nr_attrs = f_header.attrs.size / sizeof(f_attr);
+        lseek(fd, f_header.attrs.offset, SEEK_SET);
+
+        for (i = 0; i < nr_attrs; i++) {
+                struct perf_header_attr *attr;
+                off_t tmp = lseek(fd, 0, SEEK_CUR);
+
+                do_read(fd, &f_attr, sizeof(f_attr));
+
+                attr = perf_header_attr__new(&f_attr.attr);
+
+                nr_ids = f_attr.ids.size / sizeof(u64);
+                lseek(fd, f_attr.ids.offset, SEEK_SET);
+
+                for (j = 0; j < nr_ids; j++) {
+                        do_read(fd, &f_id, sizeof(f_id));
+
+                        perf_header_attr__add_id(attr, f_id);
+                }
+                perf_header__add_attr(self, attr);
+                lseek(fd, tmp, SEEK_SET);
+        }
+
+        self->data_offset = f_header.data.offset;
+        self->data_size   = f_header.data.size;
+
+        lseek(fd, self->data_offset + self->data_size, SEEK_SET);
+
+        self->frozen = 1;
+
+        return self;
+}
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
new file mode 100644
index 000000000000..b5ef53ad4c7a
--- /dev/null
+++ b/tools/perf/util/header.h
@@ -0,0 +1,37 @@
+#ifndef _PERF_HEADER_H
+#define _PERF_HEADER_H
+
+#include "../../../include/linux/perf_counter.h"
+#include <sys/types.h>
+#include "types.h"
+
+struct perf_header_attr {
+        struct perf_counter_attr attr;
+        int ids, size;
+        u64 *id;
+        off_t id_offset;
+};
+
+struct perf_header {
+        int frozen;
+        int attrs, size;
+        struct perf_header_attr **attr;
+        off_t attr_offset;
+        u64 data_offset;
+        u64 data_size;
+};
+
+struct perf_header *perf_header__read(int fd);
+void perf_header__write(struct perf_header *self, int fd);
+
+void perf_header__add_attr(struct perf_header *self,
+                           struct perf_header_attr *attr);
+
+struct perf_header_attr *
+perf_header_attr__new(struct perf_counter_attr *attr);
+void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
+
+
+struct perf_header *perf_header__new(void);
+
+#endif /* _PERF_HEADER_H */
diff --git a/tools/perf/util/help.c b/tools/perf/util/help.c
index 6653f7dd1d78..17a00e0df2c4 100644
--- a/tools/perf/util/help.c
+++ b/tools/perf/util/help.c
@@ -126,21 +126,6 @@ static int is_executable(const char *name)
             !S_ISREG(st.st_mode))
                 return 0;
 
-#ifdef __MINGW32__
-        /* cannot trust the executable bit, peek into the file instead */
-        char buf[3] = { 0 };
-        int n;
-        int fd = open(name, O_RDONLY);
-        st.st_mode &= ~S_IXUSR;
-        if (fd >= 0) {
-                n = read(fd, buf, 2);
-                if (n == 2)
-                        /* DOS executables start with "MZ" */
-                        if (!strcmp(buf, "#!") || !strcmp(buf, "MZ"))
-                                st.st_mode |= S_IXUSR;
-                close(fd);
-        }
-#endif
         return st.st_mode & S_IXUSR;
 }
 
diff --git a/tools/perf/util/pager.c b/tools/perf/util/pager.c
index a28bccae5458..1915de20dcac 100644
--- a/tools/perf/util/pager.c
+++ b/tools/perf/util/pager.c
@@ -9,7 +9,6 @@
 
 static int spawned_pager;
 
-#ifndef __MINGW32__
 static void pager_preexec(void)
 {
         /*
@@ -24,7 +23,6 @@ static void pager_preexec(void)
 
         setenv("LESS", "FRSX", 0);
 }
-#endif
 
 static const char *pager_argv[] = { "sh", "-c", NULL, NULL };
 static struct child_process pager_process;
@@ -70,9 +68,8 @@ void setup_pager(void)
         pager_argv[2] = pager;
         pager_process.argv = pager_argv;
         pager_process.in = -1;
-#ifndef __MINGW32__
         pager_process.preexec_cb = pager_preexec;
-#endif
+
         if (start_command(&pager_process))
                 return;
 
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 35d04da38d6a..4d042f104cdc 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -16,32 +16,28 @@ struct event_symbol {
         u8      type;
         u64     config;
         char    *symbol;
+        char    *alias;
 };
 
-#define C(x, y) .type = PERF_TYPE_##x, .config = PERF_COUNT_##y
-#define CR(x, y) .type = PERF_TYPE_##x, .config = y
+#define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
+#define CSW(x) .type = PERF_TYPE_SOFTWARE, .config = PERF_COUNT_SW_##x
 
 static struct event_symbol event_symbols[] = {
-  { C(HARDWARE, HW_CPU_CYCLES),         "cpu-cycles",           },
-  { C(HARDWARE, HW_CPU_CYCLES),         "cycles",               },
-  { C(HARDWARE, HW_INSTRUCTIONS),       "instructions",         },
-  { C(HARDWARE, HW_CACHE_REFERENCES),   "cache-references",     },
-  { C(HARDWARE, HW_CACHE_MISSES),       "cache-misses",         },
-  { C(HARDWARE, HW_BRANCH_INSTRUCTIONS),"branch-instructions",  },
-  { C(HARDWARE, HW_BRANCH_INSTRUCTIONS),"branches",             },
-  { C(HARDWARE, HW_BRANCH_MISSES),      "branch-misses",        },
-  { C(HARDWARE, HW_BUS_CYCLES),         "bus-cycles",           },
-
-  { C(SOFTWARE, SW_CPU_CLOCK),          "cpu-clock",            },
-  { C(SOFTWARE, SW_TASK_CLOCK),         "task-clock",           },
-  { C(SOFTWARE, SW_PAGE_FAULTS),        "page-faults",          },
-  { C(SOFTWARE, SW_PAGE_FAULTS),        "faults",               },
-  { C(SOFTWARE, SW_PAGE_FAULTS_MIN),    "minor-faults",         },
-  { C(SOFTWARE, SW_PAGE_FAULTS_MAJ),    "major-faults",         },
-  { C(SOFTWARE, SW_CONTEXT_SWITCHES),   "context-switches",     },
-  { C(SOFTWARE, SW_CONTEXT_SWITCHES),   "cs",                   },
-  { C(SOFTWARE, SW_CPU_MIGRATIONS),     "cpu-migrations",       },
-  { C(SOFTWARE, SW_CPU_MIGRATIONS),     "migrations",           },
+  { CHW(CPU_CYCLES),            "cpu-cycles",           "cycles"        },
+  { CHW(INSTRUCTIONS),          "instructions",         ""              },
+  { CHW(CACHE_REFERENCES),      "cache-references",     ""              },
+  { CHW(CACHE_MISSES),          "cache-misses",         ""              },
+  { CHW(BRANCH_INSTRUCTIONS),   "branch-instructions",  "branches"      },
+  { CHW(BRANCH_MISSES),         "branch-misses",        ""              },
+  { CHW(BUS_CYCLES),            "bus-cycles",           ""              },
+
+  { CSW(CPU_CLOCK),             "cpu-clock",            ""              },
+  { CSW(TASK_CLOCK),            "task-clock",           ""              },
+  { CSW(PAGE_FAULTS),           "page-faults",          "faults"        },
+  { CSW(PAGE_FAULTS_MIN),       "minor-faults",         ""              },
+  { CSW(PAGE_FAULTS_MAJ),       "major-faults",         ""              },
+  { CSW(CONTEXT_SWITCHES),      "context-switches",     "cs"            },
+  { CSW(CPU_MIGRATIONS),        "cpu-migrations",       "migrations"    },
 };
 
 #define __PERF_COUNTER_FIELD(config, name) \
@@ -74,26 +70,70 @@ static char *sw_event_names[] = {
 
 #define MAX_ALIASES 8
 
-static char *hw_cache [][MAX_ALIASES] = {
-        { "L1-data"             , "l1-d", "l1d"                                 },
-        { "L1-instruction"      , "l1-i", "l1i"                                 },
-        { "L2"                  , "l2"                                          },
-        { "Data-TLB"            , "dtlb", "d-tlb"                               },
-        { "Instruction-TLB"     , "itlb", "i-tlb"                               },
-        { "Branch"              , "bpu" , "btb", "bpc"                          },
+static char *hw_cache[][MAX_ALIASES] = {
+ { "L1-d$",     "l1-d",         "l1d",          "L1-data",              },
+ { "L1-i$",     "l1-i",         "l1i",          "L1-instruction",       },
+ { "LLC",       "L2"                                                    },
+ { "dTLB",      "d-tlb",        "Data-TLB",                             },
+ { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
+ { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
 };
 
-static char *hw_cache_op [][MAX_ALIASES] = {
-        { "Load"                , "read"                                        },
-        { "Store"               , "write"                                       },
-        { "Prefetch"            , "speculative-read", "speculative-load"        },
+static char *hw_cache_op[][MAX_ALIASES] = {
+ { "load",      "loads",        "read",                                 },
+ { "store",     "stores",       "write",                                },
+ { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
 };
 
-static char *hw_cache_result [][MAX_ALIASES] = {
-        { "Reference"           , "ops", "access"                               },
-        { "Miss"                                                                },
+static char *hw_cache_result[][MAX_ALIASES] = {
+ { "refs",      "Reference",    "ops",          "access",               },
+ { "misses",    "miss",                                                 },
 };
 
+#define C(x)            PERF_COUNT_HW_CACHE_##x
+#define CACHE_READ      (1 << C(OP_READ))
+#define CACHE_WRITE     (1 << C(OP_WRITE))
+#define CACHE_PREFETCH  (1 << C(OP_PREFETCH))
+#define COP(x)          (1 << x)
+
+/*
+ * cache operartion stat
+ * L1I : Read and prefetch only
+ * ITLB and BPU : Read-only
+ */
+static unsigned long hw_cache_stat[C(MAX)] = {
+ [C(L1D)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(L1I)]       = (CACHE_READ | CACHE_PREFETCH),
+ [C(LL)]        = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(DTLB)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+ [C(ITLB)]      = (CACHE_READ),
+ [C(BPU)]       = (CACHE_READ),
+};
+
+static int is_cache_op_valid(u8 cache_type, u8 cache_op)
+{
+        if (hw_cache_stat[cache_type] & COP(cache_op))
+                return 1;       /* valid */
+        else
+                return 0;       /* invalid */
+}
+
+static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
+{
+        static char name[50];
+
+        if (cache_result) {
+                sprintf(name, "%s-%s-%s", hw_cache[cache_type][0],
+                        hw_cache_op[cache_op][0],
+                        hw_cache_result[cache_result][0]);
+        } else {
+                sprintf(name, "%s-%s", hw_cache[cache_type][0],
+                        hw_cache_op[cache_op][1]);
+        }
+
+        return name;
+}
+
 char *event_name(int counter)
 {
         u64 config = attrs[counter].config;
@@ -113,7 +153,6 @@ char *event_name(int counter)
 
         case PERF_TYPE_HW_CACHE: {
                 u8 cache_type, cache_op, cache_result;
-                static char name[100];
 
                 cache_type   = (config >>  0) & 0xff;
                 if (cache_type > PERF_COUNT_HW_CACHE_MAX)
@@ -127,12 +166,10 @@ char *event_name(int counter)
                 if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
                         return "unknown-ext-hardware-cache-result";
 
-                sprintf(name, "%s-Cache-%s-%ses",
-                        hw_cache[cache_type][0],
-                        hw_cache_op[cache_op][0],
-                        hw_cache_result[cache_result][0]);
+                if (!is_cache_op_valid(cache_type, cache_op))
+                        return "invalid-cache";
 
-                return name;
+                return event_cache_name(cache_type, cache_op, cache_result);
         }
 
         case PERF_TYPE_SOFTWARE:
@@ -163,7 +200,8 @@ static int parse_aliases(const char *str, char *names[][MAX_ALIASES], int size)
         return -1;
 }
 
-static int parse_generic_hw_symbols(const char *str, struct perf_counter_attr *attr)
+static int
+parse_generic_hw_symbols(const char *str, struct perf_counter_attr *attr)
 {
         int cache_type = -1, cache_op = 0, cache_result = 0;
 
@@ -182,6 +220,9 @@ static int parse_generic_hw_symbols(const char *str, struct perf_counter_attr *a
         if (cache_op == -1)
                 cache_op = PERF_COUNT_HW_CACHE_OP_READ;
 
+        if (!is_cache_op_valid(cache_type, cache_op))
+                return -EINVAL;
+
         cache_result = parse_aliases(str, hw_cache_result,
                                         PERF_COUNT_HW_CACHE_RESULT_MAX);
         /*
@@ -196,6 +237,19 @@ static int parse_generic_hw_symbols(const char *str, struct perf_counter_attr *a
         return 0;
 }
 
+static int check_events(const char *str, unsigned int i)
+{
+        if (!strncmp(str, event_symbols[i].symbol,
+                     strlen(event_symbols[i].symbol)))
+                return 1;
+
+        if (strlen(event_symbols[i].alias))
+                if (!strncmp(str, event_symbols[i].alias,
+                             strlen(event_symbols[i].alias)))
+                        return 1;
+        return 0;
+}
+
 /*
  * Each event can have multiple symbolic names.
  * Symbolic names are (almost) exactly matched.
@@ -235,9 +289,7 @@ static int parse_event_symbols(const char *str, struct perf_counter_attr *attr)
         }
 
         for (i = 0; i < ARRAY_SIZE(event_symbols); i++) {
-                if (!strncmp(str, event_symbols[i].symbol,
-                             strlen(event_symbols[i].symbol))) {
-
+                if (check_events(str, i)) {
                         attr->type = event_symbols[i].type;
                         attr->config = event_symbols[i].config;
 
@@ -289,6 +341,7 @@ void print_events(void)
 {
         struct event_symbol *syms = event_symbols;
         unsigned int i, type, prev_type = -1;
+        char name[40];
 
         fprintf(stderr, "\n");
         fprintf(stderr, "List of pre-defined events (to be used in -e):\n");
@@ -301,14 +354,18 @@ void print_events(void)
                 if (type != prev_type)
                         fprintf(stderr, "\n");
 
-                fprintf(stderr, "  %-30s [%s]\n", syms->symbol,
+                if (strlen(syms->alias))
+                        sprintf(name, "%s OR %s", syms->symbol, syms->alias);
+                else
+                        strcpy(name, syms->symbol);
+                fprintf(stderr, "  %-40s [%s]\n", name,
                         event_type_descriptors[type]);
 
                 prev_type = type;
         }
 
         fprintf(stderr, "\n");
-        fprintf(stderr, "  %-30s [raw hardware event descriptor]\n",
+        fprintf(stderr, "  %-40s [raw hardware event descriptor]\n",
                 "rNNN");
         fprintf(stderr, "\n");
 
diff --git a/tools/perf/util/run-command.c b/tools/perf/util/run-command.c
index b2f5e854f40a..a3935343091a 100644
--- a/tools/perf/util/run-command.c
+++ b/tools/perf/util/run-command.c
@@ -65,7 +65,6 @@ int start_command(struct child_process *cmd)
                 cmd->err = fderr[0];
         }
 
-#ifndef __MINGW32__
         fflush(NULL);
         cmd->pid = fork();
         if (!cmd->pid) {
@@ -118,71 +117,6 @@ int start_command(struct child_process *cmd)
                 }
                 exit(127);
         }
-#else
-        int s0 = -1, s1 = -1, s2 = -1;  /* backups of stdin, stdout, stderr */
-        const char **sargv = cmd->argv;
-        char **env = environ;
-
-        if (cmd->no_stdin) {
-                s0 = dup(0);
-                dup_devnull(0);
-        } else if (need_in) {
-                s0 = dup(0);
-                dup2(fdin[0], 0);
-        } else if (cmd->in) {
-                s0 = dup(0);
-                dup2(cmd->in, 0);
-        }
-
-        if (cmd->no_stderr) {
-                s2 = dup(2);
-                dup_devnull(2);
-        } else if (need_err) {
-                s2 = dup(2);
-                dup2(fderr[1], 2);
-        }
-
-        if (cmd->no_stdout) {
-                s1 = dup(1);
-                dup_devnull(1);
-        } else if (cmd->stdout_to_stderr) {
-                s1 = dup(1);
-                dup2(2, 1);
-        } else if (need_out) {
-                s1 = dup(1);
-                dup2(fdout[1], 1);
-        } else if (cmd->out > 1) {
-                s1 = dup(1);
-                dup2(cmd->out, 1);
-        }
-
-        if (cmd->dir)
-                die("chdir in start_command() not implemented");
-        if (cmd->env) {
-                env = copy_environ();
-                for (; *cmd->env; cmd->env++)
-                        env = env_setenv(env, *cmd->env);
-        }
-
-        if (cmd->perf_cmd) {
-                cmd->argv = prepare_perf_cmd(cmd->argv);
-        }
-
-        cmd->pid = mingw_spawnvpe(cmd->argv[0], cmd->argv, env);
-
-        if (cmd->env)
-                free_environ(env);
-        if (cmd->perf_cmd)
-                free(cmd->argv);
-
-        cmd->argv = sargv;
-        if (s0 >= 0)
-                dup2(s0, 0), close(s0);
-        if (s1 >= 0)
-                dup2(s1, 1), close(s1);
-        if (s2 >= 0)
-                dup2(s2, 2), close(s2);
-#endif
 
         if (cmd->pid < 0) {
                 int err = errno;
@@ -288,14 +222,6 @@ int run_command_v_opt_cd_env(const char **argv, int opt, const char *dir, const
         return run_command(&cmd);
 }
 
-#ifdef __MINGW32__
-static __stdcall unsigned run_thread(void *data)
-{
-        struct async *async = data;
-        return async->proc(async->fd_for_proc, async->data);
-}
-#endif
-
 int start_async(struct async *async)
 {
         int pipe_out[2];
@@ -304,7 +230,6 @@ int start_async(struct async *async)
                 return error("cannot create pipe: %s", strerror(errno));
         async->out = pipe_out[0];
 
-#ifndef __MINGW32__
         /* Flush stdio before fork() to avoid cloning buffers */
         fflush(NULL);
 
@@ -319,33 +244,17 @@ int start_async(struct async *async)
                 exit(!!async->proc(pipe_out[1], async->data));
         }
         close(pipe_out[1]);
-#else
-        async->fd_for_proc = pipe_out[1];
-        async->tid = (HANDLE) _beginthreadex(NULL, 0, run_thread, async, 0, NULL);
-        if (!async->tid) {
-                error("cannot create thread: %s", strerror(errno));
-                close_pair(pipe_out);
-                return -1;
-        }
-#endif
+
         return 0;
 }
 
 int finish_async(struct async *async)
 {
-#ifndef __MINGW32__
         int ret = 0;
 
         if (wait_or_whine(async->pid))
                 ret = error("waitpid (async) failed");
-#else
-        DWORD ret = 0;
-        if (WaitForSingleObject(async->tid, INFINITE) != WAIT_OBJECT_0)
-                ret = error("waiting for thread failed: %lu", GetLastError());
-        else if (!GetExitCodeThread(async->tid, &ret))
-                ret = error("cannot get thread exit code: %lu", GetLastError());
-        CloseHandle(async->tid);
-#endif
+
         return ret;
 }
 
diff --git a/tools/perf/util/run-command.h b/tools/perf/util/run-command.h
index 328289f23669..cc1837deba88 100644
--- a/tools/perf/util/run-command.h
+++ b/tools/perf/util/run-command.h
@@ -79,12 +79,7 @@ struct async {
         int (*proc)(int fd, void *data);
         void *data;
         int out;        /* caller reads from here and closes it */
-#ifndef __MINGW32__
         pid_t pid;
-#else
-        HANDLE tid;
-        int fd_for_proc;
-#endif
 };
 
 int start_async(struct async *async);
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index eaba09306802..464e7ca898cf 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -259,7 +259,7 @@ size_t strbuf_fread(struct strbuf *sb, size_t size, FILE *f)
         res = fread(sb->buf + sb->len, 1, size, f);
         if (res > 0)
                 strbuf_setlen(sb, sb->len + res);
-        else if (res < 0 && oldalloc == 0)
+        else if (oldalloc == 0)
                 strbuf_release(sb);
         return res;
 }
diff --git a/tools/perf/util/string.h b/tools/perf/util/string.h
index 37b03255b425..3dca2f654cd0 100644
--- a/tools/perf/util/string.h
+++ b/tools/perf/util/string.h
@@ -1,7 +1,7 @@
 #ifndef _PERF_STRING_H_
 #define _PERF_STRING_H_
 
-#include "../types.h"
+#include "types.h"
 
 int hex2u64(const char *ptr, u64 *val);
 
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
new file mode 100644
index 000000000000..025a78edfffe
--- /dev/null
+++ b/tools/perf/util/strlist.c
@@ -0,0 +1,184 @@
+/*
+ * (c) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
+ *
+ * Licensed under the GPLv2.
+ */
+
+#include "strlist.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct str_node *str_node__new(const char *s, bool dupstr)
+{
+        struct str_node *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                if (dupstr) {
+                        s = strdup(s);
+                        if (s == NULL)
+                                goto out_delete;
+                }
+                self->s = s;
+        }
+
+        return self;
+
+out_delete:
+        free(self);
+        return NULL;
+}
+
+static void str_node__delete(struct str_node *self, bool dupstr)
+{
+        if (dupstr)
+                free((void *)self->s);
+        free(self);
+}
+
+int strlist__add(struct strlist *self, const char *new_entry)
+{
+        struct rb_node **p = &self->entries.rb_node;
+        struct rb_node *parent = NULL;
+        struct str_node *sn;
+
+        while (*p != NULL) {
+                int rc;
+
+                parent = *p;
+                sn = rb_entry(parent, struct str_node, rb_node);
+                rc = strcmp(sn->s, new_entry);
+
+                if (rc > 0)
+                        p = &(*p)->rb_left;
+                else if (rc < 0)
+                        p = &(*p)->rb_right;
+                else
+                        return -EEXIST;
+        }
+
+        sn = str_node__new(new_entry, self->dupstr);
+        if (sn == NULL)
+                return -ENOMEM;
+
+        rb_link_node(&sn->rb_node, parent, p);
+        rb_insert_color(&sn->rb_node, &self->entries);
+
+        return 0;
+}
+
+int strlist__load(struct strlist *self, const char *filename)
+{
+        char entry[1024];
+        int err;
+        FILE *fp = fopen(filename, "r");
+
+        if (fp == NULL)
+                return errno;
+
+        while (fgets(entry, sizeof(entry), fp) != NULL) {
+                const size_t len = strlen(entry);
+
+                if (len == 0)
+                        continue;
+                entry[len - 1] = '\0';
+
+                err = strlist__add(self, entry);
+                if (err != 0)
+                        goto out;
+        }
+
+        err = 0;
+out:
+        fclose(fp);
+        return err;
+}
+
+void strlist__remove(struct strlist *self, struct str_node *sn)
+{
+        rb_erase(&sn->rb_node, &self->entries);
+        str_node__delete(sn, self->dupstr);
+}
+
+bool strlist__has_entry(struct strlist *self, const char *entry)
+{
+        struct rb_node **p = &self->entries.rb_node;
+        struct rb_node *parent = NULL;
+
+        while (*p != NULL) {
+                struct str_node *sn;
+                int rc;
+
+                parent = *p;
+                sn = rb_entry(parent, struct str_node, rb_node);
+                rc = strcmp(sn->s, entry);
+
+                if (rc > 0)
+                        p = &(*p)->rb_left;
+                else if (rc < 0)
+                        p = &(*p)->rb_right;
+                else
+                        return true;
+        }
+
+        return false;
+}
+
+static int strlist__parse_list_entry(struct strlist *self, const char *s)
+{
+        if (strncmp(s, "file://", 7) == 0)
+                return strlist__load(self, s + 7);
+
+        return strlist__add(self, s);
+}
+
+int strlist__parse_list(struct strlist *self, const char *s)
+{
+        char *sep;
+        int err;
+
+        while ((sep = strchr(s, ',')) != NULL) {
+                *sep = '\0';
+                err = strlist__parse_list_entry(self, s);
+                *sep = ',';
+                if (err != 0)
+                        return err;
+                s = sep + 1;
+        }
+
+        return *s ? strlist__parse_list_entry(self, s) : 0;
+}
+
+struct strlist *strlist__new(bool dupstr, const char *slist)
+{
+        struct strlist *self = malloc(sizeof(*self));
+
+        if (self != NULL) {
+                self->entries = RB_ROOT;
+                self->dupstr = dupstr;
+                if (slist && strlist__parse_list(self, slist) != 0)
+                        goto out_error;
+        }
+
+        return self;
+out_error:
+        free(self);
+        return NULL;
+}
+
+void strlist__delete(struct strlist *self)
+{
+        if (self != NULL) {
+                struct str_node *pos;
+                struct rb_node *next = rb_first(&self->entries);
+
+                while (next) {
+                        pos = rb_entry(next, struct str_node, rb_node);
+                        next = rb_next(&pos->rb_node);
+                        strlist__remove(self, pos);
+                }
+                self->entries = RB_ROOT;
+                free(self);
+        }
+}
diff --git a/tools/perf/util/strlist.h b/tools/perf/util/strlist.h
new file mode 100644
index 000000000000..2fb117fb4b67
--- /dev/null
+++ b/tools/perf/util/strlist.h
@@ -0,0 +1,32 @@
+#ifndef STRLIST_H_
+#define STRLIST_H_
+
+#include "rbtree.h"
+#include <stdbool.h>
+
+struct str_node {
+        struct rb_node rb_node;
+        const char     *s;
+};
+
+struct strlist {
+        struct rb_root entries;
+        bool dupstr;
+};
+
+struct strlist *strlist__new(bool dupstr, const char *slist);
+void strlist__delete(struct strlist *self);
+
+void strlist__remove(struct strlist *self, struct str_node *sn);
+int strlist__load(struct strlist *self, const char *filename);
+int strlist__add(struct strlist *self, const char *str);
+
+bool strlist__has_entry(struct strlist *self, const char *entry);
+
+static inline bool strlist__empty(const struct strlist *self)
+{
+        return rb_first(&self->entries) == NULL;
+}
+
+int strlist__parse_list(struct strlist *self, const char *s);
+#endif /* STRLIST_H_ */
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 86e14375e74e..78c2efde01b7 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -520,7 +520,9 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
         nr_syms = shdr.sh_size / shdr.sh_entsize;
 
         memset(&sym, 0, sizeof(sym));
-
+        self->prelinked = elf_section_by_name(elf, &ehdr, &shdr,
+                                              ".gnu.prelink_undo",
+                                              NULL) != NULL;
         elf_symtab__for_each_symbol(syms, nr_syms, index, sym) {
                 struct symbol *f;
                 u64 obj_start;
@@ -535,7 +537,13 @@ static int dso__load_sym(struct dso *self, int fd, const char *name,
                 gelf_getshdr(sec, &shdr);
                 obj_start = sym.st_value;
 
-                sym.st_value -= shdr.sh_addr - shdr.sh_offset;
+                if (self->prelinked) {
+                        if (verbose >= 2)
+                                printf("adjusting symbol: st_value: %Lx sh_addr: %Lx sh_offset: %Lx\n",
+                                        (u64)sym.st_value, (u64)shdr.sh_addr, (u64)shdr.sh_offset);
+
+                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
+                }
 
                 f = symbol__new(sym.st_value, sym.st_size,
                                 elf_sym__name(&sym, symstrs),
@@ -569,6 +577,8 @@ int dso__load(struct dso *self, symbol_filter_t filter, int verbose)
         if (!name)
                 return -1;
 
+        self->prelinked = 0;
+
         if (strncmp(self->name, "/tmp/perf-", 10) == 0)
                 return dso__load_perf_map(self, filter, verbose);
 
@@ -629,7 +639,7 @@ int dso__load_kernel(struct dso *self, const char *vmlinux,
         if (vmlinux)
                 err = dso__load_vmlinux(self, vmlinux, filter, verbose);
 
-        if (err)
+        if (err < 0)
                 err = dso__load_kallsyms(self, filter, verbose);
 
         return err;
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index ea332e56e458..2c48ace8203b 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -2,7 +2,7 @@
 #define _PERF_SYMBOL_ 1
 
 #include <linux/types.h>
-#include "../types.h"
+#include "types.h"
 #include "list.h"
 #include "rbtree.h"
 
@@ -20,8 +20,9 @@ struct symbol {
 struct dso {
         struct list_head node;
         struct rb_root   syms;
-        unsigned int     sym_priv_size;
         struct symbol    *(*find_symbol)(struct dso *, u64 ip);
+        unsigned int     sym_priv_size;
+        unsigned char    prelinked;
         char             name[0];
 };
 
diff --git a/tools/perf/util/types.h b/tools/perf/util/types.h
new file mode 100644
index 000000000000..5e75f9005940
--- /dev/null
+++ b/tools/perf/util/types.h
@@ -0,0 +1,17 @@
+#ifndef _PERF_TYPES_H
+#define _PERF_TYPES_H
+
+/*
+ * We define u64 as unsigned long long for every architecture
+ * so that we can print it with %Lx without getting warnings.
+ */
+typedef unsigned long long u64;
+typedef signed long long   s64;
+typedef unsigned int       u32;
+typedef signed int         s32;
+typedef unsigned short     u16;
+typedef signed short       s16;
+typedef unsigned char      u8;
+typedef signed char        s8;
+
+#endif /* _PERF_TYPES_H */
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index b8cfed776d81..b4be6071c105 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -67,7 +67,6 @@
 #include <assert.h>
 #include <regex.h>
 #include <utime.h>
-#ifndef __MINGW32__
 #include <sys/wait.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
@@ -81,20 +80,6 @@
 #include <netdb.h>
 #include <pwd.h>
 #include <inttypes.h>
-#if defined(__CYGWIN__)
-#undef _XOPEN_SOURCE
-#include <grp.h>
-#define _XOPEN_SOURCE 600
-#include "compat/cygwin.h"
-#else
-#undef _ALL_SOURCE /* AIX 5.3L defines a struct list with _ALL_SOURCE. */
-#include <grp.h>
-#define _ALL_SOURCE 1
-#endif
-#else   /* __MINGW32__ */
-/* pull in Windows compatibility stuff */
-#include "compat/mingw.h"
-#endif  /* __MINGW32__ */
 
 #ifndef NO_ICONV
 #include <iconv.h>