Merge commit 'v3.6-rc1' into linux-next

* commit 'v3.6-rc1': (9532 commits)
  Linux 3.6-rc1
  mm: remove node_start_pfn checking in new WARN_ON for now
  ARM: mmp: add missing irqs.h
  arm: mvebu: fix typo in .dtsi comment for Armada XP SoCs
  ARM: PRIMA2: delete redundant codes to restore LATCHED when timer resumes
  libceph: fix crypto key null deref, memory leak
  ceph: simplify+fix atomic_open
  sh: explicitly include sh_dma.h in setup-sh7722.c
  um: Add arch/x86/um to MAINTAINERS
  um: pass siginfo to guest process
  um: fix ubd_file_size for read-only files
  md/dm-raid: DM_RAID should select MD_RAID10
  md/raid1: submit IO from originating thread instead of md thread.
  raid5: raid5d handle stripe in batch way
  raid5: make_request use batch stripe release
  um: pull interrupt_end() into userspace()
  um: split syscall_trace(), pass pt_regs to it
  um: switch UPT_SET_RETURN_VALUE and regs_return_value to pt_regs
  MIPS: Loongson 2: Sort out clock managment.
  locks: remove unused lm_release_private
  ...

85 files changed, 5305 insertions, 1775 deletions

diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 146fd6147e84..d9834b362943 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -701,14 +701,18 @@ int main(void)
         pfd.fd = fd;
 
         while (1) {
+                struct sockaddr *addr_p = (struct sockaddr *) &addr;
+                socklen_t addr_l = sizeof(addr);
                 pfd.events = POLLIN;
                 pfd.revents = 0;
                 poll(&pfd, 1, -1);
 
-                len = recv(fd, kvp_recv_buffer, sizeof(kvp_recv_buffer), 0);
+                len = recvfrom(fd, kvp_recv_buffer, sizeof(kvp_recv_buffer), 0,
+                                addr_p, &addr_l);
 
-                if (len < 0) {
-                        syslog(LOG_ERR, "recv failed; error:%d", len);
+                if (len < 0 || addr.nl_pid) {
+                        syslog(LOG_ERR, "recvfrom failed; pid:%u error:%d %s",
+                                        addr.nl_pid, errno, strerror(errno));
                         close(fd);
                         return -1;
                 }
diff --git a/tools/lib/traceevent/.gitignore b/tools/lib/traceevent/.gitignore
new file mode 100644
index 000000000000..35f56be5a4cd
--- /dev/null
+++ b/tools/lib/traceevent/.gitignore
@@ -0,0 +1 @@
+TRACEEVENT-CFLAGS
diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile
index 3d69aa9ff51e..14131cb0522d 100644
--- a/tools/lib/traceevent/Makefile
+++ b/tools/lib/traceevent/Makefile
@@ -207,7 +207,7 @@ libtraceevent.so: $(PEVENT_LIB_OBJS)
 libtraceevent.a: $(PEVENT_LIB_OBJS)
         $(Q)$(do_build_static_lib)
 
-$(PEVENT_LIB_OBJS): %.o: $(src)/%.c
+$(PEVENT_LIB_OBJS): %.o: $(src)/%.c TRACEEVENT-CFLAGS
         $(Q)$(do_fpic_compile)
 
 define make_version.h
@@ -250,8 +250,12 @@ endef
 all_objs := $(sort $(ALL_OBJS))
 all_deps := $(all_objs:%.o=.%.d)
 
+# let .d file also depends on the source and header files
 define check_deps
-                $(CC) -M $(CFLAGS) $< > $@;
+                @set -e; $(RM) $@; \
+                $(CC) -M $(CFLAGS) $< > $@.$$$$; \
+                sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
+                $(RM) $@.$$$$
 endef
 
 $(gui_deps): ks_version.h
@@ -268,13 +272,25 @@ ifneq ($(dep_includes),)
  include $(dep_includes)
 endif
 
+### Detect environment changes
+TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):$(ARCH):$(CROSS_COMPILE)
+
+TRACEEVENT-CFLAGS: force
+        @FLAGS='$(TRACK_CFLAGS)'; \
+            if test x"$$FLAGS" != x"`cat TRACEEVENT-CFLAGS 2>/dev/null`" ; then \
+                echo 1>&2 "    * new build flags or cross compiler"; \
+                echo "$$FLAGS" >TRACEEVENT-CFLAGS; \
+            fi
+
 tags:   force
         $(RM) tags
-        find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px
+        find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px \
+        --regex-c++='/_PE\(([^,)]*).*/PEVENT_ERRNO__\1/'
 
 TAGS:   force
         $(RM) TAGS
-        find . -name '*.[ch]' | xargs etags
+        find . -name '*.[ch]' | xargs etags \
+        --regex='/_PE(\([^,)]*\).*/PEVENT_ERRNO__\1/'
 
 define do_install
         $(print_install)                                \
@@ -290,8 +306,8 @@ install_lib: all_cmd install_plugins install_python
 install: install_lib
 
 clean:
-        $(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES).*.d
-        $(RM) tags TAGS
+        $(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES) .*.d
+        $(RM) TRACEEVENT-CFLAGS tags TAGS
 
 endif # skip-makefile
 
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 554828219c33..5f34aa371b56 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -467,8 +467,10 @@ int pevent_register_function(struct pevent *pevent, char *func,
                 item->mod = NULL;
         item->addr = addr;
 
-        pevent->funclist = item;
+        if (!item->func || (mod && !item->mod))
+                die("malloc func");
 
+        pevent->funclist = item;
         pevent->func_count++;
 
         return 0;
@@ -511,12 +513,12 @@ struct printk_list {
 
 static int printk_cmp(const void *a, const void *b)
 {
-        const struct func_map *fa = a;
-        const struct func_map *fb = b;
+        const struct printk_map *pa = a;
+        const struct printk_map *pb = b;
 
-        if (fa->addr < fb->addr)
+        if (pa->addr < pb->addr)
                 return -1;
-        if (fa->addr > fb->addr)
+        if (pa->addr > pb->addr)
                 return 1;
 
         return 0;
@@ -583,10 +585,13 @@ int pevent_register_print_string(struct pevent *pevent, char *fmt,
         item = malloc_or_die(sizeof(*item));
 
         item->next = pevent->printklist;
-        pevent->printklist = item;
         item->printk = strdup(fmt);
         item->addr = addr;
 
+        if (!item->printk)
+                die("malloc fmt");
+
+        pevent->printklist = item;
         pevent->printk_count++;
 
         return 0;
@@ -616,7 +621,9 @@ static struct event_format *alloc_event(void)
 {
         struct event_format *event;
 
-        event = malloc_or_die(sizeof(*event));
+        event = malloc(sizeof(*event));
+        if (!event)
+                return NULL;
         memset(event, 0, sizeof(*event));
 
         return event;
@@ -626,12 +633,8 @@ static void add_event(struct pevent *pevent, struct event_format *event)
 {
         int i;
 
-        if (!pevent->events)
-                pevent->events = malloc_or_die(sizeof(event));
-        else
-                pevent->events =
-                        realloc(pevent->events, sizeof(event) *
-                                (pevent->nr_events + 1));
+        pevent->events = realloc(pevent->events, sizeof(event) *
+                                 (pevent->nr_events + 1));
         if (!pevent->events)
                 die("Can not allocate events");
 
@@ -697,6 +700,10 @@ static void free_arg(struct print_arg *arg)
                 free_arg(arg->symbol.field);
                 free_flag_sym(arg->symbol.symbols);
                 break;
+        case PRINT_HEX:
+                free_arg(arg->hex.field);
+                free_arg(arg->hex.size);
+                break;
         case PRINT_TYPE:
                 free(arg->typecast.type);
                 free_arg(arg->typecast.item);
@@ -775,6 +782,25 @@ int pevent_peek_char(void)
         return __peek_char();
 }
 
+static int extend_token(char **tok, char *buf, int size)
+{
+        char *newtok = realloc(*tok, size);
+
+        if (!newtok) {
+                free(*tok);
+                *tok = NULL;
+                return -1;
+        }
+
+        if (!*tok)
+                strcpy(newtok, buf);
+        else
+                strcat(newtok, buf);
+        *tok = newtok;
+
+        return 0;
+}
+
 static enum event_type force_token(const char *str, char **tok);
 
 static enum event_type __read_token(char **tok)
@@ -859,17 +885,10 @@ static enum event_type __read_token(char **tok)
                 do {
                         if (i == (BUFSIZ - 1)) {
                                 buf[i] = 0;
-                                if (*tok) {
-                                        *tok = realloc(*tok, tok_size + BUFSIZ);
-                                        if (!*tok)
-                                                return EVENT_NONE;
-                                        strcat(*tok, buf);
-                                } else
-                                        *tok = strdup(buf);
+                                tok_size += BUFSIZ;
 
-                                if (!*tok)
+                                if (extend_token(tok, buf, tok_size) < 0)
                                         return EVENT_NONE;
-                                tok_size += BUFSIZ;
                                 i = 0;
                         }
                         last_ch = ch;
@@ -908,17 +927,10 @@ static enum event_type __read_token(char **tok)
         while (get_type(__peek_char()) == type) {
                 if (i == (BUFSIZ - 1)) {
                         buf[i] = 0;
-                        if (*tok) {
-                                *tok = realloc(*tok, tok_size + BUFSIZ);
-                                if (!*tok)
-                                        return EVENT_NONE;
-                                strcat(*tok, buf);
-                        } else
-                                *tok = strdup(buf);
+                        tok_size += BUFSIZ;
 
-                        if (!*tok)
+                        if (extend_token(tok, buf, tok_size) < 0)
                                 return EVENT_NONE;
-                        tok_size += BUFSIZ;
                         i = 0;
                 }
                 ch = __read_char();
@@ -927,14 +939,7 @@ static enum event_type __read_token(char **tok)
 
  out:
         buf[i] = 0;
-        if (*tok) {
-                *tok = realloc(*tok, tok_size + i);
-                if (!*tok)
-                        return EVENT_NONE;
-                strcat(*tok, buf);
-        } else
-                *tok = strdup(buf);
-        if (!*tok)
+        if (extend_token(tok, buf, tok_size + i + 1) < 0)
                 return EVENT_NONE;
 
         if (type == EVENT_ITEM) {
@@ -1255,9 +1260,15 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                         field->flags |= FIELD_IS_POINTER;
 
                                 if (field->type) {
-                                        field->type = realloc(field->type,
-                                                              strlen(field->type) +
-                                                              strlen(last_token) + 2);
+                                        char *new_type;
+                                        new_type = realloc(field->type,
+                                                           strlen(field->type) +
+                                                           strlen(last_token) + 2);
+                                        if (!new_type) {
+                                                free(last_token);
+                                                goto fail;
+                                        }
+                                        field->type = new_type;
                                         strcat(field->type, " ");
                                         strcat(field->type, last_token);
                                         free(last_token);
@@ -1282,6 +1293,7 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                 if (strcmp(token, "[") == 0) {
                         enum event_type last_type = type;
                         char *brackets = token;
+                        char *new_brackets;
                         int len;
 
                         field->flags |= FIELD_IS_ARRAY;
@@ -1301,9 +1313,14 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                         len = 1;
                                 last_type = type;
 
-                                brackets = realloc(brackets,
-                                                   strlen(brackets) +
-                                                   strlen(token) + len);
+                                new_brackets = realloc(brackets,
+                                                       strlen(brackets) +
+                                                       strlen(token) + len);
+                                if (!new_brackets) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                brackets = new_brackets;
                                 if (len == 2)
                                         strcat(brackets, " ");
                                 strcat(brackets, token);
@@ -1319,7 +1336,12 @@ static int event_read_fields(struct event_format *event, struct format_field **f
 
                         free_token(token);
 
-                        brackets = realloc(brackets, strlen(brackets) + 2);
+                        new_brackets = realloc(brackets, strlen(brackets) + 2);
+                        if (!new_brackets) {
+                                free(brackets);
+                                goto fail;
+                        }
+                        brackets = new_brackets;
                         strcat(brackets, "]");
 
                         /* add brackets to type */
@@ -1330,10 +1352,16 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                          * the format: type [] item;
                          */
                         if (type == EVENT_ITEM) {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(field->name) +
-                                                      strlen(brackets) + 2);
+                                char *new_type;
+                                new_type = realloc(field->type,
+                                                   strlen(field->type) +
+                                                   strlen(field->name) +
+                                                   strlen(brackets) + 2);
+                                if (!new_type) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                field->type = new_type;
                                 strcat(field->type, " ");
                                 strcat(field->type, field->name);
                                 free_token(field->name);
@@ -1341,9 +1369,15 @@ static int event_read_fields(struct event_format *event, struct format_field **f
                                 field->name = token;
                                 type = read_token(&token);
                         } else {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(brackets) + 1);
+                                char *new_type;
+                                new_type = realloc(field->type,
+                                                   strlen(field->type) +
+                                                   strlen(brackets) + 1);
+                                if (!new_type) {
+                                        free(brackets);
+                                        goto fail;
+                                }
+                                field->type = new_type;
                                 strcat(field->type, brackets);
                         }
                         free(brackets);
@@ -1726,10 +1760,16 @@ process_op(struct event_format *event, struct print_arg *arg, char **tok)
                 /* could just be a type pointer */
                 if ((strcmp(arg->op.op, "*") == 0) &&
                     type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                        char *new_atom;
+
                         if (left->type != PRINT_ATOM)
                                 die("bad pointer type");
-                        left->atom.atom = realloc(left->atom.atom,
+                        new_atom = realloc(left->atom.atom,
                                             strlen(left->atom.atom) + 3);
+                        if (!new_atom)
+                                goto out_free;
+
+                        left->atom.atom = new_atom;
                         strcat(left->atom.atom, " *");
                         free(arg->op.op);
                         *arg = *left;
@@ -2146,6 +2186,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                 if (value == NULL)
                         goto out_free;
                 field->value = strdup(value);
+                if (field->value == NULL)
+                        goto out_free;
 
                 free_arg(arg);
                 arg = alloc_arg();
@@ -2159,6 +2201,8 @@ process_fields(struct event_format *event, struct print_flag_sym **list, char **
                 if (value == NULL)
                         goto out_free;
                 field->str = strdup(value);
+                if (field->str == NULL)
+                        goto out_free;
                 free_arg(arg);
                 arg = NULL;
 
@@ -2260,6 +2304,45 @@ process_symbols(struct event_format *event, struct print_arg *arg, char **tok)
 }
 
 static enum event_type
+process_hex(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_HEX;
+
+        field = alloc_arg();
+        type = process_arg(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto out_free;
+
+        arg->hex.field = field;
+
+        free_token(token);
+
+        field = alloc_arg();
+        type = process_arg(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
+                goto out_free;
+
+        arg->hex.size = field;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+ out_free:
+        free_arg(field);
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static enum event_type
 process_dynamic_array(struct event_format *event, struct print_arg *arg, char **tok)
 {
         struct format_field *field;
@@ -2488,6 +2571,10 @@ process_function(struct event_format *event, struct print_arg *arg,
                 is_symbolic_field = 1;
                 return process_symbols(event, arg, tok);
         }
+        if (strcmp(token, "__print_hex") == 0) {
+                free_token(token);
+                return process_hex(event, arg, tok);
+        }
         if (strcmp(token, "__get_str") == 0) {
                 free_token(token);
                 return process_str(event, arg, tok);
@@ -2541,7 +2628,16 @@ process_arg_token(struct event_format *event, struct print_arg *arg,
                 }
                 /* atoms can be more than one token long */
                 while (type == EVENT_ITEM) {
-                        atom = realloc(atom, strlen(atom) + strlen(token) + 2);
+                        char *new_atom;
+                        new_atom = realloc(atom,
+                                           strlen(atom) + strlen(token) + 2);
+                        if (!new_atom) {
+                                free(atom);
+                                *tok = NULL;
+                                free_token(token);
+                                return EVENT_ERROR;
+                        }
+                        atom = new_atom;
                         strcat(atom, " ");
                         strcat(atom, token);
                         free_token(token);
@@ -2835,7 +2931,7 @@ static int get_common_info(struct pevent *pevent,
         event = pevent->events[0];
         field = pevent_find_common_field(event, type);
         if (!field)
-                die("field '%s' not found", type);
+                return -1;
 
         *offset = field->offset;
         *size = field->size;
@@ -2886,15 +2982,16 @@ static int parse_common_flags(struct pevent *pevent, void *data)
 
 static int parse_common_lock_depth(struct pevent *pevent, void *data)
 {
-        int ret;
-
-        ret = __parse_common(pevent, data,
-                             &pevent->ld_size, &pevent->ld_offset,
-                             "common_lock_depth");
-        if (ret < 0)
-                return -1;
+        return __parse_common(pevent, data,
+                              &pevent->ld_size, &pevent->ld_offset,
+                              "common_lock_depth");
+}
 
-        return ret;
+static int parse_common_migrate_disable(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->ld_size, &pevent->ld_offset,
+                              "common_migrate_disable");
 }
 
 static int events_id_cmp(const void *a, const void *b);
@@ -2995,6 +3092,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                 break;
         case PRINT_FLAGS:
         case PRINT_SYMBOL:
+        case PRINT_HEX:
                 break;
         case PRINT_TYPE:
                 val = eval_num_arg(data, size, event, arg->typecast.item);
@@ -3214,11 +3312,13 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
 {
         struct pevent *pevent = event->pevent;
         struct print_flag_sym *flag;
+        struct format_field *field;
         unsigned long long val, fval;
         unsigned long addr;
         char *str;
+        unsigned char *hex;
         int print;
-        int len;
+        int i, len;
 
         switch (arg->type) {
         case PRINT_NULL:
@@ -3228,27 +3328,29 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 print_str_to_seq(s, format, len_arg, arg->atom.atom);
                 return;
         case PRINT_FIELD:
-                if (!arg->field.field) {
-                        arg->field.field = pevent_find_any_field(event, arg->field.name);
-                        if (!arg->field.field)
+                field = arg->field.field;
+                if (!field) {
+                        field = pevent_find_any_field(event, arg->field.name);
+                        if (!field)
                                 die("field %s not found", arg->field.name);
+                        arg->field.field = field;
                 }
                 /* Zero sized fields, mean the rest of the data */
-                len = arg->field.field->size ? : size - arg->field.field->offset;
+                len = field->size ? : size - field->offset;
 
                 /*
                  * Some events pass in pointers. If this is not an array
                  * and the size is the same as long_size, assume that it
                  * is a pointer.
                  */
-                if (!(arg->field.field->flags & FIELD_IS_ARRAY) &&
-                    arg->field.field->size == pevent->long_size) {
-                        addr = *(unsigned long *)(data + arg->field.field->offset);
+                if (!(field->flags & FIELD_IS_ARRAY) &&
+                    field->size == pevent->long_size) {
+                        addr = *(unsigned long *)(data + field->offset);
                         trace_seq_printf(s, "%lx", addr);
                         break;
                 }
                 str = malloc_or_die(len + 1);
-                memcpy(str, data + arg->field.field->offset, len);
+                memcpy(str, data + field->offset, len);
                 str[len] = 0;
                 print_str_to_seq(s, format, len_arg, str);
                 free(str);
@@ -3281,6 +3383,23 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                         }
                 }
                 break;
+        case PRINT_HEX:
+                field = arg->hex.field->field.field;
+                if (!field) {
+                        str = arg->hex.field->field.name;
+                        field = pevent_find_any_field(event, str);
+                        if (!field)
+                                die("field %s not found", str);
+                        arg->hex.field->field.field = field;
+                }
+                hex = data + field->offset;
+                len = eval_num_arg(data, size, event, arg->hex.size);
+                for (i = 0; i < len; i++) {
+                        if (i)
+                                trace_seq_putc(s, ' ');
+                        trace_seq_printf(s, "%02x", hex[i]);
+                }
+                break;
 
         case PRINT_TYPE:
                 break;
@@ -3299,7 +3418,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 break;
         }
         case PRINT_BSTRING:
-                trace_seq_printf(s, format, arg->string.string);
+                print_str_to_seq(s, format, len_arg, arg->string.string);
                 break;
         case PRINT_OP:
                 /*
@@ -3363,6 +3482,10 @@ process_defined_func(struct trace_seq *s, void *data, int size,
                         string = malloc_or_die(sizeof(*string));
                         string->next = strings;
                         string->str = strdup(str.buffer);
+                        if (!string->str)
+                                die("malloc str");
+
+                        args[i] = (unsigned long long)string->str;
                         strings = string;
                         trace_seq_destroy(&str);
                         break;
@@ -3400,6 +3523,7 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
         unsigned long long ip, val;
         char *ptr;
         void *bptr;
+        int vsize;
 
         field = pevent->bprint_buf_field;
         ip_field = pevent->bprint_ip_field;
@@ -3448,6 +3572,8 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                 goto process_again;
                         case '0' ... '9':
                                 goto process_again;
+                        case '.':
+                                goto process_again;
                         case 'p':
                                 ls = 1;
                                 /* fall through */
@@ -3455,23 +3581,30 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                         case 'u':
                         case 'x':
                         case 'i':
-                                /* the pointers are always 4 bytes aligned */
-                                bptr = (void *)(((unsigned long)bptr + 3) &
-                                                ~3);
                                 switch (ls) {
                                 case 0:
-                                        ls = 4;
+                                        vsize = 4;
                                         break;
                                 case 1:
-                                        ls = pevent->long_size;
+                                        vsize = pevent->long_size;
                                         break;
                                 case 2:
-                                        ls = 8;
+                                        vsize = 8;
+                                        break;
                                 default:
+                                        vsize = ls; /* ? */
                                         break;
                                 }
-                                val = pevent_read_number(pevent, bptr, ls);
-                                bptr += ls;
+                        /* fall through */
+                        case '*':
+                                if (*ptr == '*')
+                                        vsize = 4;
+
+                                /* the pointers are always 4 bytes aligned */
+                                bptr = (void *)(((unsigned long)bptr + 3) &
+                                                ~3);
+                                val = pevent_read_number(pevent, bptr, vsize);
+                                bptr += vsize;
                                 arg = alloc_arg();
                                 arg->next = NULL;
                                 arg->type = PRINT_ATOM;
@@ -3479,12 +3612,21 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                 sprintf(arg->atom.atom, "%lld", val);
                                 *next = arg;
                                 next = &arg->next;
+                                /*
+                                 * The '*' case means that an arg is used as the length.
+                                 * We need to continue to figure out for what.
+                                 */
+                                if (*ptr == '*')
+                                        goto process_again;
+
                                 break;
                         case 's':
                                 arg = alloc_arg();
                                 arg->next = NULL;
                                 arg->type = PRINT_BSTRING;
                                 arg->string.string = strdup(bptr);
+                                if (!arg->string.string)
+                                        break;
                                 bptr += strlen(bptr) + 1;
                                 *next = arg;
                                 next = &arg->next;
@@ -3589,6 +3731,16 @@ static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
 }
 
+static int is_printable_array(char *p, unsigned int len)
+{
+        unsigned int i;
+
+        for (i = 0; i < len && p[i]; i++)
+                if (!isprint(p[i]))
+                    return 0;
+        return 1;
+}
+
 static void print_event_fields(struct trace_seq *s, void *data, int size,
                                struct event_format *event)
 {
@@ -3608,7 +3760,8 @@ static void print_event_fields(struct trace_seq *s, void *data, int size,
                                 len = offset >> 16;
                                 offset &= 0xffff;
                         }
-                        if (field->flags & FIELD_IS_STRING) {
+                        if (field->flags & FIELD_IS_STRING &&
+                            is_printable_array(data + offset, len)) {
                                 trace_seq_printf(s, "%s", (char *)data + offset);
                         } else {
                                 trace_seq_puts(s, "ARRAY[");
@@ -3619,6 +3772,7 @@ static void print_event_fields(struct trace_seq *s, void *data, int size,
                                                          *((unsigned char *)data + offset + i));
                                 }
                                 trace_seq_putc(s, ']');
+                                field->flags &= ~FIELD_IS_STRING;
                         }
                 } else {
                         val = pevent_read_number(event->pevent, data + field->offset,
@@ -3758,6 +3912,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                 } else if (*(ptr+1) == 'M' || *(ptr+1) == 'm') {
                                         print_mac_arg(s, *(ptr+1), data, size, event, arg);
                                         ptr++;
+                                        arg = arg->next;
                                         break;
                                 }
 
@@ -3794,14 +3949,15 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
                                                 break;
                                         }
                                 }
-                                if (pevent->long_size == 8 && ls) {
+                                if (pevent->long_size == 8 && ls &&
+                                    sizeof(long) != 8) {
                                         char *p;
 
                                         ls = 2;
                                         /* make %l into %ll */
                                         p = strchr(format, 'l');
                                         if (p)
-                                                memmove(p, p+1, strlen(p)+1);
+                                                memmove(p+1, p, strlen(p)+1);
                                         else if (strcmp(format, "%p") == 0)
                                                 strcpy(format, "0x%llx");
                                 }
@@ -3878,8 +4034,7 @@ static void pretty_print(struct trace_seq *s, void *data, int size, struct event
  * pevent_data_lat_fmt - parse the data for the latency format
  * @pevent: a handle to the pevent
  * @s: the trace_seq to write to
- * @data: the raw data to read from
- * @size: currently unused.
+ * @record: the record to read from
  *
  * This parses out the Latency format (interrupts disabled,
  * need rescheduling, in hard/soft interrupt, preempt count
@@ -3889,10 +4044,13 @@ void pevent_data_lat_fmt(struct pevent *pevent,
                          struct trace_seq *s, struct pevent_record *record)
 {
         static int check_lock_depth = 1;
+        static int check_migrate_disable = 1;
         static int lock_depth_exists;
+        static int migrate_disable_exists;
         unsigned int lat_flags;
         unsigned int pc;
         int lock_depth;
+        int migrate_disable;
         int hardirq;
         int softirq;
         void *data = record->data;
@@ -3900,18 +4058,26 @@ void pevent_data_lat_fmt(struct pevent *pevent,
         lat_flags = parse_common_flags(pevent, data);
         pc = parse_common_pc(pevent, data);
         /* lock_depth may not always exist */
-        if (check_lock_depth) {
-                struct format_field *field;
-                struct event_format *event;
-
-                check_lock_depth = 0;
-                event = pevent->events[0];
-                field = pevent_find_common_field(event, "common_lock_depth");
-                if (field)
-                        lock_depth_exists = 1;
-        }
         if (lock_depth_exists)
                 lock_depth = parse_common_lock_depth(pevent, data);
+        else if (check_lock_depth) {
+                lock_depth = parse_common_lock_depth(pevent, data);
+                if (lock_depth < 0)
+                        check_lock_depth = 0;
+                else
+                        lock_depth_exists = 1;
+        }
+
+        /* migrate_disable may not always exist */
+        if (migrate_disable_exists)
+                migrate_disable = parse_common_migrate_disable(pevent, data);
+        else if (check_migrate_disable) {
+                migrate_disable = parse_common_migrate_disable(pevent, data);
+                if (migrate_disable < 0)
+                        check_migrate_disable = 0;
+                else
+                        migrate_disable_exists = 1;
+        }
 
         hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
         softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
@@ -3930,6 +4096,13 @@ void pevent_data_lat_fmt(struct pevent *pevent,
         else
                 trace_seq_putc(s, '.');
 
+        if (migrate_disable_exists) {
+                if (migrate_disable < 0)
+                        trace_seq_putc(s, '.');
+                else
+                        trace_seq_printf(s, "%d", migrate_disable);
+        }
+
         if (lock_depth_exists) {
                 if (lock_depth < 0)
                         trace_seq_putc(s, '.');
@@ -3996,10 +4169,7 @@ const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
  * pevent_data_comm_from_pid - parse the data into the print format
  * @s: the trace_seq to write to
  * @event: the handle to the event
- * @cpu: the cpu the event was recorded on
- * @data: the raw data
- * @size: the size of the raw data
- * @nsecs: the timestamp of the event
+ * @record: the record to read from
  *
  * This parses the raw @data using the given @event information and
  * writes the print format into the trace_seq.
@@ -4279,6 +4449,13 @@ static void print_args(struct print_arg *args)
                 trace_seq_destroy(&s);
                 printf(")");
                 break;
+        case PRINT_HEX:
+                printf("__print_hex(");
+                print_args(args->hex.field);
+                printf(", ");
+                print_args(args->hex.size);
+                printf(")");
+                break;
         case PRINT_STRING:
         case PRINT_BSTRING:
                 printf("__get_str(%s)", args->string.string);
@@ -4541,6 +4718,8 @@ int pevent_parse_event(struct pevent *pevent,
                 die("failed to read event id");
 
         event->system = strdup(sys);
+        if (!event->system)
+                die("failed to allocate system");
 
         /* Add pevent to event so that it can be referenced */
         event->pevent = pevent;
@@ -4582,6 +4761,11 @@ int pevent_parse_event(struct pevent *pevent,
                         list = &arg->next;
                         arg->type = PRINT_FIELD;
                         arg->field.name = strdup(field->name);
+                        if (!arg->field.name) {
+                                do_warning("failed to allocate field name");
+                                event->flags |= EVENT_FL_FAILED;
+                                return -1;
+                        }
                         arg->field.field = field;
                 }
                 return 0;
@@ -4753,7 +4937,7 @@ int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
  * @record: The record with the field name.
  * @err: print default error if failed.
  *
- * Returns: 0 on success, -1 field not fould, or 1 if buffer is full.
+ * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
  */
 int pevent_print_num_field(struct trace_seq *s, const char *fmt,
                            struct event_format *event, const char *name,
@@ -4795,11 +4979,12 @@ static void free_func_handle(struct pevent_function_handler *func)
  * pevent_register_print_function - register a helper function
  * @pevent: the handle to the pevent
  * @func: the function to process the helper function
+ * @ret_type: the return type of the helper function
  * @name: the name of the helper function
  * @parameters: A list of enum pevent_func_arg_type
  *
  * Some events may have helper functions in the print format arguments.
- * This allows a plugin to dynmically create a way to process one
+ * This allows a plugin to dynamically create a way to process one
  * of these functions.
  *
  * The @parameters is a variable list of pevent_func_arg_type enums that
@@ -4870,12 +5055,13 @@ int pevent_register_print_function(struct pevent *pevent,
 }
 
 /**
- * pevent_register_event_handle - register a way to parse an event
+ * pevent_register_event_handler - register a way to parse an event
  * @pevent: the handle to the pevent
  * @id: the id of the event to register
  * @sys_name: the system name the event belongs to
  * @event_name: the name of the event
  * @func: the function to call to parse the event information
+ * @context: the data to be passed to @func
  *
  * This function allows a developer to override the parsing of
  * a given event. If for some reason the default print format
@@ -4925,6 +5111,11 @@ int pevent_register_event_handler(struct pevent *pevent,
         if (sys_name)
                 handle->sys_name = strdup(sys_name);
 
+        if ((event_name && !handle->event_name) ||
+            (sys_name && !handle->sys_name)) {
+                die("Failed to allocate event/sys name");
+        }
+
         handle->func = func;
         handle->next = pevent->handlers;
         pevent->handlers = handle;
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index ac997bc7b592..5772ad8cb386 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -226,6 +226,11 @@ struct print_arg_symbol {
         struct print_flag_sym   *symbols;
 };
 
+struct print_arg_hex {
+        struct print_arg        *field;
+        struct print_arg        *size;
+};
+
 struct print_arg_dynarray {
         struct format_field     *field;
         struct print_arg        *index;
@@ -253,6 +258,7 @@ enum print_arg_type {
         PRINT_FIELD,
         PRINT_FLAGS,
         PRINT_SYMBOL,
+        PRINT_HEX,
         PRINT_TYPE,
         PRINT_STRING,
         PRINT_BSTRING,
@@ -270,6 +276,7 @@ struct print_arg {
                 struct print_arg_typecast       typecast;
                 struct print_arg_flags          flags;
                 struct print_arg_symbol         symbol;
+                struct print_arg_hex            hex;
                 struct print_arg_func           func;
                 struct print_arg_string         string;
                 struct print_arg_op             op;
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index dfcfe2c131de..ad17855528f9 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -96,7 +96,7 @@ static enum event_type read_token(char **tok)
             (strcmp(token, "=") == 0 || strcmp(token, "!") == 0) &&
             pevent_peek_char() == '~') {
                 /* append it */
-                *tok = malloc(3);
+                *tok = malloc_or_die(3);
                 sprintf(*tok, "%c%c", *token, '~');
                 free_token(token);
                 /* Now remove the '~' from the buffer */
@@ -148,17 +148,11 @@ add_filter_type(struct event_filter *filter, int id)
         if (filter_type)
                 return filter_type;
 
-        if (!filter->filters)
-                filter->event_filters =
-                        malloc_or_die(sizeof(*filter->event_filters));
-        else {
-                filter->event_filters =
-                        realloc(filter->event_filters,
-                                sizeof(*filter->event_filters) *
-                                (filter->filters + 1));
-                if (!filter->event_filters)
-                        die("Could not allocate filter");
-        }
+        filter->event_filters = realloc(filter->event_filters,
+                                        sizeof(*filter->event_filters) *
+                                        (filter->filters + 1));
+        if (!filter->event_filters)
+                die("Could not allocate filter");
 
         for (i = 0; i < filter->filters; i++) {
                 if (filter->event_filters[i].event_id > id)
@@ -1480,7 +1474,7 @@ void pevent_filter_clear_trivial(struct event_filter *filter,
 {
         struct filter_type *filter_type;
         int count = 0;
-        int *ids;
+        int *ids = NULL;
         int i;
 
         if (!filter->filters)
@@ -1504,10 +1498,8 @@ void pevent_filter_clear_trivial(struct event_filter *filter,
                 default:
                         break;
                 }
-                if (count)
-                        ids = realloc(ids, sizeof(*ids) * (count + 1));
-                else
-                        ids = malloc(sizeof(*ids));
+
+                ids = realloc(ids, sizeof(*ids) * (count + 1));
                 if (!ids)
                         die("Can't allocate ids");
                 ids[count++] = filter_type->event_id;
@@ -1710,18 +1702,43 @@ static int test_num(struct event_format *event,
 
 static const char *get_field_str(struct filter_arg *arg, struct pevent_record *record)
 {
-        const char *val = record->data + arg->str.field->offset;
+        struct event_format *event;
+        struct pevent *pevent;
+        unsigned long long addr;
+        const char *val = NULL;
+        char hex[64];
 
-        /*
-         * We need to copy the data since we can't be sure the field
-         * is null terminated.
-         */
-        if (*(val + arg->str.field->size - 1)) {
-                /* copy it */
-                memcpy(arg->str.buffer, val, arg->str.field->size);
-                /* the buffer is already NULL terminated */
-                val = arg->str.buffer;
+        /* If the field is not a string convert it */
+        if (arg->str.field->flags & FIELD_IS_STRING) {
+                val = record->data + arg->str.field->offset;
+
+                /*
+                 * We need to copy the data since we can't be sure the field
+                 * is null terminated.
+                 */
+                if (*(val + arg->str.field->size - 1)) {
+                        /* copy it */
+                        memcpy(arg->str.buffer, val, arg->str.field->size);
+                        /* the buffer is already NULL terminated */
+                        val = arg->str.buffer;
+                }
+
+        } else {
+                event = arg->str.field->event;
+                pevent = event->pevent;
+                addr = get_value(event, arg->str.field, record);
+
+                if (arg->str.field->flags & (FIELD_IS_POINTER | FIELD_IS_LONG))
+                        /* convert to a kernel symbol */
+                        val = pevent_find_function(pevent, addr);
+
+                if (val == NULL) {
+                        /* just use the hex of the string name */
+                        snprintf(hex, 64, "0x%llx", addr);
+                        val = hex;
+                }
         }
+
         return val;
 }
 
@@ -2001,11 +2018,13 @@ static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
         char *lstr;
         char *rstr;
         char *op;
-        char *str;
+        char *str = NULL;
         int len;
 
         lstr = arg_to_str(filter, arg->exp.left);
         rstr = arg_to_str(filter, arg->exp.right);
+        if (!lstr || !rstr)
+                goto out;
 
         switch (arg->exp.type) {
         case FILTER_EXP_ADD:
@@ -2045,6 +2064,7 @@ static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
         len = strlen(op) + strlen(lstr) + strlen(rstr) + 4;
         str = malloc_or_die(len);
         snprintf(str, len, "%s %s %s", lstr, op, rstr);
+out:
         free(lstr);
         free(rstr);
 
@@ -2061,6 +2081,8 @@ static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
 
         lstr = arg_to_str(filter, arg->num.left);
         rstr = arg_to_str(filter, arg->num.right);
+        if (!lstr || !rstr)
+                goto out;
 
         switch (arg->num.type) {
         case FILTER_CMP_EQ:
@@ -2097,6 +2119,7 @@ static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
                 break;
         }
 
+out:
         free(lstr);
         free(rstr);
         return str;
@@ -2247,7 +2270,12 @@ int pevent_filter_compare(struct event_filter *filter1, struct event_filter *fil
                 /* The best way to compare complex filters is with strings */
                 str1 = arg_to_str(filter1, filter_type1->filter);
                 str2 = arg_to_str(filter2, filter_type2->filter);
-                result = strcmp(str1, str2) != 0;
+                if (str1 && str2)
+                        result = strcmp(str1, str2) != 0;
+                else
+                        /* bail out if allocation fails */
+                        result = 1;
+
                 free(str1);
                 free(str2);
                 if (result)
diff --git a/tools/perf/Documentation/perf-bench.txt b/tools/perf/Documentation/perf-bench.txt
index a3dbadb26ef5..7065cd6fbdfc 100644
--- a/tools/perf/Documentation/perf-bench.txt
+++ b/tools/perf/Documentation/perf-bench.txt
@@ -12,7 +12,7 @@ SYNOPSIS
 
 DESCRIPTION
 -----------
-This 'perf bench' command is general framework for benchmark suites.
+This 'perf bench' command is a general framework for benchmark suites.
 
 COMMON OPTIONS
 --------------
@@ -45,14 +45,20 @@ SUBSYSTEM
 'sched'::
         Scheduler and IPC mechanisms.
 
+'mem'::
+        Memory access performance.
+
+'all'::
+        All benchmark subsystems.
+
 SUITES FOR 'sched'
 ~~~~~~~~~~~~~~~~~~
 *messaging*::
 Suite for evaluating performance of scheduler and IPC mechanisms.
 Based on hackbench by Rusty Russell.
 
-Options of *pipe*
-^^^^^^^^^^^^^^^^^
+Options of *messaging*
+^^^^^^^^^^^^^^^^^^^^^^
 -p::
 --pipe::
 Use pipe() instead of socketpair()
@@ -115,6 +121,72 @@ Example of *pipe*
                 59004 ops/sec
 ---------------------
 
+SUITES FOR 'mem'
+~~~~~~~~~~~~~~~~
+*memcpy*::
+Suite for evaluating performance of simple memory copy in various ways.
+
+Options of *memcpy*
+^^^^^^^^^^^^^^^^^^^
+-l::
+--length::
+Specify length of memory to copy (default: 1MB).
+Available units are B, KB, MB, GB and TB (case insensitive).
+
+-r::
+--routine::
+Specify routine to copy (default: default).
+Available routines are depend on the architecture.
+On x86-64, x86-64-unrolled, x86-64-movsq and x86-64-movsb are supported.
+
+-i::
+--iterations::
+Repeat memcpy invocation this number of times.
+
+-c::
+--cycle::
+Use perf's cpu-cycles event instead of gettimeofday syscall.
+
+-o::
+--only-prefault::
+Show only the result with page faults before memcpy.
+
+-n::
+--no-prefault::
+Show only the result without page faults before memcpy.
+
+*memset*::
+Suite for evaluating performance of simple memory set in various ways.
+
+Options of *memset*
+^^^^^^^^^^^^^^^^^^^
+-l::
+--length::
+Specify length of memory to set (default: 1MB).
+Available units are B, KB, MB, GB and TB (case insensitive).
+
+-r::
+--routine::
+Specify routine to set (default: default).
+Available routines are depend on the architecture.
+On x86-64, x86-64-unrolled, x86-64-stosq and x86-64-stosb are supported.
+
+-i::
+--iterations::
+Repeat memset invocation this number of times.
+
+-c::
+--cycle::
+Use perf's cpu-cycles event instead of gettimeofday syscall.
+
+-o::
+--only-prefault::
+Show only the result with page faults before memset.
+
+-n::
+--no-prefault::
+Show only the result without page faults before memset.
+
 SEE ALSO
 --------
 linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 2d89f02719b5..495210a612c4 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -57,7 +57,7 @@ OPTIONS
 
 -s::
 --sort=::
-        Sort by key(s): pid, comm, dso, symbol, parent.
+        Sort by key(s): pid, comm, dso, symbol, parent, srcline.
 
 -p::
 --parent=<regex>::
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index 4a5680cb242e..5b80d84d6b4a 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -112,7 +112,7 @@ Default is to monitor all CPUS.
 
 -s::
 --sort::
-        Sort by key(s): pid, comm, dso, symbol, parent
+        Sort by key(s): pid, comm, dso, symbol, parent, srcline.
 
 -n::
 --show-nr-samples::
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 0eee64cfe9a0..77f124fe57ad 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -155,7 +155,7 @@ endif
 
 ### --- END CONFIGURATION SECTION ---
 
-BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)/util -I$(TRACE_EVENT_DIR) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
+BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)util -I$(TRACE_EVENT_DIR) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 BASIC_LDFLAGS =
 
 # Guard against environment variables
@@ -354,6 +354,7 @@ 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/dso-test-data.o
 LIB_OBJS += $(OUTPUT)util/color.o
 LIB_OBJS += $(OUTPUT)util/pager.o
 LIB_OBJS += $(OUTPUT)util/header.o
@@ -503,6 +504,7 @@ else
                 LIB_OBJS += $(OUTPUT)ui/progress.o
                 LIB_OBJS += $(OUTPUT)ui/util.o
                 LIB_OBJS += $(OUTPUT)ui/tui/setup.o
+                LIB_OBJS += $(OUTPUT)ui/tui/util.o
                 LIB_H += ui/browser.h
                 LIB_H += ui/browsers/map.h
                 LIB_H += ui/helpline.h
@@ -522,13 +524,18 @@ else
                 msg := $(warning GTK2 not found, disables GTK2 support. Please install gtk2-devel or libgtk2.0-dev);
                 BASIC_CFLAGS += -DNO_GTK2_SUPPORT
         else
+                ifeq ($(call try-cc,$(SOURCE_GTK2_INFOBAR),$(FLAGS_GTK2)),y)
+                        BASIC_CFLAGS += -DHAVE_GTK_INFO_BAR
+                endif
                 BASIC_CFLAGS += $(shell pkg-config --cflags gtk+-2.0)
                 EXTLIBS += $(shell pkg-config --libs gtk+-2.0)
                 LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
                 LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
+                LIB_OBJS += $(OUTPUT)ui/gtk/util.o
                 # Make sure that it'd be included only once.
                 ifneq ($(findstring -DNO_NEWT_SUPPORT,$(BASIC_CFLAGS)),)
                         LIB_OBJS += $(OUTPUT)ui/setup.o
+                        LIB_OBJS += $(OUTPUT)ui/util.o
                 endif
         endif
 endif
@@ -797,6 +804,9 @@ $(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
+$(OUTPUT)util/parse-events.o: util/parse-events.c $(OUTPUT)PERF-CFLAGS
+        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -Wno-redundant-decls $<
+
 $(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 $<
 
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index 71557225bf92..02dad5d3359b 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -24,21 +24,21 @@
 static const char       *length_str     = "1MB";
 static const char       *routine        = "default";
 static int              iterations      = 1;
-static bool             use_clock;
-static int              clock_fd;
+static bool             use_cycle;
+static int              cycle_fd;
 static bool             only_prefault;
 static bool             no_prefault;
 
 static const struct option options[] = {
         OPT_STRING('l', "length", &length_str, "1MB",
                     "Specify length of memory to copy. "
-                    "available unit: B, MB, GB (upper and lower)"),
+                    "Available units: B, KB, MB, GB and TB (upper and lower)"),
         OPT_STRING('r', "routine", &routine, "default",
                     "Specify routine to copy"),
         OPT_INTEGER('i', "iterations", &iterations,
                     "repeat memcpy() invocation this number of times"),
-        OPT_BOOLEAN('c', "clock", &use_clock,
-                    "Use CPU clock for measuring"),
+        OPT_BOOLEAN('c', "cycle", &use_cycle,
+                    "Use cycles event instead of gettimeofday() for measuring"),
         OPT_BOOLEAN('o', "only-prefault", &only_prefault,
                     "Show only the result with page faults before memcpy()"),
         OPT_BOOLEAN('n', "no-prefault", &no_prefault,
@@ -76,27 +76,27 @@ static const char * const bench_mem_memcpy_usage[] = {
         NULL
 };
 
-static struct perf_event_attr clock_attr = {
+static struct perf_event_attr cycle_attr = {
         .type           = PERF_TYPE_HARDWARE,
         .config         = PERF_COUNT_HW_CPU_CYCLES
 };
 
-static void init_clock(void)
+static void init_cycle(void)
 {
-        clock_fd = sys_perf_event_open(&clock_attr, getpid(), -1, -1, 0);
+        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, 0);
 
-        if (clock_fd < 0 && errno == ENOSYS)
+        if (cycle_fd < 0 && errno == ENOSYS)
                 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
         else
-                BUG_ON(clock_fd < 0);
+                BUG_ON(cycle_fd < 0);
 }
 
-static u64 get_clock(void)
+static u64 get_cycle(void)
 {
         int ret;
         u64 clk;
 
-        ret = read(clock_fd, &clk, sizeof(u64));
+        ret = read(cycle_fd, &clk, sizeof(u64));
         BUG_ON(ret != sizeof(u64));
 
         return clk;
@@ -119,9 +119,9 @@ static void alloc_mem(void **dst, void **src, size_t length)
                 die("memory allocation failed - maybe length is too large?\n");
 }
 
-static u64 do_memcpy_clock(memcpy_t fn, size_t len, bool prefault)
+static u64 do_memcpy_cycle(memcpy_t fn, size_t len, bool prefault)
 {
-        u64 clock_start = 0ULL, clock_end = 0ULL;
+        u64 cycle_start = 0ULL, cycle_end = 0ULL;
         void *src = NULL, *dst = NULL;
         int i;
 
@@ -130,14 +130,14 @@ static u64 do_memcpy_clock(memcpy_t fn, size_t len, bool prefault)
         if (prefault)
                 fn(dst, src, len);
 
-        clock_start = get_clock();
+        cycle_start = get_cycle();
         for (i = 0; i < iterations; ++i)
                 fn(dst, src, len);
-        clock_end = get_clock();
+        cycle_end = get_cycle();
 
         free(src);
         free(dst);
-        return clock_end - clock_start;
+        return cycle_end - cycle_start;
 }
 
 static double do_memcpy_gettimeofday(memcpy_t fn, size_t len, bool prefault)
@@ -182,17 +182,17 @@ int bench_mem_memcpy(int argc, const char **argv,
         int i;
         size_t len;
         double result_bps[2];
-        u64 result_clock[2];
+        u64 result_cycle[2];
 
         argc = parse_options(argc, argv, options,
                              bench_mem_memcpy_usage, 0);
 
-        if (use_clock)
-                init_clock();
+        if (use_cycle)
+                init_cycle();
 
         len = (size_t)perf_atoll((char *)length_str);
 
-        result_clock[0] = result_clock[1] = 0ULL;
+        result_cycle[0] = result_cycle[1] = 0ULL;
         result_bps[0] = result_bps[1] = 0.0;
 
         if ((s64)len <= 0) {
@@ -223,11 +223,11 @@ int bench_mem_memcpy(int argc, const char **argv,
 
         if (!only_prefault && !no_prefault) {
                 /* show both of results */
-                if (use_clock) {
-                        result_clock[0] =
-                                do_memcpy_clock(routines[i].fn, len, false);
-                        result_clock[1] =
-                                do_memcpy_clock(routines[i].fn, len, true);
+                if (use_cycle) {
+                        result_cycle[0] =
+                                do_memcpy_cycle(routines[i].fn, len, false);
+                        result_cycle[1] =
+                                do_memcpy_cycle(routines[i].fn, len, true);
                 } else {
                         result_bps[0] =
                                 do_memcpy_gettimeofday(routines[i].fn,
@@ -237,9 +237,9 @@ int bench_mem_memcpy(int argc, const char **argv,
                                                 len, true);
                 }
         } else {
-                if (use_clock) {
-                        result_clock[pf] =
-                                do_memcpy_clock(routines[i].fn,
+                if (use_cycle) {
+                        result_cycle[pf] =
+                                do_memcpy_cycle(routines[i].fn,
                                                 len, only_prefault);
                 } else {
                         result_bps[pf] =
@@ -251,12 +251,12 @@ int bench_mem_memcpy(int argc, const char **argv,
         switch (bench_format) {
         case BENCH_FORMAT_DEFAULT:
                 if (!only_prefault && !no_prefault) {
-                        if (use_clock) {
-                                printf(" %14lf Clock/Byte\n",
-                                        (double)result_clock[0]
+                        if (use_cycle) {
+                                printf(" %14lf Cycle/Byte\n",
+                                        (double)result_cycle[0]
                                         / (double)len);
-                                printf(" %14lf Clock/Byte (with prefault)\n",
-                                        (double)result_clock[1]
+                                printf(" %14lf Cycle/Byte (with prefault)\n",
+                                        (double)result_cycle[1]
                                         / (double)len);
                         } else {
                                 print_bps(result_bps[0]);
@@ -265,9 +265,9 @@ int bench_mem_memcpy(int argc, const char **argv,
                                 printf(" (with prefault)\n");
                         }
                 } else {
-                        if (use_clock) {
-                                printf(" %14lf Clock/Byte",
-                                        (double)result_clock[pf]
+                        if (use_cycle) {
+                                printf(" %14lf Cycle/Byte",
+                                        (double)result_cycle[pf]
                                         / (double)len);
                         } else
                                 print_bps(result_bps[pf]);
@@ -277,17 +277,17 @@ int bench_mem_memcpy(int argc, const char **argv,
                 break;
         case BENCH_FORMAT_SIMPLE:
                 if (!only_prefault && !no_prefault) {
-                        if (use_clock) {
+                        if (use_cycle) {
                                 printf("%lf %lf\n",
-                                        (double)result_clock[0] / (double)len,
-                                        (double)result_clock[1] / (double)len);
+                                        (double)result_cycle[0] / (double)len,
+                                        (double)result_cycle[1] / (double)len);
                         } else {
                                 printf("%lf %lf\n",
                                         result_bps[0], result_bps[1]);
                         }
                 } else {
-                        if (use_clock) {
-                                printf("%lf\n", (double)result_clock[pf]
+                        if (use_cycle) {
+                                printf("%lf\n", (double)result_cycle[pf]
                                         / (double)len);
                         } else
                                 printf("%lf\n", result_bps[pf]);
diff --git a/tools/perf/bench/mem-memset.c b/tools/perf/bench/mem-memset.c
index e9079185bd72..350cc9557265 100644
--- a/tools/perf/bench/mem-memset.c
+++ b/tools/perf/bench/mem-memset.c
@@ -24,21 +24,21 @@
 static const char       *length_str     = "1MB";
 static const char       *routine        = "default";
 static int              iterations      = 1;
-static bool             use_clock;
-static int              clock_fd;
+static bool             use_cycle;
+static int              cycle_fd;
 static bool             only_prefault;
 static bool             no_prefault;
 
 static const struct option options[] = {
         OPT_STRING('l', "length", &length_str, "1MB",
-                    "Specify length of memory to copy. "
-                    "available unit: B, MB, GB (upper and lower)"),
+                    "Specify length of memory to set. "
+                    "Available units: B, KB, MB, GB and TB (upper and lower)"),
         OPT_STRING('r', "routine", &routine, "default",
-                    "Specify routine to copy"),
+                    "Specify routine to set"),
         OPT_INTEGER('i', "iterations", &iterations,
                     "repeat memset() invocation this number of times"),
-        OPT_BOOLEAN('c', "clock", &use_clock,
-                    "Use CPU clock for measuring"),
+        OPT_BOOLEAN('c', "cycle", &use_cycle,
+                    "Use cycles event instead of gettimeofday() for measuring"),
         OPT_BOOLEAN('o', "only-prefault", &only_prefault,
                     "Show only the result with page faults before memset()"),
         OPT_BOOLEAN('n', "no-prefault", &no_prefault,
@@ -76,27 +76,27 @@ static const char * const bench_mem_memset_usage[] = {
         NULL
 };
 
-static struct perf_event_attr clock_attr = {
+static struct perf_event_attr cycle_attr = {
         .type           = PERF_TYPE_HARDWARE,
         .config         = PERF_COUNT_HW_CPU_CYCLES
 };
 
-static void init_clock(void)
+static void init_cycle(void)
 {
-        clock_fd = sys_perf_event_open(&clock_attr, getpid(), -1, -1, 0);
+        cycle_fd = sys_perf_event_open(&cycle_attr, getpid(), -1, -1, 0);
 
-        if (clock_fd < 0 && errno == ENOSYS)
+        if (cycle_fd < 0 && errno == ENOSYS)
                 die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
         else
-                BUG_ON(clock_fd < 0);
+                BUG_ON(cycle_fd < 0);
 }
 
-static u64 get_clock(void)
+static u64 get_cycle(void)
 {
         int ret;
         u64 clk;
 
-        ret = read(clock_fd, &clk, sizeof(u64));
+        ret = read(cycle_fd, &clk, sizeof(u64));
         BUG_ON(ret != sizeof(u64));
 
         return clk;
@@ -115,9 +115,9 @@ static void alloc_mem(void **dst, size_t length)
                 die("memory allocation failed - maybe length is too large?\n");
 }
 
-static u64 do_memset_clock(memset_t fn, size_t len, bool prefault)
+static u64 do_memset_cycle(memset_t fn, size_t len, bool prefault)
 {
-        u64 clock_start = 0ULL, clock_end = 0ULL;
+        u64 cycle_start = 0ULL, cycle_end = 0ULL;
         void *dst = NULL;
         int i;
 
@@ -126,13 +126,13 @@ static u64 do_memset_clock(memset_t fn, size_t len, bool prefault)
         if (prefault)
                 fn(dst, -1, len);
 
-        clock_start = get_clock();
+        cycle_start = get_cycle();
         for (i = 0; i < iterations; ++i)
                 fn(dst, i, len);
-        clock_end = get_clock();
+        cycle_end = get_cycle();
 
         free(dst);
-        return clock_end - clock_start;
+        return cycle_end - cycle_start;
 }
 
 static double do_memset_gettimeofday(memset_t fn, size_t len, bool prefault)
@@ -176,17 +176,17 @@ int bench_mem_memset(int argc, const char **argv,
         int i;
         size_t len;
         double result_bps[2];
-        u64 result_clock[2];
+        u64 result_cycle[2];
 
         argc = parse_options(argc, argv, options,
                              bench_mem_memset_usage, 0);
 
-        if (use_clock)
-                init_clock();
+        if (use_cycle)
+                init_cycle();
 
         len = (size_t)perf_atoll((char *)length_str);
 
-        result_clock[0] = result_clock[1] = 0ULL;
+        result_cycle[0] = result_cycle[1] = 0ULL;
         result_bps[0] = result_bps[1] = 0.0;
 
         if ((s64)len <= 0) {
@@ -217,11 +217,11 @@ int bench_mem_memset(int argc, const char **argv,
 
         if (!only_prefault && !no_prefault) {
                 /* show both of results */
-                if (use_clock) {
-                        result_clock[0] =
-                                do_memset_clock(routines[i].fn, len, false);
-                        result_clock[1] =
-                                do_memset_clock(routines[i].fn, len, true);
+                if (use_cycle) {
+                        result_cycle[0] =
+                                do_memset_cycle(routines[i].fn, len, false);
+                        result_cycle[1] =
+                                do_memset_cycle(routines[i].fn, len, true);
                 } else {
                         result_bps[0] =
                                 do_memset_gettimeofday(routines[i].fn,
@@ -231,9 +231,9 @@ int bench_mem_memset(int argc, const char **argv,
                                                 len, true);
                 }
         } else {
-                if (use_clock) {
-                        result_clock[pf] =
-                                do_memset_clock(routines[i].fn,
+                if (use_cycle) {
+                        result_cycle[pf] =
+                                do_memset_cycle(routines[i].fn,
                                                 len, only_prefault);
                 } else {
                         result_bps[pf] =
@@ -245,12 +245,12 @@ int bench_mem_memset(int argc, const char **argv,
         switch (bench_format) {
         case BENCH_FORMAT_DEFAULT:
                 if (!only_prefault && !no_prefault) {
-                        if (use_clock) {
-                                printf(" %14lf Clock/Byte\n",
-                                        (double)result_clock[0]
+                        if (use_cycle) {
+                                printf(" %14lf Cycle/Byte\n",
+                                        (double)result_cycle[0]
                                         / (double)len);
-                                printf(" %14lf Clock/Byte (with prefault)\n ",
-                                        (double)result_clock[1]
+                                printf(" %14lf Cycle/Byte (with prefault)\n ",
+                                        (double)result_cycle[1]
                                         / (double)len);
                         } else {
                                 print_bps(result_bps[0]);
@@ -259,9 +259,9 @@ int bench_mem_memset(int argc, const char **argv,
                                 printf(" (with prefault)\n");
                         }
                 } else {
-                        if (use_clock) {
-                                printf(" %14lf Clock/Byte",
-                                        (double)result_clock[pf]
+                        if (use_cycle) {
+                                printf(" %14lf Cycle/Byte",
+                                        (double)result_cycle[pf]
                                         / (double)len);
                         } else
                                 print_bps(result_bps[pf]);
@@ -271,17 +271,17 @@ int bench_mem_memset(int argc, const char **argv,
                 break;
         case BENCH_FORMAT_SIMPLE:
                 if (!only_prefault && !no_prefault) {
-                        if (use_clock) {
+                        if (use_cycle) {
                                 printf("%lf %lf\n",
-                                        (double)result_clock[0] / (double)len,
-                                        (double)result_clock[1] / (double)len);
+                                        (double)result_cycle[0] / (double)len,
+                                        (double)result_cycle[1] / (double)len);
                         } else {
                                 printf("%lf %lf\n",
                                         result_bps[0], result_bps[1]);
                         }
                 } else {
-                        if (use_clock) {
-                                printf("%lf\n", (double)result_clock[pf]
+                        if (use_cycle) {
+                                printf("%lf\n", (double)result_cycle[pf]
                                         / (double)len);
                         } else
                                 printf("%lf\n", result_bps[pf]);
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index b0e74ab2d7a2..1f3100216448 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -33,7 +33,7 @@ struct bench_suite {
 };
                                                 \
 /* sentinel: easy for help */
-#define suite_all { "all", "test all suite (pseudo suite)", NULL }
+#define suite_all { "all", "Test all benchmark suites", NULL }
 
 static struct bench_suite sched_suites[] = {
         { "messaging",
@@ -75,7 +75,7 @@ static struct bench_subsys subsystems[] = {
           "memory access performance",
           mem_suites },
         { "all",                /* sentinel: easy for help */
-          "test all subsystem (pseudo subsystem)",
+          "all benchmark subsystem",
           NULL },
         { NULL,
           NULL,
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index acd78dc28341..0dd5a058f766 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -60,7 +60,7 @@ static int __cmd_evlist(const char *input_name, struct perf_attr_details *detail
         list_for_each_entry(pos, &session->evlist->entries, node) {
                 bool first = true;
 
-                printf("%s", event_name(pos));
+                printf("%s", perf_evsel__name(pos));
 
                 if (details->verbose || details->freq) {
                         comma_printf(&first, " sample_freq=%" PRIu64,
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 547af48deb4f..ce35015f2dc6 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -57,6 +57,11 @@ static unsigned long nr_allocs, nr_cross_allocs;
 
 #define PATH_SYS_NODE   "/sys/devices/system/node"
 
+struct perf_kmem {
+        struct perf_tool    tool;
+        struct perf_session *session;
+};
+
 static void init_cpunode_map(void)
 {
         FILE *fp;
@@ -278,14 +283,16 @@ static void process_free_event(void *data,
         s_alloc->alloc_cpu = -1;
 }
 
-static void process_raw_event(union perf_event *raw_event __used, void *data,
+static void process_raw_event(struct perf_tool *tool,
+                              union perf_event *raw_event __used, void *data,
                               int cpu, u64 timestamp, struct thread *thread)
 {
+        struct perf_kmem *kmem = container_of(tool, struct perf_kmem, tool);
         struct event_format *event;
         int type;
 
-        type = trace_parse_common_type(data);
-        event = trace_find_event(type);
+        type = trace_parse_common_type(kmem->session->pevent, data);
+        event = pevent_find_event(kmem->session->pevent, type);
 
         if (!strcmp(event->name, "kmalloc") ||
             !strcmp(event->name, "kmem_cache_alloc")) {
@@ -306,7 +313,7 @@ static void process_raw_event(union perf_event *raw_event __used, void *data,
         }
 }
 
-static int process_sample_event(struct perf_tool *tool __used,
+static int process_sample_event(struct perf_tool *tool,
                                 union perf_event *event,
                                 struct perf_sample *sample,
                                 struct perf_evsel *evsel __used,
@@ -322,16 +329,18 @@ static int process_sample_event(struct perf_tool *tool __used,
 
         dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
 
-        process_raw_event(event, sample->raw_data, sample->cpu,
+        process_raw_event(tool, event, sample->raw_data, sample->cpu,
                           sample->time, thread);
 
         return 0;
 }
 
-static struct perf_tool perf_kmem = {
-        .sample                 = process_sample_event,
-        .comm                   = perf_event__process_comm,
-        .ordered_samples        = true,
+static struct perf_kmem perf_kmem = {
+        .tool = {
+                .sample                 = process_sample_event,
+                .comm                   = perf_event__process_comm,
+                .ordered_samples        = true,
+        },
 };
 
 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
@@ -486,11 +495,15 @@ static void sort_result(void)
 static int __cmd_kmem(void)
 {
         int err = -EINVAL;
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY,
-                                                         0, false, &perf_kmem);
+        struct perf_session *session;
+
+        session = perf_session__new(input_name, O_RDONLY, 0, false,
+                                    &perf_kmem.tool);
         if (session == NULL)
                 return -ENOMEM;
 
+        perf_kmem.session = session;
+
         if (perf_session__create_kernel_maps(session) < 0)
                 goto out_delete;
 
@@ -498,7 +511,7 @@ static int __cmd_kmem(void)
                 goto out_delete;
 
         setup_pager();
-        err = perf_session__process_events(session, &perf_kmem);
+        err = perf_session__process_events(session, &perf_kmem.tool);
         if (err != 0)
                 goto out_delete;
         sort_result();
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index fd53319de20d..b3c428548868 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -724,8 +724,8 @@ process_raw_event(void *data, int cpu, u64 timestamp, struct thread *thread)
         struct event_format *event;
         int type;
 
-        type = trace_parse_common_type(data);
-        event = trace_find_event(type);
+        type = trace_parse_common_type(session->pevent, data);
+        event = pevent_find_event(session->pevent, type);
 
         if (!strcmp(event->name, "lock_acquire"))
                 process_lock_acquire_event(data, event, cpu, timestamp, thread);
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index f95840d04e4c..f5a6452931e6 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -265,7 +265,7 @@ try_again:
 
                         if (err == ENOENT) {
                                 ui__error("The %s event is not supported.\n",
-                                            event_name(pos));
+                                          perf_evsel__name(pos));
                                 exit(EXIT_FAILURE);
                         }
 
@@ -916,7 +916,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 usage_with_options(record_usage, record_options);
 
         list_for_each_entry(pos, &evsel_list->entries, node) {
-                if (perf_header__push_event(pos->attr.config, event_name(pos)))
+                if (perf_header__push_event(pos->attr.config, perf_evsel__name(pos)))
                         goto out_free_fd;
         }
 
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 25249f76329d..69b1c1185159 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -69,7 +69,7 @@ static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
 
         if ((sort__has_parent || symbol_conf.use_callchain)
             && sample->callchain) {
-                err = machine__resolve_callchain(machine, evsel, al->thread,
+                err = machine__resolve_callchain(machine, al->thread,
                                                  sample->callchain, &parent);
                 if (err)
                         return err;
@@ -140,7 +140,7 @@ static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
         struct hist_entry *he;
 
         if ((sort__has_parent || symbol_conf.use_callchain) && sample->callchain) {
-                err = machine__resolve_callchain(machine, evsel, al->thread,
+                err = machine__resolve_callchain(machine, al->thread,
                                                  sample->callchain, &parent);
                 if (err)
                         return err;
@@ -230,7 +230,7 @@ static int process_read_event(struct perf_tool *tool,
         struct perf_report *rep = container_of(tool, struct perf_report, tool);
 
         if (rep->show_threads) {
-                const char *name = evsel ? event_name(evsel) : "unknown";
+                const char *name = evsel ? perf_evsel__name(evsel) : "unknown";
                 perf_read_values_add_value(&rep->show_threads_values,
                                            event->read.pid, event->read.tid,
                                            event->read.id,
@@ -239,17 +239,18 @@ static int process_read_event(struct perf_tool *tool,
         }
 
         dump_printf(": %d %d %s %" PRIu64 "\n", event->read.pid, event->read.tid,
-                    evsel ? event_name(evsel) : "FAIL",
+                    evsel ? perf_evsel__name(evsel) : "FAIL",
                     event->read.value);
 
         return 0;
 }
 
+/* For pipe mode, sample_type is not currently set */
 static int perf_report__setup_sample_type(struct perf_report *rep)
 {
         struct perf_session *self = rep->session;
 
-        if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
+        if (!self->fd_pipe && !(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
                         ui__error("Selected --sort parent, but no "
                                     "callchain data. Did you call "
@@ -272,7 +273,8 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
         }
 
         if (sort__branch_mode == 1) {
-                if (!(self->sample_type & PERF_SAMPLE_BRANCH_STACK)) {
+                if (!self->fd_pipe &&
+                    !(self->sample_type & PERF_SAMPLE_BRANCH_STACK)) {
                         ui__error("Selected -b but no branch data. "
                                   "Did you call perf record without -b?\n");
                         return -1;
@@ -314,7 +316,7 @@ static int perf_evlist__tty_browse_hists(struct perf_evlist *evlist,
 
         list_for_each_entry(pos, &evlist->entries, node) {
                 struct hists *hists = &pos->hists;
-                const char *evname = event_name(pos);
+                const char *evname = perf_evsel__name(pos);
 
                 hists__fprintf_nr_sample_events(hists, evname, stdout);
                 hists__fprintf(hists, NULL, false, true, 0, 0, stdout);
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index b125e07eb399..7a9ad2b1ee76 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -43,6 +43,11 @@ static u64			sleep_measurement_overhead;
 
 static unsigned long            nr_tasks;
 
+struct perf_sched {
+        struct perf_tool    tool;
+        struct perf_session *session;
+};
+
 struct sched_atom;
 
 struct task_desc {
@@ -1597,11 +1602,13 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool,
                                                  struct perf_evsel *evsel,
                                                  struct machine *machine)
 {
+        struct perf_sched *sched = container_of(tool, struct perf_sched, tool);
+        struct pevent *pevent = sched->session->pevent;
         struct thread *thread = machine__findnew_thread(machine, sample->pid);
 
         if (thread == NULL) {
                 pr_debug("problem processing %s event, skipping it.\n",
-                         evsel->name);
+                         perf_evsel__name(evsel));
                 return -1;
         }
 
@@ -1612,7 +1619,8 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool,
                 tracepoint_handler f = evsel->handler.func;
 
                 if (evsel->handler.data == NULL)
-                        evsel->handler.data = trace_find_event(evsel->attr.config);
+                        evsel->handler.data = pevent_find_event(pevent,
+                                                          evsel->attr.config);
 
                 f(tool, evsel->handler.data, sample, machine, thread);
         }
@@ -1620,12 +1628,14 @@ static int perf_sched__process_tracepoint_sample(struct perf_tool *tool,
         return 0;
 }
 
-static struct perf_tool perf_sched = {
-        .sample                 = perf_sched__process_tracepoint_sample,
-        .comm                   = perf_event__process_comm,
-        .lost                   = perf_event__process_lost,
-        .fork                   = perf_event__process_task,
-        .ordered_samples        = true,
+static struct perf_sched perf_sched = {
+        .tool = {
+                .sample          = perf_sched__process_tracepoint_sample,
+                .comm            = perf_event__process_comm,
+                .lost            = perf_event__process_lost,
+                .fork            = perf_event__process_task,
+                .ordered_samples = true,
+        },
 };
 
 static void read_events(bool destroy, struct perf_session **psession)
@@ -1640,16 +1650,20 @@ static void read_events(bool destroy, struct perf_session **psession)
                 { "sched:sched_process_exit", process_sched_exit_event, },
                 { "sched:sched_migrate_task", process_sched_migrate_task_event, },
         };
-        struct perf_session *session = perf_session__new(input_name, O_RDONLY,
-                                                         0, false, &perf_sched);
+        struct perf_session *session;
+
+        session = perf_session__new(input_name, O_RDONLY, 0, false,
+                                    &perf_sched.tool);
         if (session == NULL)
                 die("No Memory");
 
-        err = perf_evlist__set_tracepoints_handlers_array(session->evlist, handlers);
+        perf_sched.session = session;
+
+        err = perf_session__set_tracepoints_handlers(session, handlers);
         assert(err == 0);
 
         if (perf_session__has_traces(session, "record -R")) {
-                err = perf_session__process_events(session, &perf_sched);
+                err = perf_session__process_events(session, &perf_sched.tool);
                 if (err)
                         die("Failed to process events, error %d", err);
 
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 8e395a538eb9..1e60ab70b2b1 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -28,6 +28,11 @@ static bool			system_wide;
 static const char               *cpu_list;
 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 
+struct perf_script {
+        struct perf_tool    tool;
+        struct perf_session *session;
+};
+
 enum perf_output_field {
         PERF_OUTPUT_COMM            = 1U << 0,
         PERF_OUTPUT_TID             = 1U << 1,
@@ -137,10 +142,11 @@ static const char *output_field2str(enum perf_output_field field)
 
 #define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
 
-static int perf_event_attr__check_stype(struct perf_event_attr *attr,
-                                  u64 sample_type, const char *sample_msg,
-                                  enum perf_output_field field)
+static int perf_evsel__check_stype(struct perf_evsel *evsel,
+                                   u64 sample_type, const char *sample_msg,
+                                   enum perf_output_field field)
 {
+        struct perf_event_attr *attr = &evsel->attr;
         int type = attr->type;
         const char *evname;
 
@@ -148,7 +154,7 @@ static int perf_event_attr__check_stype(struct perf_event_attr *attr,
                 return 0;
 
         if (output[type].user_set) {
-                evname = __event_name(attr->type, attr->config);
+                evname = perf_evsel__name(evsel);
                 pr_err("Samples for '%s' event do not have %s attribute set. "
                        "Cannot print '%s' field.\n",
                        evname, sample_msg, output_field2str(field));
@@ -157,7 +163,7 @@ static int perf_event_attr__check_stype(struct perf_event_attr *attr,
 
         /* user did not ask for it explicitly so remove from the default list */
         output[type].fields &= ~field;
-        evname = __event_name(attr->type, attr->config);
+        evname = perf_evsel__name(evsel);
         pr_debug("Samples for '%s' event do not have %s attribute set. "
                  "Skipping '%s' field.\n",
                  evname, sample_msg, output_field2str(field));
@@ -175,8 +181,8 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                 return -EINVAL;
 
         if (PRINT_FIELD(IP)) {
-                if (perf_event_attr__check_stype(attr, PERF_SAMPLE_IP, "IP",
-                                           PERF_OUTPUT_IP))
+                if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
+                                            PERF_OUTPUT_IP))
                         return -EINVAL;
 
                 if (!no_callchain &&
@@ -185,8 +191,8 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
         }
 
         if (PRINT_FIELD(ADDR) &&
-                perf_event_attr__check_stype(attr, PERF_SAMPLE_ADDR, "ADDR",
-                                       PERF_OUTPUT_ADDR))
+                perf_evsel__check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR",
+                                        PERF_OUTPUT_ADDR))
                 return -EINVAL;
 
         if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
@@ -208,18 +214,18 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
         }
 
         if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
-                perf_event_attr__check_stype(attr, PERF_SAMPLE_TID, "TID",
-                                       PERF_OUTPUT_TID|PERF_OUTPUT_PID))
+                perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
+                                        PERF_OUTPUT_TID|PERF_OUTPUT_PID))
                 return -EINVAL;
 
         if (PRINT_FIELD(TIME) &&
-                perf_event_attr__check_stype(attr, PERF_SAMPLE_TIME, "TIME",
-                                       PERF_OUTPUT_TIME))
+                perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME",
+                                        PERF_OUTPUT_TIME))
                 return -EINVAL;
 
         if (PRINT_FIELD(CPU) &&
-                perf_event_attr__check_stype(attr, PERF_SAMPLE_CPU, "CPU",
-                                       PERF_OUTPUT_CPU))
+                perf_evsel__check_stype(evsel, PERF_SAMPLE_CPU, "CPU",
+                                        PERF_OUTPUT_CPU))
                 return -EINVAL;
 
         return 0;
@@ -256,11 +262,13 @@ static int perf_session__check_output_opt(struct perf_session *session)
         return 0;
 }
 
-static void print_sample_start(struct perf_sample *sample,
+static void print_sample_start(struct pevent *pevent,
+                               struct perf_sample *sample,
                                struct thread *thread,
-                               struct perf_event_attr *attr)
+                               struct perf_evsel *evsel)
 {
         int type;
+        struct perf_event_attr *attr = &evsel->attr;
         struct event_format *event;
         const char *evname = NULL;
         unsigned long secs;
@@ -300,12 +308,18 @@ static void print_sample_start(struct perf_sample *sample,
 
         if (PRINT_FIELD(EVNAME)) {
                 if (attr->type == PERF_TYPE_TRACEPOINT) {
-                        type = trace_parse_common_type(sample->raw_data);
-                        event = trace_find_event(type);
+                        /*
+                         * XXX Do we really need this here?
+                         * perf_evlist__set_tracepoint_names should have done
+                         * this already
+                         */
+                        type = trace_parse_common_type(pevent,
+                                                       sample->raw_data);
+                        event = pevent_find_event(pevent, type);
                         if (event)
                                 evname = event->name;
                 } else
-                        evname = __event_name(attr->type, attr->config);
+                        evname = perf_evsel__name(evsel);
 
                 printf("%s: ", evname ? evname : "[unknown]");
         }
@@ -387,7 +401,7 @@ static void print_sample_bts(union perf_event *event,
                         printf(" ");
                 else
                         printf("\n");
-                perf_event__print_ip(event, sample, machine, evsel,
+                perf_event__print_ip(event, sample, machine,
                                      PRINT_FIELD(SYM), PRINT_FIELD(DSO),
                                      PRINT_FIELD(SYMOFFSET));
         }
@@ -402,6 +416,7 @@ static void print_sample_bts(union perf_event *event,
 }
 
 static void process_event(union perf_event *event __unused,
+                          struct pevent *pevent,
                           struct perf_sample *sample,
                           struct perf_evsel *evsel,
                           struct machine *machine,
@@ -412,7 +427,7 @@ static void process_event(union perf_event *event __unused,
         if (output[attr->type].fields == 0)
                 return;
 
-        print_sample_start(sample, thread, attr);
+        print_sample_start(pevent, sample, thread, evsel);
 
         if (is_bts_event(attr)) {
                 print_sample_bts(event, sample, evsel, machine, thread);
@@ -420,7 +435,7 @@ static void process_event(union perf_event *event __unused,
         }
 
         if (PRINT_FIELD(TRACE))
-                print_trace_event(sample->cpu, sample->raw_data,
+                print_trace_event(pevent, sample->cpu, sample->raw_data,
                                   sample->raw_size);
 
         if (PRINT_FIELD(ADDR))
@@ -431,7 +446,7 @@ static void process_event(union perf_event *event __unused,
                         printf(" ");
                 else
                         printf("\n");
-                perf_event__print_ip(event, sample, machine, evsel,
+                perf_event__print_ip(event, sample, machine,
                                      PRINT_FIELD(SYM), PRINT_FIELD(DSO),
                                      PRINT_FIELD(SYMOFFSET));
         }
@@ -451,7 +466,8 @@ static int default_stop_script(void)
         return 0;
 }
 
-static int default_generate_script(const char *outfile __unused)
+static int default_generate_script(struct pevent *pevent __unused,
+                                   const char *outfile __unused)
 {
         return 0;
 }
@@ -489,6 +505,7 @@ static int process_sample_event(struct perf_tool *tool __used,
                                 struct machine *machine)
 {
         struct addr_location al;
+        struct perf_script *scr = container_of(tool, struct perf_script, tool);
         struct thread *thread = machine__findnew_thread(machine, event->ip.tid);
 
         if (thread == NULL) {
@@ -520,24 +537,27 @@ static int process_sample_event(struct perf_tool *tool __used,
         if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
                 return 0;
 
-        scripting_ops->process_event(event, sample, evsel, machine, thread);
+        scripting_ops->process_event(event, scr->session->pevent,
+                                     sample, evsel, machine, thread);
 
         evsel->hists.stats.total_period += sample->period;
         return 0;
 }
 
-static struct perf_tool perf_script = {
-        .sample          = process_sample_event,
-        .mmap            = perf_event__process_mmap,
-        .comm            = perf_event__process_comm,
-        .exit            = perf_event__process_task,
-        .fork            = perf_event__process_task,
-        .attr            = perf_event__process_attr,
-        .event_type      = perf_event__process_event_type,
-        .tracing_data    = perf_event__process_tracing_data,
-        .build_id        = perf_event__process_build_id,
-        .ordered_samples = true,
-        .ordering_requires_timestamps = true,
+static struct perf_script perf_script = {
+        .tool = {
+                .sample          = process_sample_event,
+                .mmap            = perf_event__process_mmap,
+                .comm            = perf_event__process_comm,
+                .exit            = perf_event__process_task,
+                .fork            = perf_event__process_task,
+                .attr            = perf_event__process_attr,
+                .event_type      = perf_event__process_event_type,
+                .tracing_data    = perf_event__process_tracing_data,
+                .build_id        = perf_event__process_build_id,
+                .ordered_samples = true,
+                .ordering_requires_timestamps = true,
+        },
 };
 
 extern volatile int session_done;
@@ -553,7 +573,7 @@ static int __cmd_script(struct perf_session *session)
 
         signal(SIGINT, sig_handler);
 
-        ret = perf_session__process_events(session, &perf_script);
+        ret = perf_session__process_events(session, &perf_script.tool);
 
         if (debug_mode)
                 pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
@@ -1335,10 +1355,13 @@ int cmd_script(int argc, const char **argv, const char *prefix __used)
         if (!script_name)
                 setup_pager();
 
-        session = perf_session__new(input_name, O_RDONLY, 0, false, &perf_script);
+        session = perf_session__new(input_name, O_RDONLY, 0, false,
+                                    &perf_script.tool);
         if (session == NULL)
                 return -ENOMEM;
 
+        perf_script.session = session;
+
         if (cpu_list) {
                 if (perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap))
                         return -1;
@@ -1384,7 +1407,8 @@ int cmd_script(int argc, const char **argv, const char *prefix __used)
                         return -1;
                 }
 
-                err = scripting_ops->generate_script("perf-script");
+                err = scripting_ops->generate_script(session->pevent,
+                                                     "perf-script");
                 goto out;
         }
 
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 262589991ea4..861f0aec77ae 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -391,7 +391,7 @@ static int read_counter_aggr(struct perf_evsel *counter)
 
         if (verbose) {
                 fprintf(output, "%s: %" PRIu64 " %" PRIu64 " %" PRIu64 "\n",
-                        event_name(counter), count[0], count[1], count[2]);
+                        perf_evsel__name(counter), count[0], count[1], count[2]);
         }
 
         /*
@@ -496,7 +496,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                             errno == ENXIO) {
                                 if (verbose)
                                         ui__warning("%s event is not supported by the kernel.\n",
-                                                    event_name(counter));
+                                                    perf_evsel__name(counter));
                                 counter->supported = false;
                                 continue;
                         }
@@ -594,7 +594,7 @@ static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
                         csv_output ? 0 : -4,
                         evsel_list->cpus->map[cpu], csv_sep);
 
-        fprintf(output, fmt, cpustr, msecs, csv_sep, event_name(evsel));
+        fprintf(output, fmt, cpustr, msecs, csv_sep, perf_evsel__name(evsel));
 
         if (evsel->cgrp)
                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
@@ -792,7 +792,7 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
         else
                 cpu = 0;
 
-        fprintf(output, fmt, cpustr, avg, csv_sep, event_name(evsel));
+        fprintf(output, fmt, cpustr, avg, csv_sep, perf_evsel__name(evsel));
 
         if (evsel->cgrp)
                 fprintf(output, "%s%s", csv_sep, evsel->cgrp->name);
@@ -908,7 +908,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
                         counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
                         csv_sep,
                         csv_output ? 0 : -24,
-                        event_name(counter));
+                        perf_evsel__name(counter));
 
                 if (counter->cgrp)
                         fprintf(output, "%s%s", csv_sep, counter->cgrp->name);
@@ -961,7 +961,7 @@ static void print_counter(struct perf_evsel *counter)
                                 counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
                                 csv_sep,
                                 csv_output ? 0 : -24,
-                                event_name(counter));
+                                perf_evsel__name(counter));
 
                         if (counter->cgrp)
                                 fprintf(output, "%s%s",
@@ -1179,6 +1179,12 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 fprintf(stderr, "cannot use both --output and --log-fd\n");
                 usage_with_options(stat_usage, options);
         }
+
+        if (output_fd < 0) {
+                fprintf(stderr, "argument to --log-fd must be a > 0\n");
+                usage_with_options(stat_usage, options);
+        }
+
         if (!output) {
                 struct timespec tm;
                 mode = append_file ? "a" : "w";
@@ -1190,7 +1196,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
                 }
                 clock_gettime(CLOCK_REALTIME, &tm);
                 fprintf(output, "# started on %s\n", ctime(&tm.tv_sec));
-        } else if (output_fd != 2) {
+        } else if (output_fd > 0) {
                 mode = append_file ? "a" : "w";
                 output = fdopen(output_fd, mode);
                 if (!output) {
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 5a8727c08757..d909eb74a0eb 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -583,7 +583,7 @@ static int test__basic_mmap(void)
                 if (nr_events[evsel->idx] != expected_nr_events[evsel->idx]) {
                         pr_debug("expected %d %s events, got %d\n",
                                  expected_nr_events[evsel->idx],
-                                 event_name(evsel), nr_events[evsel->idx]);
+                                 perf_evsel__name(evsel), nr_events[evsel->idx]);
                         goto out_munmap;
                 }
         }
@@ -1142,6 +1142,10 @@ static struct test {
                 .func = test__perf_pmu,
         },
         {
+                .desc = "Test dso data interface",
+                .func = dso__test_data,
+        },
+        {
                 .func = NULL,
         },
 };
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 6bb0277b7dfe..35e86c6df713 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -125,7 +125,7 @@ static int perf_top__parse_source(struct perf_top *top, struct hist_entry *he)
         /*
          * We can't annotate with just /proc/kallsyms
          */
-        if (map->dso->symtab_type == SYMTAB__KALLSYMS) {
+        if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS) {
                 pr_err("Can't annotate %s: No vmlinux file was found in the "
                        "path\n", sym->name);
                 sleep(1);
@@ -245,7 +245,7 @@ static void perf_top__show_details(struct perf_top *top)
         if (notes->src == NULL)
                 goto out_unlock;
 
-        printf("Showing %s for %s\n", event_name(top->sym_evsel), symbol->name);
+        printf("Showing %s for %s\n", perf_evsel__name(top->sym_evsel), symbol->name);
         printf("  Events  Pcnt (>=%d%%)\n", top->sym_pcnt_filter);
 
         more = symbol__annotate_printf(symbol, he->ms.map, top->sym_evsel->idx,
@@ -408,7 +408,7 @@ static void perf_top__print_mapped_keys(struct perf_top *top)
         fprintf(stdout, "\t[e]     display entries (lines).           \t(%d)\n", top->print_entries);
 
         if (top->evlist->nr_entries > 1)
-                fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", event_name(top->sym_evsel));
+                fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", perf_evsel__name(top->sym_evsel));
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", top->count_filter);
 
@@ -503,13 +503,13 @@ static void perf_top__handle_keypress(struct perf_top *top, int c)
                                 fprintf(stderr, "\nAvailable events:");
 
                                 list_for_each_entry(top->sym_evsel, &top->evlist->entries, node)
-                                        fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, event_name(top->sym_evsel));
+                                        fprintf(stderr, "\n\t%d %s", top->sym_evsel->idx, perf_evsel__name(top->sym_evsel));
 
                                 prompt_integer(&counter, "Enter details event counter");
 
                                 if (counter >= top->evlist->nr_entries) {
                                         top->sym_evsel = list_entry(top->evlist->entries.next, struct perf_evsel, node);
-                                        fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(top->sym_evsel));
+                                        fprintf(stderr, "Sorry, no such event, using %s.\n", perf_evsel__name(top->sym_evsel));
                                         sleep(1);
                                         break;
                                 }
@@ -774,7 +774,7 @@ static void perf_event__process_sample(struct perf_tool *tool,
 
                 if ((sort__has_parent || symbol_conf.use_callchain) &&
                     sample->callchain) {
-                        err = machine__resolve_callchain(machine, evsel, al.thread,
+                        err = machine__resolve_callchain(machine, al.thread,
                                                          sample->callchain, &parent);
                         if (err)
                                 return;
@@ -960,7 +960,7 @@ try_again:
 
                         if (err == ENOENT) {
                                 ui__error("The %s event is not supported.\n",
-                                            event_name(counter));
+                                          perf_evsel__name(counter));
                                 goto out_err;
                         } else if (err == EMFILE) {
                                 ui__error("Too many events are opened.\n"
diff --git a/tools/perf/config/feature-tests.mak b/tools/perf/config/feature-tests.mak
index d9084e03ce56..6c18785a6417 100644
--- a/tools/perf/config/feature-tests.mak
+++ b/tools/perf/config/feature-tests.mak
@@ -78,6 +78,19 @@ int main(int argc, char *argv[])
         return 0;
 }
 endef
+
+define SOURCE_GTK2_INFOBAR
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#include <gtk/gtk.h>
+#pragma GCC diagnostic error \"-Wstrict-prototypes\"
+
+int main(void)
+{
+        gtk_info_bar_new();
+
+        return 0;
+}
+endef
 endif
 
 ifndef NO_LIBPERL
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
index 34b1c46eaf42..67a2703e666a 100644
--- a/tools/perf/ui/browsers/annotate.c
+++ b/tools/perf/ui/browsers/annotate.c
@@ -814,7 +814,7 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
 {
         struct disasm_line *pos, *n;
         struct annotation *notes;
-        const size_t size = symbol__size(sym);
+        size_t size;
         struct map_symbol ms = {
                 .map = map,
                 .sym = sym,
@@ -834,6 +834,8 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
         if (sym == NULL)
                 return -1;
 
+        size = symbol__size(sym);
+
         if (map->dso->annotate_warned)
                 return -1;
 
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 53f6697d014e..413bd62eedb1 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -23,6 +23,7 @@ struct hist_browser {
         struct hists        *hists;
         struct hist_entry   *he_selection;
         struct map_symbol   *selection;
+        int                  print_seq;
         bool                 has_symbols;
 };
 
@@ -800,6 +801,196 @@ do_offset:
         }
 }
 
+static int hist_browser__fprintf_callchain_node_rb_tree(struct hist_browser *browser,
+                                                        struct callchain_node *chain_node,
+                                                        u64 total, int level,
+                                                        FILE *fp)
+{
+        struct rb_node *node;
+        int offset = level * LEVEL_OFFSET_STEP;
+        u64 new_total, remaining;
+        int printed = 0;
+
+        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 = callchain_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;
+                        bool was_first = first;
+
+                        if (first)
+                                first = false;
+                        else
+                                extra_offset = LEVEL_OFFSET_STEP;
+
+                        folded_sign = callchain_list__folded(chain);
+
+                        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;
+                        }
+
+                        printed += fprintf(fp, "%*s%c %s\n", offset + extra_offset, " ", folded_sign, str);
+                        free(alloc_str);
+                        if (folded_sign == '+')
+                                break;
+                }
+
+                if (folded_sign == '-') {
+                        const int new_level = level + (extra_offset ? 2 : 1);
+                        printed += hist_browser__fprintf_callchain_node_rb_tree(browser, child, new_total,
+                                                                                new_level, fp);
+                }
+
+                node = next;
+        }
+
+        return printed;
+}
+
+static int hist_browser__fprintf_callchain_node(struct hist_browser *browser,
+                                                struct callchain_node *node,
+                                                int level, FILE *fp)
+{
+        struct callchain_list *chain;
+        int offset = level * LEVEL_OFFSET_STEP;
+        char folded_sign = ' ';
+        int printed = 0;
+
+        list_for_each_entry(chain, &node->val, list) {
+                char ipstr[BITS_PER_LONG / 4 + 1], *s;
+
+                folded_sign = callchain_list__folded(chain);
+                s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                printed += fprintf(fp, "%*s%c %s\n", offset, " ", folded_sign, s);
+        }
+
+        if (folded_sign == '-')
+                printed += hist_browser__fprintf_callchain_node_rb_tree(browser, node,
+                                                                        browser->hists->stats.total_period,
+                                                                        level + 1,  fp);
+        return printed;
+}
+
+static int hist_browser__fprintf_callchain(struct hist_browser *browser,
+                                           struct rb_root *chain, int level, FILE *fp)
+{
+        struct rb_node *nd;
+        int printed = 0;
+
+        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+
+                printed += hist_browser__fprintf_callchain_node(browser, node, level, fp);
+        }
+
+        return printed;
+}
+
+static int hist_browser__fprintf_entry(struct hist_browser *browser,
+                                       struct hist_entry *he, FILE *fp)
+{
+        char s[8192];
+        double percent;
+        int printed = 0;
+        char folded_sign = ' ';
+
+        if (symbol_conf.use_callchain)
+                folded_sign = hist_entry__folded(he);
+
+        hist_entry__snprintf(he, s, sizeof(s), browser->hists);
+        percent = (he->period * 100.0) / browser->hists->stats.total_period;
+
+        if (symbol_conf.use_callchain)
+                printed += fprintf(fp, "%c ", folded_sign);
+
+        printed += fprintf(fp, " %5.2f%%", percent);
+
+        if (symbol_conf.show_nr_samples)
+                printed += fprintf(fp, " %11u", he->nr_events);
+
+        if (symbol_conf.show_total_period)
+                printed += fprintf(fp, " %12" PRIu64, he->period);
+
+        printed += fprintf(fp, "%s\n", rtrim(s));
+
+        if (folded_sign == '-')
+                printed += hist_browser__fprintf_callchain(browser, &he->sorted_chain, 1, fp);
+
+        return printed;
+}
+
+static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
+{
+        struct rb_node *nd = hists__filter_entries(rb_first(browser->b.entries));
+        int printed = 0;
+
+        while (nd) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+
+                printed += hist_browser__fprintf_entry(browser, h, fp);
+                nd = hists__filter_entries(rb_next(nd));
+        }
+
+        return printed;
+}
+
+static int hist_browser__dump(struct hist_browser *browser)
+{
+        char filename[64];
+        FILE *fp;
+
+        while (1) {
+                scnprintf(filename, sizeof(filename), "perf.hist.%d", browser->print_seq);
+                if (access(filename, F_OK))
+                        break;
+                /*
+                 * XXX: Just an arbitrary lazy upper limit
+                 */
+                if (++browser->print_seq == 8192) {
+                        ui_helpline__fpush("Too many perf.hist.N files, nothing written!");
+                        return -1;
+                }
+        }
+
+        fp = fopen(filename, "w");
+        if (fp == NULL) {
+                char bf[64];
+                const char *err = strerror_r(errno, bf, sizeof(bf));
+                ui_helpline__fpush("Couldn't write to %s: %s", filename, err);
+                return -1;
+        }
+
+        ++browser->print_seq;
+        hist_browser__fprintf(browser, fp);
+        fclose(fp);
+        ui_helpline__fpush("%s written!", filename);
+
+        return 0;
+}
+
 static struct hist_browser *hist_browser__new(struct hists *hists)
 {
         struct hist_browser *browser = zalloc(sizeof(*browser));
@@ -937,6 +1128,9 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                             browser->selection->map->dso->annotate_warned)
                                 continue;
                         goto do_annotate;
+                case 'P':
+                        hist_browser__dump(browser);
+                        continue;
                 case 'd':
                         goto zoom_dso;
                 case 't':
@@ -969,6 +1163,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                         "E             Expand all callchains\n"
                                         "d             Zoom into current DSO\n"
                                         "t             Zoom into current Thread\n"
+                                        "P             Print histograms to perf.hist.N\n"
                                         "/             Filter symbol by name");
                         continue;
                 case K_ENTER:
@@ -1172,7 +1367,7 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
         struct perf_evsel *evsel = list_entry(entry, struct perf_evsel, node);
         bool current_entry = ui_browser__is_current_entry(browser, row);
         unsigned long nr_events = evsel->hists.stats.nr_events[PERF_RECORD_SAMPLE];
-        const char *ev_name = event_name(evsel);
+        const char *ev_name = perf_evsel__name(evsel);
         char bf[256], unit;
         const char *warn = " ";
         size_t printed;
@@ -1240,7 +1435,7 @@ browse_hists:
                          */
                         if (timer)
                                 timer(arg);
-                        ev_name = event_name(pos);
+                        ev_name = perf_evsel__name(pos);
                         key = perf_evsel__hists_browse(pos, nr_events, help,
                                                        ev_name, true, timer,
                                                        arg, delay_secs);
@@ -1309,17 +1504,11 @@ static int __perf_evlist__tui_browse_hists(struct perf_evlist *evlist,
         ui_helpline__push("Press ESC to exit");
 
         list_for_each_entry(pos, &evlist->entries, node) {
-                const char *ev_name = event_name(pos);
+                const char *ev_name = perf_evsel__name(pos);
                 size_t line_len = strlen(ev_name) + 7;
 
                 if (menu.b.width < line_len)
                         menu.b.width = line_len;
-                /*
-                 * Cache the evsel name, tracepoints have a _high_ cost per
-                 * event_name() call.
-                 */
-                if (pos->name == NULL)
-                        pos->name = strdup(ev_name);
         }
 
         return perf_evsel_menu__run(&menu, evlist->nr_entries, help, timer,
@@ -1330,11 +1519,10 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
                                   void(*timer)(void *arg), void *arg,
                                   int delay_secs)
 {
-
         if (evlist->nr_entries == 1) {
                 struct perf_evsel *first = list_entry(evlist->entries.next,
                                                       struct perf_evsel, node);
-                const char *ev_name = event_name(first);
+                const char *ev_name = perf_evsel__name(first);
                 return perf_evsel__hists_browse(first, evlist->nr_entries, help,
                                                 ev_name, false, timer, arg,
                                                 delay_secs);
diff --git a/tools/perf/ui/gtk/browser.c b/tools/perf/ui/gtk/browser.c
index 0656c381a89c..ec12e0b4ded6 100644
--- a/tools/perf/ui/gtk/browser.c
+++ b/tools/perf/ui/gtk/browser.c
@@ -11,8 +11,8 @@
 
 static void perf_gtk__signal(int sig)
 {
+        perf_gtk__exit(false);
         psignal(sig, "perf");
-        gtk_main_quit();
 }
 
 static void perf_gtk__resize_window(GtkWidget *window)
@@ -122,13 +122,59 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
         gtk_container_add(GTK_CONTAINER(window), view);
 }
 
+#ifdef HAVE_GTK_INFO_BAR
+static GtkWidget *perf_gtk__setup_info_bar(void)
+{
+        GtkWidget *info_bar;
+        GtkWidget *label;
+        GtkWidget *content_area;
+
+        info_bar = gtk_info_bar_new();
+        gtk_widget_set_no_show_all(info_bar, TRUE);
+
+        label = gtk_label_new("");
+        gtk_widget_show(label);
+
+        content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_bar));
+        gtk_container_add(GTK_CONTAINER(content_area), label);
+
+        gtk_info_bar_add_button(GTK_INFO_BAR(info_bar), GTK_STOCK_OK,
+                                GTK_RESPONSE_OK);
+        g_signal_connect(info_bar, "response",
+                         G_CALLBACK(gtk_widget_hide), NULL);
+
+        pgctx->info_bar = info_bar;
+        pgctx->message_label = label;
+
+        return info_bar;
+}
+#endif
+
+static GtkWidget *perf_gtk__setup_statusbar(void)
+{
+        GtkWidget *stbar;
+        unsigned ctxid;
+
+        stbar = gtk_statusbar_new();
+
+        ctxid = gtk_statusbar_get_context_id(GTK_STATUSBAR(stbar),
+                                             "perf report");
+        pgctx->statbar = stbar;
+        pgctx->statbar_ctx_id = ctxid;
+
+        return stbar;
+}
+
 int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
                                   const char *help __used,
                                   void (*timer) (void *arg)__used,
                                   void *arg __used, int delay_secs __used)
 {
         struct perf_evsel *pos;
+        GtkWidget *vbox;
         GtkWidget *notebook;
+        GtkWidget *info_bar;
+        GtkWidget *statbar;
         GtkWidget *window;
 
         signal(SIGSEGV, perf_gtk__signal);
@@ -143,11 +189,17 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 
         g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
 
+        pgctx = perf_gtk__activate_context(window);
+        if (!pgctx)
+                return -1;
+
+        vbox = gtk_vbox_new(FALSE, 0);
+
         notebook = gtk_notebook_new();
 
         list_for_each_entry(pos, &evlist->entries, node) {
                 struct hists *hists = &pos->hists;
-                const char *evname = event_name(pos);
+                const char *evname = perf_evsel__name(pos);
                 GtkWidget *scrolled_window;
                 GtkWidget *tab_label;
 
@@ -164,7 +216,16 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
                 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window, tab_label);
         }
 
-        gtk_container_add(GTK_CONTAINER(window), notebook);
+        gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
+
+        info_bar = perf_gtk__setup_info_bar();
+        if (info_bar)
+                gtk_box_pack_start(GTK_BOX(vbox), info_bar, FALSE, FALSE, 0);
+
+        statbar = perf_gtk__setup_statusbar();
+        gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
+
+        gtk_container_add(GTK_CONTAINER(window), vbox);
 
         gtk_widget_show_all(window);
 
@@ -174,5 +235,7 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 
         gtk_main();
 
+        perf_gtk__deactivate_context(&pgctx);
+
         return 0;
 }
diff --git a/tools/perf/ui/gtk/gtk.h b/tools/perf/ui/gtk/gtk.h
index 75177ee04032..a4d0f2b4a2dc 100644
--- a/tools/perf/ui/gtk/gtk.h
+++ b/tools/perf/ui/gtk/gtk.h
@@ -1,8 +1,39 @@
 #ifndef _PERF_GTK_H_
 #define _PERF_GTK_H_ 1
 
+#include <stdbool.h>
+
 #pragma GCC diagnostic ignored "-Wstrict-prototypes"
 #include <gtk/gtk.h>
 #pragma GCC diagnostic error "-Wstrict-prototypes"
 
+
+struct perf_gtk_context {
+        GtkWidget *main_window;
+
+#ifdef HAVE_GTK_INFO_BAR
+        GtkWidget *info_bar;
+        GtkWidget *message_label;
+#endif
+        GtkWidget *statbar;
+        guint statbar_ctx_id;
+};
+
+extern struct perf_gtk_context *pgctx;
+
+static inline bool perf_gtk__is_active_context(struct perf_gtk_context *ctx)
+{
+        return ctx && ctx->main_window;
+}
+
+struct perf_gtk_context *perf_gtk__activate_context(GtkWidget *window);
+int perf_gtk__deactivate_context(struct perf_gtk_context **ctx);
+
+#ifndef HAVE_GTK_INFO_BAR
+static inline GtkWidget *perf_gtk__setup_info_bar(void)
+{
+        return NULL;
+}
+#endif
+
 #endif /* _PERF_GTK_H_ */
diff --git a/tools/perf/ui/gtk/setup.c b/tools/perf/ui/gtk/setup.c
index 829529957766..92879ce61e2f 100644
--- a/tools/perf/ui/gtk/setup.c
+++ b/tools/perf/ui/gtk/setup.c
@@ -1,12 +1,17 @@
 #include "gtk.h"
 #include "../../util/cache.h"
+#include "../../util/debug.h"
+
+extern struct perf_error_ops perf_gtk_eops;
 
 int perf_gtk__init(void)
 {
+        perf_error__register(&perf_gtk_eops);
         return gtk_init_check(NULL, NULL) ? 0 : -1;
 }
 
 void perf_gtk__exit(bool wait_for_ok __used)
 {
+        perf_error__unregister(&perf_gtk_eops);
         gtk_main_quit();
 }
diff --git a/tools/perf/ui/gtk/util.c b/tools/perf/ui/gtk/util.c
new file mode 100644
index 000000000000..0ead373c0dfb
--- /dev/null
+++ b/tools/perf/ui/gtk/util.c
@@ -0,0 +1,129 @@
+#include "../util.h"
+#include "../../util/debug.h"
+#include "gtk.h"
+
+#include <string.h>
+
+
+struct perf_gtk_context *pgctx;
+
+struct perf_gtk_context *perf_gtk__activate_context(GtkWidget *window)
+{
+        struct perf_gtk_context *ctx;
+
+        ctx = malloc(sizeof(*pgctx));
+        if (ctx)
+                ctx->main_window = window;
+
+        return ctx;
+}
+
+int perf_gtk__deactivate_context(struct perf_gtk_context **ctx)
+{
+        if (!perf_gtk__is_active_context(*ctx))
+                return -1;
+
+        free(*ctx);
+        *ctx = NULL;
+        return 0;
+}
+
+static int perf_gtk__error(const char *format, va_list args)
+{
+        char *msg;
+        GtkWidget *dialog;
+
+        if (!perf_gtk__is_active_context(pgctx) ||
+            vasprintf(&msg, format, args) < 0) {
+                fprintf(stderr, "Error:\n");
+                vfprintf(stderr, format, args);
+                fprintf(stderr, "\n");
+                return -1;
+        }
+
+        dialog = gtk_message_dialog_new_with_markup(GTK_WINDOW(pgctx->main_window),
+                                        GTK_DIALOG_DESTROY_WITH_PARENT,
+                                        GTK_MESSAGE_ERROR,
+                                        GTK_BUTTONS_CLOSE,
+                                        "<b>Error</b>\n\n%s", msg);
+        gtk_dialog_run(GTK_DIALOG(dialog));
+
+        gtk_widget_destroy(dialog);
+        free(msg);
+        return 0;
+}
+
+#ifdef HAVE_GTK_INFO_BAR
+static int perf_gtk__warning_info_bar(const char *format, va_list args)
+{
+        char *msg;
+
+        if (!perf_gtk__is_active_context(pgctx) ||
+            vasprintf(&msg, format, args) < 0) {
+                fprintf(stderr, "Warning:\n");
+                vfprintf(stderr, format, args);
+                fprintf(stderr, "\n");
+                return -1;
+        }
+
+        gtk_label_set_text(GTK_LABEL(pgctx->message_label), msg);
+        gtk_info_bar_set_message_type(GTK_INFO_BAR(pgctx->info_bar),
+                                      GTK_MESSAGE_WARNING);
+        gtk_widget_show(pgctx->info_bar);
+
+        free(msg);
+        return 0;
+}
+#else
+static int perf_gtk__warning_statusbar(const char *format, va_list args)
+{
+        char *msg, *p;
+
+        if (!perf_gtk__is_active_context(pgctx) ||
+            vasprintf(&msg, format, args) < 0) {
+                fprintf(stderr, "Warning:\n");
+                vfprintf(stderr, format, args);
+                fprintf(stderr, "\n");
+                return -1;
+        }
+
+        gtk_statusbar_pop(GTK_STATUSBAR(pgctx->statbar),
+                          pgctx->statbar_ctx_id);
+
+        /* Only first line can be displayed */
+        p = strchr(msg, '\n');
+        if (p)
+                *p = '\0';
+
+        gtk_statusbar_push(GTK_STATUSBAR(pgctx->statbar),
+                           pgctx->statbar_ctx_id, msg);
+
+        free(msg);
+        return 0;
+}
+#endif
+
+struct perf_error_ops perf_gtk_eops = {
+        .error          = perf_gtk__error,
+#ifdef HAVE_GTK_INFO_BAR
+        .warning        = perf_gtk__warning_info_bar,
+#else
+        .warning        = perf_gtk__warning_statusbar,
+#endif
+};
+
+/*
+ * FIXME: Functions below should be implemented properly.
+ *        For now, just add stubs for NO_NEWT=1 build.
+ */
+#ifdef NO_NEWT_SUPPORT
+int ui_helpline__show_help(const char *format __used, va_list ap __used)
+{
+        return 0;
+}
+
+void ui_progress__update(u64 curr __used, u64 total __used,
+                         const char *title __used)
+{
+}
+#endif
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index d33e943ac434..e813c1d17346 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -15,6 +15,8 @@ pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
 static volatile int ui__need_resize;
 
+extern struct perf_error_ops perf_tui_eops;
+
 void ui__refresh_dimensions(bool force)
 {
         if (force || ui__need_resize) {
@@ -122,6 +124,8 @@ int ui__init(void)
         signal(SIGINT, ui__signal);
         signal(SIGQUIT, ui__signal);
         signal(SIGTERM, ui__signal);
+
+        perf_error__register(&perf_tui_eops);
 out:
         return err;
 }
@@ -137,4 +141,6 @@ void ui__exit(bool wait_for_ok)
         SLsmg_refresh();
         SLsmg_reset_smg();
         SLang_reset_tty();
+
+        perf_error__unregister(&perf_tui_eops);
 }
diff --git a/tools/perf/ui/tui/util.c b/tools/perf/ui/tui/util.c
new file mode 100644
index 000000000000..092902e30cee
--- /dev/null
+++ b/tools/perf/ui/tui/util.c
@@ -0,0 +1,243 @@
+#include "../../util/util.h"
+#include <signal.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/ttydefaults.h>
+
+#include "../../util/cache.h"
+#include "../../util/debug.h"
+#include "../browser.h"
+#include "../keysyms.h"
+#include "../helpline.h"
+#include "../ui.h"
+#include "../util.h"
+#include "../libslang.h"
+
+static void ui_browser__argv_write(struct ui_browser *browser,
+                                   void *entry, int row)
+{
+        char **arg = entry;
+        bool current_entry = ui_browser__is_current_entry(browser, row);
+
+        ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
+                                                       HE_COLORSET_NORMAL);
+        slsmg_write_nstring(*arg, browser->width);
+}
+
+static int popup_menu__run(struct ui_browser *menu)
+{
+        int key;
+
+        if (ui_browser__show(menu, " ", "ESC: exit, ENTER|->: Select option") < 0)
+                return -1;
+
+        while (1) {
+                key = ui_browser__run(menu, 0);
+
+                switch (key) {
+                case K_RIGHT:
+                case K_ENTER:
+                        key = menu->index;
+                        break;
+                case K_LEFT:
+                case K_ESC:
+                case 'q':
+                case CTRL('c'):
+                        key = -1;
+                        break;
+                default:
+                        continue;
+                }
+
+                break;
+        }
+
+        ui_browser__hide(menu);
+        return key;
+}
+
+int ui__popup_menu(int argc, char * const argv[])
+{
+        struct ui_browser menu = {
+                .entries    = (void *)argv,
+                .refresh    = ui_browser__argv_refresh,
+                .seek       = ui_browser__argv_seek,
+                .write      = ui_browser__argv_write,
+                .nr_entries = argc,
+        };
+
+        return popup_menu__run(&menu);
+}
+
+int ui_browser__input_window(const char *title, const char *text, char *input,
+                             const char *exit_msg, int delay_secs)
+{
+        int x, y, len, key;
+        int max_len = 60, nr_lines = 0;
+        static char buf[50];
+        const char *t;
+
+        t = text;
+        while (1) {
+                const char *sep = strchr(t, '\n');
+
+                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;
+        }
+
+        max_len += 2;
+        nr_lines += 8;
+        y = SLtt_Screen_Rows / 2 - nr_lines / 2;
+        x = SLtt_Screen_Cols / 2 - max_len / 2;
+
+        SLsmg_set_color(0);
+        SLsmg_draw_box(y, x++, nr_lines, max_len);
+        if (title) {
+                SLsmg_gotorc(y, x + 1);
+                SLsmg_write_string((char *)title);
+        }
+        SLsmg_gotorc(++y, x);
+        nr_lines -= 7;
+        max_len -= 2;
+        SLsmg_write_wrapped_string((unsigned char *)text, y, x,
+                                   nr_lines, max_len, 1);
+        y += nr_lines;
+        len = 5;
+        while (len--) {
+                SLsmg_gotorc(y + len - 1, x);
+                SLsmg_write_nstring((char *)" ", max_len);
+        }
+        SLsmg_draw_box(y++, x + 1, 3, max_len - 2);
+
+        SLsmg_gotorc(y + 3, x);
+        SLsmg_write_nstring((char *)exit_msg, max_len);
+        SLsmg_refresh();
+
+        x += 2;
+        len = 0;
+        key = ui__getch(delay_secs);
+        while (key != K_TIMER && key != K_ENTER && key != K_ESC) {
+                if (key == K_BKSPC) {
+                        if (len == 0)
+                                goto next_key;
+                        SLsmg_gotorc(y, x + --len);
+                        SLsmg_write_char(' ');
+                } else {
+                        buf[len] = key;
+                        SLsmg_gotorc(y, x + len++);
+                        SLsmg_write_char(key);
+                }
+                SLsmg_refresh();
+
+                /* XXX more graceful overflow handling needed */
+                if (len == sizeof(buf) - 1) {
+                        ui_helpline__push("maximum size of symbol name reached!");
+                        key = K_ENTER;
+                        break;
+                }
+next_key:
+                key = ui__getch(delay_secs);
+        }
+
+        buf[len] = '\0';
+        strncpy(input, buf, len+1);
+        return key;
+}
+
+int ui__question_window(const char *title, const char *text,
+                        const char *exit_msg, int delay_secs)
+{
+        int x, y;
+        int max_len = 0, nr_lines = 0;
+        const char *t;
+
+        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;
+        }
+
+        max_len += 2;
+        nr_lines += 4;
+        y = SLtt_Screen_Rows / 2 - nr_lines / 2,
+        x = SLtt_Screen_Cols / 2 - max_len / 2;
+
+        SLsmg_set_color(0);
+        SLsmg_draw_box(y, x++, nr_lines, max_len);
+        if (title) {
+                SLsmg_gotorc(y, x + 1);
+                SLsmg_write_string((char *)title);
+        }
+        SLsmg_gotorc(++y, x);
+        nr_lines -= 2;
+        max_len -= 2;
+        SLsmg_write_wrapped_string((unsigned char *)text, y, x,
+                                   nr_lines, max_len, 1);
+        SLsmg_gotorc(y + nr_lines - 2, x);
+        SLsmg_write_nstring((char *)" ", max_len);
+        SLsmg_gotorc(y + nr_lines - 1, x);
+        SLsmg_write_nstring((char *)exit_msg, max_len);
+        SLsmg_refresh();
+        return ui__getch(delay_secs);
+}
+
+int ui__help_window(const char *text)
+{
+        return ui__question_window("Help", text, "Press any key...", 0);
+}
+
+int ui__dialog_yesno(const char *msg)
+{
+        return ui__question_window(NULL, msg, "Enter: Yes, ESC: No", 0);
+}
+
+static int __ui__warning(const char *title, const char *format, va_list args)
+{
+        char *s;
+
+        if (vasprintf(&s, format, args) > 0) {
+                int key;
+
+                pthread_mutex_lock(&ui__lock);
+                key = ui__question_window(title, s, "Press any key...", 0);
+                pthread_mutex_unlock(&ui__lock);
+                free(s);
+                return key;
+        }
+
+        fprintf(stderr, "%s\n", title);
+        vfprintf(stderr, format, args);
+        return K_ESC;
+}
+
+static int perf_tui__error(const char *format, va_list args)
+{
+        return __ui__warning("Error:", format, args);
+}
+
+static int perf_tui__warning(const char *format, va_list args)
+{
+        return __ui__warning("Warning:", format, args);
+}
+
+struct perf_error_ops perf_tui_eops = {
+        .error          = perf_tui__error,
+        .warning        = perf_tui__warning,
+};
diff --git a/tools/perf/ui/util.c b/tools/perf/ui/util.c
index ad4374a16bb0..4f989774c8c6 100644
--- a/tools/perf/ui/util.c
+++ b/tools/perf/ui/util.c
@@ -1,250 +1,85 @@
-#include "../util.h"
-#include <signal.h>
-#include <stdbool.h>
-#include <string.h>
-#include <sys/ttydefaults.h>
-
-#include "../cache.h"
-#include "../debug.h"
-#include "browser.h"
-#include "keysyms.h"
-#include "helpline.h"
-#include "ui.h"
 #include "util.h"
-#include "libslang.h"
-
-static void ui_browser__argv_write(struct ui_browser *browser,
-                                   void *entry, int row)
-{
-        char **arg = entry;
-        bool current_entry = ui_browser__is_current_entry(browser, row);
-
-        ui_browser__set_color(browser, current_entry ? HE_COLORSET_SELECTED :
-                                                       HE_COLORSET_NORMAL);
-        slsmg_write_nstring(*arg, browser->width);
-}
-
-static int popup_menu__run(struct ui_browser *menu)
-{
-        int key;
-
-        if (ui_browser__show(menu, " ", "ESC: exit, ENTER|->: Select option") < 0)
-                return -1;
+#include "../debug.h"
 
-        while (1) {
-                key = ui_browser__run(menu, 0);
-
-                switch (key) {
-                case K_RIGHT:
-                case K_ENTER:
-                        key = menu->index;
-                        break;
-                case K_LEFT:
-                case K_ESC:
-                case 'q':
-                case CTRL('c'):
-                        key = -1;
-                        break;
-                default:
-                        continue;
-                }
-
-                break;
-        }
-
-        ui_browser__hide(menu);
-        return key;
-}
 
-int ui__popup_menu(int argc, char * const argv[])
+/*
+ * Default error logging functions
+ */
+static int perf_stdio__error(const char *format, va_list args)
 {
-        struct ui_browser menu = {
-                .entries    = (void *)argv,
-                .refresh    = ui_browser__argv_refresh,
-                .seek       = ui_browser__argv_seek,
-                .write      = ui_browser__argv_write,
-                .nr_entries = argc,
-        };
-
-        return popup_menu__run(&menu);
+        fprintf(stderr, "Error:\n");
+        vfprintf(stderr, format, args);
+        return 0;
 }
 
-int ui_browser__input_window(const char *title, const char *text, char *input,
-                             const char *exit_msg, int delay_secs)
+static int perf_stdio__warning(const char *format, va_list args)
 {
-        int x, y, len, key;
-        int max_len = 60, nr_lines = 0;
-        static char buf[50];
-        const char *t;
-
-        t = text;
-        while (1) {
-                const char *sep = strchr(t, '\n');
-
-                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;
-        }
-
-        max_len += 2;
-        nr_lines += 8;
-        y = SLtt_Screen_Rows / 2 - nr_lines / 2;
-        x = SLtt_Screen_Cols / 2 - max_len / 2;
-
-        SLsmg_set_color(0);
-        SLsmg_draw_box(y, x++, nr_lines, max_len);
-        if (title) {
-                SLsmg_gotorc(y, x + 1);
-                SLsmg_write_string((char *)title);
-        }
-        SLsmg_gotorc(++y, x);
-        nr_lines -= 7;
-        max_len -= 2;
-        SLsmg_write_wrapped_string((unsigned char *)text, y, x,
-                                   nr_lines, max_len, 1);
-        y += nr_lines;
-        len = 5;
-        while (len--) {
-                SLsmg_gotorc(y + len - 1, x);
-                SLsmg_write_nstring((char *)" ", max_len);
-        }
-        SLsmg_draw_box(y++, x + 1, 3, max_len - 2);
-
-        SLsmg_gotorc(y + 3, x);
-        SLsmg_write_nstring((char *)exit_msg, max_len);
-        SLsmg_refresh();
-
-        x += 2;
-        len = 0;
-        key = ui__getch(delay_secs);
-        while (key != K_TIMER && key != K_ENTER && key != K_ESC) {
-                if (key == K_BKSPC) {
-                        if (len == 0)
-                                goto next_key;
-                        SLsmg_gotorc(y, x + --len);
-                        SLsmg_write_char(' ');
-                } else {
-                        buf[len] = key;
-                        SLsmg_gotorc(y, x + len++);
-                        SLsmg_write_char(key);
-                }
-                SLsmg_refresh();
-
-                /* XXX more graceful overflow handling needed */
-                if (len == sizeof(buf) - 1) {
-                        ui_helpline__push("maximum size of symbol name reached!");
-                        key = K_ENTER;
-                        break;
-                }
-next_key:
-                key = ui__getch(delay_secs);
-        }
-
-        buf[len] = '\0';
-        strncpy(input, buf, len+1);
-        return key;
+        fprintf(stderr, "Warning:\n");
+        vfprintf(stderr, format, args);
+        return 0;
 }
 
-int ui__question_window(const char *title, const char *text,
-                        const char *exit_msg, int delay_secs)
+static struct perf_error_ops default_eops =
 {
-        int x, y;
-        int max_len = 0, nr_lines = 0;
-        const char *t;
-
-        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;
-        }
-
-        max_len += 2;
-        nr_lines += 4;
-        y = SLtt_Screen_Rows / 2 - nr_lines / 2,
-        x = SLtt_Screen_Cols / 2 - max_len / 2;
-
-        SLsmg_set_color(0);
-        SLsmg_draw_box(y, x++, nr_lines, max_len);
-        if (title) {
-                SLsmg_gotorc(y, x + 1);
-                SLsmg_write_string((char *)title);
-        }
-        SLsmg_gotorc(++y, x);
-        nr_lines -= 2;
-        max_len -= 2;
-        SLsmg_write_wrapped_string((unsigned char *)text, y, x,
-                                   nr_lines, max_len, 1);
-        SLsmg_gotorc(y + nr_lines - 2, x);
-        SLsmg_write_nstring((char *)" ", max_len);
-        SLsmg_gotorc(y + nr_lines - 1, x);
-        SLsmg_write_nstring((char *)exit_msg, max_len);
-        SLsmg_refresh();
-        return ui__getch(delay_secs);
-}
+        .error          = perf_stdio__error,
+        .warning        = perf_stdio__warning,
+};
 
-int ui__help_window(const char *text)
-{
-        return ui__question_window("Help", text, "Press any key...", 0);
-}
+static struct perf_error_ops *perf_eops = &default_eops;
 
-int ui__dialog_yesno(const char *msg)
-{
-        return ui__question_window(NULL, msg, "Enter: Yes, ESC: No", 0);
-}
 
-int __ui__warning(const char *title, const char *format, va_list args)
+int ui__error(const char *format, ...)
 {
-        char *s;
-
-        if (use_browser > 0 && vasprintf(&s, format, args) > 0) {
-                int key;
+        int ret;
+        va_list args;
 
-                pthread_mutex_lock(&ui__lock);
-                key = ui__question_window(title, s, "Press any key...", 0);
-                pthread_mutex_unlock(&ui__lock);
-                free(s);
-                return key;
-        }
+        va_start(args, format);
+        ret = perf_eops->error(format, args);
+        va_end(args);
 
-        fprintf(stderr, "%s:\n", title);
-        vfprintf(stderr, format, args);
-        return K_ESC;
+        return ret;
 }
 
 int ui__warning(const char *format, ...)
 {
-        int key;
+        int ret;
         va_list args;
 
         va_start(args, format);
-        key = __ui__warning("Warning", format, args);
+        ret = perf_eops->warning(format, args);
         va_end(args);
-        return key;
+
+        return ret;
 }
 
-int ui__error(const char *format, ...)
+
+/**
+ * perf_error__register - Register error logging functions
+ * @eops: The pointer to error logging function struct
+ *
+ * Register UI-specific error logging functions. Before calling this,
+ * other logging functions should be unregistered, if any.
+ */
+int perf_error__register(struct perf_error_ops *eops)
 {
-        int key;
-        va_list args;
+        if (perf_eops != &default_eops)
+                return -1;
 
-        va_start(args, format);
-        key = __ui__warning("Error", format, args);
-        va_end(args);
-        return key;
+        perf_eops = eops;
+        return 0;
+}
+
+/**
+ * perf_error__unregister - Unregister error logging functions
+ * @eops: The pointer to error logging function struct
+ *
+ * Unregister already registered error logging functions.
+ */
+int perf_error__unregister(struct perf_error_ops *eops)
+{
+        if (perf_eops != eops)
+                return -1;
+
+        perf_eops = &default_eops;
+        return 0;
 }
diff --git a/tools/perf/ui/util.h b/tools/perf/ui/util.h
index 2d1738bd71c8..361f08c52d37 100644
--- a/tools/perf/ui/util.h
+++ b/tools/perf/ui/util.h
@@ -9,6 +9,13 @@ int ui__help_window(const char *text);
 int ui__dialog_yesno(const char *msg);
 int ui__question_window(const char *title, const char *text,
                         const char *exit_msg, int delay_secs);
-int __ui__warning(const char *title, const char *format, va_list args);
+
+struct perf_error_ops {
+        int (*error)(const char *format, va_list args);
+        int (*warning)(const char *format, va_list args);
+};
+
+int perf_error__register(struct perf_error_ops *eops);
+int perf_error__unregister(struct perf_error_ops *eops);
 
 #endif /* _PERF_UI_UTIL_H_ */
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 8069dfb5ba77..3a282c0057d2 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -426,7 +426,18 @@ int symbol__alloc_hist(struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
         const size_t size = symbol__size(sym);
-        size_t sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
+        size_t sizeof_sym_hist;
+
+        /* Check for overflow when calculating sizeof_sym_hist */
+        if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(u64))
+                return -1;
+
+        sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
+
+        /* Check for overflow in zalloc argument */
+        if (sizeof_sym_hist > (SIZE_MAX - sizeof(*notes->src))
+                                / symbol_conf.nr_events)
+                return -1;
 
         notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
         if (notes->src == NULL)
@@ -777,7 +788,7 @@ fallback:
                 free_filename = false;
         }
 
-        if (dso->symtab_type == SYMTAB__KALLSYMS) {
+        if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS) {
                 char bf[BUILD_ID_SIZE * 2 + 16] = " with build id ";
                 char *build_id_msg = NULL;
 
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index efb1fce259a4..4dfe0bb3c322 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -47,7 +47,7 @@ int dump_printf(const char *fmt, ...)
         return ret;
 }
 
-#ifdef NO_NEWT_SUPPORT
+#if defined(NO_NEWT_SUPPORT) && defined(NO_GTK2_SUPPORT)
 int ui__warning(const char *format, ...)
 {
         va_list args;
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 6bebe7f0a20c..015c91dbc096 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -12,8 +12,9 @@ int dump_printf(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
 void trace_event(union perf_event *event);
 
 struct ui_progress;
+struct perf_error_ops;
 
-#ifdef NO_NEWT_SUPPORT
+#if defined(NO_NEWT_SUPPORT) && defined(NO_GTK2_SUPPORT)
 static inline int ui_helpline__show_help(const char *format __used, va_list ap __used)
 {
         return 0;
@@ -23,12 +24,28 @@ static inline void ui_progress__update(u64 curr __used, u64 total __used,
                                        const char *title __used) {}
 
 #define ui__error(format, arg...) ui__warning(format, ##arg)
-#else
+
+static inline int
+perf_error__register(struct perf_error_ops *eops __used)
+{
+        return 0;
+}
+
+static inline int
+perf_error__unregister(struct perf_error_ops *eops __used)
+{
+        return 0;
+}
+
+#else /* NO_NEWT_SUPPORT && NO_GTK2_SUPPORT */
+
 extern char ui_helpline__last_msg[];
 int ui_helpline__show_help(const char *format, va_list ap);
 #include "../ui/progress.h"
 int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
-#endif
+#include "../ui/util.h"
+
+#endif /* NO_NEWT_SUPPORT && NO_GTK2_SUPPORT */
 
 int ui__warning(const char *format, ...) __attribute__((format(printf, 1, 2)));
 int ui__error_paranoid(void);
diff --git a/tools/perf/util/dso-test-data.c b/tools/perf/util/dso-test-data.c
new file mode 100644
index 000000000000..541cdc72c7df
--- /dev/null
+++ b/tools/perf/util/dso-test-data.c
@@ -0,0 +1,153 @@
+#include "util.h"
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "symbol.h"
+
+#define TEST_ASSERT_VAL(text, cond) \
+do { \
+        if (!(cond)) { \
+                pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
+                return -1; \
+        } \
+} while (0)
+
+static char *test_file(int size)
+{
+        static char buf_templ[] = "/tmp/test-XXXXXX";
+        char *templ = buf_templ;
+        int fd, i;
+        unsigned char *buf;
+
+        fd = mkostemp(templ, O_CREAT|O_WRONLY|O_TRUNC);
+
+        buf = malloc(size);
+        if (!buf) {
+                close(fd);
+                return NULL;
+        }
+
+        for (i = 0; i < size; i++)
+                buf[i] = (unsigned char) ((int) i % 10);
+
+        if (size != write(fd, buf, size))
+                templ = NULL;
+
+        close(fd);
+        return templ;
+}
+
+#define TEST_FILE_SIZE (DSO__DATA_CACHE_SIZE * 20)
+
+struct test_data_offset {
+        off_t offset;
+        u8 data[10];
+        int size;
+};
+
+struct test_data_offset offsets[] = {
+        /* Fill first cache page. */
+        {
+                .offset = 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Read first cache page. */
+        {
+                .offset = 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Fill cache boundary pages. */
+        {
+                .offset = DSO__DATA_CACHE_SIZE - DSO__DATA_CACHE_SIZE % 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Read cache boundary pages. */
+        {
+                .offset = DSO__DATA_CACHE_SIZE - DSO__DATA_CACHE_SIZE % 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Fill final cache page. */
+        {
+                .offset = TEST_FILE_SIZE - 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Read final cache page. */
+        {
+                .offset = TEST_FILE_SIZE - 10,
+                .data   = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
+                .size   = 10,
+        },
+        /* Read final cache page. */
+        {
+                .offset = TEST_FILE_SIZE - 3,
+                .data   = { 7, 8, 9, 0, 0, 0, 0, 0, 0, 0 },
+                .size   = 3,
+        },
+};
+
+int dso__test_data(void)
+{
+        struct machine machine;
+        struct dso *dso;
+        char *file = test_file(TEST_FILE_SIZE);
+        size_t i;
+
+        TEST_ASSERT_VAL("No test file", file);
+
+        memset(&machine, 0, sizeof(machine));
+
+        dso = dso__new((const char *)file);
+
+        /* Basic 10 bytes tests. */
+        for (i = 0; i < ARRAY_SIZE(offsets); i++) {
+                struct test_data_offset *data = &offsets[i];
+                ssize_t size;
+                u8 buf[10];
+
+                memset(buf, 0, 10);
+                size = dso__data_read_offset(dso, &machine, data->offset,
+                                     buf, 10);
+
+                TEST_ASSERT_VAL("Wrong size", size == data->size);
+                TEST_ASSERT_VAL("Wrong data", !memcmp(buf, data->data, 10));
+        }
+
+        /* Read cross multiple cache pages. */
+        {
+                ssize_t size;
+                int c;
+                u8 *buf;
+
+                buf = malloc(TEST_FILE_SIZE);
+                TEST_ASSERT_VAL("ENOMEM\n", buf);
+
+                /* First iteration to fill caches, second one to read them. */
+                for (c = 0; c < 2; c++) {
+                        memset(buf, 0, TEST_FILE_SIZE);
+                        size = dso__data_read_offset(dso, &machine, 10,
+                                                     buf, TEST_FILE_SIZE);
+
+                        TEST_ASSERT_VAL("Wrong size",
+                                size == (TEST_FILE_SIZE - 10));
+
+                        for (i = 0; i < (size_t)size; i++)
+                                TEST_ASSERT_VAL("Wrong data",
+                                        buf[i] == (i % 10));
+                }
+
+                free(buf);
+        }
+
+        dso__delete(dso);
+        unlink(file);
+        return 0;
+}
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 7400fb3fc50c..3edfd3483816 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -214,7 +214,7 @@ int perf_evlist__add_tracepoints(struct perf_evlist *evlist,
                 attrs[i].type          = PERF_TYPE_TRACEPOINT;
                 attrs[i].config        = err;
                 attrs[i].sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
-                                          PERF_SAMPLE_CPU);
+                                          PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD);
                 attrs[i].sample_period = 1;
         }
 
@@ -224,8 +224,8 @@ out_free_attrs:
         return err;
 }
 
-static struct perf_evsel *
-        perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
+struct perf_evsel *
+perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id)
 {
         struct perf_evsel *evsel;
 
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 989bee9624c2..40d4d3cdced0 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -73,6 +73,9 @@ int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
 #define perf_evlist__set_tracepoints_handlers_array(evlist, array) \
         perf_evlist__set_tracepoints_handlers(evlist, array, ARRAY_SIZE(array))
 
+struct perf_evsel *
+perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id);
+
 void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
                          int cpu, int thread, u64 id);
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 9f6cebd798ee..e81771364867 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -15,7 +15,7 @@
 #include "cpumap.h"
 #include "thread_map.h"
 #include "target.h"
-#include "../../include/linux/perf_event.h"
+#include "../../../include/linux/hw_breakpoint.h"
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 #define GROUP_FD(group_fd, cpu) (*(int *)xyarray__entry(group_fd, cpu, 0))
@@ -78,7 +78,7 @@ static const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
         "ref-cycles",
 };
 
-const char *__perf_evsel__hw_name(u64 config)
+static const char *__perf_evsel__hw_name(u64 config)
 {
         if (config < PERF_COUNT_HW_MAX && perf_evsel__hw_names[config])
                 return perf_evsel__hw_names[config];
@@ -86,16 +86,15 @@ const char *__perf_evsel__hw_name(u64 config)
         return "unknown-hardware";
 }
 
-static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
+static int perf_evsel__add_modifiers(struct perf_evsel *evsel, char *bf, size_t size)
 {
-        int colon = 0;
+        int colon = 0, r = 0;
         struct perf_event_attr *attr = &evsel->attr;
-        int r = scnprintf(bf, size, "%s", __perf_evsel__hw_name(attr->config));
         bool exclude_guest_default = false;
 
 #define MOD_PRINT(context, mod) do {                                    \
                 if (!attr->exclude_##context) {                         \
-                        if (!colon) colon = r++;                        \
+                        if (!colon) colon = ++r;                        \
                         r += scnprintf(bf + r, size - r, "%c", mod);    \
                 } } while(0)
 
@@ -108,7 +107,7 @@ static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
 
         if (attr->precise_ip) {
                 if (!colon)
-                        colon = r++;
+                        colon = ++r;
                 r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp");
                 exclude_guest_default = true;
         }
@@ -119,39 +118,211 @@ static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
         }
 #undef MOD_PRINT
         if (colon)
-                bf[colon] = ':';
+                bf[colon - 1] = ':';
         return r;
 }
 
-int perf_evsel__name(struct perf_evsel *evsel, char *bf, size_t size)
+static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int r = scnprintf(bf, size, "%s", __perf_evsel__hw_name(evsel->attr.config));
+        return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
+}
+
+static const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
+        "cpu-clock",
+        "task-clock",
+        "page-faults",
+        "context-switches",
+        "CPU-migrations",
+        "minor-faults",
+        "major-faults",
+        "alignment-faults",
+        "emulation-faults",
+};
+
+static const char *__perf_evsel__sw_name(u64 config)
 {
-        int ret;
+        if (config < PERF_COUNT_SW_MAX && perf_evsel__sw_names[config])
+                return perf_evsel__sw_names[config];
+        return "unknown-software";
+}
+
+static int perf_evsel__sw_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int r = scnprintf(bf, size, "%s", __perf_evsel__sw_name(evsel->attr.config));
+        return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
+}
+
+static int __perf_evsel__bp_name(char *bf, size_t size, u64 addr, u64 type)
+{
+        int r;
+
+        r = scnprintf(bf, size, "mem:0x%" PRIx64 ":", addr);
+
+        if (type & HW_BREAKPOINT_R)
+                r += scnprintf(bf + r, size - r, "r");
+
+        if (type & HW_BREAKPOINT_W)
+                r += scnprintf(bf + r, size - r, "w");
+
+        if (type & HW_BREAKPOINT_X)
+                r += scnprintf(bf + r, size - r, "x");
+
+        return r;
+}
+
+static int perf_evsel__bp_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+        int r = __perf_evsel__bp_name(bf, size, attr->bp_addr, attr->bp_type);
+        return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
+}
+
+const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
+                                [PERF_EVSEL__MAX_ALIASES] = {
+ { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
+ { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
+ { "LLC",       "L2",                                                   },
+ { "dTLB",      "d-tlb",        "Data-TLB",                             },
+ { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
+ { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
+ { "node",                                                              },
+};
+
+const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
+                                   [PERF_EVSEL__MAX_ALIASES] = {
+ { "load",      "loads",        "read",                                 },
+ { "store",     "stores",       "write",                                },
+ { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
+};
+
+const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
+                                       [PERF_EVSEL__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 perf_evsel__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),
+ [C(NODE)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
+};
+
+bool perf_evsel__is_cache_op_valid(u8 type, u8 op)
+{
+        if (perf_evsel__hw_cache_stat[type] & COP(op))
+                return true;    /* valid */
+        else
+                return false;   /* invalid */
+}
+
+int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
+                                            char *bf, size_t size)
+{
+        if (result) {
+                return scnprintf(bf, size, "%s-%s-%s", perf_evsel__hw_cache[type][0],
+                                 perf_evsel__hw_cache_op[op][0],
+                                 perf_evsel__hw_cache_result[result][0]);
+        }
+
+        return scnprintf(bf, size, "%s-%s", perf_evsel__hw_cache[type][0],
+                         perf_evsel__hw_cache_op[op][1]);
+}
+
+static int __perf_evsel__hw_cache_name(u64 config, char *bf, size_t size)
+{
+        u8 op, result, type = (config >>  0) & 0xff;
+        const char *err = "unknown-ext-hardware-cache-type";
+
+        if (type > PERF_COUNT_HW_CACHE_MAX)
+                goto out_err;
+
+        op = (config >>  8) & 0xff;
+        err = "unknown-ext-hardware-cache-op";
+        if (op > PERF_COUNT_HW_CACHE_OP_MAX)
+                goto out_err;
+
+        result = (config >> 16) & 0xff;
+        err = "unknown-ext-hardware-cache-result";
+        if (result > PERF_COUNT_HW_CACHE_RESULT_MAX)
+                goto out_err;
+
+        err = "invalid-cache";
+        if (!perf_evsel__is_cache_op_valid(type, op))
+                goto out_err;
+
+        return __perf_evsel__hw_cache_type_op_res_name(type, op, result, bf, size);
+out_err:
+        return scnprintf(bf, size, "%s", err);
+}
+
+static int perf_evsel__hw_cache_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int ret = __perf_evsel__hw_cache_name(evsel->attr.config, bf, size);
+        return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
+}
+
+static int perf_evsel__raw_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->attr.config);
+        return ret + perf_evsel__add_modifiers(evsel, bf + ret, size - ret);
+}
+
+const char *perf_evsel__name(struct perf_evsel *evsel)
+{
+        char bf[128];
+
+        if (evsel->name)
+                return evsel->name;
 
         switch (evsel->attr.type) {
         case PERF_TYPE_RAW:
-                ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->attr.config);
+                perf_evsel__raw_name(evsel, bf, sizeof(bf));
                 break;
 
         case PERF_TYPE_HARDWARE:
-                ret = perf_evsel__hw_name(evsel, bf, size);
+                perf_evsel__hw_name(evsel, bf, sizeof(bf));
+                break;
+
+        case PERF_TYPE_HW_CACHE:
+                perf_evsel__hw_cache_name(evsel, bf, sizeof(bf));
+                break;
+
+        case PERF_TYPE_SOFTWARE:
+                perf_evsel__sw_name(evsel, bf, sizeof(bf));
                 break;
+
+        case PERF_TYPE_TRACEPOINT:
+                scnprintf(bf, sizeof(bf), "%s", "unknown tracepoint");
+                break;
+
+        case PERF_TYPE_BREAKPOINT:
+                perf_evsel__bp_name(evsel, bf, sizeof(bf));
+                break;
+
         default:
-                /*
-                 * FIXME
-                 *
-                 * This is the minimal perf_evsel__name so that we can
-                 * reconstruct event names taking into account event modifiers.
-                 *
-                 * The old event_name uses it now for raw anr hw events, so that
-                 * we don't drag all the parsing stuff into the python binding.
-                 *
-                 * On the next devel cycle the rest of the event naming will be
-                 * brought here.
-                 */
-                return 0;
-        }
-
-        return ret;
+                scnprintf(bf, sizeof(bf), "%s", "unknown attr type");
+                break;
+        }
+
+        evsel->name = strdup(bf);
+
+        return evsel->name ?: "unknown";
 }
 
 void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 4ba8b564e6f4..67cc5033d192 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -83,8 +83,19 @@ void perf_evsel__config(struct perf_evsel *evsel,
                         struct perf_record_opts *opts,
                         struct perf_evsel *first);
 
-const char* __perf_evsel__hw_name(u64 config);
-int perf_evsel__name(struct perf_evsel *evsel, char *bf, size_t size);
+bool perf_evsel__is_cache_op_valid(u8 type, u8 op);
+
+#define PERF_EVSEL__MAX_ALIASES 8
+
+extern const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
+                                       [PERF_EVSEL__MAX_ALIASES];
+extern const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
+                                          [PERF_EVSEL__MAX_ALIASES];
+const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
+                                       [PERF_EVSEL__MAX_ALIASES];
+int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
+                                            char *bf, size_t size);
+const char *perf_evsel__name(struct perf_evsel *evsel);
 
 int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 2dd5edf161b7..3a6d20443330 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -641,7 +641,7 @@ static int write_event_desc(int fd, struct perf_header *h __used,
                 /*
                  * write event string as passed on cmdline
                  */
-                ret = do_write_string(fd, event_name(attr));
+                ret = do_write_string(fd, perf_evsel__name(attr));
                 if (ret < 0)
                         return ret;
                 /*
@@ -1212,6 +1212,12 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
                                 attr.exclude_user,
                                 attr.exclude_kernel);
 
+                fprintf(fp, ", excl_host = %d, excl_guest = %d",
+                                attr.exclude_host,
+                                attr.exclude_guest);
+
+                fprintf(fp, ", precise_ip = %d", attr.precise_ip);
+
                 if (nr)
                         fprintf(fp, ", id = {");
 
@@ -1474,15 +1480,15 @@ out:
 
 static int process_tracing_data(struct perf_file_section *section __unused,
                               struct perf_header *ph __unused,
-                              int feat __unused, int fd)
+                              int feat __unused, int fd, void *data)
 {
-        trace_report(fd, false);
+        trace_report(fd, data, false);
         return 0;
 }
 
 static int process_build_id(struct perf_file_section *section,
                             struct perf_header *ph,
-                            int feat __unused, int fd)
+                            int feat __unused, int fd, void *data __used)
 {
         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
                 pr_debug("Failed to read buildids, continuing...\n");
@@ -1493,7 +1499,7 @@ struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
         int (*process)(struct perf_file_section *section,
-                       struct perf_header *h, int feat, int fd);
+                       struct perf_header *h, int feat, int fd, void *data);
         const char *name;
         bool full_only;
 };
@@ -1942,7 +1948,6 @@ int perf_file_header__read(struct perf_file_header *header,
                 else
                         return -1;
         } else if (ph->needs_swap) {
-                unsigned int i;
                 /*
                  * feature bitmap is declared as an array of unsigned longs --
                  * not good since its size can differ between the host that
@@ -1958,14 +1963,17 @@ int perf_file_header__read(struct perf_file_header *header,
                  * file), punt and fallback to the original behavior --
                  * clearing all feature bits and setting buildid.
                  */
-                for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i)
-                        header->adds_features[i] = bswap_64(header->adds_features[i]);
+                mem_bswap_64(&header->adds_features,
+                            BITS_TO_U64(HEADER_FEAT_BITS));
 
                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
-                        for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i) {
-                                header->adds_features[i] = bswap_64(header->adds_features[i]);
-                                header->adds_features[i] = bswap_32(header->adds_features[i]);
-                        }
+                        /* unswap as u64 */
+                        mem_bswap_64(&header->adds_features,
+                                    BITS_TO_U64(HEADER_FEAT_BITS));
+
+                        /* unswap as u32 */
+                        mem_bswap_32(&header->adds_features,
+                                    BITS_TO_U32(HEADER_FEAT_BITS));
                 }
 
                 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
@@ -1986,7 +1994,7 @@ int perf_file_header__read(struct perf_file_header *header,
 
 static int perf_file_section__process(struct perf_file_section *section,
                                       struct perf_header *ph,
-                                      int feat, int fd, void *data __used)
+                                      int feat, int fd, void *data)
 {
         if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
                 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
@@ -2002,7 +2010,7 @@ static int perf_file_section__process(struct perf_file_section *section,
         if (!feat_ops[feat].process)
                 return 0;
 
-        return feat_ops[feat].process(section, ph, feat, fd);
+        return feat_ops[feat].process(section, ph, feat, fd, data);
 }
 
 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
@@ -2091,6 +2099,38 @@ static int read_attr(int fd, struct perf_header *ph,
         return ret <= 0 ? -1 : 0;
 }
 
+static int perf_evsel__set_tracepoint_name(struct perf_evsel *evsel,
+                                           struct pevent *pevent)
+{
+        struct event_format *event = pevent_find_event(pevent,
+                                                       evsel->attr.config);
+        char bf[128];
+
+        if (event == NULL)
+                return -1;
+
+        snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
+        evsel->name = strdup(bf);
+        if (event->name == NULL)
+                return -1;
+
+        return 0;
+}
+
+static int perf_evlist__set_tracepoint_names(struct perf_evlist *evlist,
+                                             struct pevent *pevent)
+{
+        struct perf_evsel *pos;
+
+        list_for_each_entry(pos, &evlist->entries, node) {
+                if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
+                    perf_evsel__set_tracepoint_name(pos, pevent))
+                        return -1;
+        }
+
+        return 0;
+}
+
 int perf_session__read_header(struct perf_session *session, int fd)
 {
         struct perf_header *header = &session->header;
@@ -2167,11 +2207,14 @@ int perf_session__read_header(struct perf_session *session, int fd)
                 event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
 
-        perf_header__process_sections(header, fd, NULL,
+        perf_header__process_sections(header, fd, &session->pevent,
                                       perf_file_section__process);
 
         lseek(fd, header->data_offset, SEEK_SET);
 
+        if (perf_evlist__set_tracepoint_names(session->evlist, session->pevent))
+                goto out_delete_evlist;
+
         header->frozen = 1;
         return 0;
 out_errno:
@@ -2385,8 +2428,8 @@ int perf_event__process_tracing_data(union perf_event *event,
         lseek(session->fd, offset + sizeof(struct tracing_data_event),
               SEEK_SET);
 
-        size_read = trace_report(session->fd, session->repipe);
-
+        size_read = trace_report(session->fd, &session->pevent,
+                                 session->repipe);
         padding = ALIGN(size_read, sizeof(u64)) - size_read;
 
         if (read(session->fd, buf, padding) < 0)
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 514e2a4b367d..f247ef2789a4 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -708,7 +708,7 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
         bool printed = false;
         struct rb_node *node;
         int i = 0;
-        int ret;
+        int ret = 0;
 
         /*
          * If have one single callchain root, don't bother printing
@@ -747,8 +747,11 @@ static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
                 root = &cnode->rb_root;
         }
 
-        return __callchain__fprintf_graph(fp, root, total_samples,
+        ret += __callchain__fprintf_graph(fp, root, total_samples,
                                           1, 1, left_margin);
+        ret += fprintf(fp, "\n");
+
+        return ret;
 }
 
 static size_t __callchain__fprintf_flat(FILE *fp,
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 34bb556d6219..0b096c27a419 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -47,6 +47,7 @@ enum hist_column {
         HISTC_SYMBOL_TO,
         HISTC_DSO_FROM,
         HISTC_DSO_TO,
+        HISTC_SRCLINE,
         HISTC_NR_COLS, /* Last entry */
 };
 
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index f1584833bd22..587a230d2075 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -8,6 +8,8 @@
 #define BITS_PER_LONG __WORDSIZE
 #define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
+#define BITS_TO_U64(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))
+#define BITS_TO_U32(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))
 
 #define for_each_set_bit(bit, addr, size) \
         for ((bit) = find_first_bit((addr), (size));            \
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index 1eb804fd3fbf..b6842c1d02a8 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -108,4 +108,14 @@ int eprintf(int level,
 #define pr_debug3(fmt, ...) pr_debugN(3, pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_debug4(fmt, ...) pr_debugN(4, pr_fmt(fmt), ##__VA_ARGS__)
 
+/*
+ * This looks more complex than it should be. But we need to
+ * get the type for the ~ right in round_down (it needs to be
+ * as wide as the result!), and we want to evaluate the macro
+ * arguments just once each.
+ */
+#define __round_mask(x, y) ((__typeof__(x))((y)-1))
+#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
+#define round_down(x, y) ((x) & ~__round_mask(x, y))
+
 #endif
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 35ae56864e4f..cc33486ad9e2 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -7,6 +7,8 @@
 #include <stdio.h>
 #include <unistd.h>
 #include "map.h"
+#include "thread.h"
+#include "strlist.h"
 
 const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
@@ -585,7 +587,21 @@ int machine__init(struct machine *self, const char *root_dir, pid_t pid)
         self->kmaps.machine = self;
         self->pid           = pid;
         self->root_dir      = strdup(root_dir);
-        return self->root_dir == NULL ? -ENOMEM : 0;
+        if (self->root_dir == NULL)
+                return -ENOMEM;
+
+        if (pid != HOST_KERNEL_ID) {
+                struct thread *thread = machine__findnew_thread(self, pid);
+                char comm[64];
+
+                if (thread == NULL)
+                        return -ENOMEM;
+
+                snprintf(comm, sizeof(comm), "[guest/%d]", pid);
+                thread__set_comm(thread, comm);
+        }
+
+        return 0;
 }
 
 static void dsos__delete(struct list_head *self)
@@ -669,25 +685,34 @@ struct machine *machines__find(struct rb_root *self, pid_t pid)
 struct machine *machines__findnew(struct rb_root *self, pid_t pid)
 {
         char path[PATH_MAX];
-        const char *root_dir;
+        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)) {
+        if (machine && (machine->pid == pid))
+                goto out;
+
+        if ((pid != HOST_KERNEL_ID) &&
+            (pid != DEFAULT_GUEST_KERNEL_ID) &&
+            (symbol_conf.guestmount)) {
+                sprintf(path, "%s/%d", symbol_conf.guestmount, pid);
+                if (access(path, R_OK)) {
+                        static struct strlist *seen;
+
+                        if (!seen)
+                                seen = strlist__new(true, NULL);
+
+                        if (!strlist__has_entry(seen, path)) {
                                 pr_err("Can't access file %s\n", path);
-                                goto out;
+                                strlist__add(seen, path);
                         }
-                        root_dir = path;
+                        machine = NULL;
+                        goto out;
                 }
-                machine = machines__add(self, pid, root_dir);
+                root_dir = path;
         }
 
+        machine = machines__add(self, pid, root_dir);
+
 out:
         return machine;
 }
@@ -713,3 +738,16 @@ char *machine__mmap_name(struct machine *self, char *bf, size_t size)
 
         return bf;
 }
+
+void machines__set_id_hdr_size(struct rb_root *machines, u16 id_hdr_size)
+{
+        struct rb_node *node;
+        struct machine *machine;
+
+        for (node = rb_first(machines); node; node = rb_next(node)) {
+                machine = rb_entry(node, struct machine, rb_node);
+                machine->id_hdr_size = id_hdr_size;
+        }
+
+        return;
+}
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 81371bad4ef0..03a1e9b08b21 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -151,13 +151,14 @@ struct machine *machines__add(struct rb_root *self, pid_t pid,
 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);
+void machines__set_id_hdr_size(struct rb_root *self, u16 id_hdr_size);
 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);
 
 int machine__resolve_callchain(struct machine *machine,
-                               struct perf_evsel *evsel, struct thread *thread,
+                               struct thread *thread,
                                struct ip_callchain *chain,
                                struct symbol **parent);
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps, const char *symbol_name,
diff --git a/tools/perf/util/parse-events-test.c b/tools/perf/util/parse-events-test.c
index 76b98e2a587d..1b997d2b89ce 100644
--- a/tools/perf/util/parse-events-test.c
+++ b/tools/perf/util/parse-events-test.c
@@ -181,6 +181,22 @@ static int test__checkevent_breakpoint_w(struct perf_evlist *evlist)
         return 0;
 }
 
+static int test__checkevent_breakpoint_rw(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
+        TEST_ASSERT_VAL("wrong type",
+                        PERF_TYPE_BREAKPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 0 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong bp_type",
+                (HW_BREAKPOINT_R|HW_BREAKPOINT_W) == evsel->attr.bp_type);
+        TEST_ASSERT_VAL("wrong bp_len",
+                        HW_BREAKPOINT_LEN_4 == evsel->attr.bp_len);
+        return 0;
+}
+
 static int test__checkevent_tracepoint_modifier(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = list_entry(evlist->entries.next,
@@ -309,6 +325,8 @@ static int test__checkevent_breakpoint_modifier(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "mem:0x0:rw:u"));
 
         return test__checkevent_breakpoint(evlist);
 }
@@ -322,6 +340,8 @@ static int test__checkevent_breakpoint_x_modifier(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "mem:0x0:x:k"));
 
         return test__checkevent_breakpoint_x(evlist);
 }
@@ -335,6 +355,8 @@ static int test__checkevent_breakpoint_r_modifier(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "mem:0x0:r:hp"));
 
         return test__checkevent_breakpoint_r(evlist);
 }
@@ -348,10 +370,27 @@ static int test__checkevent_breakpoint_w_modifier(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "mem:0x0:w:up"));
 
         return test__checkevent_breakpoint_w(evlist);
 }
 
+static int test__checkevent_breakpoint_rw_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "mem:0x0:rw:kp"));
+
+        return test__checkevent_breakpoint_rw(evlist);
+}
+
 static int test__checkevent_pmu(struct perf_evlist *evlist)
 {
 
@@ -413,19 +452,63 @@ static int test__checkevent_pmu_name(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel;
 
-        /* cpu/config=1,name=krava1/u */
+        /* cpu/config=1,name=krava/u */
         evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config",  1 == evsel->attr.config);
-        TEST_ASSERT_VAL("wrong name", !strcmp(evsel->name, "krava"));
+        TEST_ASSERT_VAL("wrong name", !strcmp(perf_evsel__name(evsel), "krava"));
 
-        /* cpu/config=2/" */
+        /* cpu/config=2/u" */
         evsel = list_entry(evsel->node.next, struct perf_evsel, node);
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config",  2 == evsel->attr.config);
-        TEST_ASSERT_VAL("wrong name", !strcmp(evsel->name, "raw 0x2"));
+        TEST_ASSERT_VAL("wrong name",
+                        !strcmp(perf_evsel__name(evsel), "raw 0x2:u"));
+
+        return 0;
+}
+
+static int test__checkterms_simple(struct list_head *terms)
+{
+        struct parse_events__term *term;
+
+        /* config=10 */
+        term = list_entry(terms->next, struct parse_events__term, list);
+        TEST_ASSERT_VAL("wrong type term",
+                        term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG);
+        TEST_ASSERT_VAL("wrong type val",
+                        term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
+        TEST_ASSERT_VAL("wrong val", term->val.num == 10);
+        TEST_ASSERT_VAL("wrong config", !term->config);
+
+        /* config1 */
+        term = list_entry(term->list.next, struct parse_events__term, list);
+        TEST_ASSERT_VAL("wrong type term",
+                        term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG1);
+        TEST_ASSERT_VAL("wrong type val",
+                        term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
+        TEST_ASSERT_VAL("wrong val", term->val.num == 1);
+        TEST_ASSERT_VAL("wrong config", !term->config);
+
+        /* config2=3 */
+        term = list_entry(term->list.next, struct parse_events__term, list);
+        TEST_ASSERT_VAL("wrong type term",
+                        term->type_term == PARSE_EVENTS__TERM_TYPE_CONFIG2);
+        TEST_ASSERT_VAL("wrong type val",
+                        term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
+        TEST_ASSERT_VAL("wrong val", term->val.num == 3);
+        TEST_ASSERT_VAL("wrong config", !term->config);
+
+        /* umask=1*/
+        term = list_entry(term->list.next, struct parse_events__term, list);
+        TEST_ASSERT_VAL("wrong type term",
+                        term->type_term == PARSE_EVENTS__TERM_TYPE_USER);
+        TEST_ASSERT_VAL("wrong type val",
+                        term->type_val == PARSE_EVENTS__TERM_TYPE_NUM);
+        TEST_ASSERT_VAL("wrong val", term->val.num == 1);
+        TEST_ASSERT_VAL("wrong config", !strcmp(term->config, "umask"));
 
         return 0;
 }
@@ -541,10 +624,16 @@ static struct test__event_st test__events[] = {
                 .name  = "instructions:H",
                 .check = test__checkevent_exclude_guest_modifier,
         },
+        [26] = {
+                .name  = "mem:0:rw",
+                .check = test__checkevent_breakpoint_rw,
+        },
+        [27] = {
+                .name  = "mem:0:rw:kp",
+                .check = test__checkevent_breakpoint_rw_modifier,
+        },
 };
 
-#define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st))
-
 static struct test__event_st test__events_pmu[] = {
         [0] = {
                 .name  = "cpu/config=10,config1,config2=3,period=1000/u",
@@ -556,10 +645,23 @@ static struct test__event_st test__events_pmu[] = {
         },
 };
 
-#define TEST__EVENTS_PMU_CNT (sizeof(test__events_pmu) / \
-                              sizeof(struct test__event_st))
+struct test__term {
+        const char *str;
+        __u32 type;
+        int (*check)(struct list_head *terms);
+};
+
+static struct test__term test__terms[] = {
+        [0] = {
+                .str   = "config=10,config1,config2=3,umask=1",
+                .check = test__checkterms_simple,
+        },
+};
+
+#define TEST__TERMS_CNT (sizeof(test__terms) / \
+                         sizeof(struct test__term))
 
-static int test(struct test__event_st *e)
+static int test_event(struct test__event_st *e)
 {
         struct perf_evlist *evlist;
         int ret;
@@ -590,7 +692,48 @@ static int test_events(struct test__event_st *events, unsigned cnt)
                 struct test__event_st *e = &events[i];
 
                 pr_debug("running test %d '%s'\n", i, e->name);
-                ret = test(e);
+                ret = test_event(e);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int test_term(struct test__term *t)
+{
+        struct list_head *terms;
+        int ret;
+
+        terms = malloc(sizeof(*terms));
+        if (!terms)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(terms);
+
+        ret = parse_events_terms(terms, t->str);
+        if (ret) {
+                pr_debug("failed to parse terms '%s', err %d\n",
+                         t->str , ret);
+                return ret;
+        }
+
+        ret = t->check(terms);
+        parse_events__free_terms(terms);
+
+        return ret;
+}
+
+static int test_terms(struct test__term *terms, unsigned cnt)
+{
+        int ret = 0;
+        unsigned i;
+
+        for (i = 0; i < cnt; i++) {
+                struct test__term *t = &terms[i];
+
+                pr_debug("running test %d '%s'\n", i, t->str);
+                ret = test_term(t);
                 if (ret)
                         break;
         }
@@ -617,9 +760,17 @@ int parse_events__test(void)
 {
         int ret;
 
-        ret = test_events(test__events, TEST__EVENTS_CNT);
-        if (!ret && test_pmu())
-                ret = test_events(test__events_pmu, TEST__EVENTS_PMU_CNT);
+#define TEST_EVENTS(tests)                              \
+do {                                                    \
+        ret = test_events(tests, ARRAY_SIZE(tests));    \
+        if (ret)                                        \
+                return ret;                             \
+} while (0)
 
-        return ret;
+        TEST_EVENTS(test__events);
+
+        if (test_pmu())
+                TEST_EVENTS(test__events_pmu);
+
+        return test_terms(test__terms, ARRAY_SIZE(test__terms));
 }
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 05dbc8b3c767..74a5af4d33ec 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -11,14 +11,14 @@
 #include "cache.h"
 #include "header.h"
 #include "debugfs.h"
+#include "parse-events-bison.h"
+#define YY_EXTRA_TYPE int
 #include "parse-events-flex.h"
 #include "pmu.h"
 
 #define MAX_NAME_LEN 100
 
 struct event_symbol {
-        u8              type;
-        u64             config;
         const char      *symbol;
         const char      *alias;
 };
@@ -26,32 +26,88 @@ struct event_symbol {
 #ifdef PARSER_DEBUG
 extern int parse_events_debug;
 #endif
-int parse_events_parse(struct list_head *list, int *idx);
-
-#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[] = {
-  { CHW(CPU_CYCLES),                    "cpu-cycles",                   "cycles"                },
-  { CHW(STALLED_CYCLES_FRONTEND),       "stalled-cycles-frontend",      "idle-cycles-frontend"  },
-  { CHW(STALLED_CYCLES_BACKEND),        "stalled-cycles-backend",       "idle-cycles-backend"   },
-  { 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",                   ""                      },
-  { CHW(REF_CPU_CYCLES),                "ref-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"            },
-  { CSW(ALIGNMENT_FAULTS),              "alignment-faults",             ""                      },
-  { CSW(EMULATION_FAULTS),              "emulation-faults",             ""                      },
+int parse_events_parse(void *data, void *scanner);
+
+static struct event_symbol event_symbols_hw[PERF_COUNT_HW_MAX] = {
+        [PERF_COUNT_HW_CPU_CYCLES] = {
+                .symbol = "cpu-cycles",
+                .alias  = "cycles",
+        },
+        [PERF_COUNT_HW_INSTRUCTIONS] = {
+                .symbol = "instructions",
+                .alias  = "",
+        },
+        [PERF_COUNT_HW_CACHE_REFERENCES] = {
+                .symbol = "cache-references",
+                .alias  = "",
+        },
+        [PERF_COUNT_HW_CACHE_MISSES] = {
+                .symbol = "cache-misses",
+                .alias  = "",
+        },
+        [PERF_COUNT_HW_BRANCH_INSTRUCTIONS] = {
+                .symbol = "branch-instructions",
+                .alias  = "branches",
+        },
+        [PERF_COUNT_HW_BRANCH_MISSES] = {
+                .symbol = "branch-misses",
+                .alias  = "",
+        },
+        [PERF_COUNT_HW_BUS_CYCLES] = {
+                .symbol = "bus-cycles",
+                .alias  = "",
+        },
+        [PERF_COUNT_HW_STALLED_CYCLES_FRONTEND] = {
+                .symbol = "stalled-cycles-frontend",
+                .alias  = "idle-cycles-frontend",
+        },
+        [PERF_COUNT_HW_STALLED_CYCLES_BACKEND] = {
+                .symbol = "stalled-cycles-backend",
+                .alias  = "idle-cycles-backend",
+        },
+        [PERF_COUNT_HW_REF_CPU_CYCLES] = {
+                .symbol = "ref-cycles",
+                .alias  = "",
+        },
+};
+
+static struct event_symbol event_symbols_sw[PERF_COUNT_SW_MAX] = {
+        [PERF_COUNT_SW_CPU_CLOCK] = {
+                .symbol = "cpu-clock",
+                .alias  = "",
+        },
+        [PERF_COUNT_SW_TASK_CLOCK] = {
+                .symbol = "task-clock",
+                .alias  = "",
+        },
+        [PERF_COUNT_SW_PAGE_FAULTS] = {
+                .symbol = "page-faults",
+                .alias  = "faults",
+        },
+        [PERF_COUNT_SW_CONTEXT_SWITCHES] = {
+                .symbol = "context-switches",
+                .alias  = "cs",
+        },
+        [PERF_COUNT_SW_CPU_MIGRATIONS] = {
+                .symbol = "cpu-migrations",
+                .alias  = "migrations",
+        },
+        [PERF_COUNT_SW_PAGE_FAULTS_MIN] = {
+                .symbol = "minor-faults",
+                .alias  = "",
+        },
+        [PERF_COUNT_SW_PAGE_FAULTS_MAJ] = {
+                .symbol = "major-faults",
+                .alias  = "",
+        },
+        [PERF_COUNT_SW_ALIGNMENT_FAULTS] = {
+                .symbol = "alignment-faults",
+                .alias  = "",
+        },
+        [PERF_COUNT_SW_EMULATION_FAULTS] = {
+                .symbol = "emulation-faults",
+                .alias  = "",
+        },
 };
 
 #define __PERF_EVENT_FIELD(config, name) \
@@ -62,63 +118,6 @@ static struct event_symbol event_symbols[] = {
 #define PERF_EVENT_TYPE(config)         __PERF_EVENT_FIELD(config, TYPE)
 #define PERF_EVENT_ID(config)           __PERF_EVENT_FIELD(config, EVENT)
 
-static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
-        "cpu-clock",
-        "task-clock",
-        "page-faults",
-        "context-switches",
-        "CPU-migrations",
-        "minor-faults",
-        "major-faults",
-        "alignment-faults",
-        "emulation-faults",
-};
-
-#define MAX_ALIASES 8
-
-static const char *hw_cache[PERF_COUNT_HW_CACHE_MAX][MAX_ALIASES] = {
- { "L1-dcache", "l1-d",         "l1d",          "L1-data",              },
- { "L1-icache", "l1-i",         "l1i",          "L1-instruction",       },
- { "LLC",       "L2",                                                   },
- { "dTLB",      "d-tlb",        "Data-TLB",                             },
- { "iTLB",      "i-tlb",        "Instruction-TLB",                      },
- { "branch",    "branches",     "bpu",          "btb",          "bpc",  },
- { "node",                                                              },
-};
-
-static const char *hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][MAX_ALIASES] = {
- { "load",      "loads",        "read",                                 },
- { "store",     "stores",       "write",                                },
- { "prefetch",  "prefetches",   "speculative-read", "speculative-load", },
-};
-
-static const char *hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
-                                  [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),
- [C(NODE)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
-};
-
 #define for_each_subsystem(sys_dir, sys_dirent, sys_next)              \
         while (!readdir_r(sys_dir, &sys_dirent, &sys_next) && sys_next)        \
         if (sys_dirent.d_type == DT_DIR &&                                     \
@@ -218,48 +217,6 @@ struct tracepoint_path *tracepoint_id_to_path(u64 config)
         return NULL;
 }
 
-#define TP_PATH_LEN (MAX_EVENT_LENGTH * 2 + 1)
-static const char *tracepoint_id_to_name(u64 config)
-{
-        static char buf[TP_PATH_LEN];
-        struct tracepoint_path *path;
-
-        path = tracepoint_id_to_path(config);
-        if (path) {
-                snprintf(buf, TP_PATH_LEN, "%s:%s", path->system, path->name);
-                free(path->name);
-                free(path->system);
-                free(path);
-        } else
-                snprintf(buf, TP_PATH_LEN, "%s:%s", "unknown", "unknown");
-
-        return buf;
-}
-
-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;
-}
-
 const char *event_type(int type)
 {
         switch (type) {
@@ -282,76 +239,6 @@ const char *event_type(int type)
         return "unknown";
 }
 
-const char *event_name(struct perf_evsel *evsel)
-{
-        u64 config = evsel->attr.config;
-        int type = evsel->attr.type;
-
-        if (type == PERF_TYPE_RAW || type == PERF_TYPE_HARDWARE) {
-                /*
-                 * XXX minimal fix, see comment on perf_evsen__name, this static buffer
-                 * will go away together with event_name in the next devel cycle.
-                 */
-                static char bf[128];
-                perf_evsel__name(evsel, bf, sizeof(bf));
-                return bf;
-        }
-
-        if (evsel->name)
-                return evsel->name;
-
-        return __event_name(type, config);
-}
-
-const char *__event_name(int type, u64 config)
-{
-        static char buf[32];
-
-        if (type == PERF_TYPE_RAW) {
-                sprintf(buf, "raw 0x%" PRIx64, config);
-                return buf;
-        }
-
-        switch (type) {
-        case PERF_TYPE_HARDWARE:
-                return __perf_evsel__hw_name(config);
-
-        case PERF_TYPE_HW_CACHE: {
-                u8 cache_type, cache_op, cache_result;
-
-                cache_type   = (config >>  0) & 0xff;
-                if (cache_type > PERF_COUNT_HW_CACHE_MAX)
-                        return "unknown-ext-hardware-cache-type";
-
-                cache_op     = (config >>  8) & 0xff;
-                if (cache_op > PERF_COUNT_HW_CACHE_OP_MAX)
-                        return "unknown-ext-hardware-cache-op";
-
-                cache_result = (config >> 16) & 0xff;
-                if (cache_result > PERF_COUNT_HW_CACHE_RESULT_MAX)
-                        return "unknown-ext-hardware-cache-result";
-
-                if (!is_cache_op_valid(cache_type, cache_op))
-                        return "invalid-cache";
-
-                return event_cache_name(cache_type, cache_op, cache_result);
-        }
-
-        case PERF_TYPE_SOFTWARE:
-                if (config < PERF_COUNT_SW_MAX && sw_event_names[config])
-                        return sw_event_names[config];
-                return "unknown-software";
-
-        case PERF_TYPE_TRACEPOINT:
-                return tracepoint_id_to_name(config);
-
-        default:
-                break;
-        }
-
-        return "unknown";
-}
-
 static int add_event(struct list_head **_list, int *idx,
                      struct perf_event_attr *attr, char *name)
 {
@@ -373,19 +260,20 @@ static int add_event(struct list_head **_list, int *idx,
                 return -ENOMEM;
         }
 
-        evsel->name = strdup(name);
+        if (name)
+                evsel->name = strdup(name);
         list_add_tail(&evsel->node, list);
         *_list = list;
         return 0;
 }
 
-static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
+static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
 {
         int i, j;
         int n, longest = -1;
 
         for (i = 0; i < size; i++) {
-                for (j = 0; j < MAX_ALIASES && names[i][j]; j++) {
+                for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
                         n = strlen(names[i][j]);
                         if (n > longest && !strncasecmp(str, names[i][j], n))
                                 longest = n;
@@ -410,7 +298,7 @@ int parse_events_add_cache(struct list_head **list, int *idx,
          * No fallback - if we cannot get a clear cache type
          * then bail out:
          */
-        cache_type = parse_aliases(type, hw_cache,
+        cache_type = parse_aliases(type, perf_evsel__hw_cache,
                                    PERF_COUNT_HW_CACHE_MAX);
         if (cache_type == -1)
                 return -EINVAL;
@@ -423,18 +311,18 @@ int parse_events_add_cache(struct list_head **list, int *idx,
                 snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
 
                 if (cache_op == -1) {
-                        cache_op = parse_aliases(str, hw_cache_op,
+                        cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
                                                  PERF_COUNT_HW_CACHE_OP_MAX);
                         if (cache_op >= 0) {
-                                if (!is_cache_op_valid(cache_type, cache_op))
+                                if (!perf_evsel__is_cache_op_valid(cache_type, cache_op))
                                         return -EINVAL;
                                 continue;
                         }
                 }
 
                 if (cache_result == -1) {
-                        cache_result = parse_aliases(str, hw_cache_result,
-                                                PERF_COUNT_HW_CACHE_RESULT_MAX);
+                        cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
+                                                     PERF_COUNT_HW_CACHE_RESULT_MAX);
                         if (cache_result >= 0)
                                 continue;
                 }
@@ -489,6 +377,7 @@ static int add_tracepoint(struct list_head **list, int *idx,
         attr.sample_type |= PERF_SAMPLE_RAW;
         attr.sample_type |= PERF_SAMPLE_TIME;
         attr.sample_type |= PERF_SAMPLE_CPU;
+        attr.sample_type |= PERF_SAMPLE_PERIOD;
         attr.sample_period = 1;
 
         snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
@@ -549,21 +438,31 @@ parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
                 if (!type || !type[i])
                         break;
 
+#define CHECK_SET_TYPE(bit)             \
+do {                                    \
+        if (attr->bp_type & bit)        \
+                return -EINVAL;         \
+        else                            \
+                attr->bp_type |= bit;   \
+} while (0)
+
                 switch (type[i]) {
                 case 'r':
-                        attr->bp_type |= HW_BREAKPOINT_R;
+                        CHECK_SET_TYPE(HW_BREAKPOINT_R);
                         break;
                 case 'w':
-                        attr->bp_type |= HW_BREAKPOINT_W;
+                        CHECK_SET_TYPE(HW_BREAKPOINT_W);
                         break;
                 case 'x':
-                        attr->bp_type |= HW_BREAKPOINT_X;
+                        CHECK_SET_TYPE(HW_BREAKPOINT_X);
                         break;
                 default:
                         return -EINVAL;
                 }
         }
 
+#undef CHECK_SET_TYPE
+
         if (!attr->bp_type) /* Default */
                 attr->bp_type = HW_BREAKPOINT_R | HW_BREAKPOINT_W;
 
@@ -574,7 +473,6 @@ int parse_events_add_breakpoint(struct list_head **list, int *idx,
                                 void *ptr, char *type)
 {
         struct perf_event_attr attr;
-        char name[MAX_NAME_LEN];
 
         memset(&attr, 0, sizeof(attr));
         attr.bp_addr = (unsigned long) ptr;
@@ -592,9 +490,9 @@ int parse_events_add_breakpoint(struct list_head **list, int *idx,
                 attr.bp_len = HW_BREAKPOINT_LEN_4;
 
         attr.type = PERF_TYPE_BREAKPOINT;
+        attr.sample_period = 1;
 
-        snprintf(name, MAX_NAME_LEN, "mem:%p:%s", ptr, type ? type : "rw");
-        return add_event(list, idx, &attr, name);
+        return add_event(list, idx, &attr, NULL);
 }
 
 static int config_term(struct perf_event_attr *attr,
@@ -666,8 +564,7 @@ int parse_events_add_numeric(struct list_head **list, int *idx,
             config_attr(&attr, head_config, 1))
                 return -EINVAL;
 
-        return add_event(list, idx, &attr,
-                         (char *) __event_name(type, config));
+        return add_event(list, idx, &attr, NULL);
 }
 
 static int parse_events__is_name_term(struct parse_events__term *term)
@@ -675,8 +572,7 @@ static int parse_events__is_name_term(struct parse_events__term *term)
         return term->type_term == PARSE_EVENTS__TERM_TYPE_NAME;
 }
 
-static char *pmu_event_name(struct perf_event_attr *attr,
-                            struct list_head *head_terms)
+static char *pmu_event_name(struct list_head *head_terms)
 {
         struct parse_events__term *term;
 
@@ -684,7 +580,7 @@ static char *pmu_event_name(struct perf_event_attr *attr,
                 if (parse_events__is_name_term(term))
                         return term->val.str;
 
-        return (char *) __event_name(PERF_TYPE_RAW, attr->config);
+        return NULL;
 }
 
 int parse_events_add_pmu(struct list_head **list, int *idx,
@@ -699,6 +595,9 @@ int parse_events_add_pmu(struct list_head **list, int *idx,
 
         memset(&attr, 0, sizeof(attr));
 
+        if (perf_pmu__check_alias(pmu, head_config))
+                return -EINVAL;
+
         /*
          * Configure hardcoded terms first, no need to check
          * return value when called with fail == 0 ;)
@@ -709,7 +608,7 @@ int parse_events_add_pmu(struct list_head **list, int *idx,
                 return -EINVAL;
 
         return add_event(list, idx, &attr,
-                         pmu_event_name(&attr, head_config));
+                         pmu_event_name(head_config));
 }
 
 void parse_events_update_lists(struct list_head *list_event,
@@ -787,27 +686,62 @@ int parse_events_modifier(struct list_head *list, char *str)
         return 0;
 }
 
-int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
+static int parse_events__scanner(const char *str, void *data, int start_token)
 {
-        LIST_HEAD(list);
-        LIST_HEAD(list_tmp);
         YY_BUFFER_STATE buffer;
-        int ret, idx = evlist->nr_entries;
+        void *scanner;
+        int ret;
+
+        ret = parse_events_lex_init_extra(start_token, &scanner);
+        if (ret)
+                return ret;
 
-        buffer = parse_events__scan_string(str);
+        buffer = parse_events__scan_string(str, scanner);
 
 #ifdef PARSER_DEBUG
         parse_events_debug = 1;
 #endif
-        ret = parse_events_parse(&list, &idx);
+        ret = parse_events_parse(data, scanner);
 
-        parse_events__flush_buffer(buffer);
-        parse_events__delete_buffer(buffer);
-        parse_events_lex_destroy();
+        parse_events__flush_buffer(buffer, scanner);
+        parse_events__delete_buffer(buffer, scanner);
+        parse_events_lex_destroy(scanner);
+        return ret;
+}
+
+/*
+ * parse event config string, return a list of event terms.
+ */
+int parse_events_terms(struct list_head *terms, const char *str)
+{
+        struct parse_events_data__terms data = {
+                .terms = NULL,
+        };
+        int ret;
 
+        ret = parse_events__scanner(str, &data, PE_START_TERMS);
         if (!ret) {
-                int entries = idx - evlist->nr_entries;
-                perf_evlist__splice_list_tail(evlist, &list, entries);
+                list_splice(data.terms, terms);
+                free(data.terms);
+                return 0;
+        }
+
+        parse_events__free_terms(data.terms);
+        return ret;
+}
+
+int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
+{
+        struct parse_events_data__events data = {
+                .list = LIST_HEAD_INIT(data.list),
+                .idx  = evlist->nr_entries,
+        };
+        int ret;
+
+        ret = parse_events__scanner(str, &data, PE_START_EVENTS);
+        if (!ret) {
+                int entries = data.idx - evlist->nr_entries;
+                perf_evlist__splice_list_tail(evlist, &data.list, entries);
                 return 0;
         }
 
@@ -946,16 +880,13 @@ int is_valid_tracepoint(const char *event_string)
         return 0;
 }
 
-void print_events_type(u8 type)
+static void __print_events_type(u8 type, struct event_symbol *syms,
+                                unsigned max)
 {
-        struct event_symbol *syms = event_symbols;
-        unsigned int i;
         char name[64];
+        unsigned i;
 
-        for (i = 0; i < ARRAY_SIZE(event_symbols); i++, syms++) {
-                if (type != syms->type)
-                        continue;
-
+        for (i = 0; i < max ; i++, syms++) {
                 if (strlen(syms->alias))
                         snprintf(name, sizeof(name),  "%s OR %s",
                                  syms->symbol, syms->alias);
@@ -967,19 +898,28 @@ void print_events_type(u8 type)
         }
 }
 
+void print_events_type(u8 type)
+{
+        if (type == PERF_TYPE_SOFTWARE)
+                __print_events_type(type, event_symbols_sw, PERF_COUNT_SW_MAX);
+        else
+                __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
+}
+
 int print_hwcache_events(const char *event_glob)
 {
         unsigned int type, op, i, printed = 0;
+        char name[64];
 
         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
                         /* skip invalid cache type */
-                        if (!is_cache_op_valid(type, op))
+                        if (!perf_evsel__is_cache_op_valid(type, op))
                                 continue;
 
                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
-                                char *name = event_cache_name(type, op, i);
-
+                                __perf_evsel__hw_cache_type_op_res_name(type, op, i,
+                                                                        name, sizeof(name));
                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
                                         continue;
 
@@ -993,26 +933,13 @@ int print_hwcache_events(const char *event_glob)
         return printed;
 }
 
-/*
- * Print the help text for the event symbols:
- */
-void print_events(const char *event_glob)
+static void print_symbol_events(const char *event_glob, unsigned type,
+                                struct event_symbol *syms, unsigned max)
 {
-        unsigned int i, type, prev_type = -1, printed = 0, ntypes_printed = 0;
-        struct event_symbol *syms = event_symbols;
+        unsigned i, printed = 0;
         char name[MAX_NAME_LEN];
 
-        printf("\n");
-        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;
-
-                if (type != prev_type && printed) {
-                        printf("\n");
-                        printed = 0;
-                        ntypes_printed++;
-                }
+        for (i = 0; i < max; i++, syms++) {
 
                 if (event_glob != NULL && 
                     !(strglobmatch(syms->symbol, event_glob) ||
@@ -1023,17 +950,31 @@ void print_events(const char *event_glob)
                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
                 else
                         strncpy(name, syms->symbol, MAX_NAME_LEN);
-                printf("  %-50s [%s]\n", name,
-                        event_type_descriptors[type]);
 
-                prev_type = type;
-                ++printed;
+                printf("  %-50s [%s]\n", name, event_type_descriptors[type]);
+
+                printed++;
         }
 
-        if (ntypes_printed) {
-                printed = 0;
+        if (printed)
                 printf("\n");
-        }
+}
+
+/*
+ * Print the help text for the event symbols:
+ */
+void print_events(const char *event_glob)
+{
+
+        printf("\n");
+        printf("List of pre-defined events (to be used in -e):\n");
+
+        print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
+                            event_symbols_hw, PERF_COUNT_HW_MAX);
+
+        print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
+                            event_symbols_sw, PERF_COUNT_SW_MAX);
+
         print_hwcache_events(event_glob);
 
         if (event_glob != NULL)
@@ -1106,6 +1047,13 @@ int parse_events__term_str(struct parse_events__term **term,
                         config, str, 0);
 }
 
+int parse_events__term_clone(struct parse_events__term **new,
+                             struct parse_events__term *term)
+{
+        return new_term(new, term->type_val, term->type_term, term->config,
+                        term->val.str, term->val.num);
+}
+
 void parse_events__free_terms(struct list_head *terms)
 {
         struct parse_events__term *term, *h;
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index 8cac57ab4ee6..ee9c218a193c 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -26,13 +26,12 @@ extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
 extern bool have_tracepoints(struct list_head *evlist);
 
 const char *event_type(int type);
-const char *event_name(struct perf_evsel *event);
-extern const char *__event_name(int type, u64 config);
 
 extern int parse_events_option(const struct option *opt, const char *str,
                                int unset);
 extern int parse_events(struct perf_evlist *evlist, const char *str,
                         int unset);
+extern int parse_events_terms(struct list_head *terms, const char *str);
 extern int parse_filter(const struct option *opt, const char *str, int unset);
 
 #define EVENTS_HELP_MAX (128*1024)
@@ -63,11 +62,22 @@ struct parse_events__term {
         struct list_head list;
 };
 
+struct parse_events_data__events {
+        struct list_head list;
+        int idx;
+};
+
+struct parse_events_data__terms {
+        struct list_head *terms;
+};
+
 int parse_events__is_hardcoded_term(struct parse_events__term *term);
 int parse_events__term_num(struct parse_events__term **_term,
                            int type_term, char *config, long num);
 int parse_events__term_str(struct parse_events__term **_term,
                            int type_term, char *config, char *str);
+int parse_events__term_clone(struct parse_events__term **new,
+                             struct parse_events__term *term);
 void parse_events__free_terms(struct list_head *terms);
 int parse_events_modifier(struct list_head *list, char *str);
 int parse_events_add_tracepoint(struct list_head **list, int *idx,
@@ -83,8 +93,7 @@ int parse_events_add_pmu(struct list_head **list, int *idx,
                          char *pmu , struct list_head *head_config);
 void parse_events_update_lists(struct list_head *list_event,
                                struct list_head *list_all);
-void parse_events_error(struct list_head *list_all,
-                        int *idx, char const *msg);
+void parse_events_error(void *data, void *scanner, char const *msg);
 int parse_events__test(void);
 
 void print_events(const char *event_glob);
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 618a8e788399..384ca74c6b22 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -1,4 +1,6 @@
 
+%option reentrant
+%option bison-bridge
 %option prefix="parse_events_"
 %option stack
 
@@ -8,7 +10,10 @@
 #include "parse-events-bison.h"
 #include "parse-events.h"
 
-static int __value(char *str, int base, int token)
+char *parse_events_get_text(yyscan_t yyscanner);
+YYSTYPE *parse_events_get_lval(yyscan_t yyscanner);
+
+static int __value(YYSTYPE *yylval, char *str, int base, int token)
 {
         long num;
 
@@ -17,35 +22,48 @@ static int __value(char *str, int base, int token)
         if (errno)
                 return PE_ERROR;
 
-        parse_events_lval.num = num;
+        yylval->num = num;
         return token;
 }
 
-static int value(int base)
+static int value(yyscan_t scanner, int base)
 {
-        return __value(parse_events_text, base, PE_VALUE);
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+        char *text = parse_events_get_text(scanner);
+
+        return __value(yylval, text, base, PE_VALUE);
 }
 
-static int raw(void)
+static int raw(yyscan_t scanner)
 {
-        return __value(parse_events_text + 1, 16, PE_RAW);
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+        char *text = parse_events_get_text(scanner);
+
+        return __value(yylval, text + 1, 16, PE_RAW);
 }
 
-static int str(int token)
+static int str(yyscan_t scanner, int token)
 {
-        parse_events_lval.str = strdup(parse_events_text);
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+        char *text = parse_events_get_text(scanner);
+
+        yylval->str = strdup(text);
         return token;
 }
 
-static int sym(int type, int config)
+static int sym(yyscan_t scanner, int type, int config)
 {
-        parse_events_lval.num = (type << 16) + config;
-        return PE_VALUE_SYM;
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+
+        yylval->num = (type << 16) + config;
+        return type == PERF_TYPE_HARDWARE ? PE_VALUE_SYM_HW : PE_VALUE_SYM_SW;
 }
 
-static int term(int type)
+static int term(yyscan_t scanner, int type)
 {
-        parse_events_lval.num = type;
+        YYSTYPE *yylval = parse_events_get_lval(scanner);
+
+        yylval->num = type;
         return PE_TERM;
 }
 
@@ -58,28 +76,41 @@ num_hex		0x[a-fA-F0-9]+
 num_raw_hex     [a-fA-F0-9]+
 name            [a-zA-Z_*?][a-zA-Z0-9_*?]*
 modifier_event  [ukhpGH]{1,8}
-modifier_bp     [rwx]
+modifier_bp     [rwx]{1,3}
 
 %%
-cpu-cycles|cycles                               { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
-stalled-cycles-frontend|idle-cycles-frontend    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
-stalled-cycles-backend|idle-cycles-backend      { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
-instructions                                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
-cache-references                                { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
-cache-misses                                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
-branch-instructions|branches                    { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
-branch-misses                                   { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
-bus-cycles                                      { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
-ref-cycles                                      { return sym(PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
-cpu-clock                                       { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
-task-clock                                      { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
-page-faults|faults                              { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
-minor-faults                                    { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
-major-faults                                    { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
-context-switches|cs                             { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
-cpu-migrations|migrations                       { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
-alignment-faults                                { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
-emulation-faults                                { return sym(PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
+
+%{
+        {
+                int start_token;
+
+                start_token = (int) parse_events_get_extra(yyscanner);
+                if (start_token) {
+                        parse_events_set_extra(NULL, yyscanner);
+                        return start_token;
+                }
+         }
+%}
+
+cpu-cycles|cycles                               { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
+stalled-cycles-frontend|idle-cycles-frontend    { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
+stalled-cycles-backend|idle-cycles-backend      { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
+instructions                                    { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); }
+cache-references                                { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); }
+cache-misses                                    { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); }
+branch-instructions|branches                    { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); }
+branch-misses                                   { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_MISSES); }
+bus-cycles                                      { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BUS_CYCLES); }
+ref-cycles                                      { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_REF_CPU_CYCLES); }
+cpu-clock                                       { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_CLOCK); }
+task-clock                                      { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_TASK_CLOCK); }
+page-faults|faults                              { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS); }
+minor-faults                                    { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MIN); }
+major-faults                                    { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_PAGE_FAULTS_MAJ); }
+context-switches|cs                             { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CONTEXT_SWITCHES); }
+cpu-migrations|migrations                       { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_CPU_MIGRATIONS); }
+alignment-faults                                { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_ALIGNMENT_FAULTS); }
+emulation-faults                                { return sym(yyscanner, PERF_TYPE_SOFTWARE, PERF_COUNT_SW_EMULATION_FAULTS); }
 
 L1-dcache|l1-d|l1d|L1-data              |
 L1-icache|l1-i|l1i|L1-instruction       |
@@ -87,14 +118,14 @@ LLC|L2					|
 dTLB|d-tlb|Data-TLB                     |
 iTLB|i-tlb|Instruction-TLB              |
 branch|branches|bpu|btb|bpc             |
-node                                    { return str(PE_NAME_CACHE_TYPE); }
+node                                    { return str(yyscanner, PE_NAME_CACHE_TYPE); }
 
 load|loads|read                         |
 store|stores|write                      |
 prefetch|prefetches                     |
 speculative-read|speculative-load       |
 refs|Reference|ops|access               |
-misses|miss                             { return str(PE_NAME_CACHE_OP_RESULT); }
+misses|miss                             { return str(yyscanner, PE_NAME_CACHE_OP_RESULT); }
 
         /*
          * These are event config hardcoded term names to be specified
@@ -102,38 +133,39 @@ misses|miss				{ return str(PE_NAME_CACHE_OP_RESULT); }
          * so we can put them here directly. In case the we have a conflict
          * in future, this needs to go into '//' condition block.
          */
-config                  { return term(PARSE_EVENTS__TERM_TYPE_CONFIG); }
-config1                 { return term(PARSE_EVENTS__TERM_TYPE_CONFIG1); }
-config2                 { return term(PARSE_EVENTS__TERM_TYPE_CONFIG2); }
-name                    { return term(PARSE_EVENTS__TERM_TYPE_NAME); }
-period                  { return term(PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
-branch_type             { return term(PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
+config                  { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); }
+config1                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); }
+config2                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); }
+name                    { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); }
+period                  { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
+branch_type             { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
 
 mem:                    { BEGIN(mem); return PE_PREFIX_MEM; }
-r{num_raw_hex}          { return raw(); }
-{num_dec}               { return value(10); }
-{num_hex}               { return value(16); }
+r{num_raw_hex}          { return raw(yyscanner); }
+{num_dec}               { return value(yyscanner, 10); }
+{num_hex}               { return value(yyscanner, 16); }
 
-{modifier_event}        { return str(PE_MODIFIER_EVENT); }
-{name}                  { return str(PE_NAME); }
+{modifier_event}        { return str(yyscanner, PE_MODIFIER_EVENT); }
+{name}                  { return str(yyscanner, PE_NAME); }
 "/"                     { return '/'; }
 -                       { return '-'; }
 ,                       { return ','; }
 :                       { return ':'; }
 =                       { return '='; }
+\n                      { }
 
 <mem>{
-{modifier_bp}           { return str(PE_MODIFIER_BP); }
+{modifier_bp}           { return str(yyscanner, PE_MODIFIER_BP); }
 :                       { return ':'; }
-{num_dec}               { return value(10); }
-{num_hex}               { return value(16); }
+{num_dec}               { return value(yyscanner, 10); }
+{num_hex}               { return value(yyscanner, 16); }
         /*
          * We need to separate 'mem:' scanner part, in order to get specific
          * modifier bits parsed out. Otherwise we would need to handle PE_NAME
          * and we'd need to parse it manually. During the escape from <mem>
          * state we need to put the escaping char back, so we dont miss it.
          */
-.                       { unput(*parse_events_text); BEGIN(INITIAL); }
+.                       { unput(*yytext); BEGIN(INITIAL); }
         /*
          * We destroy the scanner after reaching EOF,
          * but anyway just to be sure get back to INIT state.
@@ -143,7 +175,7 @@ r{num_raw_hex}		{ return raw(); }
 
 %%
 
-int parse_events_wrap(void)
+int parse_events_wrap(void *scanner __used)
 {
         return 1;
 }
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 362cc59332ae..2bc5fbff2b5d 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -1,7 +1,8 @@
-
+%pure-parser
 %name-prefix "parse_events_"
-%parse-param {struct list_head *list_all}
-%parse-param {int *idx}
+%parse-param {void *_data}
+%parse-param {void *scanner}
+%lex-param {void* scanner}
 
 %{
 
@@ -12,8 +13,9 @@
 #include "types.h"
 #include "util.h"
 #include "parse-events.h"
+#include "parse-events-bison.h"
 
-extern int parse_events_lex (void);
+extern int parse_events_lex (YYSTYPE* lvalp, void* scanner);
 
 #define ABORT_ON(val) \
 do { \
@@ -23,14 +25,16 @@ do { \
 
 %}
 
-%token PE_VALUE PE_VALUE_SYM PE_RAW PE_TERM
+%token PE_START_EVENTS PE_START_TERMS
+%token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
 %token PE_NAME
 %token PE_MODIFIER_EVENT PE_MODIFIER_BP
 %token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
 %token PE_PREFIX_MEM PE_PREFIX_RAW
 %token PE_ERROR
 %type <num> PE_VALUE
-%type <num> PE_VALUE_SYM
+%type <num> PE_VALUE_SYM_HW
+%type <num> PE_VALUE_SYM_SW
 %type <num> PE_RAW
 %type <num> PE_TERM
 %type <str> PE_NAME
@@ -38,6 +42,7 @@ do { \
 %type <str> PE_NAME_CACHE_OP_RESULT
 %type <str> PE_MODIFIER_EVENT
 %type <str> PE_MODIFIER_BP
+%type <num> value_sym
 %type <head> event_config
 %type <term> event_term
 %type <head> event_pmu
@@ -58,24 +63,33 @@ do { \
 }
 %%
 
+start:
+PE_START_EVENTS events
+|
+PE_START_TERMS  terms
+
 events:
 events ',' event | event
 
 event:
 event_def PE_MODIFIER_EVENT
 {
+        struct parse_events_data__events *data = _data;
+
         /*
          * Apply modifier on all events added by single event definition
          * (there could be more events added for multiple tracepoint
          * definitions via '*?'.
          */
         ABORT_ON(parse_events_modifier($1, $2));
-        parse_events_update_lists($1, list_all);
+        parse_events_update_lists($1, &data->list);
 }
 |
 event_def
 {
-        parse_events_update_lists($1, list_all);
+        struct parse_events_data__events *data = _data;
+
+        parse_events_update_lists($1, &data->list);
 }
 
 event_def: event_pmu |
@@ -89,104 +103,131 @@ event_def: event_pmu |
 event_pmu:
 PE_NAME '/' event_config '/'
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_pmu(&list, idx, $1, $3));
+        ABORT_ON(parse_events_add_pmu(&list, &data->idx, $1, $3));
         parse_events__free_terms($3);
         $$ = list;
 }
 
+value_sym:
+PE_VALUE_SYM_HW
+|
+PE_VALUE_SYM_SW
+
 event_legacy_symbol:
-PE_VALUE_SYM '/' event_config '/'
+value_sym '/' event_config '/'
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(&list, idx, type, config, $3));
+        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+                                          type, config, $3));
         parse_events__free_terms($3);
         $$ = list;
 }
 |
-PE_VALUE_SYM sep_slash_dc
+value_sym sep_slash_dc
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(&list, idx, type, config, NULL));
+        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+                                          type, config, NULL));
         $$ = list;
 }
 
 event_legacy_cache:
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_cache(&list, idx, $1, $3, $5));
+        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, $5));
         $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_cache(&list, idx, $1, $3, NULL));
+        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, $3, NULL));
         $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_cache(&list, idx, $1, NULL, NULL));
+        ABORT_ON(parse_events_add_cache(&list, &data->idx, $1, NULL, NULL));
         $$ = list;
 }
 
 event_legacy_mem:
 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_breakpoint(&list, idx, (void *) $2, $4));
+        ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
+                                             (void *) $2, $4));
         $$ = list;
 }
 |
 PE_PREFIX_MEM PE_VALUE sep_dc
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_breakpoint(&list, idx, (void *) $2, NULL));
+        ABORT_ON(parse_events_add_breakpoint(&list, &data->idx,
+                                             (void *) $2, NULL));
         $$ = list;
 }
 
 event_legacy_tracepoint:
 PE_NAME ':' PE_NAME
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_tracepoint(&list, idx, $1, $3));
+        ABORT_ON(parse_events_add_tracepoint(&list, &data->idx, $1, $3));
         $$ = list;
 }
 
 event_legacy_numeric:
 PE_VALUE ':' PE_VALUE
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_numeric(&list, idx, $1, $3, NULL));
+        ABORT_ON(parse_events_add_numeric(&list, &data->idx, $1, $3, NULL));
         $$ = list;
 }
 
 event_legacy_raw:
 PE_RAW
 {
+        struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_numeric(&list, idx, PERF_TYPE_RAW, $1, NULL));
+        ABORT_ON(parse_events_add_numeric(&list, &data->idx,
+                                          PERF_TYPE_RAW, $1, NULL));
         $$ = list;
 }
 
+terms: event_config
+{
+        struct parse_events_data__terms *data = _data;
+        data->terms = $1;
+}
+
 event_config:
 event_config ',' event_term
 {
@@ -267,8 +308,7 @@ sep_slash_dc: '/' | ':' |
 
 %%
 
-void parse_events_error(struct list_head *list_all __used,
-                        int *idx __used,
+void parse_events_error(void *data __used, void *scanner __used,
                         char const *msg __used)
 {
 }
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index a119a5371699..67715a42cd6d 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -72,7 +72,7 @@ static int pmu_format(char *name, struct list_head *format)
                  "%s/bus/event_source/devices/%s/format", sysfs, name);
 
         if (stat(path, &st) < 0)
-                return -1;
+                return 0;       /* no error if format does not exist */
 
         if (pmu_format_parse(path, format))
                 return -1;
@@ -80,6 +80,114 @@ static int pmu_format(char *name, struct list_head *format)
         return 0;
 }
 
+static int perf_pmu__new_alias(struct list_head *list, char *name, FILE *file)
+{
+        struct perf_pmu__alias *alias;
+        char buf[256];
+        int ret;
+
+        ret = fread(buf, 1, sizeof(buf), file);
+        if (ret == 0)
+                return -EINVAL;
+        buf[ret] = 0;
+
+        alias = malloc(sizeof(*alias));
+        if (!alias)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&alias->terms);
+        ret = parse_events_terms(&alias->terms, buf);
+        if (ret) {
+                free(alias);
+                return ret;
+        }
+
+        alias->name = strdup(name);
+        list_add_tail(&alias->list, list);
+        return 0;
+}
+
+/*
+ * Process all the sysfs attributes located under the directory
+ * specified in 'dir' parameter.
+ */
+static int pmu_aliases_parse(char *dir, struct list_head *head)
+{
+        struct dirent *evt_ent;
+        DIR *event_dir;
+        int ret = 0;
+
+        event_dir = opendir(dir);
+        if (!event_dir)
+                return -EINVAL;
+
+        while (!ret && (evt_ent = readdir(event_dir))) {
+                char path[PATH_MAX];
+                char *name = evt_ent->d_name;
+                FILE *file;
+
+                if (!strcmp(name, ".") || !strcmp(name, ".."))
+                        continue;
+
+                snprintf(path, PATH_MAX, "%s/%s", dir, name);
+
+                ret = -EINVAL;
+                file = fopen(path, "r");
+                if (!file)
+                        break;
+                ret = perf_pmu__new_alias(head, name, file);
+                fclose(file);
+        }
+
+        closedir(event_dir);
+        return ret;
+}
+
+/*
+ * Reading the pmu event aliases definition, which should be located at:
+ * /sys/bus/event_source/devices/<dev>/events as sysfs group attributes.
+ */
+static int pmu_aliases(char *name, struct list_head *head)
+{
+        struct stat st;
+        char path[PATH_MAX];
+        const char *sysfs;
+
+        sysfs = sysfs_find_mountpoint();
+        if (!sysfs)
+                return -1;
+
+        snprintf(path, PATH_MAX,
+                 "%s/bus/event_source/devices/%s/events", sysfs, name);
+
+        if (stat(path, &st) < 0)
+                return -1;
+
+        if (pmu_aliases_parse(path, head))
+                return -1;
+
+        return 0;
+}
+
+static int pmu_alias_terms(struct perf_pmu__alias *alias,
+                           struct list_head *terms)
+{
+        struct parse_events__term *term, *clone;
+        LIST_HEAD(list);
+        int ret;
+
+        list_for_each_entry(term, &alias->terms, list) {
+                ret = parse_events__term_clone(&clone, term);
+                if (ret) {
+                        parse_events__free_terms(&list);
+                        return ret;
+                }
+                list_add_tail(&clone->list, &list);
+        }
+        list_splice(&list, terms);
+        return 0;
+}
+
 /*
  * Reading/parsing the default pmu type value, which should be
  * located at:
@@ -118,6 +226,7 @@ static struct perf_pmu *pmu_lookup(char *name)
 {
         struct perf_pmu *pmu;
         LIST_HEAD(format);
+        LIST_HEAD(aliases);
         __u32 type;
 
         /*
@@ -135,10 +244,15 @@ static struct perf_pmu *pmu_lookup(char *name)
         if (!pmu)
                 return NULL;
 
+        pmu_aliases(name, &aliases);
+
         INIT_LIST_HEAD(&pmu->format);
+        INIT_LIST_HEAD(&pmu->aliases);
         list_splice(&format, &pmu->format);
+        list_splice(&aliases, &pmu->aliases);
         pmu->name = strdup(name);
         pmu->type = type;
+        list_add_tail(&pmu->list, &pmus);
         return pmu;
 }
 
@@ -279,6 +393,59 @@ int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
         return pmu_config(&pmu->format, attr, head_terms);
 }
 
+static struct perf_pmu__alias *pmu_find_alias(struct perf_pmu *pmu,
+                                              struct parse_events__term *term)
+{
+        struct perf_pmu__alias *alias;
+        char *name;
+
+        if (parse_events__is_hardcoded_term(term))
+                return NULL;
+
+        if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM) {
+                if (term->val.num != 1)
+                        return NULL;
+                if (pmu_find_format(&pmu->format, term->config))
+                        return NULL;
+                name = term->config;
+        } else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR) {
+                if (strcasecmp(term->config, "event"))
+                        return NULL;
+                name = term->val.str;
+        } else {
+                return NULL;
+        }
+
+        list_for_each_entry(alias, &pmu->aliases, list) {
+                if (!strcasecmp(alias->name, name))
+                        return alias;
+        }
+        return NULL;
+}
+
+/*
+ * Find alias in the terms list and replace it with the terms
+ * defined for the alias
+ */
+int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms)
+{
+        struct parse_events__term *term, *h;
+        struct perf_pmu__alias *alias;
+        int ret;
+
+        list_for_each_entry_safe(term, h, head_terms, list) {
+                alias = pmu_find_alias(pmu, term);
+                if (!alias)
+                        continue;
+                ret = pmu_alias_terms(alias, &term->list);
+                if (ret)
+                        return ret;
+                list_del(&term->list);
+                free(term);
+        }
+        return 0;
+}
+
 int perf_pmu__new_format(struct list_head *list, char *name,
                          int config, unsigned long *bits)
 {
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 68c0db965e1f..535f2c5258ab 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -19,17 +19,26 @@ struct perf_pmu__format {
         struct list_head list;
 };
 
+struct perf_pmu__alias {
+        char *name;
+        struct list_head terms;
+        struct list_head list;
+};
+
 struct perf_pmu {
         char *name;
         __u32 type;
         struct list_head format;
+        struct list_head aliases;
         struct list_head list;
 };
 
 struct perf_pmu *perf_pmu__find(char *name);
 int perf_pmu__config(struct perf_pmu *pmu, struct perf_event_attr *attr,
                      struct list_head *head_terms);
-
+int perf_pmu__check_alias(struct perf_pmu *pmu, struct list_head *head_terms);
+struct list_head *perf_pmu__alias(struct perf_pmu *pmu,
+                                struct list_head *head_terms);
 int perf_pmu_wrap(void);
 void perf_pmu_error(struct list_head *list, char *name, char const *msg);
 
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 4c1b3d72a1d2..02dfa19a467f 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -209,6 +209,10 @@ static void define_event_symbols(struct event_format *event,
                 define_symbolic_values(args->symbol.symbols, ev_name,
                                        cur_field_name);
                 break;
+        case PRINT_HEX:
+                define_event_symbols(event, ev_name, args->hex.field);
+                define_event_symbols(event, ev_name, args->hex.size);
+                break;
         case PRINT_BSTRING:
         case PRINT_DYNAMIC_ARRAY:
         case PRINT_STRING:
@@ -233,7 +237,8 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline struct event_format *find_cache_event(int type)
+static inline
+struct event_format *find_cache_event(struct pevent *pevent, int type)
 {
         static char ev_name[256];
         struct event_format *event;
@@ -241,7 +246,7 @@ static inline struct event_format *find_cache_event(int type)
         if (events[type])
                 return events[type];
 
-        events[type] = event = trace_find_event(type);
+        events[type] = event = pevent_find_event(pevent, type);
         if (!event)
                 return NULL;
 
@@ -252,7 +257,8 @@ static inline struct event_format *find_cache_event(int type)
         return event;
 }
 
-static void perl_process_tracepoint(union perf_event *pevent __unused,
+static void perl_process_tracepoint(union perf_event *perf_event __unused,
+                                    struct pevent *pevent,
                                     struct perf_sample *sample,
                                     struct perf_evsel *evsel,
                                     struct machine *machine __unused,
@@ -275,13 +281,13 @@ static void perl_process_tracepoint(union perf_event *pevent __unused,
         if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
                 return;
 
-        type = trace_parse_common_type(data);
+        type = trace_parse_common_type(pevent, data);
 
-        event = find_cache_event(type);
+        event = find_cache_event(pevent, type);
         if (!event)
                 die("ug! no event found for type %d", type);
 
-        pid = trace_parse_common_pid(data);
+        pid = trace_parse_common_pid(pevent, data);
 
         sprintf(handler, "%s::%s", event->system, event->name);
 
@@ -314,7 +320,8 @@ static void perl_process_tracepoint(union perf_event *pevent __unused,
                                 offset = field->offset;
                         XPUSHs(sv_2mortal(newSVpv((char *)data + offset, 0)));
                 } else { /* FIELD_IS_NUMERIC */
-                        val = read_size(data + field->offset, field->size);
+                        val = read_size(pevent, data + field->offset,
+                                        field->size);
                         if (field->flags & FIELD_IS_SIGNED) {
                                 XPUSHs(sv_2mortal(newSViv(val)));
                         } else {
@@ -368,14 +375,15 @@ static void perl_process_event_generic(union perf_event *pevent __unused,
         LEAVE;
 }
 
-static void perl_process_event(union perf_event *pevent,
+static void perl_process_event(union perf_event *event,
+                               struct pevent *pevent,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
                                struct thread *thread)
 {
-        perl_process_tracepoint(pevent, sample, evsel, machine, thread);
-        perl_process_event_generic(pevent, sample, evsel, machine, thread);
+        perl_process_tracepoint(event, pevent, sample, evsel, machine, thread);
+        perl_process_event_generic(event, sample, evsel, machine, thread);
 }
 
 static void run_start_sub(void)
@@ -448,7 +456,7 @@ static int perl_stop_script(void)
         return 0;
 }
 
-static int perl_generate_script(const char *outfile)
+static int perl_generate_script(struct pevent *pevent, const char *outfile)
 {
         struct event_format *event = NULL;
         struct format_field *f;
@@ -495,7 +503,7 @@ static int perl_generate_script(const char *outfile)
         fprintf(ofp, "sub trace_begin\n{\n\t# optional\n}\n\n");
         fprintf(ofp, "sub trace_end\n{\n\t# optional\n}\n\n");
 
-        while ((event = trace_find_next_event(event))) {
+        while ((event = trace_find_next_event(pevent, event))) {
                 fprintf(ofp, "sub %s::%s\n{\n", event->system, event->name);
                 fprintf(ofp, "\tmy (");
 
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index acb9795286c4..ce4d1b0c3862 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -166,6 +166,10 @@ static void define_event_symbols(struct event_format *event,
                 define_values(PRINT_SYMBOL, args->symbol.symbols, ev_name,
                               cur_field_name);
                 break;
+        case PRINT_HEX:
+                define_event_symbols(event, ev_name, args->hex.field);
+                define_event_symbols(event, ev_name, args->hex.size);
+                break;
         case PRINT_STRING:
                 break;
         case PRINT_TYPE:
@@ -190,7 +194,8 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline struct event_format *find_cache_event(int type)
+static inline
+struct event_format *find_cache_event(struct pevent *pevent, int type)
 {
         static char ev_name[256];
         struct event_format *event;
@@ -198,7 +203,7 @@ static inline struct event_format *find_cache_event(int type)
         if (events[type])
                 return events[type];
 
-        events[type] = event = trace_find_event(type);
+        events[type] = event = pevent_find_event(pevent, type);
         if (!event)
                 return NULL;
 
@@ -209,7 +214,8 @@ static inline struct event_format *find_cache_event(int type)
         return event;
 }
 
-static void python_process_event(union perf_event *pevent __unused,
+static void python_process_event(union perf_event *perf_event __unused,
+                                 struct pevent *pevent,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel __unused,
                                  struct machine *machine __unused,
@@ -233,13 +239,13 @@ static void python_process_event(union perf_event *pevent __unused,
         if (!t)
                 Py_FatalError("couldn't create Python tuple");
 
-        type = trace_parse_common_type(data);
+        type = trace_parse_common_type(pevent, data);
 
-        event = find_cache_event(type);
+        event = find_cache_event(pevent, type);
         if (!event)
                 die("ug! no event found for type %d", type);
 
-        pid = trace_parse_common_pid(data);
+        pid = trace_parse_common_pid(pevent, data);
 
         sprintf(handler_name, "%s__%s", event->system, event->name);
 
@@ -284,7 +290,8 @@ static void python_process_event(union perf_event *pevent __unused,
                                 offset = field->offset;
                         obj = PyString_FromString((char *)data + offset);
                 } else { /* FIELD_IS_NUMERIC */
-                        val = read_size(data + field->offset, field->size);
+                        val = read_size(pevent, data + field->offset,
+                                        field->size);
                         if (field->flags & FIELD_IS_SIGNED) {
                                 if ((long long)val >= LONG_MIN &&
                                     (long long)val <= LONG_MAX)
@@ -438,7 +445,7 @@ out:
         return err;
 }
 
-static int python_generate_script(const char *outfile)
+static int python_generate_script(struct pevent *pevent, const char *outfile)
 {
         struct event_format *event = NULL;
         struct format_field *f;
@@ -487,7 +494,7 @@ static int python_generate_script(const char *outfile)
         fprintf(ofp, "def trace_end():\n");
         fprintf(ofp, "\tprint \"in trace_end\"\n\n");
 
-        while ((event = trace_find_next_event(event))) {
+        while ((event = trace_find_next_event(pevent, event))) {
                 fprintf(ofp, "def %s__%s(", event->system, event->name);
                 fprintf(ofp, "event_name, ");
                 fprintf(ofp, "context, ");
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 2600916efa83..8e4f0755d2aa 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -14,6 +14,7 @@
 #include "sort.h"
 #include "util.h"
 #include "cpumap.h"
+#include "event-parse.h"
 
 static int perf_session__open(struct perf_session *self, bool force)
 {
@@ -86,6 +87,7 @@ void perf_session__update_sample_type(struct perf_session *self)
         self->sample_id_all = perf_evlist__sample_id_all(self->evlist);
         self->id_hdr_size = perf_evlist__id_hdr_size(self->evlist);
         self->host_machine.id_hdr_size = self->id_hdr_size;
+        machines__set_id_hdr_size(&self->machines, self->id_hdr_size);
 }
 
 int perf_session__create_kernel_maps(struct perf_session *self)
@@ -289,7 +291,6 @@ struct branch_info *machine__resolve_bstack(struct machine *self,
 }
 
 int machine__resolve_callchain(struct machine *self,
-                               struct perf_evsel *evsel __used,
                                struct thread *thread,
                                struct ip_callchain *chain,
                                struct symbol **parent)
@@ -442,6 +443,16 @@ static void perf_tool__fill_defaults(struct perf_tool *tool)
                         tool->finished_round = process_finished_round_stub;
         }
 }
+ 
+void mem_bswap_32(void *src, int byte_size)
+{
+        u32 *m = src;
+        while (byte_size > 0) {
+                *m = bswap_32(*m);
+                byte_size -= sizeof(u32);
+                ++m;
+        }
+}
 
 void mem_bswap_64(void *src, int byte_size)
 {
@@ -908,7 +919,9 @@ static struct machine *
 {
         const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-        if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL && perf_guest) {
+        if (perf_guest &&
+            ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
+             (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
                 u32 pid;
 
                 if (event->header.type == PERF_RECORD_MMAP)
@@ -916,7 +929,7 @@ static struct machine *
                 else
                         pid = event->ip.pid;
 
-                return perf_session__find_machine(session, pid);
+                return perf_session__findnew_machine(session, pid);
         }
 
         return perf_session__find_host_machine(session);
@@ -1439,7 +1452,7 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
         ret += hists__fprintf_nr_events(&session->hists, fp);
 
         list_for_each_entry(pos, &session->evlist->entries, node) {
-                ret += fprintf(fp, "%s stats:\n", event_name(pos));
+                ret += fprintf(fp, "%s stats:\n", perf_evsel__name(pos));
                 ret += hists__fprintf_nr_events(&pos->hists, fp);
         }
 
@@ -1480,8 +1493,8 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 }
 
 void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
-                          struct machine *machine, struct perf_evsel *evsel,
-                          int print_sym, int print_dso, int print_symoffset)
+                          struct machine *machine, int print_sym,
+                          int print_dso, int print_symoffset)
 {
         struct addr_location al;
         struct callchain_cursor_node *node;
@@ -1495,7 +1508,7 @@ void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
 
         if (symbol_conf.use_callchain && sample->callchain) {
 
-                if (machine__resolve_callchain(machine, evsel, al.thread,
+                if (machine__resolve_callchain(machine, al.thread,
                                                 sample->callchain, NULL) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
@@ -1601,3 +1614,58 @@ void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
         perf_header__fprintf_info(session, fp, full);
         fprintf(fp, "# ========\n#\n");
 }
+
+
+int __perf_session__set_tracepoints_handlers(struct perf_session *session,
+                                             const struct perf_evsel_str_handler *assocs,
+                                             size_t nr_assocs)
+{
+        struct perf_evlist *evlist = session->evlist;
+        struct event_format *format;
+        struct perf_evsel *evsel;
+        char *tracepoint, *name;
+        size_t i;
+        int err;
+
+        for (i = 0; i < nr_assocs; i++) {
+                err = -ENOMEM;
+                tracepoint = strdup(assocs[i].name);
+                if (tracepoint == NULL)
+                        goto out;
+
+                err = -ENOENT;
+                name = strchr(tracepoint, ':');
+                if (name == NULL)
+                        goto out_free;
+
+                *name++ = '\0';
+                format = pevent_find_event_by_name(session->pevent,
+                                                   tracepoint, name);
+                if (format == NULL) {
+                        /*
+                         * Adding a handler for an event not in the session,
+                         * just ignore it.
+                         */
+                        goto next;
+                }
+
+                evsel = perf_evlist__find_tracepoint_by_id(evlist, format->id);
+                if (evsel == NULL)
+                        goto next;
+
+                err = -EEXIST;
+                if (evsel->handler.func != NULL)
+                        goto out_free;
+                evsel->handler.func = assocs[i].handler;
+next:
+                free(tracepoint);
+        }
+
+        err = 0;
+out:
+        return err;
+
+out_free:
+        free(tracepoint);
+        goto out;
+}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 7a5434c00565..7c435bde6eb0 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -33,6 +33,7 @@ struct perf_session {
         struct machine          host_machine;
         struct rb_root          machines;
         struct perf_evlist      *evlist;
+        struct pevent           *pevent;
         /*
          * FIXME: Need to split this up further, we need global
          *        stats + per event stats. 'perf diff' also needs
@@ -80,6 +81,7 @@ struct branch_info *machine__resolve_bstack(struct machine *self,
 bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
 void mem_bswap_64(void *src, int byte_size);
+void mem_bswap_32(void *src, int byte_size);
 void perf_event__attr_swap(struct perf_event_attr *attr);
 
 int perf_session__create_kernel_maps(struct perf_session *self);
@@ -150,11 +152,20 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                             unsigned int type);
 
 void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
-                          struct machine *machine, struct perf_evsel *evsel,
-                          int print_sym, int print_dso, int print_symoffset);
+                          struct machine *machine, int print_sym,
+                          int print_dso, int print_symoffset);
 
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
 
 void perf_session__fprintf_info(struct perf_session *s, FILE *fp, bool full);
+
+struct perf_evsel_str_handler;
+
+int __perf_session__set_tracepoints_handlers(struct perf_session *session,
+                                             const struct perf_evsel_str_handler *assocs,
+                                             size_t nr_assocs);
+
+#define perf_session__set_tracepoints_handlers(session, array) \
+        __perf_session__set_tracepoints_handlers(session, array, ARRAY_SIZE(array))
 #endif /* __PERF_SESSION_H */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index a27237430c5f..0f5a0a496bc4 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -241,6 +241,54 @@ struct sort_entry sort_sym = {
         .se_width_idx   = HISTC_SYMBOL,
 };
 
+/* --sort srcline */
+
+static int64_t
+sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return (int64_t)(right->ip - left->ip);
+}
+
+static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
+                                   size_t size, unsigned int width __used)
+{
+        FILE *fp;
+        char cmd[PATH_MAX + 2], *path = self->srcline, *nl;
+        size_t line_len;
+
+        if (path != NULL)
+                goto out_path;
+
+        snprintf(cmd, sizeof(cmd), "addr2line -e %s %016" PRIx64,
+                 self->ms.map->dso->long_name, self->ip);
+        fp = popen(cmd, "r");
+        if (!fp)
+                goto out_ip;
+
+        if (getline(&path, &line_len, fp) < 0 || !line_len)
+                goto out_ip;
+        fclose(fp);
+        self->srcline = strdup(path);
+        if (self->srcline == NULL)
+                goto out_ip;
+
+        nl = strchr(self->srcline, '\n');
+        if (nl != NULL)
+                *nl = '\0';
+        path = self->srcline;
+out_path:
+        return repsep_snprintf(bf, size, "%s", path);
+out_ip:
+        return repsep_snprintf(bf, size, "%-#*llx", BITS_PER_LONG / 4, self->ip);
+}
+
+struct sort_entry sort_srcline = {
+        .se_header      = "Source:Line",
+        .se_cmp         = sort__srcline_cmp,
+        .se_snprintf    = hist_entry__srcline_snprintf,
+        .se_width_idx   = HISTC_SRCLINE,
+};
+
 /* --sort parent */
 
 static int64_t
@@ -439,6 +487,7 @@ static struct sort_dimension sort_dimensions[] = {
         DIM(SORT_PARENT, "parent", sort_parent),
         DIM(SORT_CPU, "cpu", sort_cpu),
         DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
+        DIM(SORT_SRCLINE, "srcline", sort_srcline),
 };
 
 int sort_dimension__add(const char *tok)
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 472aa5a63a58..e724b26acd51 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -71,6 +71,7 @@ struct hist_entry {
         char                    level;
         bool                    used;
         u8                      filtered;
+        char                    *srcline;
         struct symbol           *parent;
         union {
                 unsigned long     position;
@@ -93,6 +94,7 @@ enum sort_type {
         SORT_SYM_FROM,
         SORT_SYM_TO,
         SORT_MISPREDICT,
+        SORT_SRCLINE,
 };
 
 /*
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index d5836382ff2c..199bc4d8905d 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -313,3 +313,25 @@ int strtailcmp(const char *s1, const char *s2)
         return 0;
 }
 
+/**
+ * rtrim - Removes trailing whitespace from @s.
+ * @s: The string to be stripped.
+ *
+ * Note that the first trailing whitespace is replaced with a %NUL-terminator
+ * in the given string @s. Returns @s.
+ */
+char *rtrim(char *s)
+{
+        size_t size = strlen(s);
+        char *end;
+
+        if (!size)
+                return s;
+
+        end = s + size - 1;
+        while (end >= s && isspace(*end))
+                end--;
+        *(end + 1) = '\0';
+
+        return s;
+}
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 3e2e5ea0f03f..fdad4eeeb429 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -29,6 +29,7 @@
 #define NT_GNU_BUILD_ID 3
 #endif
 
+static void dso_cache__free(struct rb_root *root);
 static bool dso__build_id_equal(const struct dso *dso, 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);
@@ -48,6 +49,31 @@ struct symbol_conf symbol_conf = {
         .symfs            = "",
 };
 
+static enum dso_binary_type binary_type_symtab[] = {
+        DSO_BINARY_TYPE__KALLSYMS,
+        DSO_BINARY_TYPE__GUEST_KALLSYMS,
+        DSO_BINARY_TYPE__JAVA_JIT,
+        DSO_BINARY_TYPE__DEBUGLINK,
+        DSO_BINARY_TYPE__BUILD_ID_CACHE,
+        DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
+        DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
+        DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
+        DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
+        DSO_BINARY_TYPE__GUEST_KMODULE,
+        DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
+        DSO_BINARY_TYPE__NOT_FOUND,
+};
+
+#define DSO_BINARY_TYPE__SYMTAB_CNT sizeof(binary_type_symtab)
+
+static enum dso_binary_type binary_type_data[] = {
+        DSO_BINARY_TYPE__BUILD_ID_CACHE,
+        DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
+        DSO_BINARY_TYPE__NOT_FOUND,
+};
+
+#define DSO_BINARY_TYPE__DATA_CNT sizeof(binary_type_data)
+
 int dso__name_len(const struct dso *dso)
 {
         if (!dso)
@@ -318,7 +344,9 @@ struct dso *dso__new(const char *name)
                 dso__set_short_name(dso, dso->name);
                 for (i = 0; i < MAP__NR_TYPES; ++i)
                         dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
-                dso->symtab_type = SYMTAB__NOT_FOUND;
+                dso->cache = RB_ROOT;
+                dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
+                dso->data_type   = DSO_BINARY_TYPE__NOT_FOUND;
                 dso->loaded = 0;
                 dso->sorted_by_name = 0;
                 dso->has_build_id = 0;
@@ -352,6 +380,7 @@ void dso__delete(struct dso *dso)
                 free((char *)dso->short_name);
         if (dso->lname_alloc)
                 free(dso->long_name);
+        dso_cache__free(&dso->cache);
         free(dso);
 }
 
@@ -806,9 +835,9 @@ int dso__load_kallsyms(struct dso *dso, const char *filename,
         symbols__fixup_end(&dso->symbols[map->type]);
 
         if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
-                dso->symtab_type = SYMTAB__GUEST_KALLSYMS;
+                dso->symtab_type = DSO_BINARY_TYPE__GUEST_KALLSYMS;
         else
-                dso->symtab_type = SYMTAB__KALLSYMS;
+                dso->symtab_type = DSO_BINARY_TYPE__KALLSYMS;
 
         return dso__split_kallsyms(dso, map, filter);
 }
@@ -1478,14 +1507,31 @@ static int elf_read_build_id(Elf *elf, void *bf, size_t size)
                 goto out;
         }
 
-        sec = elf_section_by_name(elf, &ehdr, &shdr,
-                                  ".note.gnu.build-id", NULL);
-        if (sec == NULL) {
+        /*
+         * Check following sections for notes:
+         *   '.note.gnu.build-id'
+         *   '.notes'
+         *   '.note' (VDSO specific)
+         */
+        do {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".note.gnu.build-id", NULL);
+                if (sec)
+                        break;
+
                 sec = elf_section_by_name(elf, &ehdr, &shdr,
                                           ".notes", NULL);
-                if (sec == NULL)
-                        goto out;
-        }
+                if (sec)
+                        break;
+
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".note", NULL);
+                if (sec)
+                        break;
+
+                return err;
+
+        } while (0);
 
         data = elf_getdata(sec, NULL);
         if (data == NULL)
@@ -1590,34 +1636,163 @@ out:
         return err;
 }
 
+static int filename__read_debuglink(const char *filename,
+                                    char *debuglink, size_t size)
+{
+        int fd, err = -1;
+        Elf *elf;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *data;
+        Elf_Scn *sec;
+        Elf_Kind ek;
+
+        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_close;
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                pr_err("%s: cannot get elf header.\n", __func__);
+                goto out_close;
+        }
+
+        sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                  ".gnu_debuglink", NULL);
+        if (sec == NULL)
+                goto out_close;
+
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
+                goto out_close;
+
+        /* the start of this section is a zero-terminated string */
+        strncpy(debuglink, data->d_buf, size);
+
+        elf_end(elf);
+
+out_close:
+        close(fd);
+out:
+        return err;
+}
+
 char dso__symtab_origin(const struct dso *dso)
 {
         static const char origin[] = {
-                [SYMTAB__KALLSYMS]            = 'k',
-                [SYMTAB__JAVA_JIT]            = 'j',
-                [SYMTAB__BUILD_ID_CACHE]      = 'B',
-                [SYMTAB__FEDORA_DEBUGINFO]    = 'f',
-                [SYMTAB__UBUNTU_DEBUGINFO]    = 'u',
-                [SYMTAB__BUILDID_DEBUGINFO]   = 'b',
-                [SYMTAB__SYSTEM_PATH_DSO]     = 'd',
-                [SYMTAB__SYSTEM_PATH_KMODULE] = 'K',
-                [SYMTAB__GUEST_KALLSYMS]      =  'g',
-                [SYMTAB__GUEST_KMODULE]       =  'G',
+                [DSO_BINARY_TYPE__KALLSYMS]             = 'k',
+                [DSO_BINARY_TYPE__JAVA_JIT]             = 'j',
+                [DSO_BINARY_TYPE__DEBUGLINK]            = 'l',
+                [DSO_BINARY_TYPE__BUILD_ID_CACHE]       = 'B',
+                [DSO_BINARY_TYPE__FEDORA_DEBUGINFO]     = 'f',
+                [DSO_BINARY_TYPE__UBUNTU_DEBUGINFO]     = 'u',
+                [DSO_BINARY_TYPE__BUILDID_DEBUGINFO]    = 'b',
+                [DSO_BINARY_TYPE__SYSTEM_PATH_DSO]      = 'd',
+                [DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE]  = 'K',
+                [DSO_BINARY_TYPE__GUEST_KALLSYMS]       = 'g',
+                [DSO_BINARY_TYPE__GUEST_KMODULE]        = 'G',
         };
 
-        if (dso == NULL || dso->symtab_type == SYMTAB__NOT_FOUND)
+        if (dso == NULL || dso->symtab_type == DSO_BINARY_TYPE__NOT_FOUND)
                 return '!';
         return origin[dso->symtab_type];
 }
 
+int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
+                          char *root_dir, char *file, size_t size)
+{
+        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+        int ret = 0;
+
+        switch (type) {
+        case DSO_BINARY_TYPE__DEBUGLINK: {
+                char *debuglink;
+
+                strncpy(file, dso->long_name, size);
+                debuglink = file + dso->long_name_len;
+                while (debuglink != file && *debuglink != '/')
+                        debuglink--;
+                if (*debuglink == '/')
+                        debuglink++;
+                filename__read_debuglink(dso->long_name, debuglink,
+                                         size - (debuglink - file));
+                }
+                break;
+        case DSO_BINARY_TYPE__BUILD_ID_CACHE:
+                /* skip the locally configured cache if a symfs is given */
+                if (symbol_conf.symfs[0] ||
+                    (dso__build_id_filename(dso, file, size) == NULL))
+                        ret = -1;
+                break;
+
+        case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
+                snprintf(file, size, "%s/usr/lib/debug%s.debug",
+                         symbol_conf.symfs, dso->long_name);
+                break;
+
+        case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
+                snprintf(file, size, "%s/usr/lib/debug%s",
+                         symbol_conf.symfs, dso->long_name);
+                break;
+
+        case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
+                if (!dso->has_build_id) {
+                        ret = -1;
+                        break;
+                }
+
+                build_id__sprintf(dso->build_id,
+                                  sizeof(dso->build_id),
+                                  build_id_hex);
+                snprintf(file, size,
+                         "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
+                         symbol_conf.symfs, build_id_hex, build_id_hex + 2);
+                break;
+
+        case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
+                snprintf(file, size, "%s%s",
+                         symbol_conf.symfs, dso->long_name);
+                break;
+
+        case DSO_BINARY_TYPE__GUEST_KMODULE:
+                snprintf(file, size, "%s%s%s", symbol_conf.symfs,
+                         root_dir, dso->long_name);
+                break;
+
+        case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
+                snprintf(file, size, "%s%s", symbol_conf.symfs,
+                         dso->long_name);
+                break;
+
+        default:
+        case DSO_BINARY_TYPE__KALLSYMS:
+        case DSO_BINARY_TYPE__GUEST_KALLSYMS:
+        case DSO_BINARY_TYPE__JAVA_JIT:
+        case DSO_BINARY_TYPE__NOT_FOUND:
+                ret = -1;
+                break;
+        }
+
+        return ret;
+}
+
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 {
-        int size = PATH_MAX;
         char *name;
         int ret = -1;
         int fd;
+        u_int i;
         struct machine *machine;
-        const char *root_dir;
+        char *root_dir = (char *) "";
         int want_symtab;
 
         dso__set_loaded(dso, map->type);
@@ -1632,7 +1807,7 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         else
                 machine = NULL;
 
-        name = malloc(size);
+        name = malloc(PATH_MAX);
         if (!name)
                 return -1;
 
@@ -1651,69 +1826,27 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
                 }
 
                 ret = dso__load_perf_map(dso, map, filter);
-                dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
-                                              SYMTAB__NOT_FOUND;
+                dso->symtab_type = ret > 0 ? DSO_BINARY_TYPE__JAVA_JIT :
+                                             DSO_BINARY_TYPE__NOT_FOUND;
                 return ret;
         }
 
+        if (machine)
+                root_dir = machine->root_dir;
+
         /* 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
          */
         want_symtab = 1;
 restart:
-        for (dso->symtab_type = SYMTAB__BUILD_ID_CACHE;
-             dso->symtab_type != SYMTAB__NOT_FOUND;
-             dso->symtab_type++) {
-                switch (dso->symtab_type) {
-                case SYMTAB__BUILD_ID_CACHE:
-                        /* skip the locally configured cache if a symfs is given */
-                        if (symbol_conf.symfs[0] ||
-                            (dso__build_id_filename(dso, name, size) == NULL)) {
-                                continue;
-                        }
-                        break;
-                case SYMTAB__FEDORA_DEBUGINFO:
-                        snprintf(name, size, "%s/usr/lib/debug%s.debug",
-                                 symbol_conf.symfs, dso->long_name);
-                        break;
-                case SYMTAB__UBUNTU_DEBUGINFO:
-                        snprintf(name, size, "%s/usr/lib/debug%s",
-                                 symbol_conf.symfs, dso->long_name);
-                        break;
-                case SYMTAB__BUILDID_DEBUGINFO: {
-                        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
-
-                        if (!dso->has_build_id)
-                                continue;
+        for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
 
-                        build_id__sprintf(dso->build_id,
-                                          sizeof(dso->build_id),
-                                          build_id_hex);
-                        snprintf(name, size,
-                                 "%s/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                 symbol_conf.symfs, build_id_hex, build_id_hex + 2);
-                        }
-                        break;
-                case SYMTAB__SYSTEM_PATH_DSO:
-                        snprintf(name, size, "%s%s",
-                             symbol_conf.symfs, dso->long_name);
-                        break;
-                case SYMTAB__GUEST_KMODULE:
-                        if (map->groups && machine)
-                                root_dir = machine->root_dir;
-                        else
-                                root_dir = "";
-                        snprintf(name, size, "%s%s%s", symbol_conf.symfs,
-                                 root_dir, dso->long_name);
-                        break;
+                dso->symtab_type = binary_type_symtab[i];
 
-                case SYMTAB__SYSTEM_PATH_KMODULE:
-                        snprintf(name, size, "%s%s", symbol_conf.symfs,
-                                 dso->long_name);
-                        break;
-                default:;
-                }
+                if (dso__binary_type_file(dso, dso->symtab_type,
+                                          root_dir, name, PATH_MAX))
+                        continue;
 
                 /* Name is now the name of the next image to try */
                 fd = open(name, O_RDONLY);
@@ -1930,9 +2063,9 @@ struct map *machine__new_module(struct machine *machine, u64 start,
                 return NULL;
 
         if (machine__is_host(machine))
-                dso->symtab_type = SYMTAB__SYSTEM_PATH_KMODULE;
+                dso->symtab_type = DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE;
         else
-                dso->symtab_type = SYMTAB__GUEST_KMODULE;
+                dso->symtab_type = DSO_BINARY_TYPE__GUEST_KMODULE;
         map_groups__insert(&machine->kmaps, map);
         return map;
 }
@@ -2484,8 +2617,15 @@ int machine__create_kernel_maps(struct machine *machine)
             __machine__create_kernel_maps(machine, kernel) < 0)
                 return -1;
 
-        if (symbol_conf.use_modules && machine__create_modules(machine) < 0)
-                pr_debug("Problems creating module maps, continuing anyway...\n");
+        if (symbol_conf.use_modules && machine__create_modules(machine) < 0) {
+                if (machine__is_host(machine))
+                        pr_debug("Problems creating module maps, "
+                                 "continuing anyway...\n");
+                else
+                        pr_debug("Problems creating module maps for guest %d, "
+                                 "continuing anyway...\n", machine->pid);
+        }
+
         /*
          * Now that we have all the maps created, just set the ->end of them:
          */
@@ -2825,3 +2965,218 @@ struct map *dso__new_map(const char *name)
 
         return map;
 }
+
+static int open_dso(struct dso *dso, struct machine *machine)
+{
+        char *root_dir = (char *) "";
+        char *name;
+        int fd;
+
+        name = malloc(PATH_MAX);
+        if (!name)
+                return -ENOMEM;
+
+        if (machine)
+                root_dir = machine->root_dir;
+
+        if (dso__binary_type_file(dso, dso->data_type,
+                                  root_dir, name, PATH_MAX)) {
+                free(name);
+                return -EINVAL;
+        }
+
+        fd = open(name, O_RDONLY);
+        free(name);
+        return fd;
+}
+
+int dso__data_fd(struct dso *dso, struct machine *machine)
+{
+        int i = 0;
+
+        if (dso->data_type != DSO_BINARY_TYPE__NOT_FOUND)
+                return open_dso(dso, machine);
+
+        do {
+                int fd;
+
+                dso->data_type = binary_type_data[i++];
+
+                fd = open_dso(dso, machine);
+                if (fd >= 0)
+                        return fd;
+
+        } while (dso->data_type != DSO_BINARY_TYPE__NOT_FOUND);
+
+        return -EINVAL;
+}
+
+static void
+dso_cache__free(struct rb_root *root)
+{
+        struct rb_node *next = rb_first(root);
+
+        while (next) {
+                struct dso_cache *cache;
+
+                cache = rb_entry(next, struct dso_cache, rb_node);
+                next = rb_next(&cache->rb_node);
+                rb_erase(&cache->rb_node, root);
+                free(cache);
+        }
+}
+
+static struct dso_cache*
+dso_cache__find(struct rb_root *root, u64 offset)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct dso_cache *cache;
+
+        while (*p != NULL) {
+                u64 end;
+
+                parent = *p;
+                cache = rb_entry(parent, struct dso_cache, rb_node);
+                end = cache->offset + DSO__DATA_CACHE_SIZE;
+
+                if (offset < cache->offset)
+                        p = &(*p)->rb_left;
+                else if (offset >= end)
+                        p = &(*p)->rb_right;
+                else
+                        return cache;
+        }
+        return NULL;
+}
+
+static void
+dso_cache__insert(struct rb_root *root, struct dso_cache *new)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct dso_cache *cache;
+        u64 offset = new->offset;
+
+        while (*p != NULL) {
+                u64 end;
+
+                parent = *p;
+                cache = rb_entry(parent, struct dso_cache, rb_node);
+                end = cache->offset + DSO__DATA_CACHE_SIZE;
+
+                if (offset < cache->offset)
+                        p = &(*p)->rb_left;
+                else if (offset >= end)
+                        p = &(*p)->rb_right;
+        }
+
+        rb_link_node(&new->rb_node, parent, p);
+        rb_insert_color(&new->rb_node, root);
+}
+
+static ssize_t
+dso_cache__memcpy(struct dso_cache *cache, u64 offset,
+                  u8 *data, u64 size)
+{
+        u64 cache_offset = offset - cache->offset;
+        u64 cache_size   = min(cache->size - cache_offset, size);
+
+        memcpy(data, cache->data + cache_offset, cache_size);
+        return cache_size;
+}
+
+static ssize_t
+dso_cache__read(struct dso *dso, struct machine *machine,
+                 u64 offset, u8 *data, ssize_t size)
+{
+        struct dso_cache *cache;
+        ssize_t ret;
+        int fd;
+
+        fd = dso__data_fd(dso, machine);
+        if (fd < 0)
+                return -1;
+
+        do {
+                u64 cache_offset;
+
+                ret = -ENOMEM;
+
+                cache = zalloc(sizeof(*cache) + DSO__DATA_CACHE_SIZE);
+                if (!cache)
+                        break;
+
+                cache_offset = offset & DSO__DATA_CACHE_MASK;
+                ret = -EINVAL;
+
+                if (-1 == lseek(fd, cache_offset, SEEK_SET))
+                        break;
+
+                ret = read(fd, cache->data, DSO__DATA_CACHE_SIZE);
+                if (ret <= 0)
+                        break;
+
+                cache->offset = cache_offset;
+                cache->size   = ret;
+                dso_cache__insert(&dso->cache, cache);
+
+                ret = dso_cache__memcpy(cache, offset, data, size);
+
+        } while (0);
+
+        if (ret <= 0)
+                free(cache);
+
+        close(fd);
+        return ret;
+}
+
+static ssize_t dso_cache_read(struct dso *dso, struct machine *machine,
+                              u64 offset, u8 *data, ssize_t size)
+{
+        struct dso_cache *cache;
+
+        cache = dso_cache__find(&dso->cache, offset);
+        if (cache)
+                return dso_cache__memcpy(cache, offset, data, size);
+        else
+                return dso_cache__read(dso, machine, offset, data, size);
+}
+
+ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
+                              u64 offset, u8 *data, ssize_t size)
+{
+        ssize_t r = 0;
+        u8 *p = data;
+
+        do {
+                ssize_t ret;
+
+                ret = dso_cache_read(dso, machine, offset, p, size);
+                if (ret < 0)
+                        return ret;
+
+                /* Reached EOF, return what we have. */
+                if (!ret)
+                        break;
+
+                BUG_ON(ret > size);
+
+                r      += ret;
+                p      += ret;
+                offset += ret;
+                size   -= ret;
+
+        } while (size);
+
+        return r;
+}
+
+ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
+                            struct machine *machine, u64 addr,
+                            u8 *data, ssize_t size)
+{
+        u64 offset = map->map_ip(map, addr);
+        return dso__data_read_offset(dso, machine, offset, data, size);
+}
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index af0752b1aca1..1fe733a1e21f 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -155,6 +155,21 @@ struct addr_location {
         s32           cpu;
 };
 
+enum dso_binary_type {
+        DSO_BINARY_TYPE__KALLSYMS = 0,
+        DSO_BINARY_TYPE__GUEST_KALLSYMS,
+        DSO_BINARY_TYPE__JAVA_JIT,
+        DSO_BINARY_TYPE__DEBUGLINK,
+        DSO_BINARY_TYPE__BUILD_ID_CACHE,
+        DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
+        DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
+        DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
+        DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
+        DSO_BINARY_TYPE__GUEST_KMODULE,
+        DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE,
+        DSO_BINARY_TYPE__NOT_FOUND,
+};
+
 enum dso_kernel_type {
         DSO_TYPE_USER = 0,
         DSO_TYPE_KERNEL,
@@ -167,19 +182,31 @@ enum dso_swap_type {
         DSO_SWAP__YES,
 };
 
+#define DSO__DATA_CACHE_SIZE 4096
+#define DSO__DATA_CACHE_MASK ~(DSO__DATA_CACHE_SIZE - 1)
+
+struct dso_cache {
+        struct rb_node  rb_node;
+        u64 offset;
+        u64 size;
+        char data[0];
+};
+
 struct dso {
         struct list_head node;
         struct rb_root   symbols[MAP__NR_TYPES];
         struct rb_root   symbol_names[MAP__NR_TYPES];
+        struct rb_root   cache;
         enum dso_kernel_type    kernel;
         enum dso_swap_type      needs_swap;
+        enum dso_binary_type    symtab_type;
+        enum dso_binary_type    data_type;
         u8               adjust_symbols:1;
         u8               has_build_id:1;
         u8               hit:1;
         u8               annotate_warned:1;
         u8               sname_alloc:1;
         u8               lname_alloc:1;
-        unsigned char    symtab_type;
         u8               sorted_by_name;
         u8               loaded;
         u8               build_id[BUILD_ID_SIZE];
@@ -253,20 +280,6 @@ size_t dso__fprintf_symbols_by_name(struct dso *dso,
                                     enum map_type type, FILE *fp);
 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp);
 
-enum symtab_type {
-        SYMTAB__KALLSYMS = 0,
-        SYMTAB__GUEST_KALLSYMS,
-        SYMTAB__JAVA_JIT,
-        SYMTAB__BUILD_ID_CACHE,
-        SYMTAB__FEDORA_DEBUGINFO,
-        SYMTAB__UBUNTU_DEBUGINFO,
-        SYMTAB__BUILDID_DEBUGINFO,
-        SYMTAB__SYSTEM_PATH_DSO,
-        SYMTAB__GUEST_KMODULE,
-        SYMTAB__SYSTEM_PATH_KMODULE,
-        SYMTAB__NOT_FOUND,
-};
-
 char dso__symtab_origin(const struct dso *dso);
 void dso__set_long_name(struct dso *dso, char *name);
 void dso__set_build_id(struct dso *dso, void *build_id);
@@ -303,4 +316,14 @@ bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 
 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp);
 
+int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
+                          char *root_dir, char *file, size_t size);
+
+int dso__data_fd(struct dso *dso, struct machine *machine);
+ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
+                              u64 offset, u8 *data, ssize_t size);
+ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
+                            struct machine *machine, u64 addr,
+                            u8 *data, ssize_t size);
+int dso__test_data(void);
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
index 1064d5b148ad..3f59c496e64c 100644
--- a/tools/perf/util/target.c
+++ b/tools/perf/util/target.c
@@ -110,8 +110,17 @@ int perf_target__strerror(struct perf_target *target, int errnum,
         int idx;
         const char *msg;
 
+        BUG_ON(buflen > 0);
+
         if (errnum >= 0) {
-                strerror_r(errnum, buf, buflen);
+                const char *err = strerror_r(errnum, buf, buflen);
+
+                if (err != buf) {
+                        size_t len = strlen(err);
+                        char *c = mempcpy(buf, err, min(buflen - 1, len));
+                        *c = '\0';
+                }
+
                 return 0;
         }
 
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index abe0e8e95068..7eeebcee291c 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -65,7 +65,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
                                 top->freq ? "Hz" : "");
         }
 
-        ret += SNPRINTF(bf + ret, size - ret, "%s", event_name(top->sym_evsel));
+        ret += SNPRINTF(bf + ret, size - ret, "%s", perf_evsel__name(top->sym_evsel));
 
         ret += SNPRINTF(bf + ret, size - ret, "], ");
 
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index df2fddbf0cd2..0715c843c2e7 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -32,29 +32,25 @@ int header_page_size_size;
 int header_page_ts_size;
 int header_page_data_offset;
 
-struct pevent *perf_pevent;
-static struct pevent *pevent;
-
 bool latency_format;
 
-int read_trace_init(int file_bigendian, int host_bigendian)
+struct pevent *read_trace_init(int file_bigendian, int host_bigendian)
 {
-        if (pevent)
-                return 0;
-
-        perf_pevent = pevent_alloc();
-        pevent = perf_pevent;
+        struct pevent *pevent = pevent_alloc();
 
-        pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
-        pevent_set_file_bigendian(pevent, file_bigendian);
-        pevent_set_host_bigendian(pevent, host_bigendian);
+        if (pevent != NULL) {
+                pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
+                pevent_set_file_bigendian(pevent, file_bigendian);
+                pevent_set_host_bigendian(pevent, host_bigendian);
+        }
 
-        return 0;
+        return pevent;
 }
 
 static int get_common_field(struct scripting_context *context,
                             int *offset, int *size, const char *type)
 {
+        struct pevent *pevent = context->pevent;
         struct event_format *event;
         struct format_field *field;
 
@@ -150,7 +146,7 @@ void *raw_field_ptr(struct event_format *event, const char *name, void *data)
         return data + field->offset;
 }
 
-int trace_parse_common_type(void *data)
+int trace_parse_common_type(struct pevent *pevent, void *data)
 {
         struct pevent_record record;
 
@@ -158,7 +154,7 @@ int trace_parse_common_type(void *data)
         return pevent_data_type(pevent, &record);
 }
 
-int trace_parse_common_pid(void *data)
+int trace_parse_common_pid(struct pevent *pevent, void *data)
 {
         struct pevent_record record;
 
@@ -166,27 +162,21 @@ int trace_parse_common_pid(void *data)
         return pevent_data_pid(pevent, &record);
 }
 
-unsigned long long read_size(void *ptr, int size)
+unsigned long long read_size(struct pevent *pevent, void *ptr, int size)
 {
         return pevent_read_number(pevent, ptr, size);
 }
 
-struct event_format *trace_find_event(int type)
-{
-        return pevent_find_event(pevent, type);
-}
-
-
-void print_trace_event(int cpu, void *data, int size)
+void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
 {
         struct event_format *event;
         struct pevent_record record;
         struct trace_seq s;
         int type;
 
-        type = trace_parse_common_type(data);
+        type = trace_parse_common_type(pevent, data);
 
-        event = trace_find_event(type);
+        event = pevent_find_event(pevent, type);
         if (!event) {
                 warning("ug! no event found for type %d", type);
                 return;
@@ -198,13 +188,12 @@ void print_trace_event(int cpu, void *data, int size)
         record.data = data;
 
         trace_seq_init(&s);
-        pevent_print_event(pevent, &s, &record);
+        pevent_event_info(&s, event, &record);
         trace_seq_do_printf(&s);
-        printf("\n");
 }
 
-void print_event(int cpu, void *data, int size, unsigned long long nsecs,
-                  char *comm)
+void print_event(struct pevent *pevent, int cpu, void *data, int size,
+                 unsigned long long nsecs, char *comm)
 {
         struct pevent_record record;
         struct trace_seq s;
@@ -227,7 +216,8 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs,
         printf("\n");
 }
 
-void parse_proc_kallsyms(char *file, unsigned int size __unused)
+void parse_proc_kallsyms(struct pevent *pevent,
+                         char *file, unsigned int size __unused)
 {
         unsigned long long addr;
         char *func;
@@ -258,7 +248,8 @@ void parse_proc_kallsyms(char *file, unsigned int size __unused)
         }
 }
 
-void parse_ftrace_printk(char *file, unsigned int size __unused)
+void parse_ftrace_printk(struct pevent *pevent,
+                         char *file, unsigned int size __unused)
 {
         unsigned long long addr;
         char *printk;
@@ -282,17 +273,19 @@ void parse_ftrace_printk(char *file, unsigned int size __unused)
         }
 }
 
-int parse_ftrace_file(char *buf, unsigned long size)
+int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size)
 {
         return pevent_parse_event(pevent, buf, size, "ftrace");
 }
 
-int parse_event_file(char *buf, unsigned long size, char *sys)
+int parse_event_file(struct pevent *pevent,
+                     char *buf, unsigned long size, char *sys)
 {
         return pevent_parse_event(pevent, buf, size, sys);
 }
 
-struct event_format *trace_find_next_event(struct event_format *event)
+struct event_format *trace_find_next_event(struct pevent *pevent,
+                                           struct event_format *event)
 {
         static int idx;
 
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index f097e0dd6c5c..719ed74a8565 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -114,20 +114,20 @@ static void skip(int size)
         };
 }
 
-static unsigned int read4(void)
+static unsigned int read4(struct pevent *pevent)
 {
         unsigned int data;
 
         read_or_die(&data, 4);
-        return __data2host4(perf_pevent, data);
+        return __data2host4(pevent, data);
 }
 
-static unsigned long long read8(void)
+static unsigned long long read8(struct pevent *pevent)
 {
         unsigned long long data;
 
         read_or_die(&data, 8);
-        return __data2host8(perf_pevent, data);
+        return __data2host8(pevent, data);
 }
 
 static char *read_string(void)
@@ -168,12 +168,12 @@ static char *read_string(void)
         return str;
 }
 
-static void read_proc_kallsyms(void)
+static void read_proc_kallsyms(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
-        size = read4();
+        size = read4(pevent);
         if (!size)
                 return;
 
@@ -181,29 +181,29 @@ static void read_proc_kallsyms(void)
         read_or_die(buf, size);
         buf[size] = '\0';
 
-        parse_proc_kallsyms(buf, size);
+        parse_proc_kallsyms(pevent, buf, size);
 
         free(buf);
 }
 
-static void read_ftrace_printk(void)
+static void read_ftrace_printk(struct pevent *pevent)
 {
         unsigned int size;
         char *buf;
 
-        size = read4();
+        size = read4(pevent);
         if (!size)
                 return;
 
         buf = malloc_or_die(size);
         read_or_die(buf, size);
 
-        parse_ftrace_printk(buf, size);
+        parse_ftrace_printk(pevent, buf, size);
 
         free(buf);
 }
 
-static void read_header_files(void)
+static void read_header_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *header_event;
@@ -214,7 +214,7 @@ static void read_header_files(void)
         if (memcmp(buf, "header_page", 12) != 0)
                 die("did not read header page");
 
-        size = read8();
+        size = read8(pevent);
         skip(size);
 
         /*
@@ -227,47 +227,48 @@ static void read_header_files(void)
         if (memcmp(buf, "header_event", 13) != 0)
                 die("did not read header event");
 
-        size = read8();
+        size = read8(pevent);
         header_event = malloc_or_die(size);
         read_or_die(header_event, size);
         free(header_event);
 }
 
-static void read_ftrace_file(unsigned long long size)
+static void read_ftrace_file(struct pevent *pevent, unsigned long long size)
 {
         char *buf;
 
         buf = malloc_or_die(size);
         read_or_die(buf, size);
-        parse_ftrace_file(buf, size);
+        parse_ftrace_file(pevent, buf, size);
         free(buf);
 }
 
-static void read_event_file(char *sys, unsigned long long size)
+static void read_event_file(struct pevent *pevent, char *sys,
+                            unsigned long long size)
 {
         char *buf;
 
         buf = malloc_or_die(size);
         read_or_die(buf, size);
-        parse_event_file(buf, size, sys);
+        parse_event_file(pevent, buf, size, sys);
         free(buf);
 }
 
-static void read_ftrace_files(void)
+static void read_ftrace_files(struct pevent *pevent)
 {
         unsigned long long size;
         int count;
         int i;
 
-        count = read4();
+        count = read4(pevent);
 
         for (i = 0; i < count; i++) {
-                size = read8();
-                read_ftrace_file(size);
+                size = read8(pevent);
+                read_ftrace_file(pevent, size);
         }
 }
 
-static void read_event_files(void)
+static void read_event_files(struct pevent *pevent)
 {
         unsigned long long size;
         char *sys;
@@ -275,15 +276,15 @@ static void read_event_files(void)
         int count;
         int i,x;
 
-        systems = read4();
+        systems = read4(pevent);
 
         for (i = 0; i < systems; i++) {
                 sys = read_string();
 
-                count = read4();
+                count = read4(pevent);
                 for (x=0; x < count; x++) {
-                        size = read8();
-                        read_event_file(sys, size);
+                        size = read8(pevent);
+                        read_event_file(pevent, sys, size);
                 }
         }
 }
@@ -377,7 +378,7 @@ static int calc_index(void *ptr, int cpu)
         return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
 }
 
-struct pevent_record *trace_peek_data(int cpu)
+struct pevent_record *trace_peek_data(struct pevent *pevent, int cpu)
 {
         struct pevent_record *data;
         void *page = cpu_data[cpu].page;
@@ -399,15 +400,15 @@ struct pevent_record *trace_peek_data(int cpu)
                 /* FIXME: handle header page */
                 if (header_page_ts_size != 8)
                         die("expected a long long type for timestamp");
-                cpu_data[cpu].timestamp = data2host8(perf_pevent, ptr);
+                cpu_data[cpu].timestamp = data2host8(pevent, ptr);
                 ptr += 8;
                 switch (header_page_size_size) {
                 case 4:
-                        cpu_data[cpu].page_size = data2host4(perf_pevent, ptr);
+                        cpu_data[cpu].page_size = data2host4(pevent, ptr);
                         ptr += 4;
                         break;
                 case 8:
-                        cpu_data[cpu].page_size = data2host8(perf_pevent, ptr);
+                        cpu_data[cpu].page_size = data2host8(pevent, ptr);
                         ptr += 8;
                         break;
                 default:
@@ -421,10 +422,10 @@ read_again:
 
         if (idx >= cpu_data[cpu].page_size) {
                 get_next_page(cpu);
-                return trace_peek_data(cpu);
+                return trace_peek_data(pevent, cpu);
         }
 
-        type_len_ts = data2host4(perf_pevent, ptr);
+        type_len_ts = data2host4(pevent, ptr);
         ptr += 4;
 
         type_len = type_len4host(type_len_ts);
@@ -434,14 +435,14 @@ read_again:
         case RINGBUF_TYPE_PADDING:
                 if (!delta)
                         die("error, hit unexpected end of page");
-                length = data2host4(perf_pevent, ptr);
+                length = data2host4(pevent, ptr);
                 ptr += 4;
                 length *= 4;
                 ptr += length;
                 goto read_again;
 
         case RINGBUF_TYPE_TIME_EXTEND:
-                extend = data2host4(perf_pevent, ptr);
+                extend = data2host4(pevent, ptr);
                 ptr += 4;
                 extend <<= TS_SHIFT;
                 extend += delta;
@@ -452,7 +453,7 @@ read_again:
                 ptr += 12;
                 break;
         case 0:
-                length = data2host4(perf_pevent, ptr);
+                length = data2host4(pevent, ptr);
                 ptr += 4;
                 die("here! length=%d", length);
                 break;
@@ -477,17 +478,17 @@ read_again:
         return data;
 }
 
-struct pevent_record *trace_read_data(int cpu)
+struct pevent_record *trace_read_data(struct pevent *pevent, int cpu)
 {
         struct pevent_record *data;
 
-        data = trace_peek_data(cpu);
+        data = trace_peek_data(pevent, cpu);
         cpu_data[cpu].next = NULL;
 
         return data;
 }
 
-ssize_t trace_report(int fd, bool __repipe)
+ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
 {
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
@@ -519,30 +520,32 @@ ssize_t trace_report(int fd, bool __repipe)
         file_bigendian = buf[0];
         host_bigendian = bigendian();
 
-        read_trace_init(file_bigendian, host_bigendian);
+        *ppevent = read_trace_init(file_bigendian, host_bigendian);
+        if (*ppevent == NULL)
+                die("read_trace_init failed");
 
         read_or_die(buf, 1);
         long_size = buf[0];
 
-        page_size = read4();
+        page_size = read4(*ppevent);
 
-        read_header_files();
+        read_header_files(*ppevent);
 
-        read_ftrace_files();
-        read_event_files();
-        read_proc_kallsyms();
-        read_ftrace_printk();
+        read_ftrace_files(*ppevent);
+        read_event_files(*ppevent);
+        read_proc_kallsyms(*ppevent);
+        read_ftrace_printk(*ppevent);
 
         size = calc_data_size - 1;
         calc_data_size = 0;
         repipe = false;
 
         if (show_funcs) {
-                pevent_print_funcs(perf_pevent);
+                pevent_print_funcs(*ppevent);
                 return size;
         }
         if (show_printk) {
-                pevent_print_printk(perf_pevent);
+                pevent_print_printk(*ppevent);
                 return size;
         }
 
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index 18ae6c1831d3..474aa7a7df43 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -36,6 +36,7 @@ static int stop_script_unsupported(void)
 }
 
 static void process_event_unsupported(union perf_event *event __unused,
+                                      struct pevent *pevent __unused,
                                       struct perf_sample *sample __unused,
                                       struct perf_evsel *evsel __unused,
                                       struct machine *machine __unused,
@@ -61,7 +62,8 @@ static int python_start_script_unsupported(const char *script __unused,
         return -1;
 }
 
-static int python_generate_script_unsupported(const char *outfile __unused)
+static int python_generate_script_unsupported(struct pevent *pevent __unused,
+                                              const char *outfile __unused)
 {
         print_python_unsupported_msg();
 
@@ -122,7 +124,8 @@ static int perl_start_script_unsupported(const char *script __unused,
         return -1;
 }
 
-static int perl_generate_script_unsupported(const char *outfile __unused)
+static int perl_generate_script_unsupported(struct pevent *pevent __unused,
+                                            const char *outfile __unused)
 {
         print_perl_unsupported_msg();
 
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 639852ac1117..8fef1d6687b7 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -8,6 +8,7 @@
 struct machine;
 struct perf_sample;
 union perf_event;
+struct perf_tool;
 struct thread;
 
 extern int header_page_size_size;
@@ -29,35 +30,36 @@ enum {
 
 int bigendian(void);
 
-int read_trace_init(int file_bigendian, int host_bigendian);
-void print_trace_event(int cpu, void *data, int size);
+struct pevent *read_trace_init(int file_bigendian, int host_bigendian);
+void print_trace_event(struct pevent *pevent, int cpu, void *data, int size);
 
-void print_event(int cpu, void *data, int size, unsigned long long nsecs,
-                  char *comm);
+void print_event(struct pevent *pevent, int cpu, void *data, int size,
+                 unsigned long long nsecs, char *comm);
 
-int parse_ftrace_file(char *buf, unsigned long size);
-int parse_event_file(char *buf, unsigned long size, char *sys);
+int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size);
+int parse_event_file(struct pevent *pevent,
+                     char *buf, unsigned long size, char *sys);
 
-struct pevent_record *trace_peek_data(int cpu);
-struct event_format *trace_find_event(int type);
+struct pevent_record *trace_peek_data(struct pevent *pevent, int cpu);
 
 unsigned long long
 raw_field_value(struct event_format *event, const char *name, void *data);
 void *raw_field_ptr(struct event_format *event, const char *name, void *data);
 
-void parse_proc_kallsyms(char *file, unsigned int size __unused);
-void parse_ftrace_printk(char *file, unsigned int size __unused);
+void parse_proc_kallsyms(struct pevent *pevent, char *file, unsigned int size);
+void parse_ftrace_printk(struct pevent *pevent, char *file, unsigned int size);
 
-ssize_t trace_report(int fd, bool repipe);
+ssize_t trace_report(int fd, struct pevent **pevent, bool repipe);
 
-int trace_parse_common_type(void *data);
-int trace_parse_common_pid(void *data);
+int trace_parse_common_type(struct pevent *pevent, void *data);
+int trace_parse_common_pid(struct pevent *pevent, void *data);
 
-struct event_format *trace_find_next_event(struct event_format *event);
-unsigned long long read_size(void *ptr, int size);
+struct event_format *trace_find_next_event(struct pevent *pevent,
+                                           struct event_format *event);
+unsigned long long read_size(struct pevent *pevent, void *ptr, int size);
 unsigned long long eval_flag(const char *flag);
 
-struct pevent_record *trace_read_data(int cpu);
+struct pevent_record *trace_read_data(struct pevent *pevent, int cpu);
 int read_tracing_data(int fd, struct list_head *pattrs);
 
 struct tracing_data {
@@ -77,11 +79,12 @@ struct scripting_ops {
         int (*start_script) (const char *script, int argc, const char **argv);
         int (*stop_script) (void);
         void (*process_event) (union perf_event *event,
+                               struct pevent *pevent,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
                                struct thread *thread);
-        int (*generate_script) (const char *outfile);
+        int (*generate_script) (struct pevent *pevent, const char *outfile);
 };
 
 int script_spec_register(const char *spec, struct scripting_ops *ops);
@@ -90,6 +93,7 @@ void setup_perl_scripting(void);
 void setup_python_scripting(void);
 
 struct scripting_context {
+        struct pevent *pevent;
         void *event_data;
 };
 
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 2daaedb83d84..b13c7331eaf8 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -264,4 +264,6 @@ bool is_power_of_2(unsigned long n)
 
 size_t hex_width(u64 v);
 
+char *rtrim(char *s);
+
 #endif
diff --git a/tools/power/x86/turbostat/Makefile b/tools/power/x86/turbostat/Makefile
index fd8e1f1297aa..f85649554191 100644
--- a/tools/power/x86/turbostat/Makefile
+++ b/tools/power/x86/turbostat/Makefile
@@ -1,4 +1,5 @@
 turbostat : turbostat.c
+CFLAGS +=       -Wall
 
 clean :
         rm -f turbostat
diff --git a/tools/power/x86/turbostat/turbostat.8 b/tools/power/x86/turbostat/turbostat.8
index adf175f61496..74e44507dfe9 100644
--- a/tools/power/x86/turbostat/turbostat.8
+++ b/tools/power/x86/turbostat/turbostat.8
@@ -27,7 +27,11 @@ supports an "invariant" TSC, plus the APERF and MPERF MSRs.
 on processors that additionally support C-state residency counters.
 
 .SS Options
-The \fB-s\fP option prints only a 1-line summary for each sample interval.
+The \fB-s\fP option limits output to a 1-line system summary for each interval.
+.PP
+The \fB-c\fP option limits output to the 1st thread in each core.
+.PP
+The \fB-p\fP option limits output to the 1st thread in each package.
 .PP
 The \fB-v\fP option increases verbosity.
 .PP
@@ -65,19 +69,19 @@ Subsequent rows show per-CPU statistics.
 .nf
 [root@x980]# ./turbostat
 cor CPU    %c0  GHz  TSC    %c1    %c3    %c6   %pc3   %pc6
-          0.60 1.63 3.38   2.91   0.00  96.49   0.00  76.64
-  0   0   0.59 1.62 3.38   4.51   0.00  94.90   0.00  76.64
-  0   6   1.13 1.64 3.38   3.97   0.00  94.90   0.00  76.64
-  1   2   0.08 1.62 3.38   0.07   0.00  99.85   0.00  76.64
-  1   8   0.03 1.62 3.38   0.12   0.00  99.85   0.00  76.64
-  2   4   0.01 1.62 3.38   0.06   0.00  99.93   0.00  76.64
-  2  10   0.04 1.62 3.38   0.02   0.00  99.93   0.00  76.64
-  8   1   2.85 1.62 3.38  11.71   0.00  85.44   0.00  76.64
-  8   7   1.98 1.62 3.38  12.58   0.00  85.44   0.00  76.64
-  9   3   0.36 1.62 3.38   0.71   0.00  98.93   0.00  76.64
-  9   9   0.09 1.62 3.38   0.98   0.00  98.93   0.00  76.64
- 10   5   0.03 1.62 3.38   0.09   0.00  99.87   0.00  76.64
- 10  11   0.07 1.62 3.38   0.06   0.00  99.87   0.00  76.64
+          0.09 1.62 3.38   1.83   0.32  97.76   1.26  83.61
+  0   0   0.15 1.62 3.38  10.23   0.05  89.56   1.26  83.61
+  0   6   0.05 1.62 3.38  10.34
+  1   2   0.03 1.62 3.38   0.07   0.05  99.86
+  1   8   0.03 1.62 3.38   0.06
+  2   4   0.21 1.62 3.38   0.10   1.49  98.21
+  2  10   0.02 1.62 3.38   0.29
+  8   1   0.04 1.62 3.38   0.04   0.08  99.84
+  8   7   0.01 1.62 3.38   0.06
+  9   3   0.53 1.62 3.38   0.10   0.20  99.17
+  9   9   0.02 1.62 3.38   0.60
+ 10   5   0.01 1.62 3.38   0.02   0.04  99.92
+ 10  11   0.02 1.62 3.38   0.02
 .fi
 .SH SUMMARY EXAMPLE
 The "-s" option prints the column headers just once,
@@ -86,9 +90,10 @@ and then the one line system summary for each sample interval.
 .nf
 [root@x980]# ./turbostat -s
    %c0  GHz  TSC    %c1    %c3    %c6   %pc3   %pc6
-  0.61 1.89 3.38   5.95   0.00  93.44   0.00  66.33
-  0.52 1.62 3.38   6.83   0.00  92.65   0.00  61.11
-  0.62 1.92 3.38   5.47   0.00  93.91   0.00  67.31
+  0.23 1.67 3.38   2.00   0.30  97.47   1.07  82.12
+  0.10 1.62 3.38   1.87   2.25  95.77  12.02  72.60
+  0.20 1.64 3.38   1.98   0.11  97.72   0.30  83.36
+  0.11 1.70 3.38   1.86   1.81  96.22   9.71  74.90
 .fi
 .SH VERBOSE EXAMPLE
 The "-v" option adds verbosity to the output:
@@ -120,30 +125,28 @@ until ^C while the other CPUs are mostly idle:
 [root@x980 lenb]# ./turbostat cat /dev/zero > /dev/null
 ^C
 cor CPU    %c0  GHz  TSC    %c1    %c3    %c6   %pc3   %pc6
-          8.63 3.64 3.38  14.46   0.49  76.42   0.00   0.00
-  0   0   0.34 3.36 3.38  99.66   0.00   0.00   0.00   0.00
-  0   6  99.96 3.64 3.38   0.04   0.00   0.00   0.00   0.00
-  1   2   0.14 3.50 3.38   1.75   2.04  96.07   0.00   0.00
-  1   8   0.38 3.57 3.38   1.51   2.04  96.07   0.00   0.00
-  2   4   0.01 2.65 3.38   0.06   0.00  99.93   0.00   0.00
-  2  10   0.03 2.12 3.38   0.04   0.00  99.93   0.00   0.00
-  8   1   0.91 3.59 3.38  35.27   0.92  62.90   0.00   0.00
-  8   7   1.61 3.63 3.38  34.57   0.92  62.90   0.00   0.00
-  9   3   0.04 3.38 3.38   0.20   0.00  99.76   0.00   0.00
-  9   9   0.04 3.29 3.38   0.20   0.00  99.76   0.00   0.00
- 10   5   0.03 3.08 3.38   0.12   0.00  99.85   0.00   0.00
- 10  11   0.05 3.07 3.38   0.10   0.00  99.85   0.00   0.00
-4.907015 sec
-
+          8.86 3.61 3.38  15.06  31.19  44.89   0.00   0.00
+  0   0   1.46 3.22 3.38  16.84  29.48  52.22   0.00   0.00
+  0   6   0.21 3.06 3.38  18.09
+  1   2   0.53 3.33 3.38   2.80  46.40  50.27
+  1   8   0.89 3.47 3.38   2.44
+  2   4   1.36 3.43 3.38   9.04  23.71  65.89
+  2  10   0.18 2.86 3.38  10.22
+  8   1   0.04 2.87 3.38  99.96   0.01   0.00
+  8   7  99.72 3.63 3.38   0.27
+  9   3   0.31 3.21 3.38   7.64  56.55  35.50
+  9   9   0.08 2.95 3.38   7.88
+ 10   5   1.42 3.43 3.38   2.14  30.99  65.44
+ 10  11   0.16 2.88 3.38   3.40
 .fi
-Above the cycle soaker drives cpu6 up 3.6 Ghz turbo limit
+Above the cycle soaker drives cpu7 up its 3.6 Ghz turbo limit
 while the other processors are generally in various states of idle.
 
-Note that cpu0 is an HT sibling sharing core0
-with cpu6, and thus it is unable to get to an idle state
-deeper than c1 while cpu6 is busy.
+Note that cpu1 and cpu7 are HT siblings within core8.
+As cpu7 is very busy, it prevents its sibling, cpu1,
+from entering a c-state deeper than c1.
 
-Note that turbostat reports average GHz of 3.64, while
+Note that turbostat reports average GHz of 3.63, while
 the arithmetic average of the GHz column above is lower.
 This is a weighted average, where the weight is %c0.  ie. it is the total number of
 un-halted cycles elapsed per time divided by the number of CPUs.
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 16de7ad4850f..861d77190206 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -67,92 +67,119 @@ double bclk;
 unsigned int show_pkg;
 unsigned int show_core;
 unsigned int show_cpu;
+unsigned int show_pkg_only;
+unsigned int show_core_only;
+char *output_buffer, *outp;
 
 int aperf_mperf_unstable;
 int backwards_count;
 char *progname;
 
-int num_cpus;
-cpu_set_t *cpu_present_set, *cpu_mask;
-size_t cpu_present_setsize, cpu_mask_size;
-
-struct counters {
-        unsigned long long tsc;         /* per thread */
-        unsigned long long aperf;       /* per thread */
-        unsigned long long mperf;       /* per thread */
-        unsigned long long c1;  /* per thread (calculated) */
-        unsigned long long c3;  /* per core */
-        unsigned long long c6;  /* per core */
-        unsigned long long c7;  /* per core */
-        unsigned long long pc2; /* per package */
-        unsigned long long pc3; /* per package */
-        unsigned long long pc6; /* per package */
-        unsigned long long pc7; /* per package */
-        unsigned long long extra_msr;   /* per thread */
-        int pkg;
-        int core;
-        int cpu;
-        struct counters *next;
-};
-
-struct counters *cnt_even;
-struct counters *cnt_odd;
-struct counters *cnt_delta;
-struct counters *cnt_average;
-struct timeval tv_even;
-struct timeval tv_odd;
-struct timeval tv_delta;
-
-int mark_cpu_present(int pkg, int core, int cpu)
+cpu_set_t *cpu_present_set, *cpu_affinity_set;
+size_t cpu_present_setsize, cpu_affinity_setsize;
+
+struct thread_data {
+        unsigned long long tsc;
+        unsigned long long aperf;
+        unsigned long long mperf;
+        unsigned long long c1;  /* derived */
+        unsigned long long extra_msr;
+        unsigned int cpu_id;
+        unsigned int flags;
+#define CPU_IS_FIRST_THREAD_IN_CORE     0x2
+#define CPU_IS_FIRST_CORE_IN_PACKAGE    0x4
+} *thread_even, *thread_odd;
+
+struct core_data {
+        unsigned long long c3;
+        unsigned long long c6;
+        unsigned long long c7;
+        unsigned int core_id;
+} *core_even, *core_odd;
+
+struct pkg_data {
+        unsigned long long pc2;
+        unsigned long long pc3;
+        unsigned long long pc6;
+        unsigned long long pc7;
+        unsigned int package_id;
+} *package_even, *package_odd;
+
+#define ODD_COUNTERS thread_odd, core_odd, package_odd
+#define EVEN_COUNTERS thread_even, core_even, package_even
+
+#define GET_THREAD(thread_base, thread_no, core_no, pkg_no) \
+        (thread_base + (pkg_no) * topo.num_cores_per_pkg * \
+                topo.num_threads_per_core + \
+                (core_no) * topo.num_threads_per_core + (thread_no))
+#define GET_CORE(core_base, core_no, pkg_no) \
+        (core_base + (pkg_no) * topo.num_cores_per_pkg + (core_no))
+#define GET_PKG(pkg_base, pkg_no) (pkg_base + pkg_no)
+
+struct system_summary {
+        struct thread_data threads;
+        struct core_data cores;
+        struct pkg_data packages;
+} sum, average;
+
+
+struct topo_params {
+        int num_packages;
+        int num_cpus;
+        int num_cores;
+        int max_cpu_num;
+        int num_cores_per_pkg;
+        int num_threads_per_core;
+} topo;
+
+struct timeval tv_even, tv_odd, tv_delta;
+
+void setup_all_buffers(void);
+
+int cpu_is_not_present(int cpu)
 {
-        CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
-        return 0;
+        return !CPU_ISSET_S(cpu, cpu_present_setsize, cpu_present_set);
 }
-
 /*
- * cpu_mask_init(ncpus)
- *
- * allocate and clear cpu_mask
- * set cpu_mask_size
+ * run func(thread, core, package) in topology order
+ * skip non-present cpus
  */
-void cpu_mask_init(int ncpus)
+
+int for_all_cpus(int (func)(struct thread_data *, struct core_data *, struct pkg_data *),
+        struct thread_data *thread_base, struct core_data *core_base, struct pkg_data *pkg_base)
 {
-        cpu_mask = CPU_ALLOC(ncpus);
-        if (cpu_mask == NULL) {
-                perror("CPU_ALLOC");
-                exit(3);
-        }
-        cpu_mask_size = CPU_ALLOC_SIZE(ncpus);
-        CPU_ZERO_S(cpu_mask_size, cpu_mask);
+        int retval, pkg_no, core_no, thread_no;
 
-        /*
-         * Allocate and initialize cpu_present_set
-         */
-        cpu_present_set = CPU_ALLOC(ncpus);
-        if (cpu_present_set == NULL) {
-                perror("CPU_ALLOC");
-                exit(3);
-        }
-        cpu_present_setsize = CPU_ALLOC_SIZE(ncpus);
-        CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
-        for_all_cpus(mark_cpu_present);
-}
+        for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
+                for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
+                        for (thread_no = 0; thread_no <
+                                topo.num_threads_per_core; ++thread_no) {
+                                struct thread_data *t;
+                                struct core_data *c;
+                                struct pkg_data *p;
 
-void cpu_mask_uninit()
-{
-        CPU_FREE(cpu_mask);
-        cpu_mask = NULL;
-        cpu_mask_size = 0;
-        CPU_FREE(cpu_present_set);
-        cpu_present_set = NULL;
-        cpu_present_setsize = 0;
+                                t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
+
+                                if (cpu_is_not_present(t->cpu_id))
+                                        continue;
+
+                                c = GET_CORE(core_base, core_no, pkg_no);
+                                p = GET_PKG(pkg_base, pkg_no);
+
+                                retval = func(t, c, p);
+                                if (retval)
+                                        return retval;
+                        }
+                }
+        }
+        return 0;
 }
 
 int cpu_migrate(int cpu)
 {
-        CPU_ZERO_S(cpu_mask_size, cpu_mask);
-        CPU_SET_S(cpu, cpu_mask_size, cpu_mask);
-        if (sched_setaffinity(0, cpu_mask_size, cpu_mask) == -1)
+        CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
+        CPU_SET_S(cpu, cpu_affinity_setsize, cpu_affinity_set);
+        if (sched_setaffinity(0, cpu_affinity_setsize, cpu_affinity_set) == -1)
                 return -1;
         else
                 return 0;
@@ -181,67 +208,72 @@ int get_msr(int cpu, off_t offset, unsigned long long *msr)
 void print_header(void)
 {
         if (show_pkg)
-                fprintf(stderr, "pk");
+                outp += sprintf(outp, "pk");
         if (show_pkg)
-                fprintf(stderr, " ");
+                outp += sprintf(outp, " ");
         if (show_core)
-                fprintf(stderr, "cor");
+                outp += sprintf(outp, "cor");
         if (show_cpu)
-                fprintf(stderr, " CPU");
+                outp += sprintf(outp, " CPU");
         if (show_pkg || show_core || show_cpu)
-                fprintf(stderr, " ");
+                outp += sprintf(outp, " ");
         if (do_nhm_cstates)
-                fprintf(stderr, "   %%c0");
+                outp += sprintf(outp, "   %%c0");
         if (has_aperf)
-                fprintf(stderr, "  GHz");
-        fprintf(stderr, "  TSC");
+                outp += sprintf(outp, "  GHz");
+        outp += sprintf(outp, "  TSC");
         if (do_nhm_cstates)
-                fprintf(stderr, "    %%c1");
+                outp += sprintf(outp, "    %%c1");
         if (do_nhm_cstates)
-                fprintf(stderr, "    %%c3");
+                outp += sprintf(outp, "    %%c3");
         if (do_nhm_cstates)
-                fprintf(stderr, "    %%c6");
+                outp += sprintf(outp, "    %%c6");
         if (do_snb_cstates)
-                fprintf(stderr, "    %%c7");
+                outp += sprintf(outp, "    %%c7");
         if (do_snb_cstates)
-                fprintf(stderr, "   %%pc2");
+                outp += sprintf(outp, "   %%pc2");
         if (do_nhm_cstates)
-                fprintf(stderr, "   %%pc3");
+                outp += sprintf(outp, "   %%pc3");
         if (do_nhm_cstates)
-                fprintf(stderr, "   %%pc6");
+                outp += sprintf(outp, "   %%pc6");
         if (do_snb_cstates)
-                fprintf(stderr, "   %%pc7");
+                outp += sprintf(outp, "   %%pc7");
         if (extra_msr_offset)
-                fprintf(stderr, "        MSR 0x%x ", extra_msr_offset);
+                outp += sprintf(outp, "        MSR 0x%x ", extra_msr_offset);
 
-        putc('\n', stderr);
+        outp += sprintf(outp, "\n");
 }
 
-void dump_cnt(struct counters *cnt)
+int dump_counters(struct thread_data *t, struct core_data *c,
+        struct pkg_data *p)
 {
-        if (!cnt)
-                return;
-        if (cnt->pkg) fprintf(stderr, "package: %d ", cnt->pkg);
-        if (cnt->core) fprintf(stderr, "core:: %d ", cnt->core);
-        if (cnt->cpu) fprintf(stderr, "CPU: %d ", cnt->cpu);
-        if (cnt->tsc) fprintf(stderr, "TSC: %016llX\n", cnt->tsc);
-        if (cnt->c3) fprintf(stderr, "c3: %016llX\n", cnt->c3);
-        if (cnt->c6) fprintf(stderr, "c6: %016llX\n", cnt->c6);
-        if (cnt->c7) fprintf(stderr, "c7: %016llX\n", cnt->c7);
-        if (cnt->aperf) fprintf(stderr, "aperf: %016llX\n", cnt->aperf);
-        if (cnt->pc2) fprintf(stderr, "pc2: %016llX\n", cnt->pc2);
-        if (cnt->pc3) fprintf(stderr, "pc3: %016llX\n", cnt->pc3);
-        if (cnt->pc6) fprintf(stderr, "pc6: %016llX\n", cnt->pc6);
-        if (cnt->pc7) fprintf(stderr, "pc7: %016llX\n", cnt->pc7);
-        if (cnt->extra_msr) fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, cnt->extra_msr);
-}
+        fprintf(stderr, "t %p, c %p, p %p\n", t, c, p);
+
+        if (t) {
+                fprintf(stderr, "CPU: %d flags 0x%x\n", t->cpu_id, t->flags);
+                fprintf(stderr, "TSC: %016llX\n", t->tsc);
+                fprintf(stderr, "aperf: %016llX\n", t->aperf);
+                fprintf(stderr, "mperf: %016llX\n", t->mperf);
+                fprintf(stderr, "c1: %016llX\n", t->c1);
+                fprintf(stderr, "msr0x%x: %016llX\n",
+                        extra_msr_offset, t->extra_msr);
+        }
 
-void dump_list(struct counters *cnt)
-{
-        printf("dump_list 0x%p\n", cnt);
+        if (c) {
+                fprintf(stderr, "core: %d\n", c->core_id);
+                fprintf(stderr, "c3: %016llX\n", c->c3);
+                fprintf(stderr, "c6: %016llX\n", c->c6);
+                fprintf(stderr, "c7: %016llX\n", c->c7);
+        }
 
-        for (; cnt; cnt = cnt->next)
-                dump_cnt(cnt);
+        if (p) {
+                fprintf(stderr, "package: %d\n", p->package_id);
+                fprintf(stderr, "pc2: %016llX\n", p->pc2);
+                fprintf(stderr, "pc3: %016llX\n", p->pc3);
+                fprintf(stderr, "pc6: %016llX\n", p->pc6);
+                fprintf(stderr, "pc7: %016llX\n", p->pc7);
+        }
+        return 0;
 }
 
 /*
@@ -253,321 +285,389 @@ void dump_list(struct counters *cnt)
  * TSC: "TSC" 3 columns %3.2
  * percentage " %pc3" %6.2
  */
-void print_cnt(struct counters *p)
+int format_counters(struct thread_data *t, struct core_data *c,
+        struct pkg_data *p)
 {
         double interval_float;
 
+         /* if showing only 1st thread in core and this isn't one, bail out */
+        if (show_core_only && !(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
+                return 0;
+
+         /* if showing only 1st thread in pkg and this isn't one, bail out */
+        if (show_pkg_only && !(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
+                return 0;
+
         interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
 
-        /* topology columns, print blanks on 1st (average) line */
-        if (p == cnt_average) {
+        /* topo columns, print blanks on 1st (average) line */
+        if (t == &average.threads) {
                 if (show_pkg)
-                        fprintf(stderr, "  ");
+                        outp += sprintf(outp, "  ");
                 if (show_pkg && show_core)
-                        fprintf(stderr, " ");
+                        outp += sprintf(outp, " ");
                 if (show_core)
-                        fprintf(stderr, "   ");
+                        outp += sprintf(outp, "   ");
                 if (show_cpu)
-                        fprintf(stderr, " " "   ");
+                        outp += sprintf(outp, " " "   ");
         } else {
-                if (show_pkg)
-                        fprintf(stderr, "%2d", p->pkg);
+                if (show_pkg) {
+                        if (p)
+                                outp += sprintf(outp, "%2d", p->package_id);
+                        else
+                                outp += sprintf(outp, "  ");
+                }
                 if (show_pkg && show_core)
-                        fprintf(stderr, " ");
-                if (show_core)
-                        fprintf(stderr, "%3d", p->core);
+                        outp += sprintf(outp, " ");
+                if (show_core) {
+                        if (c)
+                                outp += sprintf(outp, "%3d", c->core_id);
+                        else
+                                outp += sprintf(outp, "   ");
+                }
                 if (show_cpu)
-                        fprintf(stderr, " %3d", p->cpu);
+                        outp += sprintf(outp, " %3d", t->cpu_id);
         }
 
         /* %c0 */
         if (do_nhm_cstates) {
                 if (show_pkg || show_core || show_cpu)
-                        fprintf(stderr, " ");
+                        outp += sprintf(outp, " ");
                 if (!skip_c0)
-                        fprintf(stderr, "%6.2f", 100.0 * p->mperf/p->tsc);
+                        outp += sprintf(outp, "%6.2f", 100.0 * t->mperf/t->tsc);
                 else
-                        fprintf(stderr, "  ****");
+                        outp += sprintf(outp, "  ****");
         }
 
         /* GHz */
         if (has_aperf) {
                 if (!aperf_mperf_unstable) {
-                        fprintf(stderr, " %3.2f",
-                                1.0 * p->tsc / units * p->aperf /
-                                p->mperf / interval_float);
+                        outp += sprintf(outp, " %3.2f",
+                                1.0 * t->tsc / units * t->aperf /
+                                t->mperf / interval_float);
                 } else {
-                        if (p->aperf > p->tsc || p->mperf > p->tsc) {
-                                fprintf(stderr, " ***");
+                        if (t->aperf > t->tsc || t->mperf > t->tsc) {
+                                outp += sprintf(outp, " ***");
                         } else {
-                                fprintf(stderr, "%3.1f*",
-                                        1.0 * p->tsc /
-                                        units * p->aperf /
-                                        p->mperf / interval_float);
+                                outp += sprintf(outp, "%3.1f*",
+                                        1.0 * t->tsc /
+                                        units * t->aperf /
+                                        t->mperf / interval_float);
                         }
                 }
         }
 
         /* TSC */
-        fprintf(stderr, "%5.2f", 1.0 * p->tsc/units/interval_float);
+        outp += sprintf(outp, "%5.2f", 1.0 * t->tsc/units/interval_float);
 
         if (do_nhm_cstates) {
                 if (!skip_c1)
-                        fprintf(stderr, " %6.2f", 100.0 * p->c1/p->tsc);
+                        outp += sprintf(outp, " %6.2f", 100.0 * t->c1/t->tsc);
                 else
-                        fprintf(stderr, "  ****");
+                        outp += sprintf(outp, "  ****");
         }
+
+        /* print per-core data only for 1st thread in core */
+        if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
+                goto done;
+
         if (do_nhm_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->c3/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * c->c3/t->tsc);
         if (do_nhm_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->c6/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * c->c6/t->tsc);
         if (do_snb_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->c7/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * c->c7/t->tsc);
+
+        /* print per-package data only for 1st core in package */
+        if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
+                goto done;
+
         if (do_snb_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->pc2/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * p->pc2/t->tsc);
         if (do_nhm_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->pc3/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * p->pc3/t->tsc);
         if (do_nhm_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->pc6/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * p->pc6/t->tsc);
         if (do_snb_cstates)
-                fprintf(stderr, " %6.2f", 100.0 * p->pc7/p->tsc);
+                outp += sprintf(outp, " %6.2f", 100.0 * p->pc7/t->tsc);
+done:
         if (extra_msr_offset)
-                fprintf(stderr, "  0x%016llx", p->extra_msr);
-        putc('\n', stderr);
+                outp += sprintf(outp, "  0x%016llx", t->extra_msr);
+        outp += sprintf(outp, "\n");
+
+        return 0;
 }
 
-void print_counters(struct counters *counters)
+void flush_stdout()
+{
+        fputs(output_buffer, stdout);
+        outp = output_buffer;
+}
+void flush_stderr()
+{
+        fputs(output_buffer, stderr);
+        outp = output_buffer;
+}
+void format_all_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
 {
-        struct counters *cnt;
         static int printed;
 
-
         if (!printed || !summary_only)
                 print_header();
 
-        if (num_cpus > 1)
-                print_cnt(cnt_average);
+        if (topo.num_cpus > 1)
+                format_counters(&average.threads, &average.cores,
+                        &average.packages);
 
         printed = 1;
 
         if (summary_only)
                 return;
 
-        for (cnt = counters; cnt != NULL; cnt = cnt->next)
-                print_cnt(cnt);
-
+        for_all_cpus(format_counters, t, c, p);
 }
 
-#define SUBTRACT_COUNTER(after, before, delta) (delta = (after - before), (before > after))
+void
+delta_package(struct pkg_data *new, struct pkg_data *old)
+{
+        old->pc2 = new->pc2 - old->pc2;
+        old->pc3 = new->pc3 - old->pc3;
+        old->pc6 = new->pc6 - old->pc6;
+        old->pc7 = new->pc7 - old->pc7;
+}
 
-int compute_delta(struct counters *after,
-        struct counters *before, struct counters *delta)
+void
+delta_core(struct core_data *new, struct core_data *old)
 {
-        int errors = 0;
-        int perf_err = 0;
+        old->c3 = new->c3 - old->c3;
+        old->c6 = new->c6 - old->c6;
+        old->c7 = new->c7 - old->c7;
+}
 
-        skip_c0 = skip_c1 = 0;
+/*
+ * old = new - old
+ */
+void
+delta_thread(struct thread_data *new, struct thread_data *old,
+        struct core_data *core_delta)
+{
+        old->tsc = new->tsc - old->tsc;
+
+        /* check for TSC < 1 Mcycles over interval */
+        if (old->tsc < (1000 * 1000)) {
+                fprintf(stderr, "Insanely slow TSC rate, TSC stops in idle?\n");
+                fprintf(stderr, "You can disable all c-states by booting with \"idle=poll\"\n");
+                fprintf(stderr, "or just the deep ones with \"processor.max_cstate=1\"\n");
+                exit(-3);
+        }
 
-        for ( ; after && before && delta;
-                after = after->next, before = before->next, delta = delta->next) {
-                if (before->cpu != after->cpu) {
-                        printf("cpu configuration changed: %d != %d\n",
-                                before->cpu, after->cpu);
-                        return -1;
-                }
+        old->c1 = new->c1 - old->c1;
 
-                if (SUBTRACT_COUNTER(after->tsc, before->tsc, delta->tsc)) {
-                        fprintf(stderr, "cpu%d TSC went backwards %llX to %llX\n",
-                                before->cpu, before->tsc, after->tsc);
-                        errors++;
-                }
-                /* check for TSC < 1 Mcycles over interval */
-                if (delta->tsc < (1000 * 1000)) {
-                        fprintf(stderr, "Insanely slow TSC rate,"
-                                " TSC stops in idle?\n");
-                        fprintf(stderr, "You can disable all c-states"
-                                " by booting with \"idle=poll\"\n");
-                        fprintf(stderr, "or just the deep ones with"
-                                " \"processor.max_cstate=1\"\n");
-                        exit(-3);
-                }
-                if (SUBTRACT_COUNTER(after->c3, before->c3, delta->c3)) {
-                        fprintf(stderr, "cpu%d c3 counter went backwards %llX to %llX\n",
-                                before->cpu, before->c3, after->c3);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->c6, before->c6, delta->c6)) {
-                        fprintf(stderr, "cpu%d c6 counter went backwards %llX to %llX\n",
-                                before->cpu, before->c6, after->c6);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->c7, before->c7, delta->c7)) {
-                        fprintf(stderr, "cpu%d c7 counter went backwards %llX to %llX\n",
-                                before->cpu, before->c7, after->c7);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->pc2, before->pc2, delta->pc2)) {
-                        fprintf(stderr, "cpu%d pc2 counter went backwards %llX to %llX\n",
-                                before->cpu, before->pc2, after->pc2);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->pc3, before->pc3, delta->pc3)) {
-                        fprintf(stderr, "cpu%d pc3 counter went backwards %llX to %llX\n",
-                                before->cpu, before->pc3, after->pc3);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->pc6, before->pc6, delta->pc6)) {
-                        fprintf(stderr, "cpu%d pc6 counter went backwards %llX to %llX\n",
-                                before->cpu, before->pc6, after->pc6);
-                        errors++;
-                }
-                if (SUBTRACT_COUNTER(after->pc7, before->pc7, delta->pc7)) {
-                        fprintf(stderr, "cpu%d pc7 counter went backwards %llX to %llX\n",
-                                before->cpu, before->pc7, after->pc7);
-                        errors++;
-                }
+        if ((new->aperf > old->aperf) && (new->mperf > old->mperf)) {
+                old->aperf = new->aperf - old->aperf;
+                old->mperf = new->mperf - old->mperf;
+        } else {
 
-                perf_err = SUBTRACT_COUNTER(after->aperf, before->aperf, delta->aperf);
-                if (perf_err) {
-                        fprintf(stderr, "cpu%d aperf counter went backwards %llX to %llX\n",
-                                before->cpu, before->aperf, after->aperf);
-                }
-                perf_err |= SUBTRACT_COUNTER(after->mperf, before->mperf, delta->mperf);
-                if (perf_err) {
-                        fprintf(stderr, "cpu%d mperf counter went backwards %llX to %llX\n",
-                                before->cpu, before->mperf, after->mperf);
-                }
-                if (perf_err) {
-                        if (!aperf_mperf_unstable) {
-                                fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
-                                fprintf(stderr, "* Frequency results do not cover entire interval *\n");
-                                fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
+                if (!aperf_mperf_unstable) {
+                        fprintf(stderr, "%s: APERF or MPERF went backwards *\n", progname);
+                        fprintf(stderr, "* Frequency results do not cover entire interval *\n");
+                        fprintf(stderr, "* fix this by running Linux-2.6.30 or later *\n");
 
-                                aperf_mperf_unstable = 1;
-                        }
-                        /*
-                         * mperf delta is likely a huge "positive" number
-                         * can not use it for calculating c0 time
-                         */
-                        skip_c0 = 1;
-                        skip_c1 = 1;
+                        aperf_mperf_unstable = 1;
                 }
-
                 /*
-                 * As mperf and tsc collection are not atomic,
-                 * it is possible for mperf's non-halted cycles
-                 * to exceed TSC's all cycles: show c1 = 0% in that case.
+                 * mperf delta is likely a huge "positive" number
+                 * can not use it for calculating c0 time
                  */
-                if (delta->mperf > delta->tsc)
-                        delta->c1 = 0;
-                else /* normal case, derive c1 */
-                        delta->c1 = delta->tsc - delta->mperf
-                                - delta->c3 - delta->c6 - delta->c7;
+                skip_c0 = 1;
+                skip_c1 = 1;
+        }
 
-                if (delta->mperf == 0)
-                        delta->mperf = 1;       /* divide by 0 protection */
 
-                /*
-                 * for "extra msr", just copy the latest w/o subtracting
-                 */
-                delta->extra_msr = after->extra_msr;
-                if (errors) {
-                        fprintf(stderr, "ERROR cpu%d before:\n", before->cpu);
-                        dump_cnt(before);
-                        fprintf(stderr, "ERROR cpu%d after:\n", before->cpu);
-                        dump_cnt(after);
-                        errors = 0;
-                }
+        /*
+         * As counter collection is not atomic,
+         * it is possible for mperf's non-halted cycles + idle states
+         * to exceed TSC's all cycles: show c1 = 0% in that case.
+         */
+        if ((old->mperf + core_delta->c3 + core_delta->c6 + core_delta->c7) > old->tsc)
+                old->c1 = 0;
+        else {
+                /* normal case, derive c1 */
+                old->c1 = old->tsc - old->mperf - core_delta->c3
+                                - core_delta->c6 - core_delta->c7;
         }
+
+        if (old->mperf == 0) {
+                if (verbose > 1) fprintf(stderr, "cpu%d MPERF 0!\n", old->cpu_id);
+                old->mperf = 1; /* divide by 0 protection */
+        }
+
+        /*
+         * for "extra msr", just copy the latest w/o subtracting
+         */
+        old->extra_msr = new->extra_msr;
+}
+
+int delta_cpu(struct thread_data *t, struct core_data *c,
+        struct pkg_data *p, struct thread_data *t2,
+        struct core_data *c2, struct pkg_data *p2)
+{
+        /* calculate core delta only for 1st thread in core */
+        if (t->flags & CPU_IS_FIRST_THREAD_IN_CORE)
+                delta_core(c, c2);
+
+        /* always calculate thread delta */
+        delta_thread(t, t2, c2);        /* c2 is core delta */
+
+        /* calculate package delta only for 1st core in package */
+        if (t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE)
+                delta_package(p, p2);
+
         return 0;
 }
 
-void compute_average(struct counters *delta, struct counters *avg)
+void clear_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
+{
+        t->tsc = 0;
+        t->aperf = 0;
+        t->mperf = 0;
+        t->c1 = 0;
+
+        /* tells format_counters to dump all fields from this set */
+        t->flags = CPU_IS_FIRST_THREAD_IN_CORE | CPU_IS_FIRST_CORE_IN_PACKAGE;
+
+        c->c3 = 0;
+        c->c6 = 0;
+        c->c7 = 0;
+
+        p->pc2 = 0;
+        p->pc3 = 0;
+        p->pc6 = 0;
+        p->pc7 = 0;
+}
+int sum_counters(struct thread_data *t, struct core_data *c,
+        struct pkg_data *p)
 {
-        struct counters *sum;
+        average.threads.tsc += t->tsc;
+        average.threads.aperf += t->aperf;
+        average.threads.mperf += t->mperf;
+        average.threads.c1 += t->c1;
 
-        sum = calloc(1, sizeof(struct counters));
-        if (sum == NULL) {
-                perror("calloc sum");
-                exit(1);
-        }
+        /* sum per-core values only for 1st thread in core */
+        if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
+                return 0;
 
-        for (; delta; delta = delta->next) {
-                sum->tsc += delta->tsc;
-                sum->c1 += delta->c1;
-                sum->c3 += delta->c3;
-                sum->c6 += delta->c6;
-                sum->c7 += delta->c7;
-                sum->aperf += delta->aperf;
-                sum->mperf += delta->mperf;
-                sum->pc2 += delta->pc2;
-                sum->pc3 += delta->pc3;
-                sum->pc6 += delta->pc6;
-                sum->pc7 += delta->pc7;
-        }
-        avg->tsc = sum->tsc/num_cpus;
-        avg->c1 = sum->c1/num_cpus;
-        avg->c3 = sum->c3/num_cpus;
-        avg->c6 = sum->c6/num_cpus;
-        avg->c7 = sum->c7/num_cpus;
-        avg->aperf = sum->aperf/num_cpus;
-        avg->mperf = sum->mperf/num_cpus;
-        avg->pc2 = sum->pc2/num_cpus;
-        avg->pc3 = sum->pc3/num_cpus;
-        avg->pc6 = sum->pc6/num_cpus;
-        avg->pc7 = sum->pc7/num_cpus;
-
-        free(sum);
+        average.cores.c3 += c->c3;
+        average.cores.c6 += c->c6;
+        average.cores.c7 += c->c7;
+
+        /* sum per-pkg values only for 1st core in pkg */
+        if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
+                return 0;
+
+        average.packages.pc2 += p->pc2;
+        average.packages.pc3 += p->pc3;
+        average.packages.pc6 += p->pc6;
+        average.packages.pc7 += p->pc7;
+
+        return 0;
+}
+/*
+ * sum the counters for all cpus in the system
+ * compute the weighted average
+ */
+void compute_average(struct thread_data *t, struct core_data *c,
+        struct pkg_data *p)
+{
+        clear_counters(&average.threads, &average.cores, &average.packages);
+
+        for_all_cpus(sum_counters, t, c, p);
+
+        average.threads.tsc /= topo.num_cpus;
+        average.threads.aperf /= topo.num_cpus;
+        average.threads.mperf /= topo.num_cpus;
+        average.threads.c1 /= topo.num_cpus;
+
+        average.cores.c3 /= topo.num_cores;
+        average.cores.c6 /= topo.num_cores;
+        average.cores.c7 /= topo.num_cores;
+
+        average.packages.pc2 /= topo.num_packages;
+        average.packages.pc3 /= topo.num_packages;
+        average.packages.pc6 /= topo.num_packages;
+        average.packages.pc7 /= topo.num_packages;
 }
 
-int get_counters(struct counters *cnt)
+static unsigned long long rdtsc(void)
 {
-        for ( ; cnt; cnt = cnt->next) {
+        unsigned int low, high;
 
-                if (cpu_migrate(cnt->cpu))
-                        return -1;
+        asm volatile("rdtsc" : "=a" (low), "=d" (high));
 
-                if (get_msr(cnt->cpu, MSR_TSC, &cnt->tsc))
-                        return -1;
+        return low | ((unsigned long long)high) << 32;
+}
 
-                if (has_aperf) {
-                        if (get_msr(cnt->cpu, MSR_APERF, &cnt->aperf))
-                                return -1;
-                        if (get_msr(cnt->cpu, MSR_MPERF, &cnt->mperf))
-                                return -1;
-                }
 
-                if (do_nhm_cstates) {
-                        if (get_msr(cnt->cpu, MSR_CORE_C3_RESIDENCY, &cnt->c3))
-                                return -1;
-                        if (get_msr(cnt->cpu, MSR_CORE_C6_RESIDENCY, &cnt->c6))
-                                return -1;
-                }
+/*
+ * get_counters(...)
+ * migrate to cpu
+ * acquire and record local counters for that cpu
+ */
+int get_counters(struct thread_data *t, struct core_data *c, struct pkg_data *p)
+{
+        int cpu = t->cpu_id;
 
-                if (do_snb_cstates)
-                        if (get_msr(cnt->cpu, MSR_CORE_C7_RESIDENCY, &cnt->c7))
-                                return -1;
+        if (cpu_migrate(cpu))
+                return -1;
 
-                if (do_nhm_cstates) {
-                        if (get_msr(cnt->cpu, MSR_PKG_C3_RESIDENCY, &cnt->pc3))
-                                return -1;
-                        if (get_msr(cnt->cpu, MSR_PKG_C6_RESIDENCY, &cnt->pc6))
-                                return -1;
-                }
-                if (do_snb_cstates) {
-                        if (get_msr(cnt->cpu, MSR_PKG_C2_RESIDENCY, &cnt->pc2))
-                                return -1;
-                        if (get_msr(cnt->cpu, MSR_PKG_C7_RESIDENCY, &cnt->pc7))
-                                return -1;
-                }
-                if (extra_msr_offset)
-                        if (get_msr(cnt->cpu, extra_msr_offset, &cnt->extra_msr))
-                                return -1;
+        t->tsc = rdtsc();       /* we are running on local CPU of interest */
+
+        if (has_aperf) {
+                if (get_msr(cpu, MSR_APERF, &t->aperf))
+                        return -3;
+                if (get_msr(cpu, MSR_MPERF, &t->mperf))
+                        return -4;
+        }
+
+        if (extra_msr_offset)
+                if (get_msr(cpu, extra_msr_offset, &t->extra_msr))
+                        return -5;
+
+        /* collect core counters only for 1st thread in core */
+        if (!(t->flags & CPU_IS_FIRST_THREAD_IN_CORE))
+                return 0;
+
+        if (do_nhm_cstates) {
+                if (get_msr(cpu, MSR_CORE_C3_RESIDENCY, &c->c3))
+                        return -6;
+                if (get_msr(cpu, MSR_CORE_C6_RESIDENCY, &c->c6))
+                        return -7;
+        }
+
+        if (do_snb_cstates)
+                if (get_msr(cpu, MSR_CORE_C7_RESIDENCY, &c->c7))
+                        return -8;
+
+        /* collect package counters only for 1st core in package */
+        if (!(t->flags & CPU_IS_FIRST_CORE_IN_PACKAGE))
+                return 0;
+
+        if (do_nhm_cstates) {
+                if (get_msr(cpu, MSR_PKG_C3_RESIDENCY, &p->pc3))
+                        return -9;
+                if (get_msr(cpu, MSR_PKG_C6_RESIDENCY, &p->pc6))
+                        return -10;
+        }
+        if (do_snb_cstates) {
+                if (get_msr(cpu, MSR_PKG_C2_RESIDENCY, &p->pc2))
+                        return -11;
+                if (get_msr(cpu, MSR_PKG_C7_RESIDENCY, &p->pc7))
+                        return -12;
         }
         return 0;
 }
 
-void print_nehalem_info(void)
+void print_verbose_header(void)
 {
         unsigned long long msr;
         unsigned int ratio;
@@ -615,143 +715,82 @@ void print_nehalem_info(void)
 
 }
 
-void free_counter_list(struct counters *list)
+void free_all_buffers(void)
 {
-        struct counters *p;
+        CPU_FREE(cpu_present_set);
+        cpu_present_set = NULL;
+        cpu_present_set = 0;
 
-        for (p = list; p; ) {
-                struct counters *free_me;
+        CPU_FREE(cpu_affinity_set);
+        cpu_affinity_set = NULL;
+        cpu_affinity_setsize = 0;
 
-                free_me = p;
-                p = p->next;
-                free(free_me);
-        }
-}
+        free(thread_even);
+        free(core_even);
+        free(package_even);
 
-void free_all_counters(void)
-{
-        free_counter_list(cnt_even);
-        cnt_even = NULL;
+        thread_even = NULL;
+        core_even = NULL;
+        package_even = NULL;
 
-        free_counter_list(cnt_odd);
-        cnt_odd = NULL;
+        free(thread_odd);
+        free(core_odd);
+        free(package_odd);
 
-        free_counter_list(cnt_delta);
-        cnt_delta = NULL;
+        thread_odd = NULL;
+        core_odd = NULL;
+        package_odd = NULL;
 
-        free_counter_list(cnt_average);
-        cnt_average = NULL;
+        free(output_buffer);
+        output_buffer = NULL;
+        outp = NULL;
 }
 
-void insert_counters(struct counters **list,
-        struct counters *new)
+/*
+ * cpu_is_first_sibling_in_core(cpu)
+ * return 1 if given CPU is 1st HT sibling in the core
+ */
+int cpu_is_first_sibling_in_core(int cpu)
 {
-        struct counters *prev;
-
-        /*
-         * list was empty
-         */
-        if (*list == NULL) {
-                new->next = *list;
-                *list = new;
-                return;
-        }
-
-        if (!summary_only)
-                show_cpu = 1;   /* there is more than one CPU */
-
-        /*
-         * insert on front of list.
-         * It is sorted by ascending package#, core#, cpu#
-         */
-        if (((*list)->pkg > new->pkg) ||
-            (((*list)->pkg == new->pkg) && ((*list)->core > new->core)) ||
-            (((*list)->pkg == new->pkg) && ((*list)->core == new->core) && ((*list)->cpu > new->cpu))) {
-                new->next = *list;
-                *list = new;
-                return;
-        }
-
-        prev = *list;
-
-        while (prev->next && (prev->next->pkg < new->pkg)) {
-                prev = prev->next;
-                if (!summary_only)
-                        show_pkg = 1;   /* there is more than 1 package */
-        }
-
-        while (prev->next && (prev->next->pkg == new->pkg)
-                && (prev->next->core < new->core)) {
-                prev = prev->next;
-                if (!summary_only)
-                        show_core = 1;  /* there is more than 1 core */
-        }
+        char path[64];
+        FILE *filep;
+        int first_cpu;
 
-        while (prev->next && (prev->next->pkg == new->pkg)
-                && (prev->next->core == new->core)
-                && (prev->next->cpu < new->cpu)) {
-                prev = prev->next;
+        sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
+        filep = fopen(path, "r");
+        if (filep == NULL) {
+                perror(path);
+                exit(1);
         }
-
-        /*
-         * insert after "prev"
-         */
-        new->next = prev->next;
-        prev->next = new;
+        fscanf(filep, "%d", &first_cpu);
+        fclose(filep);
+        return (cpu == first_cpu);
 }
 
-void alloc_new_counters(int pkg, int core, int cpu)
+/*
+ * cpu_is_first_core_in_package(cpu)
+ * return 1 if given CPU is 1st core in package
+ */
+int cpu_is_first_core_in_package(int cpu)
 {
-        struct counters *new;
-
-        if (verbose > 1)
-                printf("pkg%d core%d, cpu%d\n", pkg, core, cpu);
-
-        new = (struct counters *)calloc(1, sizeof(struct counters));
-        if (new == NULL) {
-                perror("calloc");
-                exit(1);
-        }
-        new->pkg = pkg;
-        new->core = core;
-        new->cpu = cpu;
-        insert_counters(&cnt_odd, new);
-
-        new = (struct counters *)calloc(1,
-                sizeof(struct counters));
-        if (new == NULL) {
-                perror("calloc");
-                exit(1);
-        }
-        new->pkg = pkg;
-        new->core = core;
-        new->cpu = cpu;
-        insert_counters(&cnt_even, new);
-
-        new = (struct counters *)calloc(1, sizeof(struct counters));
-        if (new == NULL) {
-                perror("calloc");
-                exit(1);
-        }
-        new->pkg = pkg;
-        new->core = core;
-        new->cpu = cpu;
-        insert_counters(&cnt_delta, new);
+        char path[64];
+        FILE *filep;
+        int first_cpu;
 
-        new = (struct counters *)calloc(1, sizeof(struct counters));
-        if (new == NULL) {
-                perror("calloc");
+        sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list", cpu);
+        filep = fopen(path, "r");
+        if (filep == NULL) {
+                perror(path);
                 exit(1);
         }
-        new->pkg = pkg;
-        new->core = core;
-        new->cpu = cpu;
-        cnt_average = new;
+        fscanf(filep, "%d", &first_cpu);
+        fclose(filep);
+        return (cpu == first_cpu);
 }
 
 int get_physical_package_id(int cpu)
 {
-        char path[64];
+        char path[80];
         FILE *filep;
         int pkg;
 
@@ -768,7 +807,7 @@ int get_physical_package_id(int cpu)
 
 int get_core_id(int cpu)
 {
-        char path[64];
+        char path[80];
         FILE *filep;
         int core;
 
@@ -783,14 +822,87 @@ int get_core_id(int cpu)
         return core;
 }
 
+int get_num_ht_siblings(int cpu)
+{
+        char path[80];
+        FILE *filep;
+        int sib1, sib2;
+        int matches;
+        char character;
+
+        sprintf(path, "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", cpu);
+        filep = fopen(path, "r");
+        if (filep == NULL) {
+                perror(path);
+                exit(1);
+        }
+        /*
+         * file format:
+         * if a pair of number with a character between: 2 siblings (eg. 1-2, or 1,4)
+         * otherwinse 1 sibling (self).
+         */
+        matches = fscanf(filep, "%d%c%d\n", &sib1, &character, &sib2);
+
+        fclose(filep);
+
+        if (matches == 3)
+                return 2;
+        else
+                return 1;
+}
+
 /*
- * run func(pkg, core, cpu) on every cpu in /proc/stat
+ * run func(thread, core, package) in topology order
+ * skip non-present cpus
  */
 
-int for_all_cpus(void (func)(int, int, int))
+int for_all_cpus_2(int (func)(struct thread_data *, struct core_data *,
+        struct pkg_data *, struct thread_data *, struct core_data *,
+        struct pkg_data *), struct thread_data *thread_base,
+        struct core_data *core_base, struct pkg_data *pkg_base,
+        struct thread_data *thread_base2, struct core_data *core_base2,
+        struct pkg_data *pkg_base2)
+{
+        int retval, pkg_no, core_no, thread_no;
+
+        for (pkg_no = 0; pkg_no < topo.num_packages; ++pkg_no) {
+                for (core_no = 0; core_no < topo.num_cores_per_pkg; ++core_no) {
+                        for (thread_no = 0; thread_no <
+                                topo.num_threads_per_core; ++thread_no) {
+                                struct thread_data *t, *t2;
+                                struct core_data *c, *c2;
+                                struct pkg_data *p, *p2;
+
+                                t = GET_THREAD(thread_base, thread_no, core_no, pkg_no);
+
+                                if (cpu_is_not_present(t->cpu_id))
+                                        continue;
+
+                                t2 = GET_THREAD(thread_base2, thread_no, core_no, pkg_no);
+
+                                c = GET_CORE(core_base, core_no, pkg_no);
+                                c2 = GET_CORE(core_base2, core_no, pkg_no);
+
+                                p = GET_PKG(pkg_base, pkg_no);
+                                p2 = GET_PKG(pkg_base2, pkg_no);
+
+                                retval = func(t, c, p, t2, c2, p2);
+                                if (retval)
+                                        return retval;
+                        }
+                }
+        }
+        return 0;
+}
+
+/*
+ * run func(cpu) on every cpu in /proc/stat
+ * return max_cpu number
+ */
+int for_all_proc_cpus(int (func)(int))
 {
         FILE *fp;
-        int cpu_count;
+        int cpu_num;
         int retval;
 
         fp = fopen(proc_stat, "r");
@@ -805,78 +917,88 @@ int for_all_cpus(void (func)(int, int, int))
                 exit(1);
         }
 
-        for (cpu_count = 0; ; cpu_count++) {
-                int cpu;
-
-                retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu);
+        while (1) {
+                retval = fscanf(fp, "cpu%u %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d\n", &cpu_num);
                 if (retval != 1)
                         break;
 
-                func(get_physical_package_id(cpu), get_core_id(cpu), cpu);
+                retval = func(cpu_num);
+                if (retval) {
+                        fclose(fp);
+                        return(retval);
+                }
         }
         fclose(fp);
-        return cpu_count;
+        return 0;
 }
 
 void re_initialize(void)
 {
-        free_all_counters();
-        num_cpus = for_all_cpus(alloc_new_counters);
-        cpu_mask_uninit();
-        cpu_mask_init(num_cpus);
-        printf("turbostat: re-initialized with num_cpus %d\n", num_cpus);
+        free_all_buffers();
+        setup_all_buffers();
+        printf("turbostat: re-initialized with num_cpus %d\n", topo.num_cpus);
 }
 
-void dummy(int pkg, int core, int cpu) { return; }
+
 /*
- * check to see if a cpu came on-line
+ * count_cpus()
+ * remember the last one seen, it will be the max
  */
-int verify_num_cpus(void)
+int count_cpus(int cpu)
 {
-        int new_num_cpus;
-
-        new_num_cpus = for_all_cpus(dummy);
+        if (topo.max_cpu_num < cpu)
+                topo.max_cpu_num = cpu;
 
-        if (new_num_cpus != num_cpus) {
-                if (verbose)
-                        printf("num_cpus was %d, is now  %d\n",
-                                num_cpus, new_num_cpus);
-                return -1;
-        }
+        topo.num_cpus += 1;
+        return 0;
+}
+int mark_cpu_present(int cpu)
+{
+        CPU_SET_S(cpu, cpu_present_setsize, cpu_present_set);
         return 0;
 }
 
 void turbostat_loop()
 {
+        int retval;
+
 restart:
-        get_counters(cnt_even);
+        retval = for_all_cpus(get_counters, EVEN_COUNTERS);
+        if (retval) {
+                re_initialize();
+                goto restart;
+        }
         gettimeofday(&tv_even, (struct timezone *)NULL);
 
         while (1) {
-                if (verify_num_cpus()) {
+                if (for_all_proc_cpus(cpu_is_not_present)) {
                         re_initialize();
                         goto restart;
                 }
                 sleep(interval_sec);
-                if (get_counters(cnt_odd)) {
+                retval = for_all_cpus(get_counters, ODD_COUNTERS);
+                if (retval) {
                         re_initialize();
                         goto restart;
                 }
                 gettimeofday(&tv_odd, (struct timezone *)NULL);
-                compute_delta(cnt_odd, cnt_even, cnt_delta);
                 timersub(&tv_odd, &tv_even, &tv_delta);
-                compute_average(cnt_delta, cnt_average);
-                print_counters(cnt_delta);
+                for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
+                compute_average(EVEN_COUNTERS);
+                format_all_counters(EVEN_COUNTERS);
+                flush_stdout();
                 sleep(interval_sec);
-                if (get_counters(cnt_even)) {
+                retval = for_all_cpus(get_counters, EVEN_COUNTERS);
+                if (retval) {
                         re_initialize();
                         goto restart;
                 }
                 gettimeofday(&tv_even, (struct timezone *)NULL);
-                compute_delta(cnt_even, cnt_odd, cnt_delta);
                 timersub(&tv_even, &tv_odd, &tv_delta);
-                compute_average(cnt_delta, cnt_average);
-                print_counters(cnt_delta);
+                for_all_cpus_2(delta_cpu, EVEN_COUNTERS, ODD_COUNTERS);
+                compute_average(ODD_COUNTERS);
+                format_all_counters(ODD_COUNTERS);
+                flush_stdout();
         }
 }
 
@@ -1051,6 +1173,208 @@ int open_dev_cpu_msr(int dummy1)
         return 0;
 }
 
+void topology_probe()
+{
+        int i;
+        int max_core_id = 0;
+        int max_package_id = 0;
+        int max_siblings = 0;
+        struct cpu_topology {
+                int core_id;
+                int physical_package_id;
+        } *cpus;
+
+        /* Initialize num_cpus, max_cpu_num */
+        topo.num_cpus = 0;
+        topo.max_cpu_num = 0;
+        for_all_proc_cpus(count_cpus);
+        if (!summary_only && topo.num_cpus > 1)
+                show_cpu = 1;
+
+        if (verbose > 1)
+                fprintf(stderr, "num_cpus %d max_cpu_num %d\n", topo.num_cpus, topo.max_cpu_num);
+
+        cpus = calloc(1, (topo.max_cpu_num  + 1) * sizeof(struct cpu_topology));
+        if (cpus == NULL) {
+                perror("calloc cpus");
+                exit(1);
+        }
+
+        /*
+         * Allocate and initialize cpu_present_set
+         */
+        cpu_present_set = CPU_ALLOC((topo.max_cpu_num + 1));
+        if (cpu_present_set == NULL) {
+                perror("CPU_ALLOC");
+                exit(3);
+        }
+        cpu_present_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
+        CPU_ZERO_S(cpu_present_setsize, cpu_present_set);
+        for_all_proc_cpus(mark_cpu_present);
+
+        /*
+         * Allocate and initialize cpu_affinity_set
+         */
+        cpu_affinity_set = CPU_ALLOC((topo.max_cpu_num + 1));
+        if (cpu_affinity_set == NULL) {
+                perror("CPU_ALLOC");
+                exit(3);
+        }
+        cpu_affinity_setsize = CPU_ALLOC_SIZE((topo.max_cpu_num + 1));
+        CPU_ZERO_S(cpu_affinity_setsize, cpu_affinity_set);
+
+
+        /*
+         * For online cpus
+         * find max_core_id, max_package_id
+         */
+        for (i = 0; i <= topo.max_cpu_num; ++i) {
+                int siblings;
+
+                if (cpu_is_not_present(i)) {
+                        if (verbose > 1)
+                                fprintf(stderr, "cpu%d NOT PRESENT\n", i);
+                        continue;
+                }
+                cpus[i].core_id = get_core_id(i);
+                if (cpus[i].core_id > max_core_id)
+                        max_core_id = cpus[i].core_id;
+
+                cpus[i].physical_package_id = get_physical_package_id(i);
+                if (cpus[i].physical_package_id > max_package_id)
+                        max_package_id = cpus[i].physical_package_id;
+
+                siblings = get_num_ht_siblings(i);
+                if (siblings > max_siblings)
+                        max_siblings = siblings;
+                if (verbose > 1)
+                        fprintf(stderr, "cpu %d pkg %d core %d\n",
+                                i, cpus[i].physical_package_id, cpus[i].core_id);
+        }
+        topo.num_cores_per_pkg = max_core_id + 1;
+        if (verbose > 1)
+                fprintf(stderr, "max_core_id %d, sizing for %d cores per package\n",
+                        max_core_id, topo.num_cores_per_pkg);
+        if (!summary_only && topo.num_cores_per_pkg > 1)
+                show_core = 1;
+
+        topo.num_packages = max_package_id + 1;
+        if (verbose > 1)
+                fprintf(stderr, "max_package_id %d, sizing for %d packages\n",
+                        max_package_id, topo.num_packages);
+        if (!summary_only && topo.num_packages > 1)
+                show_pkg = 1;
+
+        topo.num_threads_per_core = max_siblings;
+        if (verbose > 1)
+                fprintf(stderr, "max_siblings %d\n", max_siblings);
+
+        free(cpus);
+}
+
+void
+allocate_counters(struct thread_data **t, struct core_data **c, struct pkg_data **p)
+{
+        int i;
+
+        *t = calloc(topo.num_threads_per_core * topo.num_cores_per_pkg *
+                topo.num_packages, sizeof(struct thread_data));
+        if (*t == NULL)
+                goto error;
+
+        for (i = 0; i < topo.num_threads_per_core *
+                topo.num_cores_per_pkg * topo.num_packages; i++)
+                (*t)[i].cpu_id = -1;
+
+        *c = calloc(topo.num_cores_per_pkg * topo.num_packages,
+                sizeof(struct core_data));
+        if (*c == NULL)
+                goto error;
+
+        for (i = 0; i < topo.num_cores_per_pkg * topo.num_packages; i++)
+                (*c)[i].core_id = -1;
+
+        *p = calloc(topo.num_packages, sizeof(struct pkg_data));
+        if (*p == NULL)
+                goto error;
+
+        for (i = 0; i < topo.num_packages; i++)
+                (*p)[i].package_id = i;
+
+        return;
+error:
+        perror("calloc counters");
+        exit(1);
+}
+/*
+ * init_counter()
+ *
+ * set cpu_id, core_num, pkg_num
+ * set FIRST_THREAD_IN_CORE and FIRST_CORE_IN_PACKAGE
+ *
+ * increment topo.num_cores when 1st core in pkg seen
+ */
+void init_counter(struct thread_data *thread_base, struct core_data *core_base,
+        struct pkg_data *pkg_base, int thread_num, int core_num,
+        int pkg_num, int cpu_id)
+{
+        struct thread_data *t;
+        struct core_data *c;
+        struct pkg_data *p;
+
+        t = GET_THREAD(thread_base, thread_num, core_num, pkg_num);
+        c = GET_CORE(core_base, core_num, pkg_num);
+        p = GET_PKG(pkg_base, pkg_num);
+
+        t->cpu_id = cpu_id;
+        if (thread_num == 0) {
+                t->flags |= CPU_IS_FIRST_THREAD_IN_CORE;
+                if (cpu_is_first_core_in_package(cpu_id))
+                        t->flags |= CPU_IS_FIRST_CORE_IN_PACKAGE;
+        }
+
+        c->core_id = core_num;
+        p->package_id = pkg_num;
+}
+
+
+int initialize_counters(int cpu_id)
+{
+        int my_thread_id, my_core_id, my_package_id;
+
+        my_package_id = get_physical_package_id(cpu_id);
+        my_core_id = get_core_id(cpu_id);
+
+        if (cpu_is_first_sibling_in_core(cpu_id)) {
+                my_thread_id = 0;
+                topo.num_cores++;
+        } else {
+                my_thread_id = 1;
+        }
+
+        init_counter(EVEN_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
+        init_counter(ODD_COUNTERS, my_thread_id, my_core_id, my_package_id, cpu_id);
+        return 0;
+}
+
+void allocate_output_buffer()
+{
+        output_buffer = calloc(1, (1 + topo.num_cpus) * 128);
+        outp = output_buffer;
+        if (outp == NULL) {
+                perror("calloc");
+                exit(-1);
+        }
+}
+
+void setup_all_buffers(void)
+{
+        topology_probe();
+        allocate_counters(&thread_even, &core_even, &package_even);
+        allocate_counters(&thread_odd, &core_odd, &package_odd);
+        allocate_output_buffer();
+        for_all_proc_cpus(initialize_counters);
+}
 void turbostat_init()
 {
         check_cpuid();
@@ -1058,21 +1382,19 @@ void turbostat_init()
         check_dev_msr();
         check_super_user();
 
-        num_cpus = for_all_cpus(alloc_new_counters);
-        cpu_mask_init(num_cpus);
+        setup_all_buffers();
 
         if (verbose)
-                print_nehalem_info();
+                print_verbose_header();
 }
 
 int fork_it(char **argv)
 {
-        int retval;
         pid_t child_pid;
-        get_counters(cnt_even);
 
-        /* clear affinity side-effect of get_counters() */
-        sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
+        for_all_cpus(get_counters, EVEN_COUNTERS);
+        /* clear affinity side-effect of get_counters() */
+        sched_setaffinity(0, cpu_present_setsize, cpu_present_set);
         gettimeofday(&tv_even, (struct timezone *)NULL);
 
         child_pid = fork();
@@ -1095,14 +1417,17 @@ int fork_it(char **argv)
                         exit(1);
                 }
         }
-        get_counters(cnt_odd);
+        /*
+         * n.b. fork_it() does not check for errors from for_all_cpus()
+         * because re-starting is problematic when forking
+         */
+        for_all_cpus(get_counters, ODD_COUNTERS);
         gettimeofday(&tv_odd, (struct timezone *)NULL);
-        retval = compute_delta(cnt_odd, cnt_even, cnt_delta);
-
         timersub(&tv_odd, &tv_even, &tv_delta);
-        compute_average(cnt_delta, cnt_average);
-        if (!retval)
-                print_counters(cnt_delta);
+        for_all_cpus_2(delta_cpu, ODD_COUNTERS, EVEN_COUNTERS);
+        compute_average(EVEN_COUNTERS);
+        format_all_counters(EVEN_COUNTERS);
+        flush_stderr();
 
         fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);
 
@@ -1115,8 +1440,14 @@ void cmdline(int argc, char **argv)
 
         progname = argv[0];
 
-        while ((opt = getopt(argc, argv, "+svi:M:")) != -1) {
+        while ((opt = getopt(argc, argv, "+cpsvi:M:")) != -1) {
                 switch (opt) {
+                case 'c':
+                        show_core_only++;
+                        break;
+                case 'p':
+                        show_pkg_only++;
+                        break;
                 case 's':
                         summary_only++;
                         break;
@@ -1142,10 +1473,8 @@ int main(int argc, char **argv)
         cmdline(argc, argv);
 
         if (verbose > 1)
-                fprintf(stderr, "turbostat Dec 6, 2010"
+                fprintf(stderr, "turbostat v2.0 May 16, 2012"
                         " - Len Brown <lenb@kernel.org>\n");
-        if (verbose > 1)
-                fprintf(stderr, "http://userweb.kernel.org/~lenb/acpi/utils/pmtools/turbostat/\n");
 
         turbostat_init();
 
diff --git a/tools/testing/fault-injection/failcmd.sh b/tools/testing/fault-injection/failcmd.sh
new file mode 100644
index 000000000000..78a9ed7fecdb
--- /dev/null
+++ b/tools/testing/fault-injection/failcmd.sh
@@ -0,0 +1,219 @@
+#!/bin/bash
+#
+# NAME
+#       failcmd.sh - run a command with injecting slab/page allocation failures
+#
+# SYNOPSIS
+#       failcmd.sh --help
+#       failcmd.sh [<options>] command [arguments]
+#
+# DESCRIPTION
+#       Run command with injecting slab/page allocation failures by fault
+#       injection.
+#
+#       NOTE: you need to run this script as root.
+#
+
+usage()
+{
+        cat >&2 <<EOF
+Usage: $0 [options] command [arguments]
+
+OPTIONS
+        -p percent
+        --probability=percent
+                likelihood of failure injection, in percent.
+                Default value is 1
+
+        -t value
+        --times=value
+                specifies how many times failures may happen at most.
+                Default value is 1
+
+        --oom-kill-allocating-task=value
+                set /proc/sys/vm/oom_kill_allocating_task to specified value
+                before running the command.
+                Default value is 1
+
+        -h, --help
+                Display a usage message and exit
+
+        --interval=value, --space=value, --verbose=value, --task-filter=value,
+        --stacktrace-depth=value, --require-start=value, --require-end=value,
+        --reject-start=value, --reject-end=value, --ignore-gfp-wait=value
+                See Documentation/fault-injection/fault-injection.txt for more
+                information
+
+        failslab options:
+        --cache-filter=value
+
+        fail_page_alloc options:
+        --ignore-gfp-highmem=value, --min-order=value
+
+ENVIRONMENT
+        FAILCMD_TYPE
+                The following values for FAILCMD_TYPE are recognized:
+
+                failslab
+                        inject slab allocation failures
+                fail_page_alloc
+                        inject page allocation failures
+
+                If FAILCMD_TYPE is not defined, then failslab is used.
+EOF
+}
+
+if [ $UID != 0 ]; then
+        echo must be run as root >&2
+        exit 1
+fi
+
+DEBUGFS=`mount -t debugfs | head -1 | awk '{ print $3}'`
+
+if [ ! -d "$DEBUGFS" ]; then
+        echo debugfs is not mounted >&2
+        exit 1
+fi
+
+FAILCMD_TYPE=${FAILCMD_TYPE:-failslab}
+FAULTATTR=$DEBUGFS/$FAILCMD_TYPE
+
+if [ ! -d $FAULTATTR ]; then
+        echo $FAILCMD_TYPE is not available >&2
+        exit 1
+fi
+
+LONGOPTS=probability:,interval:,times:,space:,verbose:,task-filter:
+LONGOPTS=$LONGOPTS,stacktrace-depth:,require-start:,require-end:
+LONGOPTS=$LONGOPTS,reject-start:,reject-end:,oom-kill-allocating-task:,help
+
+if [ $FAILCMD_TYPE = failslab ]; then
+        LONGOPTS=$LONGOPTS,ignore-gfp-wait:,cache-filter:
+elif [ $FAILCMD_TYPE = fail_page_alloc ]; then
+        LONGOPTS=$LONGOPTS,ignore-gfp-wait:,ignore-gfp-highmem:,min-order:
+fi
+
+TEMP=`getopt -o p:i:t:s:v:h --long $LONGOPTS -n 'failcmd.sh' -- "$@"`
+
+if [ $? != 0 ]; then
+        usage
+        exit 1
+fi
+
+eval set -- "$TEMP"
+
+fault_attr_default()
+{
+        echo N > $FAULTATTR/task-filter
+        echo 0 > $FAULTATTR/probability
+        echo 1 > $FAULTATTR/times
+}
+
+fault_attr_default
+
+oom_kill_allocating_task_saved=`cat /proc/sys/vm/oom_kill_allocating_task`
+
+restore_values()
+{
+        fault_attr_default
+        echo $oom_kill_allocating_task_saved \
+                > /proc/sys/vm/oom_kill_allocating_task
+}
+
+#
+# Default options
+#
+declare -i oom_kill_allocating_task=1
+declare task_filter=Y
+declare -i probability=1
+declare -i times=1
+
+while true; do
+        case "$1" in
+        -p|--probability)
+                probability=$2
+                shift 2
+                ;;
+        -i|--interval)
+                echo $2 > $FAULTATTR/interval
+                shift 2
+                ;;
+        -t|--times)
+                times=$2
+                shift 2
+                ;;
+        -s|--space)
+                echo $2 > $FAULTATTR/space
+                shift 2
+                ;;
+        -v|--verbose)
+                echo $2 > $FAULTATTR/verbose
+                shift 2
+                ;;
+        --task-filter)
+                task_filter=$2
+                shift 2
+                ;;
+        --stacktrace-depth)
+                echo $2 > $FAULTATTR/stacktrace-depth
+                shift 2
+                ;;
+        --require-start)
+                echo $2 > $FAULTATTR/require-start
+                shift 2
+                ;;
+        --require-end)
+                echo $2 > $FAULTATTR/require-end
+                shift 2
+                ;;
+        --reject-start)
+                echo $2 > $FAULTATTR/reject-start
+                shift 2
+                ;;
+        --reject-end)
+                echo $2 > $FAULTATTR/reject-end
+                shift 2
+                ;;
+        --oom-kill-allocating-task)
+                oom_kill_allocating_task=$2
+                shift 2
+                ;;
+        --ignore-gfp-wait)
+                echo $2 > $FAULTATTR/ignore-gfp-wait
+                shift 2
+                ;;
+        --cache-filter)
+                echo $2 > $FAULTATTR/cache_filter
+                shift 2
+                ;;
+        --ignore-gfp-highmem)
+                echo $2 > $FAULTATTR/ignore-gfp-highmem
+                shift 2
+                ;;
+        --min-order)
+                echo $2 > $FAULTATTR/min-order
+                shift 2
+                ;;
+        -h|--help)
+                usage
+                exit 0
+                shift
+                ;;
+        --)
+                shift
+                break
+                ;;
+        esac
+done
+
+[ -z "$1" ] && exit 0
+
+echo $oom_kill_allocating_task > /proc/sys/vm/oom_kill_allocating_task
+echo $task_filter > $FAULTATTR/task-filter
+echo $probability > $FAULTATTR/probability
+echo $times > $FAULTATTR/times
+
+trap "restore_values" SIGINT SIGTERM EXIT
+
+cmd="echo 1 > /proc/self/make-it-fail && exec $@"
+bash -c "$cmd"
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 292b13ad03f5..52b7959cd513 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -52,6 +52,7 @@ my %default = (
     "STOP_AFTER_SUCCESS"        => 10,
     "STOP_AFTER_FAILURE"        => 60,
     "STOP_TEST_AFTER"           => 600,
+    "MAX_MONITOR_WAIT"          => 1800,
 
 # required, and we will ask users if they don't have them but we keep the default
 # value something that is common.
@@ -77,6 +78,11 @@ my $output_config;
 my $test_type;
 my $build_type;
 my $build_options;
+my $final_post_ktest;
+my $pre_ktest;
+my $post_ktest;
+my $pre_test;
+my $post_test;
 my $pre_build;
 my $post_build;
 my $pre_build_die;
@@ -93,6 +99,7 @@ my $reboot_on_success;
 my $die_on_failure;
 my $powercycle_after_reboot;
 my $poweroff_after_halt;
+my $max_monitor_wait;
 my $ssh_exec;
 my $scp_to_target;
 my $scp_to_target_install;
@@ -101,6 +108,7 @@ my $grub_menu;
 my $grub_number;
 my $target;
 my $make;
+my $pre_install;
 my $post_install;
 my $no_install;
 my $noclean;
@@ -167,6 +175,7 @@ my $bisect_check;
 
 my $config_bisect;
 my $config_bisect_type;
+my $config_bisect_check;
 
 my $patchcheck_type;
 my $patchcheck_start;
@@ -182,6 +191,9 @@ my $newconfig = 0;
 my %entered_configs;
 my %config_help;
 my %variable;
+
+# force_config is the list of configs that we force enabled (or disabled)
+# in a .config file. The MIN_CONFIG and ADD_CONFIG configs.
 my %force_config;
 
 # do not force reboots on config problems
@@ -197,6 +209,10 @@ my %option_map = (
     "OUTPUT_DIR"                => \$outputdir,
     "BUILD_DIR"                 => \$builddir,
     "TEST_TYPE"                 => \$test_type,
+    "PRE_KTEST"                 => \$pre_ktest,
+    "POST_KTEST"                => \$post_ktest,
+    "PRE_TEST"                  => \$pre_test,
+    "POST_TEST"                 => \$post_test,
     "BUILD_TYPE"                => \$build_type,
     "BUILD_OPTIONS"             => \$build_options,
     "PRE_BUILD"                 => \$pre_build,
@@ -216,6 +232,7 @@ my %option_map = (
     "ADD_CONFIG"                => \$addconfig,
     "REBOOT_TYPE"               => \$reboot_type,
     "GRUB_MENU"                 => \$grub_menu,
+    "PRE_INSTALL"               => \$pre_install,
     "POST_INSTALL"              => \$post_install,
     "NO_INSTALL"                => \$no_install,
     "REBOOT_SCRIPT"             => \$reboot_script,
@@ -228,6 +245,7 @@ my %option_map = (
     "POWER_OFF"                 => \$power_off,
     "POWERCYCLE_AFTER_REBOOT"   => \$powercycle_after_reboot,
     "POWEROFF_AFTER_HALT"       => \$poweroff_after_halt,
+    "MAX_MONITOR_WAIT"          => \$max_monitor_wait,
     "SLEEP_TIME"                => \$sleep_time,
     "BISECT_SLEEP_TIME"         => \$bisect_sleep_time,
     "PATCHCHECK_SLEEP_TIME"     => \$patchcheck_sleep_time,
@@ -272,6 +290,7 @@ my %option_map = (
 
     "CONFIG_BISECT"             => \$config_bisect,
     "CONFIG_BISECT_TYPE"        => \$config_bisect_type,
+    "CONFIG_BISECT_CHECK"       => \$config_bisect_check,
 
     "PATCHCHECK_TYPE"           => \$patchcheck_type,
     "PATCHCHECK_START"          => \$patchcheck_start,
@@ -604,6 +623,10 @@ sub process_compare {
         return $lval eq $rval;
     } elsif ($cmp eq "!=") {
         return $lval ne $rval;
+    } elsif ($cmp eq "=~") {
+        return $lval =~ m/$rval/;
+    } elsif ($cmp eq "!~") {
+        return $lval !~ m/$rval/;
     }
 
     my $statement = "$lval $cmp $rval";
@@ -659,7 +682,7 @@ sub process_expression {
         }
     }
 
-    if ($val =~ /(.*)(==|\!=|>=|<=|>|<)(.*)/) {
+    if ($val =~ /(.*)(==|\!=|>=|<=|>|<|=~|\!~)(.*)/) {
         my $ret = process_compare($1, $2, $3);
         if ($ret < 0) {
             die "$name: $.: Unable to process comparison\n";
@@ -1117,7 +1140,11 @@ sub reboot {
     }
 
     if (defined($time)) {
-        wait_for_monitor($time, $reboot_success_line);
+        if (wait_for_monitor($time, $reboot_success_line)) {
+            # reboot got stuck?
+            doprint "Reboot did not finish. Forcing power cycle\n";
+            run_command "$power_cycle";
+        }
         end_monitor;
     }
 }
@@ -1212,6 +1239,11 @@ sub wait_for_monitor {
     my $full_line = "";
     my $line;
     my $booted = 0;
+    my $start_time = time;
+    my $skip_call_trace = 0;
+    my $bug = 0;
+    my $bug_ignored = 0;
+    my $now;
 
     doprint "** Wait for monitor to settle down **\n";
 
@@ -1227,11 +1259,39 @@ sub wait_for_monitor {
             $booted = 1;
         }
 
+        if ($full_line =~ /\[ backtrace testing \]/) {
+            $skip_call_trace = 1;
+        }
+
+        if ($full_line =~ /call trace:/i) {
+            if (!$bug && !$skip_call_trace) {
+                if ($ignore_errors) {
+                    $bug_ignored = 1;
+                } else {
+                    $bug = 1;
+                }
+            }
+        }
+
+        if ($full_line =~ /\[ end of backtrace testing \]/) {
+            $skip_call_trace = 0;
+        }
+
+        if ($full_line =~ /Kernel panic -/) {
+            $bug = 1;
+        }
+
         if ($line =~ /\n/) {
             $full_line = "";
         }
+        $now = time;
+        if ($now - $start_time >= $max_monitor_wait) {
+            doprint "Exiting monitor flush due to hitting MAX_MONITOR_WAIT\n";
+            return 1;
+        }
     }
     print "** Monitor flushed **\n";
+    return $bug;
 }
 
 sub save_logs {
@@ -1273,6 +1333,10 @@ sub save_logs {
 
 sub fail {
 
+        if (defined($post_test)) {
+                run_command $post_test;
+        }
+
         if ($die_on_failure) {
                 dodie @_;
         }
@@ -1656,6 +1720,12 @@ sub install {
 
     return if ($no_install);
 
+    if (defined($pre_install)) {
+        my $cp_pre_install = eval_kernel_version $pre_install;
+        run_command "$cp_pre_install" or
+            dodie "Failed to run pre install";
+    }
+
     my $cp_target = eval_kernel_version $target_image;
 
     run_scp_install "$outputdir/$build_target", "$cp_target" or
@@ -1814,6 +1884,7 @@ sub make_oldconfig {
 sub load_force_config {
     my ($config) = @_;
 
+    doprint "Loading force configs from $config\n";
     open(IN, $config) or
         dodie "failed to read $config";
     while (<IN>) {
@@ -1937,6 +2008,10 @@ sub halt {
 sub success {
     my ($i) = @_;
 
+    if (defined($post_test)) {
+        run_command $post_test;
+    }
+
     $successes++;
 
     my $name = "";
@@ -2003,6 +2078,7 @@ sub do_run_test {
     my $line;
     my $full_line;
     my $bug = 0;
+    my $bug_ignored = 0;
 
     wait_for_monitor 1;
 
@@ -2027,7 +2103,11 @@ sub do_run_test {
             doprint $line;
 
             if ($full_line =~ /call trace:/i) {
-                $bug = 1;
+                if ($ignore_errors) {
+                    $bug_ignored = 1;
+                } else {
+                    $bug = 1;
+                }
             }
 
             if ($full_line =~ /Kernel panic -/) {
@@ -2040,6 +2120,10 @@ sub do_run_test {
         }
     } while (!$child_done && !$bug);
 
+    if (!$bug && $bug_ignored) {
+        doprint "WARNING: Call Trace detected but ignored due to IGNORE_ERRORS=1\n";
+    }
+
     if ($bug) {
         my $failure_start = time;
         my $now;
@@ -2362,9 +2446,24 @@ sub bisect {
     success $i;
 }
 
+# config_ignore holds the configs that were set (or unset) for
+# a good config and we will ignore these configs for the rest
+# of a config bisect. These configs stay as they were.
 my %config_ignore;
+
+# config_set holds what all configs were set as.
 my %config_set;
 
+# config_off holds the set of configs that the bad config had disabled.
+# We need to record them and set them in the .config when running
+# oldnoconfig, because oldnoconfig does not turn off new symbols, but
+# instead just keeps the defaults.
+my %config_off;
+
+# config_off_tmp holds a set of configs to turn off for now
+my @config_off_tmp;
+
+# config_list is the set of configs that are being tested
 my %config_list;
 my %null_config;
 
@@ -2443,12 +2542,21 @@ sub create_config {
         }
     }
 
+    # turn off configs to keep off
+    foreach my $config (keys %config_off) {
+        print OUT "# $config is not set\n";
+    }
+
+    # turn off configs that should be off for now
+    foreach my $config (@config_off_tmp) {
+        print OUT "# $config is not set\n";
+    }
+
     foreach my $config (keys %config_ignore) {
         print OUT "$config_ignore{$config}\n";
     }
     close(OUT);
 
-#    exit;
     make_oldconfig;
 }
 
@@ -2525,6 +2633,13 @@ sub run_config_bisect {
     do {
         my @tophalf = @start_list[0 .. $half];
 
+        # keep the bottom half off
+        if ($half < $#start_list) {
+            @config_off_tmp = @start_list[$half + 1 .. $#start_list];
+        } else {
+            @config_off_tmp = ();
+        }
+
         create_config @tophalf;
         read_current_config \%current_config;
 
@@ -2541,7 +2656,11 @@ sub run_config_bisect {
         if (!$found) {
             # try the other half
             doprint "Top half produced no set configs, trying bottom half\n";
+
+            # keep the top half off
+            @config_off_tmp = @tophalf;
             @tophalf = @start_list[$half + 1 .. $#start_list];
+
             create_config @tophalf;
             read_current_config \%current_config;
             foreach my $config (@tophalf) {
@@ -2679,6 +2798,10 @@ sub config_bisect {
                 $added_configs{$2} = $1;
                 $config_list{$2} = $1;
             }
+        } elsif (/^# ((CONFIG\S*).*)/) {
+            # Keep these configs disabled
+            $config_set{$2} = $1;
+            $config_off{$2} = $1;
         }
     }
     close(IN);
@@ -2701,6 +2824,8 @@ sub config_bisect {
     my %config_test;
     my $once = 0;
 
+    @config_off_tmp = ();
+
     # Sometimes kconfig does weird things. We must make sure
     # that the config we autocreate has everything we need
     # to test, otherwise we may miss testing configs, or
@@ -2719,6 +2844,18 @@ sub config_bisect {
         }
     }
     my $ret;
+
+    if (defined($config_bisect_check) && $config_bisect_check) {
+        doprint " Checking to make sure bad config with min config fails\n";
+        create_config keys %config_list;
+        $ret = run_config_bisect_test $config_bisect_type;
+        if ($ret) {
+            doprint " FAILED! Bad config with min config boots fine\n";
+            return -1;
+        }
+        doprint " Bad config with min config fails as expected\n";
+    }
+
     do {
         $ret = run_config_bisect;
     } while (!$ret);
@@ -3510,6 +3647,8 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     $iteration = $i;
 
+    undef %force_config;
+
     my $makecmd = set_test_option("MAKE_CMD", $i);
 
     # Load all the options into their mapped variable names
@@ -3519,6 +3658,18 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
 
     $start_minconfig_defined = 1;
 
+    # The first test may override the PRE_KTEST option
+    if (defined($pre_ktest) && $i == 1) {
+        doprint "\n";
+        run_command $pre_ktest;
+    }
+
+    # Any test can override the POST_KTEST option
+    # The last test takes precedence.
+    if (defined($post_ktest)) {
+        $final_post_ktest = $post_ktest;
+    }
+
     if (!defined($start_minconfig)) {
         $start_minconfig_defined = 0;
         $start_minconfig = $minconfig;
@@ -3573,6 +3724,10 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     doprint "\n\n";
     doprint "RUNNING TEST $i of $opt{NUM_TESTS} with option $test_type $run_type$installme\n\n";
 
+    if (defined($pre_test)) {
+        run_command $pre_test;
+    }
+
     unlink $dmesg;
     unlink $buildlog;
     unlink $testlog;
@@ -3638,6 +3793,10 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     success $i;
 }
 
+if (defined($final_post_ktest)) {
+    run_command $final_post_ktest;
+}
+
 if ($opt{"POWEROFF_ON_SUCCESS"}) {
     halt;
 } elsif ($opt{"REBOOT_ON_SUCCESS"} && !do_not_reboot && $reboot_success) {
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index cf362b3d1ec9..de28a0a3b8fc 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -376,6 +376,24 @@
 # DEFAULTS
 # DEFAULTS SKIP
 
+# If you want to execute some command before the first test runs
+# you can set this option. Note, it can be set as a default option
+# or an option in the first test case. All other test cases will
+# ignore it. If both the default and first test have this option
+# set, then the first test will take precedence.
+#
+# default (undefined)
+#PRE_KTEST = ${SSH} ~/set_up_test
+
+# If you want to execute some command after all the tests have
+# completed, you can set this option. Note, it can be set as a
+# default or any test case can override it. If multiple test cases
+# set this option, then the last test case that set it will take
+# precedence
+#
+# default (undefined)
+#POST_KTEST = ${SSH} ~/dismantle_test
+
 # The default test type (default test)
 # The test types may be:
 #   build   - only build the kernel, do nothing else
@@ -408,6 +426,14 @@
 # (default "")
 #BUILD_OPTIONS = -j20
 
+# If you need to do some special handling before installing
+# you can add a script with this option.
+# The environment variable KERNEL_VERSION will be set to the
+# kernel version that is used.
+#
+# default (undefined)
+#PRE_INSTALL = ssh user@target rm -rf '/lib/modules/*-test*'
+
 # If you need an initrd, you can add a script or code here to install
 # it. The environment variable KERNEL_VERSION will be set to the
 # kernel version that is used. Remember to add the initrd line
@@ -426,6 +452,18 @@
 # (default 0)
 #NO_INSTALL = 1
 
+# If there is a command that you want to run before the individual test
+# case executes, then you can set this option
+#
+# default (undefined)
+#PRE_TEST = ${SSH} reboot_to_special_kernel
+
+# If there is a command you want to run after the individual test case
+# completes, then you can set this option.
+#
+# default (undefined)
+#POST_TEST = cd ${BUILD_DIR}; git reset --hard
+
 # If there is a script that you require to run before the build is done
 # you can specify it with PRE_BUILD.
 #
@@ -657,6 +695,14 @@
 # (default 60)
 #BISECT_SLEEP_TIME = 60
 
+# The max wait time (in seconds) for waiting for the console to finish.
+# If for some reason, the console is outputting content without
+# ever finishing, this will cause ktest to get stuck. This
+# option is the max time ktest will wait for the monitor (console)
+# to settle down before continuing.
+# (default 1800)
+#MAX_MONITOR_WAIT
+
 # The time in between patch checks to sleep (in seconds)
 # (default 60)
 #PATCHCHECK_SLEEP_TIME = 60
@@ -1039,6 +1085,12 @@
 #  can specify it with CONFIG_BISECT_GOOD. Otherwise
 #  the MIN_CONFIG is the base.
 #
+# CONFIG_BISECT_CHECK (optional)
+#  Set this to 1 if you want to confirm that the config ktest
+#  generates (the bad config with the min config) is still bad.
+#  It may be that the min config fixes what broke the bad config
+#  and the test will not return a result.
+#
 # Example:
 #   TEST_START
 #   TEST_TYPE = config_bisect
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index a4162e15c25f..85baf11e2acd 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -1,4 +1,4 @@
-TARGETS = breakpoints kcmp mqueue vm
+TARGETS = breakpoints kcmp mqueue vm cpu-hotplug memory-hotplug
 
 all:
         for TARGET in $(TARGETS); do \
diff --git a/tools/testing/selftests/cpu-hotplug/Makefile b/tools/testing/selftests/cpu-hotplug/Makefile
new file mode 100644
index 000000000000..7c9c20ff578a
--- /dev/null
+++ b/tools/testing/selftests/cpu-hotplug/Makefile
@@ -0,0 +1,6 @@
+all:
+
+run_tests:
+        ./on-off-test.sh
+
+clean:
diff --git a/tools/testing/selftests/cpu-hotplug/on-off-test.sh b/tools/testing/selftests/cpu-hotplug/on-off-test.sh
new file mode 100644
index 000000000000..bdde7cf428bb
--- /dev/null
+++ b/tools/testing/selftests/cpu-hotplug/on-off-test.sh
@@ -0,0 +1,221 @@
+#!/bin/bash
+
+SYSFS=
+
+prerequisite()
+{
+        msg="skip all tests:"
+
+        if [ $UID != 0 ]; then
+                echo $msg must be run as root >&2
+                exit 0
+        fi
+
+        SYSFS=`mount -t sysfs | head -1 | awk '{ print $3 }'`
+
+        if [ ! -d "$SYSFS" ]; then
+                echo $msg sysfs is not mounted >&2
+                exit 0
+        fi
+
+        if ! ls $SYSFS/devices/system/cpu/cpu* > /dev/null 2>&1; then
+                echo $msg cpu hotplug is not supported >&2
+                exit 0
+        fi
+}
+
+#
+# list all hot-pluggable CPUs
+#
+hotpluggable_cpus()
+{
+        local state=${1:-.\*}
+
+        for cpu in $SYSFS/devices/system/cpu/cpu*; do
+                if [ -f $cpu/online ] && grep -q $state $cpu/online; then
+                        echo ${cpu##/*/cpu}
+                fi
+        done
+}
+
+hotplaggable_offline_cpus()
+{
+        hotpluggable_cpus 0
+}
+
+hotpluggable_online_cpus()
+{
+        hotpluggable_cpus 1
+}
+
+cpu_is_online()
+{
+        grep -q 1 $SYSFS/devices/system/cpu/cpu$1/online
+}
+
+cpu_is_offline()
+{
+        grep -q 0 $SYSFS/devices/system/cpu/cpu$1/online
+}
+
+online_cpu()
+{
+        echo 1 > $SYSFS/devices/system/cpu/cpu$1/online
+}
+
+offline_cpu()
+{
+        echo 0 > $SYSFS/devices/system/cpu/cpu$1/online
+}
+
+online_cpu_expect_success()
+{
+        local cpu=$1
+
+        if ! online_cpu $cpu; then
+                echo $FUNCNAME $cpu: unexpected fail >&2
+        elif ! cpu_is_online $cpu; then
+                echo $FUNCNAME $cpu: unexpected offline >&2
+        fi
+}
+
+online_cpu_expect_fail()
+{
+        local cpu=$1
+
+        if online_cpu $cpu 2> /dev/null; then
+                echo $FUNCNAME $cpu: unexpected success >&2
+        elif ! cpu_is_offline $cpu; then
+                echo $FUNCNAME $cpu: unexpected online >&2
+        fi
+}
+
+offline_cpu_expect_success()
+{
+        local cpu=$1
+
+        if ! offline_cpu $cpu; then
+                echo $FUNCNAME $cpu: unexpected fail >&2
+        elif ! cpu_is_offline $cpu; then
+                echo $FUNCNAME $cpu: unexpected offline >&2
+        fi
+}
+
+offline_cpu_expect_fail()
+{
+        local cpu=$1
+
+        if offline_cpu $cpu 2> /dev/null; then
+                echo $FUNCNAME $cpu: unexpected success >&2
+        elif ! cpu_is_online $cpu; then
+                echo $FUNCNAME $cpu: unexpected offline >&2
+        fi
+}
+
+error=-12
+priority=0
+
+while getopts e:hp: opt; do
+        case $opt in
+        e)
+                error=$OPTARG
+                ;;
+        h)
+                echo "Usage $0 [ -e errno ] [ -p notifier-priority ]"
+                exit
+                ;;
+        p)
+                priority=$OPTARG
+                ;;
+        esac
+done
+
+if ! [ "$error" -ge -4095 -a "$error" -lt 0 ]; then
+        echo "error code must be -4095 <= errno < 0" >&2
+        exit 1
+fi
+
+prerequisite
+
+#
+# Online all hot-pluggable CPUs
+#
+for cpu in `hotplaggable_offline_cpus`; do
+        online_cpu_expect_success $cpu
+done
+
+#
+# Offline all hot-pluggable CPUs
+#
+for cpu in `hotpluggable_online_cpus`; do
+        offline_cpu_expect_success $cpu
+done
+
+#
+# Online all hot-pluggable CPUs again
+#
+for cpu in `hotplaggable_offline_cpus`; do
+        online_cpu_expect_success $cpu
+done
+
+#
+# Test with cpu notifier error injection
+#
+
+DEBUGFS=`mount -t debugfs | head -1 | awk '{ print $3 }'`
+NOTIFIER_ERR_INJECT_DIR=$DEBUGFS/notifier-error-inject/cpu
+
+prerequisite_extra()
+{
+        msg="skip extra tests:"
+
+        /sbin/modprobe -q -r cpu-notifier-error-inject
+        /sbin/modprobe -q cpu-notifier-error-inject priority=$priority
+
+        if [ ! -d "$DEBUGFS" ]; then
+                echo $msg debugfs is not mounted >&2
+                exit 0
+        fi
+
+        if [ ! -d $NOTIFIER_ERR_INJECT_DIR ]; then
+                echo $msg cpu-notifier-error-inject module is not available >&2
+                exit 0
+        fi
+}
+
+prerequisite_extra
+
+#
+# Offline all hot-pluggable CPUs
+#
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/CPU_DOWN_PREPARE/error
+for cpu in `hotpluggable_online_cpus`; do
+        offline_cpu_expect_success $cpu
+done
+
+#
+# Test CPU hot-add error handling (offline => online)
+#
+echo $error > $NOTIFIER_ERR_INJECT_DIR/actions/CPU_UP_PREPARE/error
+for cpu in `hotplaggable_offline_cpus`; do
+        online_cpu_expect_fail $cpu
+done
+
+#
+# Online all hot-pluggable CPUs
+#
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/CPU_UP_PREPARE/error
+for cpu in `hotplaggable_offline_cpus`; do
+        online_cpu_expect_success $cpu
+done
+
+#
+# Test CPU hot-remove error handling (online => offline)
+#
+echo $error > $NOTIFIER_ERR_INJECT_DIR/actions/CPU_DOWN_PREPARE/error
+for cpu in `hotpluggable_online_cpus`; do
+        offline_cpu_expect_fail $cpu
+done
+
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/CPU_DOWN_PREPARE/error
+/sbin/modprobe -q -r cpu-notifier-error-inject
diff --git a/tools/testing/selftests/memory-hotplug/Makefile b/tools/testing/selftests/memory-hotplug/Makefile
new file mode 100644
index 000000000000..7c9c20ff578a
--- /dev/null
+++ b/tools/testing/selftests/memory-hotplug/Makefile
@@ -0,0 +1,6 @@
+all:
+
+run_tests:
+        ./on-off-test.sh
+
+clean:
diff --git a/tools/testing/selftests/memory-hotplug/on-off-test.sh b/tools/testing/selftests/memory-hotplug/on-off-test.sh
new file mode 100644
index 000000000000..a2816f631542
--- /dev/null
+++ b/tools/testing/selftests/memory-hotplug/on-off-test.sh
@@ -0,0 +1,230 @@
+#!/bin/bash
+
+SYSFS=
+
+prerequisite()
+{
+        msg="skip all tests:"
+
+        if [ $UID != 0 ]; then
+                echo $msg must be run as root >&2
+                exit 0
+        fi
+
+        SYSFS=`mount -t sysfs | head -1 | awk '{ print $3 }'`
+
+        if [ ! -d "$SYSFS" ]; then
+                echo $msg sysfs is not mounted >&2
+                exit 0
+        fi
+
+        if ! ls $SYSFS/devices/system/memory/memory* > /dev/null 2>&1; then
+                echo $msg memory hotplug is not supported >&2
+                exit 0
+        fi
+}
+
+#
+# list all hot-pluggable memory
+#
+hotpluggable_memory()
+{
+        local state=${1:-.\*}
+
+        for memory in $SYSFS/devices/system/memory/memory*; do
+                if grep -q 1 $memory/removable &&
+                   grep -q $state $memory/state; then
+                        echo ${memory##/*/memory}
+                fi
+        done
+}
+
+hotplaggable_offline_memory()
+{
+        hotpluggable_memory offline
+}
+
+hotpluggable_online_memory()
+{
+        hotpluggable_memory online
+}
+
+memory_is_online()
+{
+        grep -q online $SYSFS/devices/system/memory/memory$1/state
+}
+
+memory_is_offline()
+{
+        grep -q offline $SYSFS/devices/system/memory/memory$1/state
+}
+
+online_memory()
+{
+        echo online > $SYSFS/devices/system/memory/memory$1/state
+}
+
+offline_memory()
+{
+        echo offline > $SYSFS/devices/system/memory/memory$1/state
+}
+
+online_memory_expect_success()
+{
+        local memory=$1
+
+        if ! online_memory $memory; then
+                echo $FUNCNAME $memory: unexpected fail >&2
+        elif ! memory_is_online $memory; then
+                echo $FUNCNAME $memory: unexpected offline >&2
+        fi
+}
+
+online_memory_expect_fail()
+{
+        local memory=$1
+
+        if online_memory $memory 2> /dev/null; then
+                echo $FUNCNAME $memory: unexpected success >&2
+        elif ! memory_is_offline $memory; then
+                echo $FUNCNAME $memory: unexpected online >&2
+        fi
+}
+
+offline_memory_expect_success()
+{
+        local memory=$1
+
+        if ! offline_memory $memory; then
+                echo $FUNCNAME $memory: unexpected fail >&2
+        elif ! memory_is_offline $memory; then
+                echo $FUNCNAME $memory: unexpected offline >&2
+        fi
+}
+
+offline_memory_expect_fail()
+{
+        local memory=$1
+
+        if offline_memory $memory 2> /dev/null; then
+                echo $FUNCNAME $memory: unexpected success >&2
+        elif ! memory_is_online $memory; then
+                echo $FUNCNAME $memory: unexpected offline >&2
+        fi
+}
+
+error=-12
+priority=0
+ratio=10
+
+while getopts e:hp:r: opt; do
+        case $opt in
+        e)
+                error=$OPTARG
+                ;;
+        h)
+                echo "Usage $0 [ -e errno ] [ -p notifier-priority ] [ -r percent-of-memory-to-offline ]"
+                exit
+                ;;
+        p)
+                priority=$OPTARG
+                ;;
+        r)
+                ratio=$OPTARG
+                ;;
+        esac
+done
+
+if ! [ "$error" -ge -4095 -a "$error" -lt 0 ]; then
+        echo "error code must be -4095 <= errno < 0" >&2
+        exit 1
+fi
+
+prerequisite
+
+#
+# Online all hot-pluggable memory
+#
+for memory in `hotplaggable_offline_memory`; do
+        online_memory_expect_success $memory
+done
+
+#
+# Offline $ratio percent of hot-pluggable memory
+#
+for memory in `hotpluggable_online_memory`; do
+        if [ $((RANDOM % 100)) -lt $ratio ]; then
+                offline_memory_expect_success $memory
+        fi
+done
+
+#
+# Online all hot-pluggable memory again
+#
+for memory in `hotplaggable_offline_memory`; do
+        online_memory_expect_success $memory
+done
+
+#
+# Test with memory notifier error injection
+#
+
+DEBUGFS=`mount -t debugfs | head -1 | awk '{ print $3 }'`
+NOTIFIER_ERR_INJECT_DIR=$DEBUGFS/notifier-error-inject/memory
+
+prerequisite_extra()
+{
+        msg="skip extra tests:"
+
+        /sbin/modprobe -q -r memory-notifier-error-inject
+        /sbin/modprobe -q memory-notifier-error-inject priority=$priority
+
+        if [ ! -d "$DEBUGFS" ]; then
+                echo $msg debugfs is not mounted >&2
+                exit 0
+        fi
+
+        if [ ! -d $NOTIFIER_ERR_INJECT_DIR ]; then
+                echo $msg memory-notifier-error-inject module is not available >&2
+                exit 0
+        fi
+}
+
+prerequisite_extra
+
+#
+# Offline $ratio percent of hot-pluggable memory
+#
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/MEM_GOING_OFFLINE/error
+for memory in `hotpluggable_online_memory`; do
+        if [ $((RANDOM % 100)) -lt $ratio ]; then
+                offline_memory_expect_success $memory
+        fi
+done
+
+#
+# Test memory hot-add error handling (offline => online)
+#
+echo $error > $NOTIFIER_ERR_INJECT_DIR/actions/MEM_GOING_ONLINE/error
+for memory in `hotplaggable_offline_memory`; do
+        online_memory_expect_fail $memory
+done
+
+#
+# Online all hot-pluggable memory
+#
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/MEM_GOING_ONLINE/error
+for memory in `hotplaggable_offline_memory`; do
+        online_memory_expect_success $memory
+done
+
+#
+# Test memory hot-remove error handling (online => offline)
+#
+echo $error > $NOTIFIER_ERR_INJECT_DIR/actions/MEM_GOING_OFFLINE/error
+for memory in `hotpluggable_online_memory`; do
+        offline_memory_expect_fail $memory
+done
+
+echo 0 > $NOTIFIER_ERR_INJECT_DIR/actions/MEM_GOING_OFFLINE/error
+/sbin/modprobe -q -r memory-notifier-error-inject
diff --git a/tools/usb/testusb.c b/tools/usb/testusb.c
index 82d7c590c026..b0adb2710c02 100644
--- a/tools/usb/testusb.c
+++ b/tools/usb/testusb.c
@@ -425,7 +425,7 @@ int main (int argc, char **argv)
         /* for easy use when hotplugging */
         device = getenv ("DEVICE");
 
-        while ((c = getopt (argc, argv, "D:aA:c:g:hns:t:v:")) != EOF)
+        while ((c = getopt (argc, argv, "D:aA:c:g:hlns:t:v:")) != EOF)
         switch (c) {
         case 'D':       /* device, if only one */
                 device = optarg;
@@ -468,10 +468,21 @@ int main (int argc, char **argv)
         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]);
+                fprintf (stderr,
+                        "usage: %s [options]\n"
+                        "Options:\n"
+                        "\t-D dev               only test specific device\n"
+                        "\t-A usbfs-dir\n"
+                        "\t-a           test all recognized devices\n"
+                        "\t-l           loop forever(for stress test)\n"
+                        "\t-t testnum   only run specified case\n"
+                        "\t-n           no test running, show devices to be tested\n"
+                        "Case arguments:\n"
+                        "\t-c iterations        default 1000\n"
+                        "\t-s packetsize        default 512\n"
+                        "\t-g sglen     default 32\n"
+                        "\t-v vary              default 512\n",
+                        argv[0]);
                 return 1;
         }
         if (optind != argc)
diff --git a/tools/vm/slabinfo.c b/tools/vm/slabinfo.c
index 164cbcf61106..808d5a9d5dcf 100644
--- a/tools/vm/slabinfo.c
+++ b/tools/vm/slabinfo.c
@@ -437,34 +437,34 @@ static void slab_stats(struct slabinfo *s)
         printf("Fastpath             %8lu %8lu %3lu %3lu\n",
                 s->alloc_fastpath, s->free_fastpath,
                 s->alloc_fastpath * 100 / total_alloc,
-                s->free_fastpath * 100 / total_free);
+                total_free ? s->free_fastpath * 100 / total_free : 0);
         printf("Slowpath             %8lu %8lu %3lu %3lu\n",
                 total_alloc - s->alloc_fastpath, s->free_slowpath,
                 (total_alloc - s->alloc_fastpath) * 100 / total_alloc,
-                s->free_slowpath * 100 / total_free);
+                total_free ? s->free_slowpath * 100 / total_free : 0);
         printf("Page Alloc           %8lu %8lu %3lu %3lu\n",
                 s->alloc_slab, s->free_slab,
                 s->alloc_slab * 100 / total_alloc,
-                s->free_slab * 100 / total_free);
+                total_free ? s->free_slab * 100 / total_free : 0);
         printf("Add partial          %8lu %8lu %3lu %3lu\n",
                 s->deactivate_to_head + s->deactivate_to_tail,
                 s->free_add_partial,
                 (s->deactivate_to_head + s->deactivate_to_tail) * 100 / total_alloc,
-                s->free_add_partial * 100 / total_free);
+                total_free ? s->free_add_partial * 100 / total_free : 0);
         printf("Remove partial       %8lu %8lu %3lu %3lu\n",
                 s->alloc_from_partial, s->free_remove_partial,
                 s->alloc_from_partial * 100 / total_alloc,
-                s->free_remove_partial * 100 / total_free);
+                total_free ? s->free_remove_partial * 100 / total_free : 0);
 
         printf("Cpu partial list     %8lu %8lu %3lu %3lu\n",
                 s->cpu_partial_alloc, s->cpu_partial_free,
                 s->cpu_partial_alloc * 100 / total_alloc,
-                s->cpu_partial_free * 100 / total_free);
+                total_free ? s->cpu_partial_free * 100 / total_free : 0);
 
         printf("RemoteObj/SlabFrozen %8lu %8lu %3lu %3lu\n",
                 s->deactivate_remote_frees, s->free_frozen,
                 s->deactivate_remote_frees * 100 / total_alloc,
-                s->free_frozen * 100 / total_free);
+                total_free ? s->free_frozen * 100 / total_free : 0);
 
         printf("Total                %8lu %8lu\n\n", total_alloc, total_free);