Merge branch 'upstream' into bugfix-video

Update bugfix-video branch to 2.5-rc1
so I don't have to again resolve the
conflict in these patches vs. upstream.

Conflicts:
	drivers/gpu/drm/gma500/psb_drv.c

	text conflict: add comment vs delete neighboring line

	keep just this:
	/* igd_opregion_init(&dev_priv->opregion_dev); */
	/* acpi_video_register(); */

Signed-off-by: Len Brown <len.brown@intel.com>

118 files changed, 15882 insertions, 5336 deletions

diff --git a/tools/Makefile b/tools/Makefile
new file mode 100644
index 000000000000..3ae43947a171
--- /dev/null
+++ b/tools/Makefile
@@ -0,0 +1,77 @@
+include scripts/Makefile.include
+
+help:
+        @echo 'Possible targets:'
+        @echo ''
+        @echo '  cpupower   - a tool for all things x86 CPU power'
+        @echo '  firewire   - the userspace part of nosy, an IEEE-1394 traffic sniffer'
+        @echo '  lguest     - a minimal 32-bit x86 hypervisor'
+        @echo '  perf       - Linux performance measurement and analysis tool'
+        @echo '  selftests  - various kernel selftests'
+        @echo '  turbostat  - Intel CPU idle stats and freq reporting tool'
+        @echo '  usb        - USB testing tools'
+        @echo '  virtio     - vhost test module'
+        @echo '  vm         - misc vm tools'
+        @echo '  x86_energy_perf_policy - Intel energy policy tool'
+        @echo ''
+        @echo 'You can do:'
+        @echo ' $$ make -C tools/<tool>_install'
+        @echo ''
+        @echo '  from the kernel command line to build and install one of'
+        @echo '  the tools above'
+        @echo ''
+        @echo '  $$ make tools/install'
+        @echo ''
+        @echo '  installs all tools.'
+        @echo ''
+        @echo 'Cleaning targets:'
+        @echo ''
+        @echo '  all of the above with the "_clean" string appended cleans'
+        @echo '    the respective build directory.'
+        @echo '  clean: a summary clean target to clean _all_ folders'
+
+cpupower: FORCE
+        $(QUIET_SUBDIR0)power/$@/ $(QUIET_SUBDIR1)
+
+firewire lguest perf usb virtio vm: FORCE
+        $(QUIET_SUBDIR0)$@/ $(QUIET_SUBDIR1)
+
+selftests: FORCE
+        $(QUIET_SUBDIR0)testing/$@/ $(QUIET_SUBDIR1)
+
+turbostat x86_energy_perf_policy: FORCE
+        $(QUIET_SUBDIR0)power/x86/$@/ $(QUIET_SUBDIR1)
+
+cpupower_install:
+        $(QUIET_SUBDIR0)power/$(@:_install=)/ $(QUIET_SUBDIR1) install
+
+firewire_install lguest_install perf_install usb_install virtio_install vm_install:
+        $(QUIET_SUBDIR0)$(@:_install=)/ $(QUIET_SUBDIR1) install
+
+selftests_install:
+        $(QUIET_SUBDIR0)testing/$(@:_clean=)/ $(QUIET_SUBDIR1) install
+
+turbostat_install x86_energy_perf_policy_install:
+        $(QUIET_SUBDIR0)power/x86/$(@:_install=)/ $(QUIET_SUBDIR1) install
+
+install: cpupower_install firewire_install lguest_install perf_install \
+                selftests_install turbostat_install usb_install virtio_install \
+                vm_install x86_energy_perf_policy_install
+
+cpupower_clean:
+        $(QUIET_SUBDIR0)power/cpupower/ $(QUIET_SUBDIR1) clean
+
+firewire_clean lguest_clean perf_clean usb_clean virtio_clean vm_clean:
+        $(QUIET_SUBDIR0)$(@:_clean=)/ $(QUIET_SUBDIR1) clean
+
+selftests_clean:
+        $(QUIET_SUBDIR0)testing/$(@:_clean=)/ $(QUIET_SUBDIR1) clean
+
+turbostat_clean x86_energy_perf_policy_clean:
+        $(QUIET_SUBDIR0)power/x86/$(@:_clean=)/ $(QUIET_SUBDIR1) clean
+
+clean: cpupower_clean firewire_clean lguest_clean perf_clean selftests_clean \
+                turbostat_clean usb_clean virtio_clean vm_clean \
+                x86_energy_perf_policy_clean
+
+.PHONY: FORCE
diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile
new file mode 100644
index 000000000000..3d69aa9ff51e
--- /dev/null
+++ b/tools/lib/traceevent/Makefile
@@ -0,0 +1,303 @@
+# trace-cmd version
+EP_VERSION = 1
+EP_PATCHLEVEL = 1
+EP_EXTRAVERSION = 0
+
+# file format version
+FILE_VERSION = 6
+
+MAKEFLAGS += --no-print-directory
+
+
+# Makefiles suck: This macro sets a default value of $(2) for the
+# variable named by $(1), unless the variable has been set by
+# environment or command line. This is necessary for CC and AR
+# because make sets default values, so the simpler ?= approach
+# won't work as expected.
+define allow-override
+  $(if $(or $(findstring environment,$(origin $(1))),\
+            $(findstring command line,$(origin $(1)))),,\
+    $(eval $(1) = $(2)))
+endef
+
+# Allow setting CC and AR, or setting CROSS_COMPILE as a prefix.
+$(call allow-override,CC,$(CROSS_COMPILE)gcc)
+$(call allow-override,AR,$(CROSS_COMPILE)ar)
+
+EXT = -std=gnu99
+INSTALL = install
+
+# Use DESTDIR for installing into a different root directory.
+# This is useful for building a package. The program will be
+# installed in this directory as if it was the root directory.
+# Then the build tool can move it later.
+DESTDIR ?=
+DESTDIR_SQ = '$(subst ','\'',$(DESTDIR))'
+
+prefix ?= /usr/local
+bindir_relative = bin
+bindir = $(prefix)/$(bindir_relative)
+man_dir = $(prefix)/share/man
+man_dir_SQ = '$(subst ','\'',$(man_dir))'
+html_install = $(prefix)/share/kernelshark/html
+html_install_SQ = '$(subst ','\'',$(html_install))'
+img_install = $(prefix)/share/kernelshark/html/images
+img_install_SQ = '$(subst ','\'',$(img_install))'
+
+export man_dir man_dir_SQ html_install html_install_SQ INSTALL
+export img_install img_install_SQ
+export DESTDIR DESTDIR_SQ
+
+# copy a bit from Linux kbuild
+
+ifeq ("$(origin V)", "command line")
+  VERBOSE = $(V)
+endif
+ifndef VERBOSE
+  VERBOSE = 0
+endif
+
+ifeq ("$(origin O)", "command line")
+  BUILD_OUTPUT := $(O)
+endif
+
+ifeq ($(BUILD_SRC),)
+ifneq ($(BUILD_OUTPUT),)
+
+define build_output
+        $(if $(VERBOSE:1=),@)$(MAKE) -C $(BUILD_OUTPUT)         \
+        BUILD_SRC=$(CURDIR) -f $(CURDIR)/Makefile $1
+endef
+
+saved-output := $(BUILD_OUTPUT)
+BUILD_OUTPUT := $(shell cd $(BUILD_OUTPUT) && /bin/pwd)
+$(if $(BUILD_OUTPUT),, \
+     $(error output directory "$(saved-output)" does not exist))
+
+all: sub-make
+
+gui: force
+        $(call build_output, all_cmd)
+
+$(filter-out gui,$(MAKECMDGOALS)): sub-make
+
+sub-make: force
+        $(call build_output, $(MAKECMDGOALS))
+
+
+# Leave processing to above invocation of make
+skip-makefile := 1
+
+endif # BUILD_OUTPUT
+endif # BUILD_SRC
+
+# We process the rest of the Makefile if this is the final invocation of make
+ifeq ($(skip-makefile),)
+
+srctree         := $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR))
+objtree         := $(CURDIR)
+src             := $(srctree)
+obj             := $(objtree)
+
+export prefix bindir src obj
+
+# Shell quotes
+bindir_SQ = $(subst ','\'',$(bindir))
+bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
+
+LIB_FILE = libtraceevent.a libtraceevent.so
+
+CONFIG_INCLUDES = 
+CONFIG_LIBS     =
+CONFIG_FLAGS    =
+
+VERSION         = $(EP_VERSION)
+PATCHLEVEL      = $(EP_PATCHLEVEL)
+EXTRAVERSION    = $(EP_EXTRAVERSION)
+
+OBJ             = $@
+N               =
+
+export Q VERBOSE
+
+EVENT_PARSE_VERSION = $(EP_VERSION).$(EP_PATCHLEVEL).$(EP_EXTRAVERSION)
+
+INCLUDES = -I. -I/usr/local/include $(CONFIG_INCLUDES)
+
+# Set compile option CFLAGS if not set elsewhere
+CFLAGS ?= -g -Wall
+
+# Append required CFLAGS
+override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
+override CFLAGS += $(udis86-flags)
+
+ifeq ($(VERBOSE),1)
+  Q =
+  print_compile =
+  print_app_build =
+  print_fpic_compile =
+  print_shared_lib_compile =
+  print_plugin_obj_compile =
+  print_plugin_build =
+  print_install =
+else
+  Q = @
+  print_compile =               echo '  CC                 '$(OBJ);
+  print_app_build =             echo '  BUILD              '$(OBJ);
+  print_fpic_compile =          echo '  CC FPIC            '$(OBJ);
+  print_shared_lib_compile =    echo '  BUILD SHARED LIB   '$(OBJ);
+  print_plugin_obj_compile =    echo '  CC PLUGIN OBJ      '$(OBJ);
+  print_plugin_build =          echo '  CC PLUGI           '$(OBJ);
+  print_static_lib_build =      echo '  BUILD STATIC LIB   '$(OBJ);
+  print_install =               echo '  INSTALL     '$1'        to      $(DESTDIR_SQ)$2';
+endif
+
+do_fpic_compile =                                       \
+        ($(print_fpic_compile)                          \
+        $(CC) -c $(CFLAGS) $(EXT) -fPIC $< -o $@)
+
+do_app_build =                                          \
+        ($(print_app_build)                             \
+        $(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS))
+
+do_compile_shared_library =                     \
+        ($(print_shared_lib_compile)            \
+        $(CC) --shared $^ -o $@)
+
+do_compile_plugin_obj =                         \
+        ($(print_plugin_obj_compile)            \
+        $(CC) -c $(CFLAGS) -fPIC -o $@ $<)
+
+do_plugin_build =                               \
+        ($(print_plugin_build)                  \
+        $(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<)
+
+do_build_static_lib =                           \
+        ($(print_static_lib_build)              \
+        $(RM) $@;  $(AR) rcs $@ $^)
+
+
+define do_compile
+        $(print_compile)                                                \
+        $(CC) -c $(CFLAGS) $(EXT) $< -o $(obj)/$@;
+endef
+
+$(obj)/%.o: $(src)/%.c
+        $(Q)$(call do_compile)
+
+%.o: $(src)/%.c
+        $(Q)$(call do_compile)
+
+PEVENT_LIB_OBJS = event-parse.o trace-seq.o parse-filter.o parse-utils.o
+
+ALL_OBJS = $(PEVENT_LIB_OBJS)
+
+CMD_TARGETS = $(LIB_FILE)
+
+TARGETS = $(CMD_TARGETS)
+
+
+all: all_cmd
+
+all_cmd: $(CMD_TARGETS)
+
+libtraceevent.so: $(PEVENT_LIB_OBJS)
+        $(Q)$(do_compile_shared_library)
+
+libtraceevent.a: $(PEVENT_LIB_OBJS)
+        $(Q)$(do_build_static_lib)
+
+$(PEVENT_LIB_OBJS): %.o: $(src)/%.c
+        $(Q)$(do_fpic_compile)
+
+define make_version.h
+        (echo '/* This file is automatically generated. Do not modify. */';             \
+        echo \#define VERSION_CODE $(shell                                              \
+        expr $(VERSION) \* 256 + $(PATCHLEVEL));                                        \
+        echo '#define EXTRAVERSION ' $(EXTRAVERSION);                                   \
+        echo '#define VERSION_STRING "'$(VERSION).$(PATCHLEVEL).$(EXTRAVERSION)'"';     \
+        echo '#define FILE_VERSION '$(FILE_VERSION);                                    \
+        ) > $1
+endef
+
+define update_version.h
+        ($(call make_version.h, $@.tmp);                \
+        if [ -r $@ ] && cmp -s $@ $@.tmp; then          \
+                rm -f $@.tmp;                           \
+        else                                            \
+                echo '  UPDATE                 $@';     \
+                mv -f $@.tmp $@;                        \
+        fi);
+endef
+
+ep_version.h: force
+        $(Q)$(N)$(call update_version.h)
+
+VERSION_FILES = ep_version.h
+
+define update_dir
+        (echo $1 > $@.tmp;      \
+        if [ -r $@ ] && cmp -s $@ $@.tmp; then          \
+                rm -f $@.tmp;                           \
+        else                                            \
+                echo '  UPDATE                 $@';     \
+                mv -f $@.tmp $@;                        \
+        fi);
+endef
+
+## make deps
+
+all_objs := $(sort $(ALL_OBJS))
+all_deps := $(all_objs:%.o=.%.d)
+
+define check_deps
+                $(CC) -M $(CFLAGS) $< > $@;
+endef
+
+$(gui_deps): ks_version.h
+$(non_gui_deps): tc_version.h
+
+$(all_deps): .%.d: $(src)/%.c
+        $(Q)$(call check_deps)
+
+$(all_objs) : %.o : .%.d
+
+dep_includes := $(wildcard $(all_deps))
+
+ifneq ($(dep_includes),)
+ include $(dep_includes)
+endif
+
+tags:   force
+        $(RM) tags
+        find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px
+
+TAGS:   force
+        $(RM) TAGS
+        find . -name '*.[ch]' | xargs etags
+
+define do_install
+        $(print_install)                                \
+        if [ ! -d '$(DESTDIR_SQ)$2' ]; then             \
+                $(INSTALL) -d -m 755 '$(DESTDIR_SQ)$2'; \
+        fi;                                             \
+        $(INSTALL) $1 '$(DESTDIR_SQ)$2'
+endef
+
+install_lib: all_cmd install_plugins install_python
+        $(Q)$(call do_install,$(LIB_FILE),$(bindir_SQ))
+
+install: install_lib
+
+clean:
+        $(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES).*.d
+        $(RM) tags TAGS
+
+endif # skip-makefile
+
+PHONY += force
+force:
+
+# Declare the contents of the .PHONY variable as phony.  We keep that
+# information in a variable so we can use it in if_changed and friends.
+.PHONY: $(PHONY)
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
new file mode 100644
index 000000000000..554828219c33
--- /dev/null
+++ b/tools/lib/traceevent/event-parse.c
@@ -0,0 +1,5079 @@
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ *  The parts for function graph printing was taken and modified from the
+ *  Linux Kernel that were written by
+ *    - Copyright (C) 2009  Frederic Weisbecker,
+ *  Frederic Weisbecker gave his permission to relicense the code to
+ *  the Lesser General Public License.
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "event-parse.h"
+#include "event-utils.h"
+
+static const char *input_buf;
+static unsigned long long input_buf_ptr;
+static unsigned long long input_buf_siz;
+
+static int is_flag_field;
+static int is_symbolic_field;
+
+static int show_warning = 1;
+
+#define do_warning(fmt, ...)                            \
+        do {                                            \
+                if (show_warning)                       \
+                        warning(fmt, ##__VA_ARGS__);    \
+        } while (0)
+
+static void init_input_buf(const char *buf, unsigned long long size)
+{
+        input_buf = buf;
+        input_buf_siz = size;
+        input_buf_ptr = 0;
+}
+
+const char *pevent_get_input_buf(void)
+{
+        return input_buf;
+}
+
+unsigned long long pevent_get_input_buf_ptr(void)
+{
+        return input_buf_ptr;
+}
+
+struct event_handler {
+        struct event_handler            *next;
+        int                             id;
+        const char                      *sys_name;
+        const char                      *event_name;
+        pevent_event_handler_func       func;
+        void                            *context;
+};
+
+struct pevent_func_params {
+        struct pevent_func_params       *next;
+        enum pevent_func_arg_type       type;
+};
+
+struct pevent_function_handler {
+        struct pevent_function_handler  *next;
+        enum pevent_func_arg_type       ret_type;
+        char                            *name;
+        pevent_func_handler             func;
+        struct pevent_func_params       *params;
+        int                             nr_args;
+};
+
+static unsigned long long
+process_defined_func(struct trace_seq *s, void *data, int size,
+                     struct event_format *event, struct print_arg *arg);
+
+static void free_func_handle(struct pevent_function_handler *func);
+
+/**
+ * pevent_buffer_init - init buffer for parsing
+ * @buf: buffer to parse
+ * @size: the size of the buffer
+ *
+ * For use with pevent_read_token(), this initializes the internal
+ * buffer that pevent_read_token() will parse.
+ */
+void pevent_buffer_init(const char *buf, unsigned long long size)
+{
+        init_input_buf(buf, size);
+}
+
+void breakpoint(void)
+{
+        static int x;
+        x++;
+}
+
+struct print_arg *alloc_arg(void)
+{
+        struct print_arg *arg;
+
+        arg = malloc_or_die(sizeof(*arg));
+        if (!arg)
+                return NULL;
+        memset(arg, 0, sizeof(*arg));
+
+        return arg;
+}
+
+struct cmdline {
+        char *comm;
+        int pid;
+};
+
+static int cmdline_cmp(const void *a, const void *b)
+{
+        const struct cmdline *ca = a;
+        const struct cmdline *cb = b;
+
+        if (ca->pid < cb->pid)
+                return -1;
+        if (ca->pid > cb->pid)
+                return 1;
+
+        return 0;
+}
+
+struct cmdline_list {
+        struct cmdline_list     *next;
+        char                    *comm;
+        int                     pid;
+};
+
+static int cmdline_init(struct pevent *pevent)
+{
+        struct cmdline_list *cmdlist = pevent->cmdlist;
+        struct cmdline_list *item;
+        struct cmdline *cmdlines;
+        int i;
+
+        cmdlines = malloc_or_die(sizeof(*cmdlines) * pevent->cmdline_count);
+
+        i = 0;
+        while (cmdlist) {
+                cmdlines[i].pid = cmdlist->pid;
+                cmdlines[i].comm = cmdlist->comm;
+                i++;
+                item = cmdlist;
+                cmdlist = cmdlist->next;
+                free(item);
+        }
+
+        qsort(cmdlines, pevent->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
+
+        pevent->cmdlines = cmdlines;
+        pevent->cmdlist = NULL;
+
+        return 0;
+}
+
+static char *find_cmdline(struct pevent *pevent, int pid)
+{
+        const struct cmdline *comm;
+        struct cmdline key;
+
+        if (!pid)
+                return "<idle>";
+
+        if (!pevent->cmdlines)
+                cmdline_init(pevent);
+
+        key.pid = pid;
+
+        comm = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
+                       sizeof(*pevent->cmdlines), cmdline_cmp);
+
+        if (comm)
+                return comm->comm;
+        return "<...>";
+}
+
+/**
+ * pevent_pid_is_registered - return if a pid has a cmdline registered
+ * @pevent: handle for the pevent
+ * @pid: The pid to check if it has a cmdline registered with.
+ *
+ * Returns 1 if the pid has a cmdline mapped to it
+ * 0 otherwise.
+ */
+int pevent_pid_is_registered(struct pevent *pevent, int pid)
+{
+        const struct cmdline *comm;
+        struct cmdline key;
+
+        if (!pid)
+                return 1;
+
+        if (!pevent->cmdlines)
+                cmdline_init(pevent);
+
+        key.pid = pid;
+
+        comm = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
+                       sizeof(*pevent->cmdlines), cmdline_cmp);
+
+        if (comm)
+                return 1;
+        return 0;
+}
+
+/*
+ * If the command lines have been converted to an array, then
+ * we must add this pid. This is much slower than when cmdlines
+ * are added before the array is initialized.
+ */
+static int add_new_comm(struct pevent *pevent, const char *comm, int pid)
+{
+        struct cmdline *cmdlines = pevent->cmdlines;
+        const struct cmdline *cmdline;
+        struct cmdline key;
+
+        if (!pid)
+                return 0;
+
+        /* avoid duplicates */
+        key.pid = pid;
+
+        cmdline = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
+                       sizeof(*pevent->cmdlines), cmdline_cmp);
+        if (cmdline) {
+                errno = EEXIST;
+                return -1;
+        }
+
+        cmdlines = realloc(cmdlines, sizeof(*cmdlines) * (pevent->cmdline_count + 1));
+        if (!cmdlines) {
+                errno = ENOMEM;
+                return -1;
+        }
+
+        cmdlines[pevent->cmdline_count].pid = pid;
+        cmdlines[pevent->cmdline_count].comm = strdup(comm);
+        if (!cmdlines[pevent->cmdline_count].comm)
+                die("malloc comm");
+                
+        if (cmdlines[pevent->cmdline_count].comm)
+                pevent->cmdline_count++;
+
+        qsort(cmdlines, pevent->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
+        pevent->cmdlines = cmdlines;
+
+        return 0;
+}
+
+/**
+ * pevent_register_comm - register a pid / comm mapping
+ * @pevent: handle for the pevent
+ * @comm: the command line to register
+ * @pid: the pid to map the command line to
+ *
+ * This adds a mapping to search for command line names with
+ * a given pid. The comm is duplicated.
+ */
+int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
+{
+        struct cmdline_list *item;
+
+        if (pevent->cmdlines)
+                return add_new_comm(pevent, comm, pid);
+
+        item = malloc_or_die(sizeof(*item));
+        item->comm = strdup(comm);
+        if (!item->comm)
+                die("malloc comm");
+        item->pid = pid;
+        item->next = pevent->cmdlist;
+
+        pevent->cmdlist = item;
+        pevent->cmdline_count++;
+
+        return 0;
+}
+
+struct func_map {
+        unsigned long long              addr;
+        char                            *func;
+        char                            *mod;
+};
+
+struct func_list {
+        struct func_list        *next;
+        unsigned long long      addr;
+        char                    *func;
+        char                    *mod;
+};
+
+static int func_cmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if (fa->addr < fb->addr)
+                return -1;
+        if (fa->addr > fb->addr)
+                return 1;
+
+        return 0;
+}
+
+/*
+ * We are searching for a record in between, not an exact
+ * match.
+ */
+static int func_bcmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if ((fa->addr == fb->addr) ||
+
+            (fa->addr > fb->addr &&
+             fa->addr < (fb+1)->addr))
+                return 0;
+
+        if (fa->addr < fb->addr)
+                return -1;
+
+        return 1;
+}
+
+static int func_map_init(struct pevent *pevent)
+{
+        struct func_list *funclist;
+        struct func_list *item;
+        struct func_map *func_map;
+        int i;
+
+        func_map = malloc_or_die(sizeof(*func_map) * (pevent->func_count + 1));
+        funclist = pevent->funclist;
+
+        i = 0;
+        while (funclist) {
+                func_map[i].func = funclist->func;
+                func_map[i].addr = funclist->addr;
+                func_map[i].mod = funclist->mod;
+                i++;
+                item = funclist;
+                funclist = funclist->next;
+                free(item);
+        }
+
+        qsort(func_map, pevent->func_count, sizeof(*func_map), func_cmp);
+
+        /*
+         * Add a special record at the end.
+         */
+        func_map[pevent->func_count].func = NULL;
+        func_map[pevent->func_count].addr = 0;
+        func_map[pevent->func_count].mod = NULL;
+
+        pevent->func_map = func_map;
+        pevent->funclist = NULL;
+
+        return 0;
+}
+
+static struct func_map *
+find_func(struct pevent *pevent, unsigned long long addr)
+{
+        struct func_map *func;
+        struct func_map key;
+
+        if (!pevent->func_map)
+                func_map_init(pevent);
+
+        key.addr = addr;
+
+        func = bsearch(&key, pevent->func_map, pevent->func_count,
+                       sizeof(*pevent->func_map), func_bcmp);
+
+        return func;
+}
+
+/**
+ * pevent_find_function - find a function by a given address
+ * @pevent: handle for the pevent
+ * @addr: the address to find the function with
+ *
+ * Returns a pointer to the function stored that has the given
+ * address. Note, the address does not have to be exact, it
+ * will select the function that would contain the address.
+ */
+const char *pevent_find_function(struct pevent *pevent, unsigned long long addr)
+{
+        struct func_map *map;
+
+        map = find_func(pevent, addr);
+        if (!map)
+                return NULL;
+
+        return map->func;
+}
+
+/**
+ * pevent_find_function_address - find a function address by a given address
+ * @pevent: handle for the pevent
+ * @addr: the address to find the function with
+ *
+ * Returns the address the function starts at. This can be used in
+ * conjunction with pevent_find_function to print both the function
+ * name and the function offset.
+ */
+unsigned long long
+pevent_find_function_address(struct pevent *pevent, unsigned long long addr)
+{
+        struct func_map *map;
+
+        map = find_func(pevent, addr);
+        if (!map)
+                return 0;
+
+        return map->addr;
+}
+
+/**
+ * pevent_register_function - register a function with a given address
+ * @pevent: handle for the pevent
+ * @function: the function name to register
+ * @addr: the address the function starts at
+ * @mod: the kernel module the function may be in (NULL for none)
+ *
+ * This registers a function name with an address and module.
+ * The @func passed in is duplicated.
+ */
+int pevent_register_function(struct pevent *pevent, char *func,
+                             unsigned long long addr, char *mod)
+{
+        struct func_list *item;
+
+        item = malloc_or_die(sizeof(*item));
+
+        item->next = pevent->funclist;
+        item->func = strdup(func);
+        if (mod)
+                item->mod = strdup(mod);
+        else
+                item->mod = NULL;
+        item->addr = addr;
+
+        pevent->funclist = item;
+
+        pevent->func_count++;
+
+        return 0;
+}
+
+/**
+ * pevent_print_funcs - print out the stored functions
+ * @pevent: handle for the pevent
+ *
+ * This prints out the stored functions.
+ */
+void pevent_print_funcs(struct pevent *pevent)
+{
+        int i;
+
+        if (!pevent->func_map)
+                func_map_init(pevent);
+
+        for (i = 0; i < (int)pevent->func_count; i++) {
+                printf("%016llx %s",
+                       pevent->func_map[i].addr,
+                       pevent->func_map[i].func);
+                if (pevent->func_map[i].mod)
+                        printf(" [%s]\n", pevent->func_map[i].mod);
+                else
+                        printf("\n");
+        }
+}
+
+struct printk_map {
+        unsigned long long              addr;
+        char                            *printk;
+};
+
+struct printk_list {
+        struct printk_list      *next;
+        unsigned long long      addr;
+        char                    *printk;
+};
+
+static int printk_cmp(const void *a, const void *b)
+{
+        const struct func_map *fa = a;
+        const struct func_map *fb = b;
+
+        if (fa->addr < fb->addr)
+                return -1;
+        if (fa->addr > fb->addr)
+                return 1;
+
+        return 0;
+}
+
+static void printk_map_init(struct pevent *pevent)
+{
+        struct printk_list *printklist;
+        struct printk_list *item;
+        struct printk_map *printk_map;
+        int i;
+
+        printk_map = malloc_or_die(sizeof(*printk_map) * (pevent->printk_count + 1));
+
+        printklist = pevent->printklist;
+
+        i = 0;
+        while (printklist) {
+                printk_map[i].printk = printklist->printk;
+                printk_map[i].addr = printklist->addr;
+                i++;
+                item = printklist;
+                printklist = printklist->next;
+                free(item);
+        }
+
+        qsort(printk_map, pevent->printk_count, sizeof(*printk_map), printk_cmp);
+
+        pevent->printk_map = printk_map;
+        pevent->printklist = NULL;
+}
+
+static struct printk_map *
+find_printk(struct pevent *pevent, unsigned long long addr)
+{
+        struct printk_map *printk;
+        struct printk_map key;
+
+        if (!pevent->printk_map)
+                printk_map_init(pevent);
+
+        key.addr = addr;
+
+        printk = bsearch(&key, pevent->printk_map, pevent->printk_count,
+                         sizeof(*pevent->printk_map), printk_cmp);
+
+        return printk;
+}
+
+/**
+ * pevent_register_print_string - register a string by its address
+ * @pevent: handle for the pevent
+ * @fmt: the string format to register
+ * @addr: the address the string was located at
+ *
+ * This registers a string by the address it was stored in the kernel.
+ * The @fmt passed in is duplicated.
+ */
+int pevent_register_print_string(struct pevent *pevent, char *fmt,
+                                 unsigned long long addr)
+{
+        struct printk_list *item;
+
+        item = malloc_or_die(sizeof(*item));
+
+        item->next = pevent->printklist;
+        pevent->printklist = item;
+        item->printk = strdup(fmt);
+        item->addr = addr;
+
+        pevent->printk_count++;
+
+        return 0;
+}
+
+/**
+ * pevent_print_printk - print out the stored strings
+ * @pevent: handle for the pevent
+ *
+ * This prints the string formats that were stored.
+ */
+void pevent_print_printk(struct pevent *pevent)
+{
+        int i;
+
+        if (!pevent->printk_map)
+                printk_map_init(pevent);
+
+        for (i = 0; i < (int)pevent->printk_count; i++) {
+                printf("%016llx %s\n",
+                       pevent->printk_map[i].addr,
+                       pevent->printk_map[i].printk);
+        }
+}
+
+static struct event_format *alloc_event(void)
+{
+        struct event_format *event;
+
+        event = malloc_or_die(sizeof(*event));
+        memset(event, 0, sizeof(*event));
+
+        return event;
+}
+
+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));
+        if (!pevent->events)
+                die("Can not allocate events");
+
+        for (i = 0; i < pevent->nr_events; i++) {
+                if (pevent->events[i]->id > event->id)
+                        break;
+        }
+        if (i < pevent->nr_events)
+                memmove(&pevent->events[i + 1],
+                        &pevent->events[i],
+                        sizeof(event) * (pevent->nr_events - i));
+
+        pevent->events[i] = event;
+        pevent->nr_events++;
+
+        event->pevent = pevent;
+}
+
+static int event_item_type(enum event_type type)
+{
+        switch (type) {
+        case EVENT_ITEM ... EVENT_SQUOTE:
+                return 1;
+        case EVENT_ERROR ... EVENT_DELIM:
+        default:
+                return 0;
+        }
+}
+
+static void free_flag_sym(struct print_flag_sym *fsym)
+{
+        struct print_flag_sym *next;
+
+        while (fsym) {
+                next = fsym->next;
+                free(fsym->value);
+                free(fsym->str);
+                free(fsym);
+                fsym = next;
+        }
+}
+
+static void free_arg(struct print_arg *arg)
+{
+        struct print_arg *farg;
+
+        if (!arg)
+                return;
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                free(arg->atom.atom);
+                break;
+        case PRINT_FIELD:
+                free(arg->field.name);
+                break;
+        case PRINT_FLAGS:
+                free_arg(arg->flags.field);
+                free(arg->flags.delim);
+                free_flag_sym(arg->flags.flags);
+                break;
+        case PRINT_SYMBOL:
+                free_arg(arg->symbol.field);
+                free_flag_sym(arg->symbol.symbols);
+                break;
+        case PRINT_TYPE:
+                free(arg->typecast.type);
+                free_arg(arg->typecast.item);
+                break;
+        case PRINT_STRING:
+        case PRINT_BSTRING:
+                free(arg->string.string);
+                break;
+        case PRINT_DYNAMIC_ARRAY:
+                free(arg->dynarray.index);
+                break;
+        case PRINT_OP:
+                free(arg->op.op);
+                free_arg(arg->op.left);
+                free_arg(arg->op.right);
+                break;
+        case PRINT_FUNC:
+                while (arg->func.args) {
+                        farg = arg->func.args;
+                        arg->func.args = farg->next;
+                        free_arg(farg);
+                }
+                break;
+
+        case PRINT_NULL:
+        default:
+                break;
+        }
+
+        free(arg);
+}
+
+static enum event_type get_type(int ch)
+{
+        if (ch == '\n')
+                return EVENT_NEWLINE;
+        if (isspace(ch))
+                return EVENT_SPACE;
+        if (isalnum(ch) || ch == '_')
+                return EVENT_ITEM;
+        if (ch == '\'')
+                return EVENT_SQUOTE;
+        if (ch == '"')
+                return EVENT_DQUOTE;
+        if (!isprint(ch))
+                return EVENT_NONE;
+        if (ch == '(' || ch == ')' || ch == ',')
+                return EVENT_DELIM;
+
+        return EVENT_OP;
+}
+
+static int __read_char(void)
+{
+        if (input_buf_ptr >= input_buf_siz)
+                return -1;
+
+        return input_buf[input_buf_ptr++];
+}
+
+static int __peek_char(void)
+{
+        if (input_buf_ptr >= input_buf_siz)
+                return -1;
+
+        return input_buf[input_buf_ptr];
+}
+
+/**
+ * pevent_peek_char - peek at the next character that will be read
+ *
+ * Returns the next character read, or -1 if end of buffer.
+ */
+int pevent_peek_char(void)
+{
+        return __peek_char();
+}
+
+static enum event_type force_token(const char *str, char **tok);
+
+static enum event_type __read_token(char **tok)
+{
+        char buf[BUFSIZ];
+        int ch, last_ch, quote_ch, next_ch;
+        int i = 0;
+        int tok_size = 0;
+        enum event_type type;
+
+        *tok = NULL;
+
+
+        ch = __read_char();
+        if (ch < 0)
+                return EVENT_NONE;
+
+        type = get_type(ch);
+        if (type == EVENT_NONE)
+                return type;
+
+        buf[i++] = ch;
+
+        switch (type) {
+        case EVENT_NEWLINE:
+        case EVENT_DELIM:
+                *tok = malloc_or_die(2);
+                (*tok)[0] = ch;
+                (*tok)[1] = 0;
+                return type;
+
+        case EVENT_OP:
+                switch (ch) {
+                case '-':
+                        next_ch = __peek_char();
+                        if (next_ch == '>') {
+                                buf[i++] = __read_char();
+                                break;
+                        }
+                        /* fall through */
+                case '+':
+                case '|':
+                case '&':
+                case '>':
+                case '<':
+                        last_ch = ch;
+                        ch = __peek_char();
+                        if (ch != last_ch)
+                                goto test_equal;
+                        buf[i++] = __read_char();
+                        switch (last_ch) {
+                        case '>':
+                        case '<':
+                                goto test_equal;
+                        default:
+                                break;
+                        }
+                        break;
+                case '!':
+                case '=':
+                        goto test_equal;
+                default: /* what should we do instead? */
+                        break;
+                }
+                buf[i] = 0;
+                *tok = strdup(buf);
+                return type;
+
+ test_equal:
+                ch = __peek_char();
+                if (ch == '=')
+                        buf[i++] = __read_char();
+                goto out;
+
+        case EVENT_DQUOTE:
+        case EVENT_SQUOTE:
+                /* don't keep quotes */
+                i--;
+                quote_ch = ch;
+                last_ch = 0;
+ concat:
+                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);
+
+                                if (!*tok)
+                                        return EVENT_NONE;
+                                tok_size += BUFSIZ;
+                                i = 0;
+                        }
+                        last_ch = ch;
+                        ch = __read_char();
+                        buf[i++] = ch;
+                        /* the '\' '\' will cancel itself */
+                        if (ch == '\\' && last_ch == '\\')
+                                last_ch = 0;
+                } while (ch != quote_ch || last_ch == '\\');
+                /* remove the last quote */
+                i--;
+
+                /*
+                 * For strings (double quotes) check the next token.
+                 * If it is another string, concatinate the two.
+                 */
+                if (type == EVENT_DQUOTE) {
+                        unsigned long long save_input_buf_ptr = input_buf_ptr;
+
+                        do {
+                                ch = __read_char();
+                        } while (isspace(ch));
+                        if (ch == '"')
+                                goto concat;
+                        input_buf_ptr = save_input_buf_ptr;
+                }
+
+                goto out;
+
+        case EVENT_ERROR ... EVENT_SPACE:
+        case EVENT_ITEM:
+        default:
+                break;
+        }
+
+        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);
+
+                        if (!*tok)
+                                return EVENT_NONE;
+                        tok_size += BUFSIZ;
+                        i = 0;
+                }
+                ch = __read_char();
+                buf[i++] = ch;
+        }
+
+ 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)
+                return EVENT_NONE;
+
+        if (type == EVENT_ITEM) {
+                /*
+                 * Older versions of the kernel has a bug that
+                 * creates invalid symbols and will break the mac80211
+                 * parsing. This is a work around to that bug.
+                 *
+                 * See Linux kernel commit:
+                 *  811cb50baf63461ce0bdb234927046131fc7fa8b
+                 */
+                if (strcmp(*tok, "LOCAL_PR_FMT") == 0) {
+                        free(*tok);
+                        *tok = NULL;
+                        return force_token("\"\%s\" ", tok);
+                } else if (strcmp(*tok, "STA_PR_FMT") == 0) {
+                        free(*tok);
+                        *tok = NULL;
+                        return force_token("\" sta:%pM\" ", tok);
+                } else if (strcmp(*tok, "VIF_PR_FMT") == 0) {
+                        free(*tok);
+                        *tok = NULL;
+                        return force_token("\" vif:%p(%d)\" ", tok);
+                }
+        }
+
+        return type;
+}
+
+static enum event_type force_token(const char *str, char **tok)
+{
+        const char *save_input_buf;
+        unsigned long long save_input_buf_ptr;
+        unsigned long long save_input_buf_siz;
+        enum event_type type;
+        
+        /* save off the current input pointers */
+        save_input_buf = input_buf;
+        save_input_buf_ptr = input_buf_ptr;
+        save_input_buf_siz = input_buf_siz;
+
+        init_input_buf(str, strlen(str));
+
+        type = __read_token(tok);
+
+        /* reset back to original token */
+        input_buf = save_input_buf;
+        input_buf_ptr = save_input_buf_ptr;
+        input_buf_siz = save_input_buf_siz;
+
+        return type;
+}
+
+static void free_token(char *tok)
+{
+        if (tok)
+                free(tok);
+}
+
+static enum event_type read_token(char **tok)
+{
+        enum event_type type;
+
+        for (;;) {
+                type = __read_token(tok);
+                if (type != EVENT_SPACE)
+                        return type;
+
+                free_token(*tok);
+        }
+
+        /* not reached */
+        *tok = NULL;
+        return EVENT_NONE;
+}
+
+/**
+ * pevent_read_token - access to utilites to use the pevent parser
+ * @tok: The token to return
+ *
+ * This will parse tokens from the string given by
+ * pevent_init_data().
+ *
+ * Returns the token type.
+ */
+enum event_type pevent_read_token(char **tok)
+{
+        return read_token(tok);
+}
+
+/**
+ * pevent_free_token - free a token returned by pevent_read_token
+ * @token: the token to free
+ */
+void pevent_free_token(char *token)
+{
+        free_token(token);
+}
+
+/* no newline */
+static enum event_type read_token_item(char **tok)
+{
+        enum event_type type;
+
+        for (;;) {
+                type = __read_token(tok);
+                if (type != EVENT_SPACE && type != EVENT_NEWLINE)
+                        return type;
+                free_token(*tok);
+                *tok = NULL;
+        }
+
+        /* not reached */
+        *tok = NULL;
+        return EVENT_NONE;
+}
+
+static int test_type(enum event_type type, enum event_type expect)
+{
+        if (type != expect) {
+                do_warning("Error: expected type %d but read %d",
+                    expect, type);
+                return -1;
+        }
+        return 0;
+}
+
+static int test_type_token(enum event_type type, const char *token,
+                    enum event_type expect, const char *expect_tok)
+{
+        if (type != expect) {
+                do_warning("Error: expected type %d but read %d",
+                    expect, type);
+                return -1;
+        }
+
+        if (strcmp(token, expect_tok) != 0) {
+                do_warning("Error: expected '%s' but read '%s'",
+                    expect_tok, token);
+                return -1;
+        }
+        return 0;
+}
+
+static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
+{
+        enum event_type type;
+
+        if (newline_ok)
+                type = read_token(tok);
+        else
+                type = read_token_item(tok);
+        return test_type(type, expect);
+}
+
+static int read_expect_type(enum event_type expect, char **tok)
+{
+        return __read_expect_type(expect, tok, 1);
+}
+
+static int __read_expected(enum event_type expect, const char *str,
+                           int newline_ok)
+{
+        enum event_type type;
+        char *token;
+        int ret;
+
+        if (newline_ok)
+                type = read_token(&token);
+        else
+                type = read_token_item(&token);
+
+        ret = test_type_token(type, token, expect, str);
+
+        free_token(token);
+
+        return ret;
+}
+
+static int read_expected(enum event_type expect, const char *str)
+{
+        return __read_expected(expect, str, 1);
+}
+
+static int read_expected_item(enum event_type expect, const char *str)
+{
+        return __read_expected(expect, str, 0);
+}
+
+static char *event_read_name(void)
+{
+        char *token;
+
+        if (read_expected(EVENT_ITEM, "name") < 0)
+                return NULL;
+
+        if (read_expected(EVENT_OP, ":") < 0)
+                return NULL;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+
+        return token;
+
+ fail:
+        free_token(token);
+        return NULL;
+}
+
+static int event_read_id(void)
+{
+        char *token;
+        int id;
+
+        if (read_expected_item(EVENT_ITEM, "ID") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, ":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+
+        id = strtoul(token, NULL, 0);
+        free_token(token);
+        return id;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+static int field_is_string(struct format_field *field)
+{
+        if ((field->flags & FIELD_IS_ARRAY) &&
+            (strstr(field->type, "char") || strstr(field->type, "u8") ||
+             strstr(field->type, "s8")))
+                return 1;
+
+        return 0;
+}
+
+static int field_is_dynamic(struct format_field *field)
+{
+        if (strncmp(field->type, "__data_loc", 10) == 0)
+                return 1;
+
+        return 0;
+}
+
+static int field_is_long(struct format_field *field)
+{
+        /* includes long long */
+        if (strstr(field->type, "long"))
+                return 1;
+
+        return 0;
+}
+
+static int event_read_fields(struct event_format *event, struct format_field **fields)
+{
+        struct format_field *field = NULL;
+        enum event_type type;
+        char *token;
+        char *last_token;
+        int count = 0;
+
+        do {
+                type = read_token(&token);
+                if (type == EVENT_NEWLINE) {
+                        free_token(token);
+                        return count;
+                }
+
+                count++;
+
+                if (test_type_token(type, token, EVENT_ITEM, "field"))
+                        goto fail;
+                free_token(token);
+
+                type = read_token(&token);
+                /*
+                 * The ftrace fields may still use the "special" name.
+                 * Just ignore it.
+                 */
+                if (event->flags & EVENT_FL_ISFTRACE &&
+                    type == EVENT_ITEM && strcmp(token, "special") == 0) {
+                        free_token(token);
+                        type = read_token(&token);
+                }
+
+                if (test_type_token(type, token, EVENT_OP, ":") < 0)
+                        goto fail;
+
+                free_token(token);
+                if (read_expect_type(EVENT_ITEM, &token) < 0)
+                        goto fail;
+
+                last_token = token;
+
+                field = malloc_or_die(sizeof(*field));
+                memset(field, 0, sizeof(*field));
+                field->event = event;
+
+                /* read the rest of the type */
+                for (;;) {
+                        type = read_token(&token);
+                        if (type == EVENT_ITEM ||
+                            (type == EVENT_OP && strcmp(token, "*") == 0) ||
+                            /*
+                             * Some of the ftrace fields are broken and have
+                             * an illegal "." in them.
+                             */
+                            (event->flags & EVENT_FL_ISFTRACE &&
+                             type == EVENT_OP && strcmp(token, ".") == 0)) {
+
+                                if (strcmp(token, "*") == 0)
+                                        field->flags |= FIELD_IS_POINTER;
+
+                                if (field->type) {
+                                        field->type = realloc(field->type,
+                                                              strlen(field->type) +
+                                                              strlen(last_token) + 2);
+                                        strcat(field->type, " ");
+                                        strcat(field->type, last_token);
+                                        free(last_token);
+                                } else
+                                        field->type = last_token;
+                                last_token = token;
+                                continue;
+                        }
+
+                        break;
+                }
+
+                if (!field->type) {
+                        die("no type found");
+                        goto fail;
+                }
+                field->name = last_token;
+
+                if (test_type(type, EVENT_OP))
+                        goto fail;
+
+                if (strcmp(token, "[") == 0) {
+                        enum event_type last_type = type;
+                        char *brackets = token;
+                        int len;
+
+                        field->flags |= FIELD_IS_ARRAY;
+
+                        type = read_token(&token);
+
+                        if (type == EVENT_ITEM)
+                                field->arraylen = strtoul(token, NULL, 0);
+                        else
+                                field->arraylen = 0;
+
+                        while (strcmp(token, "]") != 0) {
+                                if (last_type == EVENT_ITEM &&
+                                    type == EVENT_ITEM)
+                                        len = 2;
+                                else
+                                        len = 1;
+                                last_type = type;
+
+                                brackets = realloc(brackets,
+                                                   strlen(brackets) +
+                                                   strlen(token) + len);
+                                if (len == 2)
+                                        strcat(brackets, " ");
+                                strcat(brackets, token);
+                                /* We only care about the last token */
+                                field->arraylen = strtoul(token, NULL, 0);
+                                free_token(token);
+                                type = read_token(&token);
+                                if (type == EVENT_NONE) {
+                                        die("failed to find token");
+                                        goto fail;
+                                }
+                        }
+
+                        free_token(token);
+
+                        brackets = realloc(brackets, strlen(brackets) + 2);
+                        strcat(brackets, "]");
+
+                        /* add brackets to type */
+
+                        type = read_token(&token);
+                        /*
+                         * If the next token is not an OP, then it is of
+                         * the format: type [] item;
+                         */
+                        if (type == EVENT_ITEM) {
+                                field->type = realloc(field->type,
+                                                      strlen(field->type) +
+                                                      strlen(field->name) +
+                                                      strlen(brackets) + 2);
+                                strcat(field->type, " ");
+                                strcat(field->type, field->name);
+                                free_token(field->name);
+                                strcat(field->type, brackets);
+                                field->name = token;
+                                type = read_token(&token);
+                        } else {
+                                field->type = realloc(field->type,
+                                                      strlen(field->type) +
+                                                      strlen(brackets) + 1);
+                                strcat(field->type, brackets);
+                        }
+                        free(brackets);
+                }
+
+                if (field_is_string(field))
+                        field->flags |= FIELD_IS_STRING;
+                if (field_is_dynamic(field))
+                        field->flags |= FIELD_IS_DYNAMIC;
+                if (field_is_long(field))
+                        field->flags |= FIELD_IS_LONG;
+
+                if (test_type_token(type, token,  EVENT_OP, ";"))
+                        goto fail;
+                free_token(token);
+
+                if (read_expected(EVENT_ITEM, "offset") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_OP, ":") < 0)
+                        goto fail_expect;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+                field->offset = strtoul(token, NULL, 0);
+                free_token(token);
+
+                if (read_expected(EVENT_OP, ";") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_ITEM, "size") < 0)
+                        goto fail_expect;
+
+                if (read_expected(EVENT_OP, ":") < 0)
+                        goto fail_expect;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+                field->size = strtoul(token, NULL, 0);
+                free_token(token);
+
+                if (read_expected(EVENT_OP, ";") < 0)
+                        goto fail_expect;
+
+                type = read_token(&token);
+                if (type != EVENT_NEWLINE) {
+                        /* newer versions of the kernel have a "signed" type */
+                        if (test_type_token(type, token, EVENT_ITEM, "signed"))
+                                goto fail;
+
+                        free_token(token);
+
+                        if (read_expected(EVENT_OP, ":") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_ITEM, &token))
+                                goto fail;
+
+                        /* add signed type */
+
+                        free_token(token);
+                        if (read_expected(EVENT_OP, ";") < 0)
+                                goto fail_expect;
+
+                        if (read_expect_type(EVENT_NEWLINE, &token))
+                                goto fail;
+                }
+
+                free_token(token);
+
+                if (field->flags & FIELD_IS_ARRAY) {
+                        if (field->arraylen)
+                                field->elementsize = field->size / field->arraylen;
+                        else if (field->flags & FIELD_IS_STRING)
+                                field->elementsize = 1;
+                        else
+                                field->elementsize = event->pevent->long_size;
+                } else
+                        field->elementsize = field->size;
+
+                *fields = field;
+                fields = &field->next;
+
+        } while (1);
+
+        return 0;
+
+fail:
+        free_token(token);
+fail_expect:
+        if (field) {
+                free(field->type);
+                free(field->name);
+                free(field);
+        }
+        return -1;
+}
+
+static int event_read_format(struct event_format *event)
+{
+        char *token;
+        int ret;
+
+        if (read_expected_item(EVENT_ITEM, "format") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, ":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_NEWLINE, &token))
+                goto fail;
+        free_token(token);
+
+        ret = event_read_fields(event, &event->format.common_fields);
+        if (ret < 0)
+                return ret;
+        event->format.nr_common = ret;
+
+        ret = event_read_fields(event, &event->format.fields);
+        if (ret < 0)
+                return ret;
+        event->format.nr_fields = ret;
+
+        return 0;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+static enum event_type
+process_arg_token(struct event_format *event, struct print_arg *arg,
+                  char **tok, enum event_type type);
+
+static enum event_type
+process_arg(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        enum event_type type;
+        char *token;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return process_arg_token(event, arg, tok, type);
+}
+
+static enum event_type
+process_op(struct event_format *event, struct print_arg *arg, char **tok);
+
+static enum event_type
+process_cond(struct event_format *event, struct print_arg *top, char **tok)
+{
+        struct print_arg *arg, *left, *right;
+        enum event_type type;
+        char *token = NULL;
+
+        arg = alloc_arg();
+        left = alloc_arg();
+        right = alloc_arg();
+
+        arg->type = PRINT_OP;
+        arg->op.left = left;
+        arg->op.right = right;
+
+        *tok = NULL;
+        type = process_arg(event, left, &token);
+
+ again:
+        /* Handle other operations in the arguments */
+        if (type == EVENT_OP && strcmp(token, ":") != 0) {
+                type = process_op(event, left, &token);
+                goto again;
+        }
+
+        if (test_type_token(type, token, EVENT_OP, ":"))
+                goto out_free;
+
+        arg->op.op = token;
+
+        type = process_arg(event, right, &token);
+
+        top->op.right = arg;
+
+        *tok = token;
+        return type;
+
+out_free:
+        /* Top may point to itself */
+        top->op.right = NULL;
+        free_token(token);
+        free_arg(arg);
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_array(struct event_format *event, struct print_arg *top, char **tok)
+{
+        struct print_arg *arg;
+        enum event_type type;
+        char *token = NULL;
+
+        arg = alloc_arg();
+
+        *tok = NULL;
+        type = process_arg(event, arg, &token);
+        if (test_type_token(type, token, EVENT_OP, "]"))
+                goto out_free;
+
+        top->op.right = arg;
+
+        free_token(token);
+        type = read_token_item(&token);
+        *tok = token;
+
+        return type;
+
+out_free:
+        free_token(*tok);
+        *tok = NULL;
+        free_arg(arg);
+        return EVENT_ERROR;
+}
+
+static int get_op_prio(char *op)
+{
+        if (!op[1]) {
+                switch (op[0]) {
+                case '~':
+                case '!':
+                        return 4;
+                case '*':
+                case '/':
+                case '%':
+                        return 6;
+                case '+':
+                case '-':
+                        return 7;
+                        /* '>>' and '<<' are 8 */
+                case '<':
+                case '>':
+                        return 9;
+                        /* '==' and '!=' are 10 */
+                case '&':
+                        return 11;
+                case '^':
+                        return 12;
+                case '|':
+                        return 13;
+                case '?':
+                        return 16;
+                default:
+                        do_warning("unknown op '%c'", op[0]);
+                        return -1;
+                }
+        } else {
+                if (strcmp(op, "++") == 0 ||
+                    strcmp(op, "--") == 0) {
+                        return 3;
+                } else if (strcmp(op, ">>") == 0 ||
+                           strcmp(op, "<<") == 0) {
+                        return 8;
+                } else if (strcmp(op, ">=") == 0 ||
+                           strcmp(op, "<=") == 0) {
+                        return 9;
+                } else if (strcmp(op, "==") == 0 ||
+                           strcmp(op, "!=") == 0) {
+                        return 10;
+                } else if (strcmp(op, "&&") == 0) {
+                        return 14;
+                } else if (strcmp(op, "||") == 0) {
+                        return 15;
+                } else {
+                        do_warning("unknown op '%s'", op);
+                        return -1;
+                }
+        }
+}
+
+static int set_op_prio(struct print_arg *arg)
+{
+
+        /* single ops are the greatest */
+        if (!arg->op.left || arg->op.left->type == PRINT_NULL)
+                arg->op.prio = 0;
+        else
+                arg->op.prio = get_op_prio(arg->op.op);
+
+        return arg->op.prio;
+}
+
+/* Note, *tok does not get freed, but will most likely be saved */
+static enum event_type
+process_op(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *left, *right = NULL;
+        enum event_type type;
+        char *token;
+
+        /* the op is passed in via tok */
+        token = *tok;
+
+        if (arg->type == PRINT_OP && !arg->op.left) {
+                /* handle single op */
+                if (token[1]) {
+                        die("bad op token %s", token);
+                        goto out_free;
+                }
+                switch (token[0]) {
+                case '~':
+                case '!':
+                case '+':
+                case '-':
+                        break;
+                default:
+                        do_warning("bad op token %s", token);
+                        goto out_free;
+
+                }
+
+                /* make an empty left */
+                left = alloc_arg();
+                left->type = PRINT_NULL;
+                arg->op.left = left;
+
+                right = alloc_arg();
+                arg->op.right = right;
+
+                /* do not free the token, it belongs to an op */
+                *tok = NULL;
+                type = process_arg(event, right, tok);
+
+        } else if (strcmp(token, "?") == 0) {
+
+                left = alloc_arg();
+                /* copy the top arg to the left */
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+                arg->op.prio = 0;
+
+                type = process_cond(event, arg, tok);
+
+        } else if (strcmp(token, ">>") == 0 ||
+                   strcmp(token, "<<") == 0 ||
+                   strcmp(token, "&") == 0 ||
+                   strcmp(token, "|") == 0 ||
+                   strcmp(token, "&&") == 0 ||
+                   strcmp(token, "||") == 0 ||
+                   strcmp(token, "-") == 0 ||
+                   strcmp(token, "+") == 0 ||
+                   strcmp(token, "*") == 0 ||
+                   strcmp(token, "^") == 0 ||
+                   strcmp(token, "/") == 0 ||
+                   strcmp(token, "<") == 0 ||
+                   strcmp(token, ">") == 0 ||
+                   strcmp(token, "==") == 0 ||
+                   strcmp(token, "!=") == 0) {
+
+                left = alloc_arg();
+
+                /* copy the top arg to the left */
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+
+                if (set_op_prio(arg) == -1) {
+                        event->flags |= EVENT_FL_FAILED;
+                        /* arg->op.op (= token) will be freed at out_free */
+                        arg->op.op = NULL;
+                        goto out_free;
+                }
+
+                type = read_token_item(&token);
+                *tok = token;
+
+                /* could just be a type pointer */
+                if ((strcmp(arg->op.op, "*") == 0) &&
+                    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
+                        if (left->type != PRINT_ATOM)
+                                die("bad pointer type");
+                        left->atom.atom = realloc(left->atom.atom,
+                                            strlen(left->atom.atom) + 3);
+                        strcat(left->atom.atom, " *");
+                        free(arg->op.op);
+                        *arg = *left;
+                        free(left);
+
+                        return type;
+                }
+
+                right = alloc_arg();
+                type = process_arg_token(event, right, tok, type);
+                arg->op.right = right;
+
+        } else if (strcmp(token, "[") == 0) {
+
+                left = alloc_arg();
+                *left = *arg;
+
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = left;
+
+                arg->op.prio = 0;
+
+                type = process_array(event, arg, tok);
+
+        } else {
+                do_warning("unknown op '%s'", token);
+                event->flags |= EVENT_FL_FAILED;
+                /* the arg is now the left side */
+                goto out_free;
+        }
+
+        if (type == EVENT_OP && strcmp(*tok, ":") != 0) {
+                int prio;
+
+                /* higher prios need to be closer to the root */
+                prio = get_op_prio(*tok);
+
+                if (prio > arg->op.prio)
+                        return process_op(event, arg, tok);
+
+                return process_op(event, right, tok);
+        }
+
+        return type;
+
+ out_free:
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_entry(struct event_format *event __unused, struct print_arg *arg,
+              char **tok)
+{
+        enum event_type type;
+        char *field;
+        char *token;
+
+        if (read_expected(EVENT_OP, "->") < 0)
+                goto out_err;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto out_free;
+        field = token;
+
+        arg->type = PRINT_FIELD;
+        arg->field.name = field;
+
+        if (is_flag_field) {
+                arg->field.field = pevent_find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_FLAG;
+                is_flag_field = 0;
+        } else if (is_symbolic_field) {
+                arg->field.field = pevent_find_any_field(event, arg->field.name);
+                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
+                is_symbolic_field = 0;
+        }
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+
+ out_free:
+        free_token(token);
+ out_err:
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static char *arg_eval (struct print_arg *arg);
+
+static unsigned long long
+eval_type_str(unsigned long long val, const char *type, int pointer)
+{
+        int sign = 0;
+        char *ref;
+        int len;
+
+        len = strlen(type);
+
+        if (pointer) {
+
+                if (type[len-1] != '*') {
+                        do_warning("pointer expected with non pointer type");
+                        return val;
+                }
+
+                ref = malloc_or_die(len);
+                memcpy(ref, type, len);
+
+                /* chop off the " *" */
+                ref[len - 2] = 0;
+
+                val = eval_type_str(val, ref, 0);
+                free(ref);
+                return val;
+        }
+
+        /* check if this is a pointer */
+        if (type[len - 1] == '*')
+                return val;
+
+        /* Try to figure out the arg size*/
+        if (strncmp(type, "struct", 6) == 0)
+                /* all bets off */
+                return val;
+
+        if (strcmp(type, "u8") == 0)
+                return val & 0xff;
+
+        if (strcmp(type, "u16") == 0)
+                return val & 0xffff;
+
+        if (strcmp(type, "u32") == 0)
+                return val & 0xffffffff;
+
+        if (strcmp(type, "u64") == 0 ||
+            strcmp(type, "s64"))
+                return val;
+
+        if (strcmp(type, "s8") == 0)
+                return (unsigned long long)(char)val & 0xff;
+
+        if (strcmp(type, "s16") == 0)
+                return (unsigned long long)(short)val & 0xffff;
+
+        if (strcmp(type, "s32") == 0)
+                return (unsigned long long)(int)val & 0xffffffff;
+
+        if (strncmp(type, "unsigned ", 9) == 0) {
+                sign = 0;
+                type += 9;
+        }
+
+        if (strcmp(type, "char") == 0) {
+                if (sign)
+                        return (unsigned long long)(char)val & 0xff;
+                else
+                        return val & 0xff;
+        }
+
+        if (strcmp(type, "short") == 0) {
+                if (sign)
+                        return (unsigned long long)(short)val & 0xffff;
+                else
+                        return val & 0xffff;
+        }
+
+        if (strcmp(type, "int") == 0) {
+                if (sign)
+                        return (unsigned long long)(int)val & 0xffffffff;
+                else
+                        return val & 0xffffffff;
+        }
+
+        return val;
+}
+
+/*
+ * Try to figure out the type.
+ */
+static unsigned long long
+eval_type(unsigned long long val, struct print_arg *arg, int pointer)
+{
+        if (arg->type != PRINT_TYPE)
+                die("expected type argument");
+
+        return eval_type_str(val, arg->typecast.type, pointer);
+}
+
+static int arg_num_eval(struct print_arg *arg, long long *val)
+{
+        long long left, right;
+        int ret = 1;
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                *val = strtoll(arg->atom.atom, NULL, 0);
+                break;
+        case PRINT_TYPE:
+                ret = arg_num_eval(arg->typecast.item, val);
+                if (!ret)
+                        break;
+                *val = eval_type(*val, arg, 0);
+                break;
+        case PRINT_OP:
+                switch (arg->op.op[0]) {
+                case '|':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        if (arg->op.op[1])
+                                *val = left || right;
+                        else
+                                *val = left | right;
+                        break;
+                case '&':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        if (arg->op.op[1])
+                                *val = left && right;
+                        else
+                                *val = left & right;
+                        break;
+                case '<':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                *val = left < right;
+                                break;
+                        case '<':
+                                *val = left << right;
+                                break;
+                        case '=':
+                                *val = left <= right;
+                                break;
+                        default:
+                                do_warning("unknown op '%s'", arg->op.op);
+                                ret = 0;
+                        }
+                        break;
+                case '>':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                *val = left > right;
+                                break;
+                        case '>':
+                                *val = left >> right;
+                                break;
+                        case '=':
+                                *val = left >= right;
+                                break;
+                        default:
+                                do_warning("unknown op '%s'", arg->op.op);
+                                ret = 0;
+                        }
+                        break;
+                case '=':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+
+                        if (arg->op.op[1] != '=') {
+                                do_warning("unknown op '%s'", arg->op.op);
+                                ret = 0;
+                        } else
+                                *val = left == right;
+                        break;
+                case '!':
+                        ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+
+                        switch (arg->op.op[1]) {
+                        case '=':
+                                *val = left != right;
+                                break;
+                        default:
+                                do_warning("unknown op '%s'", arg->op.op);
+                                ret = 0;
+                        }
+                        break;
+                case '-':
+                        /* check for negative */
+                        if (arg->op.left->type == PRINT_NULL)
+                                left = 0;
+                        else
+                                ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        *val = left - right;
+                        break;
+                case '+':
+                        if (arg->op.left->type == PRINT_NULL)
+                                left = 0;
+                        else
+                                ret = arg_num_eval(arg->op.left, &left);
+                        if (!ret)
+                                break;
+                        ret = arg_num_eval(arg->op.right, &right);
+                        if (!ret)
+                                break;
+                        *val = left + right;
+                        break;
+                default:
+                        do_warning("unknown op '%s'", arg->op.op);
+                        ret = 0;
+                }
+                break;
+
+        case PRINT_NULL:
+        case PRINT_FIELD ... PRINT_SYMBOL:
+        case PRINT_STRING:
+        case PRINT_BSTRING:
+        default:
+                do_warning("invalid eval type %d", arg->type);
+                ret = 0;
+
+        }
+        return ret;
+}
+
+static char *arg_eval (struct print_arg *arg)
+{
+        long long val;
+        static char buf[20];
+
+        switch (arg->type) {
+        case PRINT_ATOM:
+                return arg->atom.atom;
+        case PRINT_TYPE:
+                return arg_eval(arg->typecast.item);
+        case PRINT_OP:
+                if (!arg_num_eval(arg, &val))
+                        break;
+                sprintf(buf, "%lld", val);
+                return buf;
+
+        case PRINT_NULL:
+        case PRINT_FIELD ... PRINT_SYMBOL:
+        case PRINT_STRING:
+        case PRINT_BSTRING:
+        default:
+                die("invalid eval type %d", arg->type);
+                break;
+        }
+
+        return NULL;
+}
+
+static enum event_type
+process_fields(struct event_format *event, struct print_flag_sym **list, char **tok)
+{
+        enum event_type type;
+        struct print_arg *arg = NULL;
+        struct print_flag_sym *field;
+        char *token = *tok;
+        char *value;
+
+        do {
+                free_token(token);
+                type = read_token_item(&token);
+                if (test_type_token(type, token, EVENT_OP, "{"))
+                        break;
+
+                arg = alloc_arg();
+
+                free_token(token);
+                type = process_arg(event, arg, &token);
+
+                if (type == EVENT_OP)
+                        type = process_op(event, arg, &token);
+
+                if (type == EVENT_ERROR)
+                        goto out_free;
+
+                if (test_type_token(type, token, EVENT_DELIM, ","))
+                        goto out_free;
+
+                field = malloc_or_die(sizeof(*field));
+                memset(field, 0, sizeof(*field));
+
+                value = arg_eval(arg);
+                if (value == NULL)
+                        goto out_free;
+                field->value = strdup(value);
+
+                free_arg(arg);
+                arg = alloc_arg();
+
+                free_token(token);
+                type = process_arg(event, arg, &token);
+                if (test_type_token(type, token, EVENT_OP, "}"))
+                        goto out_free;
+
+                value = arg_eval(arg);
+                if (value == NULL)
+                        goto out_free;
+                field->str = strdup(value);
+                free_arg(arg);
+                arg = NULL;
+
+                *list = field;
+                list = &field->next;
+
+                free_token(token);
+                type = read_token_item(&token);
+        } while (type == EVENT_DELIM && strcmp(token, ",") == 0);
+
+        *tok = token;
+        return type;
+
+out_free:
+        free_arg(arg);
+        free_token(token);
+        *tok = NULL;
+
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_flags(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_FLAGS;
+
+        field = alloc_arg();
+
+        type = process_arg(event, field, &token);
+
+        /* Handle operations in the first argument */
+        while (type == EVENT_OP)
+                type = process_op(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto out_free;
+        free_token(token);
+
+        arg->flags.field = field;
+
+        type = read_token_item(&token);
+        if (event_item_type(type)) {
+                arg->flags.delim = token;
+                type = read_token_item(&token);
+        }
+
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto out_free;
+
+        type = process_fields(event, &arg->flags.flags, &token);
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+ out_free:
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_symbols(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_SYMBOL;
+
+        field = alloc_arg();
+
+        type = process_arg(event, field, &token);
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto out_free;
+
+        arg->symbol.field = field;
+
+        type = process_fields(event, &arg->symbol.symbols, &token);
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+ out_free:
+        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;
+        enum event_type type;
+        char *token;
+
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_DYNAMIC_ARRAY;
+
+        /*
+         * The item within the parenthesis is another field that holds
+         * the index into where the array starts.
+         */
+        type = read_token(&token);
+        *tok = token;
+        if (type != EVENT_ITEM)
+                goto out_free;
+
+        /* Find the field */
+
+        field = pevent_find_field(event, token);
+        if (!field)
+                goto out_free;
+
+        arg->dynarray.field = field;
+        arg->dynarray.index = 0;
+
+        if (read_expected(EVENT_DELIM, ")") < 0)
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(&token);
+        *tok = token;
+        if (type != EVENT_OP || strcmp(token, "[") != 0)
+                return type;
+
+        free_token(token);
+        arg = alloc_arg();
+        type = process_arg(event, arg, &token);
+        if (type == EVENT_ERROR)
+                goto out_free_arg;
+
+        if (!test_type_token(type, token, EVENT_OP, "]"))
+                goto out_free_arg;
+
+        free_token(token);
+        type = read_token_item(tok);
+        return type;
+
+ out_free_arg:
+        free_arg(arg);
+ out_free:
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_paren(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        struct print_arg *item_arg;
+        enum event_type type;
+        char *token;
+
+        type = process_arg(event, arg, &token);
+
+        if (type == EVENT_ERROR)
+                goto out_free;
+
+        if (type == EVENT_OP)
+                type = process_op(event, arg, &token);
+
+        if (type == EVENT_ERROR)
+                goto out_free;
+
+        if (test_type_token(type, token, EVENT_DELIM, ")"))
+                goto out_free;
+
+        free_token(token);
+        type = read_token_item(&token);
+
+        /*
+         * If the next token is an item or another open paren, then
+         * this was a typecast.
+         */
+        if (event_item_type(type) ||
+            (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
+
+                /* make this a typecast and contine */
+
+                /* prevous must be an atom */
+                if (arg->type != PRINT_ATOM)
+                        die("previous needed to be PRINT_ATOM");
+
+                item_arg = alloc_arg();
+
+                arg->type = PRINT_TYPE;
+                arg->typecast.type = arg->atom.atom;
+                arg->typecast.item = item_arg;
+                type = process_arg_token(event, item_arg, &token, type);
+
+        }
+
+        *tok = token;
+        return type;
+
+ out_free:
+        free_token(token);
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+
+static enum event_type
+process_str(struct event_format *event __unused, struct print_arg *arg, char **tok)
+{
+        enum event_type type;
+        char *token;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto out_free;
+
+        arg->type = PRINT_STRING;
+        arg->string.string = token;
+        arg->string.offset = -1;
+
+        if (read_expected(EVENT_DELIM, ")") < 0)
+                goto out_err;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+
+ out_free:
+        free_token(token);
+ out_err:
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
+static struct pevent_function_handler *
+find_func_handler(struct pevent *pevent, char *func_name)
+{
+        struct pevent_function_handler *func;
+
+        for (func = pevent->func_handlers; func; func = func->next) {
+                if (strcmp(func->name, func_name) == 0)
+                        break;
+        }
+
+        return func;
+}
+
+static void remove_func_handler(struct pevent *pevent, char *func_name)
+{
+        struct pevent_function_handler *func;
+        struct pevent_function_handler **next;
+
+        next = &pevent->func_handlers;
+        while ((func = *next)) {
+                if (strcmp(func->name, func_name) == 0) {
+                        *next = func->next;
+                        free_func_handle(func);
+                        break;
+                }
+                next = &func->next;
+        }
+}
+
+static enum event_type
+process_func_handler(struct event_format *event, struct pevent_function_handler *func,
+                     struct print_arg *arg, char **tok)
+{
+        struct print_arg **next_arg;
+        struct print_arg *farg;
+        enum event_type type;
+        char *token;
+        char *test;
+        int i;
+
+        arg->type = PRINT_FUNC;
+        arg->func.func = func;
+
+        *tok = NULL;
+
+        next_arg = &(arg->func.args);
+        for (i = 0; i < func->nr_args; i++) {
+                farg = alloc_arg();
+                type = process_arg(event, farg, &token);
+                if (i < (func->nr_args - 1))
+                        test = ",";
+                else
+                        test = ")";
+
+                if (test_type_token(type, token, EVENT_DELIM, test)) {
+                        free_arg(farg);
+                        free_token(token);
+                        return EVENT_ERROR;
+                }
+
+                *next_arg = farg;
+                next_arg = &(farg->next);
+                free_token(token);
+        }
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+}
+
+static enum event_type
+process_function(struct event_format *event, struct print_arg *arg,
+                 char *token, char **tok)
+{
+        struct pevent_function_handler *func;
+
+        if (strcmp(token, "__print_flags") == 0) {
+                free_token(token);
+                is_flag_field = 1;
+                return process_flags(event, arg, tok);
+        }
+        if (strcmp(token, "__print_symbolic") == 0) {
+                free_token(token);
+                is_symbolic_field = 1;
+                return process_symbols(event, arg, tok);
+        }
+        if (strcmp(token, "__get_str") == 0) {
+                free_token(token);
+                return process_str(event, arg, tok);
+        }
+        if (strcmp(token, "__get_dynamic_array") == 0) {
+                free_token(token);
+                return process_dynamic_array(event, arg, tok);
+        }
+
+        func = find_func_handler(event->pevent, token);
+        if (func) {
+                free_token(token);
+                return process_func_handler(event, func, arg, tok);
+        }
+
+        do_warning("function %s not defined", token);
+        free_token(token);
+        return EVENT_ERROR;
+}
+
+static enum event_type
+process_arg_token(struct event_format *event, struct print_arg *arg,
+                  char **tok, enum event_type type)
+{
+        char *token;
+        char *atom;
+
+        token = *tok;
+
+        switch (type) {
+        case EVENT_ITEM:
+                if (strcmp(token, "REC") == 0) {
+                        free_token(token);
+                        type = process_entry(event, arg, &token);
+                        break;
+                }
+                atom = token;
+                /* test the next token */
+                type = read_token_item(&token);
+
+                /*
+                 * If the next token is a parenthesis, then this
+                 * is a function.
+                 */
+                if (type == EVENT_DELIM && strcmp(token, "(") == 0) {
+                        free_token(token);
+                        token = NULL;
+                        /* this will free atom. */
+                        type = process_function(event, arg, atom, &token);
+                        break;
+                }
+                /* atoms can be more than one token long */
+                while (type == EVENT_ITEM) {
+                        atom = realloc(atom, strlen(atom) + strlen(token) + 2);
+                        strcat(atom, " ");
+                        strcat(atom, token);
+                        free_token(token);
+                        type = read_token_item(&token);
+                }
+
+                arg->type = PRINT_ATOM;
+                arg->atom.atom = atom;
+                break;
+
+        case EVENT_DQUOTE:
+        case EVENT_SQUOTE:
+                arg->type = PRINT_ATOM;
+                arg->atom.atom = token;
+                type = read_token_item(&token);
+                break;
+        case EVENT_DELIM:
+                if (strcmp(token, "(") == 0) {
+                        free_token(token);
+                        type = process_paren(event, arg, &token);
+                        break;
+                }
+        case EVENT_OP:
+                /* handle single ops */
+                arg->type = PRINT_OP;
+                arg->op.op = token;
+                arg->op.left = NULL;
+                type = process_op(event, arg, &token);
+
+                /* On error, the op is freed */
+                if (type == EVENT_ERROR)
+                        arg->op.op = NULL;
+
+                /* return error type if errored */
+                break;
+
+        case EVENT_ERROR ... EVENT_NEWLINE:
+        default:
+                die("unexpected type %d", type);
+        }
+        *tok = token;
+
+        return type;
+}
+
+static int event_read_print_args(struct event_format *event, struct print_arg **list)
+{
+        enum event_type type = EVENT_ERROR;
+        struct print_arg *arg;
+        char *token;
+        int args = 0;
+
+        do {
+                if (type == EVENT_NEWLINE) {
+                        type = read_token_item(&token);
+                        continue;
+                }
+
+                arg = alloc_arg();
+
+                type = process_arg(event, arg, &token);
+
+                if (type == EVENT_ERROR) {
+                        free_token(token);
+                        free_arg(arg);
+                        return -1;
+                }
+
+                *list = arg;
+                args++;
+
+                if (type == EVENT_OP) {
+                        type = process_op(event, arg, &token);
+                        free_token(token);
+                        if (type == EVENT_ERROR) {
+                                *list = NULL;
+                                free_arg(arg);
+                                return -1;
+                        }
+                        list = &arg->next;
+                        continue;
+                }
+
+                if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
+                        free_token(token);
+                        *list = arg;
+                        list = &arg->next;
+                        continue;
+                }
+                break;
+        } while (type != EVENT_NONE);
+
+        if (type != EVENT_NONE && type != EVENT_ERROR)
+                free_token(token);
+
+        return args;
+}
+
+static int event_read_print(struct event_format *event)
+{
+        enum event_type type;
+        char *token;
+        int ret;
+
+        if (read_expected_item(EVENT_ITEM, "print") < 0)
+                return -1;
+
+        if (read_expected(EVENT_ITEM, "fmt") < 0)
+                return -1;
+
+        if (read_expected(EVENT_OP, ":") < 0)
+                return -1;
+
+        if (read_expect_type(EVENT_DQUOTE, &token) < 0)
+                goto fail;
+
+ concat:
+        event->print_fmt.format = token;
+        event->print_fmt.args = NULL;
+
+        /* ok to have no arg */
+        type = read_token_item(&token);
+
+        if (type == EVENT_NONE)
+                return 0;
+
+        /* Handle concatenation of print lines */
+        if (type == EVENT_DQUOTE) {
+                char *cat;
+
+                cat = malloc_or_die(strlen(event->print_fmt.format) +
+                                    strlen(token) + 1);
+                strcpy(cat, event->print_fmt.format);
+                strcat(cat, token);
+                free_token(token);
+                free_token(event->print_fmt.format);
+                event->print_fmt.format = NULL;
+                token = cat;
+                goto concat;
+        }
+                             
+        if (test_type_token(type, token, EVENT_DELIM, ","))
+                goto fail;
+
+        free_token(token);
+
+        ret = event_read_print_args(event, &event->print_fmt.args);
+        if (ret < 0)
+                return -1;
+
+        return ret;
+
+ fail:
+        free_token(token);
+        return -1;
+}
+
+/**
+ * pevent_find_common_field - return a common field by event
+ * @event: handle for the event
+ * @name: the name of the common field to return
+ *
+ * Returns a common field from the event by the given @name.
+ * This only searchs the common fields and not all field.
+ */
+struct format_field *
+pevent_find_common_field(struct event_format *event, const char *name)
+{
+        struct format_field *format;
+
+        for (format = event->format.common_fields;
+             format; format = format->next) {
+                if (strcmp(format->name, name) == 0)
+                        break;
+        }
+
+        return format;
+}
+
+/**
+ * pevent_find_field - find a non-common field
+ * @event: handle for the event
+ * @name: the name of the non-common field
+ *
+ * Returns a non-common field by the given @name.
+ * This does not search common fields.
+ */
+struct format_field *
+pevent_find_field(struct event_format *event, const char *name)
+{
+        struct format_field *format;
+
+        for (format = event->format.fields;
+             format; format = format->next) {
+                if (strcmp(format->name, name) == 0)
+                        break;
+        }
+
+        return format;
+}
+
+/**
+ * pevent_find_any_field - find any field by name
+ * @event: handle for the event
+ * @name: the name of the field
+ *
+ * Returns a field by the given @name.
+ * This searchs the common field names first, then
+ * the non-common ones if a common one was not found.
+ */
+struct format_field *
+pevent_find_any_field(struct event_format *event, const char *name)
+{
+        struct format_field *format;
+
+        format = pevent_find_common_field(event, name);
+        if (format)
+                return format;
+        return pevent_find_field(event, name);
+}
+
+/**
+ * pevent_read_number - read a number from data
+ * @pevent: handle for the pevent
+ * @ptr: the raw data
+ * @size: the size of the data that holds the number
+ *
+ * Returns the number (converted to host) from the
+ * raw data.
+ */
+unsigned long long pevent_read_number(struct pevent *pevent,
+                                      const void *ptr, int size)
+{
+        switch (size) {
+        case 1:
+                return *(unsigned char *)ptr;
+        case 2:
+                return data2host2(pevent, ptr);
+        case 4:
+                return data2host4(pevent, ptr);
+        case 8:
+                return data2host8(pevent, ptr);
+        default:
+                /* BUG! */
+                return 0;
+        }
+}
+
+/**
+ * pevent_read_number_field - read a number from data
+ * @field: a handle to the field
+ * @data: the raw data to read
+ * @value: the value to place the number in
+ *
+ * Reads raw data according to a field offset and size,
+ * and translates it into @value.
+ *
+ * Returns 0 on success, -1 otherwise.
+ */
+int pevent_read_number_field(struct format_field *field, const void *data,
+                             unsigned long long *value)
+{
+        if (!field)
+                return -1;
+        switch (field->size) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+                *value = pevent_read_number(field->event->pevent,
+                                            data + field->offset, field->size);
+                return 0;
+        default:
+                return -1;
+        }
+}
+
+static int get_common_info(struct pevent *pevent,
+                           const char *type, int *offset, int *size)
+{
+        struct event_format *event;
+        struct format_field *field;
+
+        /*
+         * All events should have the same common elements.
+         * Pick any event to find where the type is;
+         */
+        if (!pevent->events)
+                die("no event_list!");
+
+        event = pevent->events[0];
+        field = pevent_find_common_field(event, type);
+        if (!field)
+                die("field '%s' not found", type);
+
+        *offset = field->offset;
+        *size = field->size;
+
+        return 0;
+}
+
+static int __parse_common(struct pevent *pevent, void *data,
+                          int *size, int *offset, const char *name)
+{
+        int ret;
+
+        if (!*size) {
+                ret = get_common_info(pevent, name, offset, size);
+                if (ret < 0)
+                        return ret;
+        }
+        return pevent_read_number(pevent, data + *offset, *size);
+}
+
+static int trace_parse_common_type(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->type_size, &pevent->type_offset,
+                              "common_type");
+}
+
+static int parse_common_pid(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->pid_size, &pevent->pid_offset,
+                              "common_pid");
+}
+
+static int parse_common_pc(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->pc_size, &pevent->pc_offset,
+                              "common_preempt_count");
+}
+
+static int parse_common_flags(struct pevent *pevent, void *data)
+{
+        return __parse_common(pevent, data,
+                              &pevent->flags_size, &pevent->flags_offset,
+                              "common_flags");
+}
+
+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 ret;
+}
+
+static int events_id_cmp(const void *a, const void *b);
+
+/**
+ * pevent_find_event - find an event by given id
+ * @pevent: a handle to the pevent
+ * @id: the id of the event
+ *
+ * Returns an event that has a given @id.
+ */
+struct event_format *pevent_find_event(struct pevent *pevent, int id)
+{
+        struct event_format **eventptr;
+        struct event_format key;
+        struct event_format *pkey = &key;
+
+        /* Check cache first */
+        if (pevent->last_event && pevent->last_event->id == id)
+                return pevent->last_event;
+
+        key.id = id;
+
+        eventptr = bsearch(&pkey, pevent->events, pevent->nr_events,
+                           sizeof(*pevent->events), events_id_cmp);
+
+        if (eventptr) {
+                pevent->last_event = *eventptr;
+                return *eventptr;
+        }
+
+        return NULL;
+}
+
+/**
+ * pevent_find_event_by_name - find an event by given name
+ * @pevent: a handle to the pevent
+ * @sys: the system name to search for
+ * @name: the name of the event to search for
+ *
+ * This returns an event with a given @name and under the system
+ * @sys. If @sys is NULL the first event with @name is returned.
+ */
+struct event_format *
+pevent_find_event_by_name(struct pevent *pevent,
+                          const char *sys, const char *name)
+{
+        struct event_format *event;
+        int i;
+
+        if (pevent->last_event &&
+            strcmp(pevent->last_event->name, name) == 0 &&
+            (!sys || strcmp(pevent->last_event->system, sys) == 0))
+                return pevent->last_event;
+
+        for (i = 0; i < pevent->nr_events; i++) {
+                event = pevent->events[i];
+                if (strcmp(event->name, name) == 0) {
+                        if (!sys)
+                                break;
+                        if (strcmp(event->system, sys) == 0)
+                                break;
+                }
+        }
+        if (i == pevent->nr_events)
+                event = NULL;
+
+        pevent->last_event = event;
+        return event;
+}
+
+static unsigned long long
+eval_num_arg(void *data, int size, struct event_format *event, struct print_arg *arg)
+{
+        struct pevent *pevent = event->pevent;
+        unsigned long long val = 0;
+        unsigned long long left, right;
+        struct print_arg *typearg = NULL;
+        struct print_arg *larg;
+        unsigned long offset;
+        unsigned int field_size;
+
+        switch (arg->type) {
+        case PRINT_NULL:
+                /* ?? */
+                return 0;
+        case PRINT_ATOM:
+                return strtoull(arg->atom.atom, NULL, 0);
+        case PRINT_FIELD:
+                if (!arg->field.field) {
+                        arg->field.field = pevent_find_any_field(event, arg->field.name);
+                        if (!arg->field.field)
+                                die("field %s not found", arg->field.name);
+                }
+                /* must be a number */
+                val = pevent_read_number(pevent, data + arg->field.field->offset,
+                                arg->field.field->size);
+                break;
+        case PRINT_FLAGS:
+        case PRINT_SYMBOL:
+                break;
+        case PRINT_TYPE:
+                val = eval_num_arg(data, size, event, arg->typecast.item);
+                return eval_type(val, arg, 0);
+        case PRINT_STRING:
+        case PRINT_BSTRING:
+                return 0;
+        case PRINT_FUNC: {
+                struct trace_seq s;
+                trace_seq_init(&s);
+                val = process_defined_func(&s, data, size, event, arg);
+                trace_seq_destroy(&s);
+                return val;
+        }
+        case PRINT_OP:
+                if (strcmp(arg->op.op, "[") == 0) {
+                        /*
+                         * Arrays are special, since we don't want
+                         * to read the arg as is.
+                         */
+                        right = eval_num_arg(data, size, event, arg->op.right);
+
+                        /* handle typecasts */
+                        larg = arg->op.left;
+                        while (larg->type == PRINT_TYPE) {
+                                if (!typearg)
+                                        typearg = larg;
+                                larg = larg->typecast.item;
+                        }
+
+                        /* Default to long size */
+                        field_size = pevent->long_size;
+
+                        switch (larg->type) {
+                        case PRINT_DYNAMIC_ARRAY:
+                                offset = pevent_read_number(pevent,
+                                                   data + larg->dynarray.field->offset,
+                                                   larg->dynarray.field->size);
+                                if (larg->dynarray.field->elementsize)
+                                        field_size = larg->dynarray.field->elementsize;
+                                /*
+                                 * The actual length of the dynamic array is stored
+                                 * in the top half of the field, and the offset
+                                 * is in the bottom half of the 32 bit field.
+                                 */
+                                offset &= 0xffff;
+                                offset += right;
+                                break;
+                        case PRINT_FIELD:
+                                if (!larg->field.field) {
+                                        larg->field.field =
+                                                pevent_find_any_field(event, larg->field.name);
+                                        if (!larg->field.field)
+                                                die("field %s not found", larg->field.name);
+                                }
+                                field_size = larg->field.field->elementsize;
+                                offset = larg->field.field->offset +
+                                        right * larg->field.field->elementsize;
+                                break;
+                        default:
+                                goto default_op; /* oops, all bets off */
+                        }
+                        val = pevent_read_number(pevent,
+                                                 data + offset, field_size);
+                        if (typearg)
+                                val = eval_type(val, typearg, 1);
+                        break;
+                } else if (strcmp(arg->op.op, "?") == 0) {
+                        left = eval_num_arg(data, size, event, arg->op.left);
+                        arg = arg->op.right;
+                        if (left)
+                                val = eval_num_arg(data, size, event, arg->op.left);
+                        else
+                                val = eval_num_arg(data, size, event, arg->op.right);
+                        break;
+                }
+ default_op:
+                left = eval_num_arg(data, size, event, arg->op.left);
+                right = eval_num_arg(data, size, event, arg->op.right);
+                switch (arg->op.op[0]) {
+                case '!':
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = !right;
+                                break;
+                        case '=':
+                                val = left != right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '~':
+                        val = ~right;
+                        break;
+                case '|':
+                        if (arg->op.op[1])
+                                val = left || right;
+                        else
+                                val = left | right;
+                        break;
+                case '&':
+                        if (arg->op.op[1])
+                                val = left && right;
+                        else
+                                val = left & right;
+                        break;
+                case '<':
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left < right;
+                                break;
+                        case '<':
+                                val = left << right;
+                                break;
+                        case '=':
+                                val = left <= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '>':
+                        switch (arg->op.op[1]) {
+                        case 0:
+                                val = left > right;
+                                break;
+                        case '>':
+                                val = left >> right;
+                                break;
+                        case '=':
+                                val = left >= right;
+                                break;
+                        default:
+                                die("unknown op '%s'", arg->op.op);
+                        }
+                        break;
+                case '=':
+                        if (arg->op.op[1] != '=')
+                                die("unknown op '%s'", arg->op.op);
+                        val = left == right;
+                        break;
+                case '-':
+                        val = left - right;
+                        break;
+                case '+':
+                        val = left + right;
+                        break;
+                case '/':
+                        val = left / right;
+                        break;
+                case '*':
+                        val = left * right;
+                        break;
+                default:
+                        die("unknown op '%s'", arg->op.op);
+                }
+                break;
+        default: /* not sure what to do there */
+                return 0;
+        }
+        return val;
+}
+
+struct flag {
+        const char *name;
+        unsigned long long value;
+};
+
+static const struct flag flags[] = {
+        { "HI_SOFTIRQ", 0 },
+        { "TIMER_SOFTIRQ", 1 },
+        { "NET_TX_SOFTIRQ", 2 },
+        { "NET_RX_SOFTIRQ", 3 },
+        { "BLOCK_SOFTIRQ", 4 },
+        { "BLOCK_IOPOLL_SOFTIRQ", 5 },
+        { "TASKLET_SOFTIRQ", 6 },
+        { "SCHED_SOFTIRQ", 7 },
+        { "HRTIMER_SOFTIRQ", 8 },
+        { "RCU_SOFTIRQ", 9 },
+
+        { "HRTIMER_NORESTART", 0 },
+        { "HRTIMER_RESTART", 1 },
+};
+
+static unsigned long long eval_flag(const char *flag)
+{
+        int i;
+
+        /*
+         * Some flags in the format files do not get converted.
+         * If the flag is not numeric, see if it is something that
+         * we already know about.
+         */
+        if (isdigit(flag[0]))
+                return strtoull(flag, NULL, 0);
+
+        for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
+                if (strcmp(flags[i].name, flag) == 0)
+                        return flags[i].value;
+
+        return 0;
+}
+
+static void print_str_to_seq(struct trace_seq *s, const char *format,
+                             int len_arg, const char *str)
+{
+        if (len_arg >= 0)
+                trace_seq_printf(s, format, len_arg, str);
+        else
+                trace_seq_printf(s, format, str);
+}
+
+static void print_str_arg(struct trace_seq *s, void *data, int size,
+                          struct event_format *event, const char *format,
+                          int len_arg, struct print_arg *arg)
+{
+        struct pevent *pevent = event->pevent;
+        struct print_flag_sym *flag;
+        unsigned long long val, fval;
+        unsigned long addr;
+        char *str;
+        int print;
+        int len;
+
+        switch (arg->type) {
+        case PRINT_NULL:
+                /* ?? */
+                return;
+        case PRINT_ATOM:
+                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)
+                                die("field %s not found", arg->field.name);
+                }
+                /* Zero sized fields, mean the rest of the data */
+                len = arg->field.field->size ? : size - arg->field.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);
+                        trace_seq_printf(s, "%lx", addr);
+                        break;
+                }
+                str = malloc_or_die(len + 1);
+                memcpy(str, data + arg->field.field->offset, len);
+                str[len] = 0;
+                print_str_to_seq(s, format, len_arg, str);
+                free(str);
+                break;
+        case PRINT_FLAGS:
+                val = eval_num_arg(data, size, event, arg->flags.field);
+                print = 0;
+                for (flag = arg->flags.flags; flag; flag = flag->next) {
+                        fval = eval_flag(flag->value);
+                        if (!val && !fval) {
+                                print_str_to_seq(s, format, len_arg, flag->str);
+                                break;
+                        }
+                        if (fval && (val & fval) == fval) {
+                                if (print && arg->flags.delim)
+                                        trace_seq_puts(s, arg->flags.delim);
+                                print_str_to_seq(s, format, len_arg, flag->str);
+                                print = 1;
+                                val &= ~fval;
+                        }
+                }
+                break;
+        case PRINT_SYMBOL:
+                val = eval_num_arg(data, size, event, arg->symbol.field);
+                for (flag = arg->symbol.symbols; flag; flag = flag->next) {
+                        fval = eval_flag(flag->value);
+                        if (val == fval) {
+                                print_str_to_seq(s, format, len_arg, flag->str);
+                                break;
+                        }
+                }
+                break;
+
+        case PRINT_TYPE:
+                break;
+        case PRINT_STRING: {
+                int str_offset;
+
+                if (arg->string.offset == -1) {
+                        struct format_field *f;
+
+                        f = pevent_find_any_field(event, arg->string.string);
+                        arg->string.offset = f->offset;
+                }
+                str_offset = data2host4(pevent, data + arg->string.offset);
+                str_offset &= 0xffff;
+                print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
+                break;
+        }
+        case PRINT_BSTRING:
+                trace_seq_printf(s, format, arg->string.string);
+                break;
+        case PRINT_OP:
+                /*
+                 * The only op for string should be ? :
+                 */
+                if (arg->op.op[0] != '?')
+                        return;
+                val = eval_num_arg(data, size, event, arg->op.left);
+                if (val)
+                        print_str_arg(s, data, size, event,
+                                      format, len_arg, arg->op.right->op.left);
+                else
+                        print_str_arg(s, data, size, event,
+                                      format, len_arg, arg->op.right->op.right);
+                break;
+        case PRINT_FUNC:
+                process_defined_func(s, data, size, event, arg);
+                break;
+        default:
+                /* well... */
+                break;
+        }
+}
+
+static unsigned long long
+process_defined_func(struct trace_seq *s, void *data, int size,
+                     struct event_format *event, struct print_arg *arg)
+{
+        struct pevent_function_handler *func_handle = arg->func.func;
+        struct pevent_func_params *param;
+        unsigned long long *args;
+        unsigned long long ret;
+        struct print_arg *farg;
+        struct trace_seq str;
+        struct save_str {
+                struct save_str *next;
+                char *str;
+        } *strings = NULL, *string;
+        int i;
+
+        if (!func_handle->nr_args) {
+                ret = (*func_handle->func)(s, NULL);
+                goto out;
+        }
+
+        farg = arg->func.args;
+        param = func_handle->params;
+
+        args = malloc_or_die(sizeof(*args) * func_handle->nr_args);
+        for (i = 0; i < func_handle->nr_args; i++) {
+                switch (param->type) {
+                case PEVENT_FUNC_ARG_INT:
+                case PEVENT_FUNC_ARG_LONG:
+                case PEVENT_FUNC_ARG_PTR:
+                        args[i] = eval_num_arg(data, size, event, farg);
+                        break;
+                case PEVENT_FUNC_ARG_STRING:
+                        trace_seq_init(&str);
+                        print_str_arg(&str, data, size, event, "%s", -1, farg);
+                        trace_seq_terminate(&str);
+                        string = malloc_or_die(sizeof(*string));
+                        string->next = strings;
+                        string->str = strdup(str.buffer);
+                        strings = string;
+                        trace_seq_destroy(&str);
+                        break;
+                default:
+                        /*
+                         * Something went totally wrong, this is not
+                         * an input error, something in this code broke.
+                         */
+                        die("Unexpected end of arguments\n");
+                        break;
+                }
+                farg = farg->next;
+                param = param->next;
+        }
+
+        ret = (*func_handle->func)(s, args);
+        free(args);
+        while (strings) {
+                string = strings;
+                strings = string->next;
+                free(string->str);
+                free(string);
+        }
+
+ out:
+        /* TBD : handle return type here */
+        return ret;
+}
+
+static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event_format *event)
+{
+        struct pevent *pevent = event->pevent;
+        struct format_field *field, *ip_field;
+        struct print_arg *args, *arg, **next;
+        unsigned long long ip, val;
+        char *ptr;
+        void *bptr;
+
+        field = pevent->bprint_buf_field;
+        ip_field = pevent->bprint_ip_field;
+
+        if (!field) {
+                field = pevent_find_field(event, "buf");
+                if (!field)
+                        die("can't find buffer field for binary printk");
+                ip_field = pevent_find_field(event, "ip");
+                if (!ip_field)
+                        die("can't find ip field for binary printk");
+                pevent->bprint_buf_field = field;
+                pevent->bprint_ip_field = ip_field;
+        }
+
+        ip = pevent_read_number(pevent, data + ip_field->offset, ip_field->size);
+
+        /*
+         * The first arg is the IP pointer.
+         */
+        args = alloc_arg();
+        arg = args;
+        arg->next = NULL;
+        next = &arg->next;
+
+        arg->type = PRINT_ATOM;
+        arg->atom.atom = malloc_or_die(32);
+        sprintf(arg->atom.atom, "%lld", ip);
+
+        /* skip the first "%pf : " */
+        for (ptr = fmt + 6, bptr = data + field->offset;
+             bptr < data + size && *ptr; ptr++) {
+                int ls = 0;
+
+                if (*ptr == '%') {
+ process_again:
+                        ptr++;
+                        switch (*ptr) {
+                        case '%':
+                                break;
+                        case 'l':
+                                ls++;
+                                goto process_again;
+                        case 'L':
+                                ls = 2;
+                                goto process_again;
+                        case '0' ... '9':
+                                goto process_again;
+                        case 'p':
+                                ls = 1;
+                                /* fall through */
+                        case 'd':
+                        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;
+                                        break;
+                                case 1:
+                                        ls = pevent->long_size;
+                                        break;
+                                case 2:
+                                        ls = 8;
+                                default:
+                                        break;
+                                }
+                                val = pevent_read_number(pevent, bptr, ls);
+                                bptr += ls;
+                                arg = alloc_arg();
+                                arg->next = NULL;
+                                arg->type = PRINT_ATOM;
+                                arg->atom.atom = malloc_or_die(32);
+                                sprintf(arg->atom.atom, "%lld", val);
+                                *next = arg;
+                                next = &arg->next;
+                                break;
+                        case 's':
+                                arg = alloc_arg();
+                                arg->next = NULL;
+                                arg->type = PRINT_BSTRING;
+                                arg->string.string = strdup(bptr);
+                                bptr += strlen(bptr) + 1;
+                                *next = arg;
+                                next = &arg->next;
+                        default:
+                                break;
+                        }
+                }
+        }
+
+        return args;
+}
+
+static void free_args(struct print_arg *args)
+{
+        struct print_arg *next;
+
+        while (args) {
+                next = args->next;
+
+                free_arg(args);
+                args = next;
+        }
+}
+
+static char *
+get_bprint_format(void *data, int size __unused, struct event_format *event)
+{
+        struct pevent *pevent = event->pevent;
+        unsigned long long addr;
+        struct format_field *field;
+        struct printk_map *printk;
+        char *format;
+        char *p;
+
+        field = pevent->bprint_fmt_field;
+
+        if (!field) {
+                field = pevent_find_field(event, "fmt");
+                if (!field)
+                        die("can't find format field for binary printk");
+                pevent->bprint_fmt_field = field;
+        }
+
+        addr = pevent_read_number(pevent, data + field->offset, field->size);
+
+        printk = find_printk(pevent, addr);
+        if (!printk) {
+                format = malloc_or_die(45);
+                sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
+                        addr);
+                return format;
+        }
+
+        p = printk->printk;
+        /* Remove any quotes. */
+        if (*p == '"')
+                p++;
+        format = malloc_or_die(strlen(p) + 10);
+        sprintf(format, "%s : %s", "%pf", p);
+        /* remove ending quotes and new line since we will add one too */
+        p = format + strlen(format) - 1;
+        if (*p == '"')
+                *p = 0;
+
+        p -= 2;
+        if (strcmp(p, "\\n") == 0)
+                *p = 0;
+
+        return format;
+}
+
+static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
+                          struct event_format *event, struct print_arg *arg)
+{
+        unsigned char *buf;
+        char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
+
+        if (arg->type == PRINT_FUNC) {
+                process_defined_func(s, data, size, event, arg);
+                return;
+        }
+
+        if (arg->type != PRINT_FIELD) {
+                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
+                                 arg->type);
+                return;
+        }
+
+        if (mac == 'm')
+                fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
+        if (!arg->field.field) {
+                arg->field.field =
+                        pevent_find_any_field(event, arg->field.name);
+                if (!arg->field.field)
+                        die("field %s not found", arg->field.name);
+        }
+        if (arg->field.field->size != 6) {
+                trace_seq_printf(s, "INVALIDMAC");
+                return;
+        }
+        buf = data + arg->field.field->offset;
+        trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
+}
+
+static void print_event_fields(struct trace_seq *s, void *data, int size,
+                               struct event_format *event)
+{
+        struct format_field *field;
+        unsigned long long val;
+        unsigned int offset, len, i;
+
+        field = event->format.fields;
+        while (field) {
+                trace_seq_printf(s, " %s=", field->name);
+                if (field->flags & FIELD_IS_ARRAY) {
+                        offset = field->offset;
+                        len = field->size;
+                        if (field->flags & FIELD_IS_DYNAMIC) {
+                                val = pevent_read_number(event->pevent, data + offset, len);
+                                offset = val;
+                                len = offset >> 16;
+                                offset &= 0xffff;
+                        }
+                        if (field->flags & FIELD_IS_STRING) {
+                                trace_seq_printf(s, "%s", (char *)data + offset);
+                        } else {
+                                trace_seq_puts(s, "ARRAY[");
+                                for (i = 0; i < len; i++) {
+                                        if (i)
+                                                trace_seq_puts(s, ", ");
+                                        trace_seq_printf(s, "%02x",
+                                                         *((unsigned char *)data + offset + i));
+                                }
+                                trace_seq_putc(s, ']');
+                        }
+                } else {
+                        val = pevent_read_number(event->pevent, data + field->offset,
+                                                 field->size);
+                        if (field->flags & FIELD_IS_POINTER) {
+                                trace_seq_printf(s, "0x%llx", val);
+                        } else if (field->flags & FIELD_IS_SIGNED) {
+                                switch (field->size) {
+                                case 4:
+                                        /*
+                                         * If field is long then print it in hex.
+                                         * A long usually stores pointers.
+                                         */
+                                        if (field->flags & FIELD_IS_LONG)
+                                                trace_seq_printf(s, "0x%x", (int)val);
+                                        else
+                                                trace_seq_printf(s, "%d", (int)val);
+                                        break;
+                                case 2:
+                                        trace_seq_printf(s, "%2d", (short)val);
+                                        break;
+                                case 1:
+                                        trace_seq_printf(s, "%1d", (char)val);
+                                        break;
+                                default:
+                                        trace_seq_printf(s, "%lld", val);
+                                }
+                        } else {
+                                if (field->flags & FIELD_IS_LONG)
+                                        trace_seq_printf(s, "0x%llx", val);
+                                else
+                                        trace_seq_printf(s, "%llu", val);
+                        }
+                }
+                field = field->next;
+        }
+}
+
+static void pretty_print(struct trace_seq *s, void *data, int size, struct event_format *event)
+{
+        struct pevent *pevent = event->pevent;
+        struct print_fmt *print_fmt = &event->print_fmt;
+        struct print_arg *arg = print_fmt->args;
+        struct print_arg *args = NULL;
+        const char *ptr = print_fmt->format;
+        unsigned long long val;
+        struct func_map *func;
+        const char *saveptr;
+        char *bprint_fmt = NULL;
+        char format[32];
+        int show_func;
+        int len_as_arg;
+        int len_arg;
+        int len;
+        int ls;
+
+        if (event->flags & EVENT_FL_FAILED) {
+                trace_seq_printf(s, "[FAILED TO PARSE]");
+                print_event_fields(s, data, size, event);
+                return;
+        }
+
+        if (event->flags & EVENT_FL_ISBPRINT) {
+                bprint_fmt = get_bprint_format(data, size, event);
+                args = make_bprint_args(bprint_fmt, data, size, event);
+                arg = args;
+                ptr = bprint_fmt;
+        }
+
+        for (; *ptr; ptr++) {
+                ls = 0;
+                if (*ptr == '\\') {
+                        ptr++;
+                        switch (*ptr) {
+                        case 'n':
+                                trace_seq_putc(s, '\n');
+                                break;
+                        case 't':
+                                trace_seq_putc(s, '\t');
+                                break;
+                        case 'r':
+                                trace_seq_putc(s, '\r');
+                                break;
+                        case '\\':
+                                trace_seq_putc(s, '\\');
+                                break;
+                        default:
+                                trace_seq_putc(s, *ptr);
+                                break;
+                        }
+
+                } else if (*ptr == '%') {
+                        saveptr = ptr;
+                        show_func = 0;
+                        len_as_arg = 0;
+ cont_process:
+                        ptr++;
+                        switch (*ptr) {
+                        case '%':
+                                trace_seq_putc(s, '%');
+                                break;
+                        case '#':
+                                /* FIXME: need to handle properly */
+                                goto cont_process;
+                        case 'h':
+                                ls--;
+                                goto cont_process;
+                        case 'l':
+                                ls++;
+                                goto cont_process;
+                        case 'L':
+                                ls = 2;
+                                goto cont_process;
+                        case '*':
+                                /* The argument is the length. */
+                                if (!arg)
+                                        die("no argument match");
+                                len_arg = eval_num_arg(data, size, event, arg);
+                                len_as_arg = 1;
+                                arg = arg->next;
+                                goto cont_process;
+                        case '.':
+                        case 'z':
+                        case 'Z':
+                        case '0' ... '9':
+                                goto cont_process;
+                        case 'p':
+                                if (pevent->long_size == 4)
+                                        ls = 1;
+                                else
+                                        ls = 2;
+
+                                if (*(ptr+1) == 'F' ||
+                                    *(ptr+1) == 'f') {
+                                        ptr++;
+                                        show_func = *ptr;
+                                } else if (*(ptr+1) == 'M' || *(ptr+1) == 'm') {
+                                        print_mac_arg(s, *(ptr+1), data, size, event, arg);
+                                        ptr++;
+                                        break;
+                                }
+
+                                /* fall through */
+                        case 'd':
+                        case 'i':
+                        case 'x':
+                        case 'X':
+                        case 'u':
+                                if (!arg)
+                                        die("no argument match");
+
+                                len = ((unsigned long)ptr + 1) -
+                                        (unsigned long)saveptr;
+
+                                /* should never happen */
+                                if (len > 31)
+                                        die("bad format!");
+
+                                memcpy(format, saveptr, len);
+                                format[len] = 0;
+
+                                val = eval_num_arg(data, size, event, arg);
+                                arg = arg->next;
+
+                                if (show_func) {
+                                        func = find_func(pevent, val);
+                                        if (func) {
+                                                trace_seq_puts(s, func->func);
+                                                if (show_func == 'F')
+                                                        trace_seq_printf(s,
+                                                               "+0x%llx",
+                                                               val - func->addr);
+                                                break;
+                                        }
+                                }
+                                if (pevent->long_size == 8 && ls) {
+                                        char *p;
+
+                                        ls = 2;
+                                        /* make %l into %ll */
+                                        p = strchr(format, 'l');
+                                        if (p)
+                                                memmove(p, p+1, strlen(p)+1);
+                                        else if (strcmp(format, "%p") == 0)
+                                                strcpy(format, "0x%llx");
+                                }
+                                switch (ls) {
+                                case -2:
+                                        if (len_as_arg)
+                                                trace_seq_printf(s, format, len_arg, (char)val);
+                                        else
+                                                trace_seq_printf(s, format, (char)val);
+                                        break;
+                                case -1:
+                                        if (len_as_arg)
+                                                trace_seq_printf(s, format, len_arg, (short)val);
+                                        else
+                                                trace_seq_printf(s, format, (short)val);
+                                        break;
+                                case 0:
+                                        if (len_as_arg)
+                                                trace_seq_printf(s, format, len_arg, (int)val);
+                                        else
+                                                trace_seq_printf(s, format, (int)val);
+                                        break;
+                                case 1:
+                                        if (len_as_arg)
+                                                trace_seq_printf(s, format, len_arg, (long)val);
+                                        else
+                                                trace_seq_printf(s, format, (long)val);
+                                        break;
+                                case 2:
+                                        if (len_as_arg)
+                                                trace_seq_printf(s, format, len_arg,
+                                                                 (long long)val);
+                                        else
+                                                trace_seq_printf(s, format, (long long)val);
+                                        break;
+                                default:
+                                        die("bad count (%d)", ls);
+                                }
+                                break;
+                        case 's':
+                                if (!arg)
+                                        die("no matching argument");
+
+                                len = ((unsigned long)ptr + 1) -
+                                        (unsigned long)saveptr;
+
+                                /* should never happen */
+                                if (len > 31)
+                                        die("bad format!");
+
+                                memcpy(format, saveptr, len);
+                                format[len] = 0;
+                                if (!len_as_arg)
+                                        len_arg = -1;
+                                print_str_arg(s, data, size, event,
+                                              format, len_arg, arg);
+                                arg = arg->next;
+                                break;
+                        default:
+                                trace_seq_printf(s, ">%c<", *ptr);
+
+                        }
+                } else
+                        trace_seq_putc(s, *ptr);
+        }
+
+        if (args) {
+                free_args(args);
+                free(bprint_fmt);
+        }
+}
+
+/**
+ * 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.
+ *
+ * This parses out the Latency format (interrupts disabled,
+ * need rescheduling, in hard/soft interrupt, preempt count
+ * and lock depth) and places it into the trace_seq.
+ */
+void pevent_data_lat_fmt(struct pevent *pevent,
+                         struct trace_seq *s, struct pevent_record *record)
+{
+        static int check_lock_depth = 1;
+        static int lock_depth_exists;
+        unsigned int lat_flags;
+        unsigned int pc;
+        int lock_depth;
+        int hardirq;
+        int softirq;
+        void *data = record->data;
+
+        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);
+
+        hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
+        softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
+
+        trace_seq_printf(s, "%c%c%c",
+               (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+               (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
+               'X' : '.',
+               (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
+               'N' : '.',
+               (hardirq && softirq) ? 'H' :
+               hardirq ? 'h' : softirq ? 's' : '.');
+
+        if (pc)
+                trace_seq_printf(s, "%x", pc);
+        else
+                trace_seq_putc(s, '.');
+
+        if (lock_depth_exists) {
+                if (lock_depth < 0)
+                        trace_seq_putc(s, '.');
+                else
+                        trace_seq_printf(s, "%d", lock_depth);
+        }
+
+        trace_seq_terminate(s);
+}
+
+/**
+ * pevent_data_type - parse out the given event type
+ * @pevent: a handle to the pevent
+ * @rec: the record to read from
+ *
+ * This returns the event id from the @rec.
+ */
+int pevent_data_type(struct pevent *pevent, struct pevent_record *rec)
+{
+        return trace_parse_common_type(pevent, rec->data);
+}
+
+/**
+ * pevent_data_event_from_type - find the event by a given type
+ * @pevent: a handle to the pevent
+ * @type: the type of the event.
+ *
+ * This returns the event form a given @type;
+ */
+struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type)
+{
+        return pevent_find_event(pevent, type);
+}
+
+/**
+ * pevent_data_pid - parse the PID from raw data
+ * @pevent: a handle to the pevent
+ * @rec: the record to parse
+ *
+ * This returns the PID from a raw data.
+ */
+int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec)
+{
+        return parse_common_pid(pevent, rec->data);
+}
+
+/**
+ * pevent_data_comm_from_pid - return the command line from PID
+ * @pevent: a handle to the pevent
+ * @pid: the PID of the task to search for
+ *
+ * This returns a pointer to the command line that has the given
+ * @pid.
+ */
+const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
+{
+        const char *comm;
+
+        comm = find_cmdline(pevent, pid);
+        return comm;
+}
+
+/**
+ * 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
+ *
+ * This parses the raw @data using the given @event information and
+ * writes the print format into the trace_seq.
+ */
+void pevent_event_info(struct trace_seq *s, struct event_format *event,
+                       struct pevent_record *record)
+{
+        int print_pretty = 1;
+
+        if (event->pevent->print_raw)
+                print_event_fields(s, record->data, record->size, event);
+        else {
+
+                if (event->handler)
+                        print_pretty = event->handler(s, record, event,
+                                                      event->context);
+
+                if (print_pretty)
+                        pretty_print(s, record->data, record->size, event);
+        }
+
+        trace_seq_terminate(s);
+}
+
+void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
+                        struct pevent_record *record)
+{
+        static char *spaces = "                    "; /* 20 spaces */
+        struct event_format *event;
+        unsigned long secs;
+        unsigned long usecs;
+        unsigned long nsecs;
+        const char *comm;
+        void *data = record->data;
+        int type;
+        int pid;
+        int len;
+        int p;
+
+        secs = record->ts / NSECS_PER_SEC;
+        nsecs = record->ts - secs * NSECS_PER_SEC;
+
+        if (record->size < 0) {
+                do_warning("ug! negative record size %d", record->size);
+                return;
+        }
+
+        type = trace_parse_common_type(pevent, data);
+
+        event = pevent_find_event(pevent, type);
+        if (!event) {
+                do_warning("ug! no event found for type %d", type);
+                return;
+        }
+
+        pid = parse_common_pid(pevent, data);
+        comm = find_cmdline(pevent, pid);
+
+        if (pevent->latency_format) {
+                trace_seq_printf(s, "%8.8s-%-5d %3d",
+                       comm, pid, record->cpu);
+                pevent_data_lat_fmt(pevent, s, record);
+        } else
+                trace_seq_printf(s, "%16s-%-5d [%03d]", comm, pid, record->cpu);
+
+        if (pevent->flags & PEVENT_NSEC_OUTPUT) {
+                usecs = nsecs;
+                p = 9;
+        } else {
+                usecs = (nsecs + 500) / NSECS_PER_USEC;
+                p = 6;
+        }
+
+        trace_seq_printf(s, " %5lu.%0*lu: %s: ", secs, p, usecs, event->name);
+
+        /* Space out the event names evenly. */
+        len = strlen(event->name);
+        if (len < 20)
+                trace_seq_printf(s, "%.*s", 20 - len, spaces);
+
+        pevent_event_info(s, event, record);
+}
+
+static int events_id_cmp(const void *a, const void *b)
+{
+        struct event_format * const * ea = a;
+        struct event_format * const * eb = b;
+
+        if ((*ea)->id < (*eb)->id)
+                return -1;
+
+        if ((*ea)->id > (*eb)->id)
+                return 1;
+
+        return 0;
+}
+
+static int events_name_cmp(const void *a, const void *b)
+{
+        struct event_format * const * ea = a;
+        struct event_format * const * eb = b;
+        int res;
+
+        res = strcmp((*ea)->name, (*eb)->name);
+        if (res)
+                return res;
+
+        res = strcmp((*ea)->system, (*eb)->system);
+        if (res)
+                return res;
+
+        return events_id_cmp(a, b);
+}
+
+static int events_system_cmp(const void *a, const void *b)
+{
+        struct event_format * const * ea = a;
+        struct event_format * const * eb = b;
+        int res;
+
+        res = strcmp((*ea)->system, (*eb)->system);
+        if (res)
+                return res;
+
+        res = strcmp((*ea)->name, (*eb)->name);
+        if (res)
+                return res;
+
+        return events_id_cmp(a, b);
+}
+
+struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type sort_type)
+{
+        struct event_format **events;
+        int (*sort)(const void *a, const void *b);
+
+        events = pevent->sort_events;
+
+        if (events && pevent->last_type == sort_type)
+                return events;
+
+        if (!events) {
+                events = malloc(sizeof(*events) * (pevent->nr_events + 1));
+                if (!events)
+                        return NULL;
+
+                memcpy(events, pevent->events, sizeof(*events) * pevent->nr_events);
+                events[pevent->nr_events] = NULL;
+
+                pevent->sort_events = events;
+
+                /* the internal events are sorted by id */
+                if (sort_type == EVENT_SORT_ID) {
+                        pevent->last_type = sort_type;
+                        return events;
+                }
+        }
+
+        switch (sort_type) {
+        case EVENT_SORT_ID:
+                sort = events_id_cmp;
+                break;
+        case EVENT_SORT_NAME:
+                sort = events_name_cmp;
+                break;
+        case EVENT_SORT_SYSTEM:
+                sort = events_system_cmp;
+                break;
+        default:
+                return events;
+        }
+
+        qsort(events, pevent->nr_events, sizeof(*events), sort);
+        pevent->last_type = sort_type;
+
+        return events;
+}
+
+static struct format_field **
+get_event_fields(const char *type, const char *name,
+                 int count, struct format_field *list)
+{
+        struct format_field **fields;
+        struct format_field *field;
+        int i = 0;
+
+        fields = malloc_or_die(sizeof(*fields) * (count + 1));
+        for (field = list; field; field = field->next) {
+                fields[i++] = field;
+                if (i == count + 1) {
+                        do_warning("event %s has more %s fields than specified",
+                                name, type);
+                        i--;
+                        break;
+                }
+        }
+
+        if (i != count)
+                do_warning("event %s has less %s fields than specified",
+                        name, type);
+
+        fields[i] = NULL;
+
+        return fields;
+}
+
+/**
+ * pevent_event_common_fields - return a list of common fields for an event
+ * @event: the event to return the common fields of.
+ *
+ * Returns an allocated array of fields. The last item in the array is NULL.
+ * The array must be freed with free().
+ */
+struct format_field **pevent_event_common_fields(struct event_format *event)
+{
+        return get_event_fields("common", event->name,
+                                event->format.nr_common,
+                                event->format.common_fields);
+}
+
+/**
+ * pevent_event_fields - return a list of event specific fields for an event
+ * @event: the event to return the fields of.
+ *
+ * Returns an allocated array of fields. The last item in the array is NULL.
+ * The array must be freed with free().
+ */
+struct format_field **pevent_event_fields(struct event_format *event)
+{
+        return get_event_fields("event", event->name,
+                                event->format.nr_fields,
+                                event->format.fields);
+}
+
+static void print_fields(struct trace_seq *s, struct print_flag_sym *field)
+{
+        trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
+        if (field->next) {
+                trace_seq_puts(s, ", ");
+                print_fields(s, field->next);
+        }
+}
+
+/* for debugging */
+static void print_args(struct print_arg *args)
+{
+        int print_paren = 1;
+        struct trace_seq s;
+
+        switch (args->type) {
+        case PRINT_NULL:
+                printf("null");
+                break;
+        case PRINT_ATOM:
+                printf("%s", args->atom.atom);
+                break;
+        case PRINT_FIELD:
+                printf("REC->%s", args->field.name);
+                break;
+        case PRINT_FLAGS:
+                printf("__print_flags(");
+                print_args(args->flags.field);
+                printf(", %s, ", args->flags.delim);
+                trace_seq_init(&s);
+                print_fields(&s, args->flags.flags);
+                trace_seq_do_printf(&s);
+                trace_seq_destroy(&s);
+                printf(")");
+                break;
+        case PRINT_SYMBOL:
+                printf("__print_symbolic(");
+                print_args(args->symbol.field);
+                printf(", ");
+                trace_seq_init(&s);
+                print_fields(&s, args->symbol.symbols);
+                trace_seq_do_printf(&s);
+                trace_seq_destroy(&s);
+                printf(")");
+                break;
+        case PRINT_STRING:
+        case PRINT_BSTRING:
+                printf("__get_str(%s)", args->string.string);
+                break;
+        case PRINT_TYPE:
+                printf("(%s)", args->typecast.type);
+                print_args(args->typecast.item);
+                break;
+        case PRINT_OP:
+                if (strcmp(args->op.op, ":") == 0)
+                        print_paren = 0;
+                if (print_paren)
+                        printf("(");
+                print_args(args->op.left);
+                printf(" %s ", args->op.op);
+                print_args(args->op.right);
+                if (print_paren)
+                        printf(")");
+                break;
+        default:
+                /* we should warn... */
+                return;
+        }
+        if (args->next) {
+                printf("\n");
+                print_args(args->next);
+        }
+}
+
+static void parse_header_field(const char *field,
+                               int *offset, int *size, int mandatory)
+{
+        unsigned long long save_input_buf_ptr;
+        unsigned long long save_input_buf_siz;
+        char *token;
+        int type;
+
+        save_input_buf_ptr = input_buf_ptr;
+        save_input_buf_siz = input_buf_siz;
+
+        if (read_expected(EVENT_ITEM, "field") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+
+        /* type */
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+        free_token(token);
+
+        /*
+         * If this is not a mandatory field, then test it first.
+         */
+        if (mandatory) {
+                if (read_expected(EVENT_ITEM, field) < 0)
+                        return;
+        } else {
+                if (read_expect_type(EVENT_ITEM, &token) < 0)
+                        goto fail;
+                if (strcmp(token, field) != 0)
+                        goto discard;
+                free_token(token);
+        }
+
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, "offset") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+        *offset = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        if (read_expected(EVENT_ITEM, "size") < 0)
+                return;
+        if (read_expected(EVENT_OP, ":") < 0)
+                return;
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto fail;
+        *size = atoi(token);
+        free_token(token);
+        if (read_expected(EVENT_OP, ";") < 0)
+                return;
+        type = read_token(&token);
+        if (type != EVENT_NEWLINE) {
+                /* newer versions of the kernel have a "signed" type */
+                if (type != EVENT_ITEM)
+                        goto fail;
+
+                if (strcmp(token, "signed") != 0)
+                        goto fail;
+
+                free_token(token);
+
+                if (read_expected(EVENT_OP, ":") < 0)
+                        return;
+
+                if (read_expect_type(EVENT_ITEM, &token))
+                        goto fail;
+
+                free_token(token);
+                if (read_expected(EVENT_OP, ";") < 0)
+                        return;
+
+                if (read_expect_type(EVENT_NEWLINE, &token))
+                        goto fail;
+        }
+ fail:
+        free_token(token);
+        return;
+
+ discard:
+        input_buf_ptr = save_input_buf_ptr;
+        input_buf_siz = save_input_buf_siz;
+        *offset = 0;
+        *size = 0;
+        free_token(token);
+}
+
+/**
+ * pevent_parse_header_page - parse the data stored in the header page
+ * @pevent: the handle to the pevent
+ * @buf: the buffer storing the header page format string
+ * @size: the size of @buf
+ * @long_size: the long size to use if there is no header
+ *
+ * This parses the header page format for information on the
+ * ring buffer used. The @buf should be copied from
+ *
+ * /sys/kernel/debug/tracing/events/header_page
+ */
+int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size,
+                             int long_size)
+{
+        int ignore;
+
+        if (!size) {
+                /*
+                 * Old kernels did not have header page info.
+                 * Sorry but we just use what we find here in user space.
+                 */
+                pevent->header_page_ts_size = sizeof(long long);
+                pevent->header_page_size_size = long_size;
+                pevent->header_page_data_offset = sizeof(long long) + long_size;
+                pevent->old_format = 1;
+                return -1;
+        }
+        init_input_buf(buf, size);
+
+        parse_header_field("timestamp", &pevent->header_page_ts_offset,
+                           &pevent->header_page_ts_size, 1);
+        parse_header_field("commit", &pevent->header_page_size_offset,
+                           &pevent->header_page_size_size, 1);
+        parse_header_field("overwrite", &pevent->header_page_overwrite,
+                           &ignore, 0);
+        parse_header_field("data", &pevent->header_page_data_offset,
+                           &pevent->header_page_data_size, 1);
+
+        return 0;
+}
+
+static int event_matches(struct event_format *event,
+                         int id, const char *sys_name,
+                         const char *event_name)
+{
+        if (id >= 0 && id != event->id)
+                return 0;
+
+        if (event_name && (strcmp(event_name, event->name) != 0))
+                return 0;
+
+        if (sys_name && (strcmp(sys_name, event->system) != 0))
+                return 0;
+
+        return 1;
+}
+
+static void free_handler(struct event_handler *handle)
+{
+        free((void *)handle->sys_name);
+        free((void *)handle->event_name);
+        free(handle);
+}
+
+static int find_event_handle(struct pevent *pevent, struct event_format *event)
+{
+        struct event_handler *handle, **next;
+
+        for (next = &pevent->handlers; *next;
+             next = &(*next)->next) {
+                handle = *next;
+                if (event_matches(event, handle->id,
+                                  handle->sys_name,
+                                  handle->event_name))
+                        break;
+        }
+
+        if (!(*next))
+                return 0;
+
+        pr_stat("overriding event (%d) %s:%s with new print handler",
+                event->id, event->system, event->name);
+
+        event->handler = handle->func;
+        event->context = handle->context;
+
+        *next = handle->next;
+        free_handler(handle);
+
+        return 1;
+}
+
+/**
+ * pevent_parse_event - parse the event format
+ * @pevent: the handle to the pevent
+ * @buf: the buffer storing the event format string
+ * @size: the size of @buf
+ * @sys: the system the event belongs to
+ *
+ * This parses the event format and creates an event structure
+ * to quickly parse raw data for a given event.
+ *
+ * These files currently come from:
+ *
+ * /sys/kernel/debug/tracing/events/.../.../format
+ */
+int pevent_parse_event(struct pevent *pevent,
+                       const char *buf, unsigned long size,
+                       const char *sys)
+{
+        struct event_format *event;
+        int ret;
+
+        init_input_buf(buf, size);
+
+        event = alloc_event();
+        if (!event)
+                return -ENOMEM;
+
+        event->name = event_read_name();
+        if (!event->name) {
+                /* Bad event? */
+                free(event);
+                return -1;
+        }
+
+        if (strcmp(sys, "ftrace") == 0) {
+
+                event->flags |= EVENT_FL_ISFTRACE;
+
+                if (strcmp(event->name, "bprint") == 0)
+                        event->flags |= EVENT_FL_ISBPRINT;
+        }
+                
+        event->id = event_read_id();
+        if (event->id < 0)
+                die("failed to read event id");
+
+        event->system = strdup(sys);
+
+        /* Add pevent to event so that it can be referenced */
+        event->pevent = pevent;
+
+        ret = event_read_format(event);
+        if (ret < 0) {
+                do_warning("failed to read event format for %s", event->name);
+                goto event_failed;
+        }
+
+        /*
+         * If the event has an override, don't print warnings if the event
+         * print format fails to parse.
+         */
+        if (find_event_handle(pevent, event))
+                show_warning = 0;
+
+        ret = event_read_print(event);
+        if (ret < 0) {
+                do_warning("failed to read event print fmt for %s",
+                           event->name);
+                show_warning = 1;
+                goto event_failed;
+        }
+        show_warning = 1;
+
+        add_event(pevent, event);
+
+        if (!ret && (event->flags & EVENT_FL_ISFTRACE)) {
+                struct format_field *field;
+                struct print_arg *arg, **list;
+
+                /* old ftrace had no args */
+
+                list = &event->print_fmt.args;
+                for (field = event->format.fields; field; field = field->next) {
+                        arg = alloc_arg();
+                        *list = arg;
+                        list = &arg->next;
+                        arg->type = PRINT_FIELD;
+                        arg->field.name = strdup(field->name);
+                        arg->field.field = field;
+                }
+                return 0;
+        }
+
+#define PRINT_ARGS 0
+        if (PRINT_ARGS && event->print_fmt.args)
+                print_args(event->print_fmt.args);
+
+        return 0;
+
+ event_failed:
+        event->flags |= EVENT_FL_FAILED;
+        /* still add it even if it failed */
+        add_event(pevent, event);
+        return -1;
+}
+
+int get_field_val(struct trace_seq *s, struct format_field *field,
+                  const char *name, struct pevent_record *record,
+                  unsigned long long *val, int err)
+{
+        if (!field) {
+                if (err)
+                        trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
+                return -1;
+        }
+
+        if (pevent_read_number_field(field, record->data, val)) {
+                if (err)
+                        trace_seq_printf(s, " %s=INVALID", name);
+                return -1;
+        }
+
+        return 0;
+}
+
+/**
+ * pevent_get_field_raw - return the raw pointer into the data field
+ * @s: The seq to print to on error
+ * @event: the event that the field is for
+ * @name: The name of the field
+ * @record: The record with the field name.
+ * @len: place to store the field length.
+ * @err: print default error if failed.
+ *
+ * Returns a pointer into record->data of the field and places
+ * the length of the field in @len.
+ *
+ * On failure, it returns NULL.
+ */
+void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
+                           const char *name, struct pevent_record *record,
+                           int *len, int err)
+{
+        struct format_field *field;
+        void *data = record->data;
+        unsigned offset;
+        int dummy;
+
+        if (!event)
+                return NULL;
+
+        field = pevent_find_field(event, name);
+
+        if (!field) {
+                if (err)
+                        trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
+                return NULL;
+        }
+
+        /* Allow @len to be NULL */
+        if (!len)
+                len = &dummy;
+
+        offset = field->offset;
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                offset = pevent_read_number(event->pevent,
+                                            data + offset, field->size);
+                *len = offset >> 16;
+                offset &= 0xffff;
+        } else
+                *len = field->size;
+
+        return data + offset;
+}
+
+/**
+ * pevent_get_field_val - find a field and return its value
+ * @s: The seq to print to on error
+ * @event: the event that the field is for
+ * @name: The name of the field
+ * @record: The record with the field name.
+ * @val: place to store the value of the field.
+ * @err: print default error if failed.
+ *
+ * Returns 0 on success -1 on field not found.
+ */
+int pevent_get_field_val(struct trace_seq *s, struct event_format *event,
+                         const char *name, struct pevent_record *record,
+                         unsigned long long *val, int err)
+{
+        struct format_field *field;
+
+        if (!event)
+                return -1;
+
+        field = pevent_find_field(event, name);
+
+        return get_field_val(s, field, name, record, val, err);
+}
+
+/**
+ * pevent_get_common_field_val - find a common field and return its value
+ * @s: The seq to print to on error
+ * @event: the event that the field is for
+ * @name: The name of the field
+ * @record: The record with the field name.
+ * @val: place to store the value of the field.
+ * @err: print default error if failed.
+ *
+ * Returns 0 on success -1 on field not found.
+ */
+int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event,
+                                const char *name, struct pevent_record *record,
+                                unsigned long long *val, int err)
+{
+        struct format_field *field;
+
+        if (!event)
+                return -1;
+
+        field = pevent_find_common_field(event, name);
+
+        return get_field_val(s, field, name, record, val, err);
+}
+
+/**
+ * pevent_get_any_field_val - find a any field and return its value
+ * @s: The seq to print to on error
+ * @event: the event that the field is for
+ * @name: The name of the field
+ * @record: The record with the field name.
+ * @val: place to store the value of the field.
+ * @err: print default error if failed.
+ *
+ * Returns 0 on success -1 on field not found.
+ */
+int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
+                             const char *name, struct pevent_record *record,
+                             unsigned long long *val, int err)
+{
+        struct format_field *field;
+
+        if (!event)
+                return -1;
+
+        field = pevent_find_any_field(event, name);
+
+        return get_field_val(s, field, name, record, val, err);
+}
+
+/**
+ * pevent_print_num_field - print a field and a format
+ * @s: The seq to print to
+ * @fmt: The printf format to print the field with.
+ * @event: the event that the field is for
+ * @name: The name of the field
+ * @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.
+ */
+int pevent_print_num_field(struct trace_seq *s, const char *fmt,
+                           struct event_format *event, const char *name,
+                           struct pevent_record *record, int err)
+{
+        struct format_field *field = pevent_find_field(event, name);
+        unsigned long long val;
+
+        if (!field)
+                goto failed;
+
+        if (pevent_read_number_field(field, record->data, &val))
+                goto failed;
+
+        return trace_seq_printf(s, fmt, val);
+
+ failed:
+        if (err)
+                trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
+        return -1;
+}
+
+static void free_func_handle(struct pevent_function_handler *func)
+{
+        struct pevent_func_params *params;
+
+        free(func->name);
+
+        while (func->params) {
+                params = func->params;
+                func->params = params->next;
+                free(params);
+        }
+
+        free(func);
+}
+
+/**
+ * pevent_register_print_function - register a helper function
+ * @pevent: the handle to the pevent
+ * @func: the function to process 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
+ * of these functions.
+ *
+ * The @parameters is a variable list of pevent_func_arg_type enums that
+ * must end with PEVENT_FUNC_ARG_VOID.
+ */
+int pevent_register_print_function(struct pevent *pevent,
+                                   pevent_func_handler func,
+                                   enum pevent_func_arg_type ret_type,
+                                   char *name, ...)
+{
+        struct pevent_function_handler *func_handle;
+        struct pevent_func_params **next_param;
+        struct pevent_func_params *param;
+        enum pevent_func_arg_type type;
+        va_list ap;
+
+        func_handle = find_func_handler(pevent, name);
+        if (func_handle) {
+                /*
+                 * This is most like caused by the users own
+                 * plugins updating the function. This overrides the
+                 * system defaults.
+                 */
+                pr_stat("override of function helper '%s'", name);
+                remove_func_handler(pevent, name);
+        }
+
+        func_handle = malloc_or_die(sizeof(*func_handle));
+        memset(func_handle, 0, sizeof(*func_handle));
+
+        func_handle->ret_type = ret_type;
+        func_handle->name = strdup(name);
+        func_handle->func = func;
+        if (!func_handle->name)
+                die("Failed to allocate function name");
+
+        next_param = &(func_handle->params);
+        va_start(ap, name);
+        for (;;) {
+                type = va_arg(ap, enum pevent_func_arg_type);
+                if (type == PEVENT_FUNC_ARG_VOID)
+                        break;
+
+                if (type < 0 || type >= PEVENT_FUNC_ARG_MAX_TYPES) {
+                        warning("Invalid argument type %d", type);
+                        goto out_free;
+                }
+
+                param = malloc_or_die(sizeof(*param));
+                param->type = type;
+                param->next = NULL;
+
+                *next_param = param;
+                next_param = &(param->next);
+
+                func_handle->nr_args++;
+        }
+        va_end(ap);
+
+        func_handle->next = pevent->func_handlers;
+        pevent->func_handlers = func_handle;
+
+        return 0;
+ out_free:
+        va_end(ap);
+        free_func_handle(func_handle);
+        return -1;
+}
+
+/**
+ * pevent_register_event_handle - 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
+ *
+ * This function allows a developer to override the parsing of
+ * a given event. If for some reason the default print format
+ * is not sufficient, this function will register a function
+ * for an event to be used to parse the data instead.
+ *
+ * If @id is >= 0, then it is used to find the event.
+ * else @sys_name and @event_name are used.
+ */
+int pevent_register_event_handler(struct pevent *pevent,
+                                  int id, char *sys_name, char *event_name,
+                                  pevent_event_handler_func func,
+                                  void *context)
+{
+        struct event_format *event;
+        struct event_handler *handle;
+
+        if (id >= 0) {
+                /* search by id */
+                event = pevent_find_event(pevent, id);
+                if (!event)
+                        goto not_found;
+                if (event_name && (strcmp(event_name, event->name) != 0))
+                        goto not_found;
+                if (sys_name && (strcmp(sys_name, event->system) != 0))
+                        goto not_found;
+        } else {
+                event = pevent_find_event_by_name(pevent, sys_name, event_name);
+                if (!event)
+                        goto not_found;
+        }
+
+        pr_stat("overriding event (%d) %s:%s with new print handler",
+                event->id, event->system, event->name);
+
+        event->handler = func;
+        event->context = context;
+        return 0;
+
+ not_found:
+        /* Save for later use. */
+        handle = malloc_or_die(sizeof(*handle));
+        memset(handle, 0, sizeof(*handle));
+        handle->id = id;
+        if (event_name)
+                handle->event_name = strdup(event_name);
+        if (sys_name)
+                handle->sys_name = strdup(sys_name);
+
+        handle->func = func;
+        handle->next = pevent->handlers;
+        pevent->handlers = handle;
+        handle->context = context;
+
+        return -1;
+}
+
+/**
+ * pevent_alloc - create a pevent handle
+ */
+struct pevent *pevent_alloc(void)
+{
+        struct pevent *pevent;
+
+        pevent = malloc(sizeof(*pevent));
+        if (!pevent)
+                return NULL;
+        memset(pevent, 0, sizeof(*pevent));
+        pevent->ref_count = 1;
+
+        return pevent;
+}
+
+void pevent_ref(struct pevent *pevent)
+{
+        pevent->ref_count++;
+}
+
+static void free_format_fields(struct format_field *field)
+{
+        struct format_field *next;
+
+        while (field) {
+                next = field->next;
+                free(field->type);
+                free(field->name);
+                free(field);
+                field = next;
+        }
+}
+
+static void free_formats(struct format *format)
+{
+        free_format_fields(format->common_fields);
+        free_format_fields(format->fields);
+}
+
+static void free_event(struct event_format *event)
+{
+        free(event->name);
+        free(event->system);
+
+        free_formats(&event->format);
+
+        free(event->print_fmt.format);
+        free_args(event->print_fmt.args);
+
+        free(event);
+}
+
+/**
+ * pevent_free - free a pevent handle
+ * @pevent: the pevent handle to free
+ */
+void pevent_free(struct pevent *pevent)
+{
+        struct cmdline_list *cmdlist, *cmdnext;
+        struct func_list *funclist, *funcnext;
+        struct printk_list *printklist, *printknext;
+        struct pevent_function_handler *func_handler;
+        struct event_handler *handle;
+        int i;
+
+        if (!pevent)
+                return;
+
+        cmdlist = pevent->cmdlist;
+        funclist = pevent->funclist;
+        printklist = pevent->printklist;
+
+        pevent->ref_count--;
+        if (pevent->ref_count)
+                return;
+
+        if (pevent->cmdlines) {
+                for (i = 0; i < pevent->cmdline_count; i++)
+                        free(pevent->cmdlines[i].comm);
+                free(pevent->cmdlines);
+        }
+
+        while (cmdlist) {
+                cmdnext = cmdlist->next;
+                free(cmdlist->comm);
+                free(cmdlist);
+                cmdlist = cmdnext;
+        }
+
+        if (pevent->func_map) {
+                for (i = 0; i < pevent->func_count; i++) {
+                        free(pevent->func_map[i].func);
+                        free(pevent->func_map[i].mod);
+                }
+                free(pevent->func_map);
+        }
+
+        while (funclist) {
+                funcnext = funclist->next;
+                free(funclist->func);
+                free(funclist->mod);
+                free(funclist);
+                funclist = funcnext;
+        }
+
+        while (pevent->func_handlers) {
+                func_handler = pevent->func_handlers;
+                pevent->func_handlers = func_handler->next;
+                free_func_handle(func_handler);
+        }
+
+        if (pevent->printk_map) {
+                for (i = 0; i < pevent->printk_count; i++)
+                        free(pevent->printk_map[i].printk);
+                free(pevent->printk_map);
+        }
+
+        while (printklist) {
+                printknext = printklist->next;
+                free(printklist->printk);
+                free(printklist);
+                printklist = printknext;
+        }
+
+        for (i = 0; i < pevent->nr_events; i++)
+                free_event(pevent->events[i]);
+
+        while (pevent->handlers) {
+                handle = pevent->handlers;
+                pevent->handlers = handle->next;
+                free_handler(handle);
+        }
+
+        free(pevent->events);
+        free(pevent->sort_events);
+
+        free(pevent);
+}
+
+void pevent_unref(struct pevent *pevent)
+{
+        pevent_free(pevent);
+}
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
new file mode 100644
index 000000000000..ac997bc7b592
--- /dev/null
+++ b/tools/lib/traceevent/event-parse.h
@@ -0,0 +1,804 @@
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#ifndef _PARSE_EVENTS_H
+#define _PARSE_EVENTS_H
+
+#include <stdarg.h>
+#include <regex.h>
+
+#ifndef __unused
+#define __unused __attribute__ ((unused))
+#endif
+
+/* ----------------------- trace_seq ----------------------- */
+
+
+#ifndef TRACE_SEQ_BUF_SIZE
+#define TRACE_SEQ_BUF_SIZE 4096
+#endif
+
+#ifndef DEBUG_RECORD
+#define DEBUG_RECORD 0
+#endif
+
+struct pevent_record {
+        unsigned long long      ts;
+        unsigned long long      offset;
+        long long               missed_events;  /* buffer dropped events before */
+        int                     record_size;    /* size of binary record */
+        int                     size;           /* size of data */
+        void                    *data;
+        int                     cpu;
+        int                     ref_count;
+        int                     locked;         /* Do not free, even if ref_count is zero */
+        void                    *private;
+#if DEBUG_RECORD
+        struct pevent_record    *prev;
+        struct pevent_record    *next;
+        long                    alloc_addr;
+#endif
+};
+
+/*
+ * Trace sequences are used to allow a function to call several other functions
+ * to create a string of data to use (up to a max of PAGE_SIZE).
+ */
+
+struct trace_seq {
+        char                    *buffer;
+        unsigned int            buffer_size;
+        unsigned int            len;
+        unsigned int            readpos;
+};
+
+void trace_seq_init(struct trace_seq *s);
+void trace_seq_destroy(struct trace_seq *s);
+
+extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
+extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+        __attribute__ ((format (printf, 2, 0)));
+
+extern int trace_seq_puts(struct trace_seq *s, const char *str);
+extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
+
+extern void trace_seq_terminate(struct trace_seq *s);
+
+extern int trace_seq_do_printf(struct trace_seq *s);
+
+
+/* ----------------------- pevent ----------------------- */
+
+struct pevent;
+struct event_format;
+
+typedef int (*pevent_event_handler_func)(struct trace_seq *s,
+                                         struct pevent_record *record,
+                                         struct event_format *event,
+                                         void *context);
+
+typedef int (*pevent_plugin_load_func)(struct pevent *pevent);
+typedef int (*pevent_plugin_unload_func)(void);
+
+struct plugin_option {
+        struct plugin_option            *next;
+        void                            *handle;
+        char                            *file;
+        char                            *name;
+        char                            *plugin_alias;
+        char                            *description;
+        char                            *value;
+        void                            *private;
+        int                             set;
+};
+
+/*
+ * Plugin hooks that can be called:
+ *
+ * PEVENT_PLUGIN_LOADER:  (required)
+ *   The function name to initialized the plugin.
+ *
+ *   int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
+ *
+ * PEVENT_PLUGIN_UNLOADER:  (optional)
+ *   The function called just before unloading
+ *
+ *   int PEVENT_PLUGIN_UNLOADER(void)
+ *
+ * PEVENT_PLUGIN_OPTIONS:  (optional)
+ *   Plugin options that can be set before loading
+ *
+ *   struct plugin_option PEVENT_PLUGIN_OPTIONS[] = {
+ *      {
+ *              .name = "option-name",
+ *              .plugin_alias = "overide-file-name", (optional)
+ *              .description = "description of option to show users",
+ *      },
+ *      {
+ *              .name = NULL,
+ *      },
+ *   };
+ *
+ *   Array must end with .name = NULL;
+ *
+ *
+ *   .plugin_alias is used to give a shorter name to access
+ *   the vairable. Useful if a plugin handles more than one event.
+ *
+ * PEVENT_PLUGIN_ALIAS: (optional)
+ *   The name to use for finding options (uses filename if not defined)
+ */
+#define PEVENT_PLUGIN_LOADER pevent_plugin_loader
+#define PEVENT_PLUGIN_UNLOADER pevent_plugin_unloader
+#define PEVENT_PLUGIN_OPTIONS pevent_plugin_options
+#define PEVENT_PLUGIN_ALIAS pevent_plugin_alias
+#define _MAKE_STR(x)    #x
+#define MAKE_STR(x)     _MAKE_STR(x)
+#define PEVENT_PLUGIN_LOADER_NAME MAKE_STR(PEVENT_PLUGIN_LOADER)
+#define PEVENT_PLUGIN_UNLOADER_NAME MAKE_STR(PEVENT_PLUGIN_UNLOADER)
+#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS)
+#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS)
+
+#define NSECS_PER_SEC           1000000000ULL
+#define NSECS_PER_USEC          1000ULL
+
+enum format_flags {
+        FIELD_IS_ARRAY          = 1,
+        FIELD_IS_POINTER        = 2,
+        FIELD_IS_SIGNED         = 4,
+        FIELD_IS_STRING         = 8,
+        FIELD_IS_DYNAMIC        = 16,
+        FIELD_IS_LONG           = 32,
+        FIELD_IS_FLAG           = 64,
+        FIELD_IS_SYMBOLIC       = 128,
+};
+
+struct format_field {
+        struct format_field     *next;
+        struct event_format     *event;
+        char                    *type;
+        char                    *name;
+        int                     offset;
+        int                     size;
+        unsigned int            arraylen;
+        unsigned int            elementsize;
+        unsigned long           flags;
+};
+
+struct format {
+        int                     nr_common;
+        int                     nr_fields;
+        struct format_field     *common_fields;
+        struct format_field     *fields;
+};
+
+struct print_arg_atom {
+        char                    *atom;
+};
+
+struct print_arg_string {
+        char                    *string;
+        int                     offset;
+};
+
+struct print_arg_field {
+        char                    *name;
+        struct format_field     *field;
+};
+
+struct print_flag_sym {
+        struct print_flag_sym   *next;
+        char                    *value;
+        char                    *str;
+};
+
+struct print_arg_typecast {
+        char                    *type;
+        struct print_arg        *item;
+};
+
+struct print_arg_flags {
+        struct print_arg        *field;
+        char                    *delim;
+        struct print_flag_sym   *flags;
+};
+
+struct print_arg_symbol {
+        struct print_arg        *field;
+        struct print_flag_sym   *symbols;
+};
+
+struct print_arg_dynarray {
+        struct format_field     *field;
+        struct print_arg        *index;
+};
+
+struct print_arg;
+
+struct print_arg_op {
+        char                    *op;
+        int                     prio;
+        struct print_arg        *left;
+        struct print_arg        *right;
+};
+
+struct pevent_function_handler;
+
+struct print_arg_func {
+        struct pevent_function_handler  *func;
+        struct print_arg                *args;
+};
+
+enum print_arg_type {
+        PRINT_NULL,
+        PRINT_ATOM,
+        PRINT_FIELD,
+        PRINT_FLAGS,
+        PRINT_SYMBOL,
+        PRINT_TYPE,
+        PRINT_STRING,
+        PRINT_BSTRING,
+        PRINT_DYNAMIC_ARRAY,
+        PRINT_OP,
+        PRINT_FUNC,
+};
+
+struct print_arg {
+        struct print_arg                *next;
+        enum print_arg_type             type;
+        union {
+                struct print_arg_atom           atom;
+                struct print_arg_field          field;
+                struct print_arg_typecast       typecast;
+                struct print_arg_flags          flags;
+                struct print_arg_symbol         symbol;
+                struct print_arg_func           func;
+                struct print_arg_string         string;
+                struct print_arg_op             op;
+                struct print_arg_dynarray       dynarray;
+        };
+};
+
+struct print_fmt {
+        char                    *format;
+        struct print_arg        *args;
+};
+
+struct event_format {
+        struct pevent           *pevent;
+        char                    *name;
+        int                     id;
+        int                     flags;
+        struct format           format;
+        struct print_fmt        print_fmt;
+        char                    *system;
+        pevent_event_handler_func handler;
+        void                    *context;
+};
+
+enum {
+        EVENT_FL_ISFTRACE       = 0x01,
+        EVENT_FL_ISPRINT        = 0x02,
+        EVENT_FL_ISBPRINT       = 0x04,
+        EVENT_FL_ISFUNCENT      = 0x10,
+        EVENT_FL_ISFUNCRET      = 0x20,
+
+        EVENT_FL_FAILED         = 0x80000000
+};
+
+enum event_sort_type {
+        EVENT_SORT_ID,
+        EVENT_SORT_NAME,
+        EVENT_SORT_SYSTEM,
+};
+
+enum event_type {
+        EVENT_ERROR,
+        EVENT_NONE,
+        EVENT_SPACE,
+        EVENT_NEWLINE,
+        EVENT_OP,
+        EVENT_DELIM,
+        EVENT_ITEM,
+        EVENT_DQUOTE,
+        EVENT_SQUOTE,
+};
+
+typedef unsigned long long (*pevent_func_handler)(struct trace_seq *s,
+                                             unsigned long long *args);
+
+enum pevent_func_arg_type {
+        PEVENT_FUNC_ARG_VOID,
+        PEVENT_FUNC_ARG_INT,
+        PEVENT_FUNC_ARG_LONG,
+        PEVENT_FUNC_ARG_STRING,
+        PEVENT_FUNC_ARG_PTR,
+        PEVENT_FUNC_ARG_MAX_TYPES
+};
+
+enum pevent_flag {
+        PEVENT_NSEC_OUTPUT              = 1,    /* output in NSECS */
+};
+
+struct cmdline;
+struct cmdline_list;
+struct func_map;
+struct func_list;
+struct event_handler;
+
+struct pevent {
+        int ref_count;
+
+        int header_page_ts_offset;
+        int header_page_ts_size;
+        int header_page_size_offset;
+        int header_page_size_size;
+        int header_page_data_offset;
+        int header_page_data_size;
+        int header_page_overwrite;
+
+        int file_bigendian;
+        int host_bigendian;
+
+        int latency_format;
+
+        int old_format;
+
+        int cpus;
+        int long_size;
+
+        struct cmdline *cmdlines;
+        struct cmdline_list *cmdlist;
+        int cmdline_count;
+
+        struct func_map *func_map;
+        struct func_list *funclist;
+        unsigned int func_count;
+
+        struct printk_map *printk_map;
+        struct printk_list *printklist;
+        unsigned int printk_count;
+
+
+        struct event_format **events;
+        int nr_events;
+        struct event_format **sort_events;
+        enum event_sort_type last_type;
+
+        int type_offset;
+        int type_size;
+
+        int pid_offset;
+        int pid_size;
+
+        int pc_offset;
+        int pc_size;
+
+        int flags_offset;
+        int flags_size;
+
+        int ld_offset;
+        int ld_size;
+
+        int print_raw;
+
+        int test_filters;
+
+        int flags;
+
+        struct format_field *bprint_ip_field;
+        struct format_field *bprint_fmt_field;
+        struct format_field *bprint_buf_field;
+
+        struct event_handler *handlers;
+        struct pevent_function_handler *func_handlers;
+
+        /* cache */
+        struct event_format *last_event;
+};
+
+static inline void pevent_set_flag(struct pevent *pevent, int flag)
+{
+        pevent->flags |= flag;
+}
+
+static inline unsigned short
+__data2host2(struct pevent *pevent, unsigned short data)
+{
+        unsigned short swap;
+
+        if (pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 8) |
+                ((data & (0xffULL << 8)) >> 8);
+
+        return swap;
+}
+
+static inline unsigned int
+__data2host4(struct pevent *pevent, unsigned int data)
+{
+        unsigned int swap;
+
+        if (pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 24) |
+                ((data & (0xffULL << 8)) << 8) |
+                ((data & (0xffULL << 16)) >> 8) |
+                ((data & (0xffULL << 24)) >> 24);
+
+        return swap;
+}
+
+static inline unsigned long long
+__data2host8(struct pevent *pevent, unsigned long long data)
+{
+        unsigned long long swap;
+
+        if (pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 56) |
+                ((data & (0xffULL << 8)) << 40) |
+                ((data & (0xffULL << 16)) << 24) |
+                ((data & (0xffULL << 24)) << 8) |
+                ((data & (0xffULL << 32)) >> 8) |
+                ((data & (0xffULL << 40)) >> 24) |
+                ((data & (0xffULL << 48)) >> 40) |
+                ((data & (0xffULL << 56)) >> 56);
+
+        return swap;
+}
+
+#define data2host2(pevent, ptr)         __data2host2(pevent, *(unsigned short *)(ptr))
+#define data2host4(pevent, ptr)         __data2host4(pevent, *(unsigned int *)(ptr))
+#define data2host8(pevent, ptr)                                 \
+({                                                              \
+        unsigned long long __val;                               \
+                                                                \
+        memcpy(&__val, (ptr), sizeof(unsigned long long));      \
+        __data2host8(pevent, __val);                            \
+})
+
+/* taken from kernel/trace/trace.h */
+enum trace_flag_type {
+        TRACE_FLAG_IRQS_OFF             = 0x01,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+};
+
+int pevent_register_comm(struct pevent *pevent, const char *comm, int pid);
+int pevent_register_function(struct pevent *pevent, char *name,
+                             unsigned long long addr, char *mod);
+int pevent_register_print_string(struct pevent *pevent, char *fmt,
+                                 unsigned long long addr);
+int pevent_pid_is_registered(struct pevent *pevent, int pid);
+
+void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
+                        struct pevent_record *record);
+
+int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size,
+                             int long_size);
+
+int pevent_parse_event(struct pevent *pevent, const char *buf,
+                       unsigned long size, const char *sys);
+
+void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
+                           const char *name, struct pevent_record *record,
+                           int *len, int err);
+
+int pevent_get_field_val(struct trace_seq *s, struct event_format *event,
+                         const char *name, struct pevent_record *record,
+                         unsigned long long *val, int err);
+int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event,
+                                const char *name, struct pevent_record *record,
+                                unsigned long long *val, int err);
+int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
+                             const char *name, struct pevent_record *record,
+                             unsigned long long *val, int err);
+
+int pevent_print_num_field(struct trace_seq *s, const char *fmt,
+                           struct event_format *event, const char *name,
+                           struct pevent_record *record, int err);
+
+int pevent_register_event_handler(struct pevent *pevent, int id, char *sys_name, char *event_name,
+                                  pevent_event_handler_func func, void *context);
+int pevent_register_print_function(struct pevent *pevent,
+                                   pevent_func_handler func,
+                                   enum pevent_func_arg_type ret_type,
+                                   char *name, ...);
+
+struct format_field *pevent_find_common_field(struct event_format *event, const char *name);
+struct format_field *pevent_find_field(struct event_format *event, const char *name);
+struct format_field *pevent_find_any_field(struct event_format *event, const char *name);
+
+const char *pevent_find_function(struct pevent *pevent, unsigned long long addr);
+unsigned long long
+pevent_find_function_address(struct pevent *pevent, unsigned long long addr);
+unsigned long long pevent_read_number(struct pevent *pevent, const void *ptr, int size);
+int pevent_read_number_field(struct format_field *field, const void *data,
+                             unsigned long long *value);
+
+struct event_format *pevent_find_event(struct pevent *pevent, int id);
+
+struct event_format *
+pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name);
+
+void pevent_data_lat_fmt(struct pevent *pevent,
+                         struct trace_seq *s, struct pevent_record *record);
+int pevent_data_type(struct pevent *pevent, struct pevent_record *rec);
+struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type);
+int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec);
+const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid);
+void pevent_event_info(struct trace_seq *s, struct event_format *event,
+                       struct pevent_record *record);
+
+struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type);
+struct format_field **pevent_event_common_fields(struct event_format *event);
+struct format_field **pevent_event_fields(struct event_format *event);
+
+static inline int pevent_get_cpus(struct pevent *pevent)
+{
+        return pevent->cpus;
+}
+
+static inline void pevent_set_cpus(struct pevent *pevent, int cpus)
+{
+        pevent->cpus = cpus;
+}
+
+static inline int pevent_get_long_size(struct pevent *pevent)
+{
+        return pevent->long_size;
+}
+
+static inline void pevent_set_long_size(struct pevent *pevent, int long_size)
+{
+        pevent->long_size = long_size;
+}
+
+static inline int pevent_is_file_bigendian(struct pevent *pevent)
+{
+        return pevent->file_bigendian;
+}
+
+static inline void pevent_set_file_bigendian(struct pevent *pevent, int endian)
+{
+        pevent->file_bigendian = endian;
+}
+
+static inline int pevent_is_host_bigendian(struct pevent *pevent)
+{
+        return pevent->host_bigendian;
+}
+
+static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian)
+{
+        pevent->host_bigendian = endian;
+}
+
+static inline int pevent_is_latency_format(struct pevent *pevent)
+{
+        return pevent->latency_format;
+}
+
+static inline void pevent_set_latency_format(struct pevent *pevent, int lat)
+{
+        pevent->latency_format = lat;
+}
+
+struct pevent *pevent_alloc(void);
+void pevent_free(struct pevent *pevent);
+void pevent_ref(struct pevent *pevent);
+void pevent_unref(struct pevent *pevent);
+
+/* access to the internal parser */
+void pevent_buffer_init(const char *buf, unsigned long long size);
+enum event_type pevent_read_token(char **tok);
+void pevent_free_token(char *token);
+int pevent_peek_char(void);
+const char *pevent_get_input_buf(void);
+unsigned long long pevent_get_input_buf_ptr(void);
+
+/* for debugging */
+void pevent_print_funcs(struct pevent *pevent);
+void pevent_print_printk(struct pevent *pevent);
+
+/* ----------------------- filtering ----------------------- */
+
+enum filter_boolean_type {
+        FILTER_FALSE,
+        FILTER_TRUE,
+};
+
+enum filter_op_type {
+        FILTER_OP_AND = 1,
+        FILTER_OP_OR,
+        FILTER_OP_NOT,
+};
+
+enum filter_cmp_type {
+        FILTER_CMP_NONE,
+        FILTER_CMP_EQ,
+        FILTER_CMP_NE,
+        FILTER_CMP_GT,
+        FILTER_CMP_LT,
+        FILTER_CMP_GE,
+        FILTER_CMP_LE,
+        FILTER_CMP_MATCH,
+        FILTER_CMP_NOT_MATCH,
+        FILTER_CMP_REGEX,
+        FILTER_CMP_NOT_REGEX,
+};
+
+enum filter_exp_type {
+        FILTER_EXP_NONE,
+        FILTER_EXP_ADD,
+        FILTER_EXP_SUB,
+        FILTER_EXP_MUL,
+        FILTER_EXP_DIV,
+        FILTER_EXP_MOD,
+        FILTER_EXP_RSHIFT,
+        FILTER_EXP_LSHIFT,
+        FILTER_EXP_AND,
+        FILTER_EXP_OR,
+        FILTER_EXP_XOR,
+        FILTER_EXP_NOT,
+};
+
+enum filter_arg_type {
+        FILTER_ARG_NONE,
+        FILTER_ARG_BOOLEAN,
+        FILTER_ARG_VALUE,
+        FILTER_ARG_FIELD,
+        FILTER_ARG_EXP,
+        FILTER_ARG_OP,
+        FILTER_ARG_NUM,
+        FILTER_ARG_STR,
+};
+
+enum filter_value_type {
+        FILTER_NUMBER,
+        FILTER_STRING,
+        FILTER_CHAR
+};
+
+struct fliter_arg;
+
+struct filter_arg_boolean {
+        enum filter_boolean_type        value;
+};
+
+struct filter_arg_field {
+        struct format_field     *field;
+};
+
+struct filter_arg_value {
+        enum filter_value_type  type;
+        union {
+                char                    *str;
+                unsigned long long      val;
+        };
+};
+
+struct filter_arg_op {
+        enum filter_op_type     type;
+        struct filter_arg       *left;
+        struct filter_arg       *right;
+};
+
+struct filter_arg_exp {
+        enum filter_exp_type    type;
+        struct filter_arg       *left;
+        struct filter_arg       *right;
+};
+
+struct filter_arg_num {
+        enum filter_cmp_type    type;
+        struct filter_arg       *left;
+        struct filter_arg       *right;
+};
+
+struct filter_arg_str {
+        enum filter_cmp_type    type;
+        struct format_field     *field;
+        char                    *val;
+        char                    *buffer;
+        regex_t                 reg;
+};
+
+struct filter_arg {
+        enum filter_arg_type    type;
+        union {
+                struct filter_arg_boolean       boolean;
+                struct filter_arg_field         field;
+                struct filter_arg_value         value;
+                struct filter_arg_op            op;
+                struct filter_arg_exp           exp;
+                struct filter_arg_num           num;
+                struct filter_arg_str           str;
+        };
+};
+
+struct filter_type {
+        int                     event_id;
+        struct event_format     *event;
+        struct filter_arg       *filter;
+};
+
+struct event_filter {
+        struct pevent           *pevent;
+        int                     filters;
+        struct filter_type      *event_filters;
+};
+
+struct event_filter *pevent_filter_alloc(struct pevent *pevent);
+
+#define FILTER_NONE             -2
+#define FILTER_NOEXIST          -1
+#define FILTER_MISS             0
+#define FILTER_MATCH            1
+
+enum filter_trivial_type {
+        FILTER_TRIVIAL_FALSE,
+        FILTER_TRIVIAL_TRUE,
+        FILTER_TRIVIAL_BOTH,
+};
+
+int pevent_filter_add_filter_str(struct event_filter *filter,
+                                 const char *filter_str,
+                                 char **error_str);
+
+
+int pevent_filter_match(struct event_filter *filter,
+                        struct pevent_record *record);
+
+int pevent_event_filtered(struct event_filter *filter,
+                          int event_id);
+
+void pevent_filter_reset(struct event_filter *filter);
+
+void pevent_filter_clear_trivial(struct event_filter *filter,
+                                 enum filter_trivial_type type);
+
+void pevent_filter_free(struct event_filter *filter);
+
+char *pevent_filter_make_string(struct event_filter *filter, int event_id);
+
+int pevent_filter_remove_event(struct event_filter *filter,
+                               int event_id);
+
+int pevent_filter_event_has_trivial(struct event_filter *filter,
+                                    int event_id,
+                                    enum filter_trivial_type type);
+
+int pevent_filter_copy(struct event_filter *dest, struct event_filter *source);
+
+int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
+                          enum filter_trivial_type type);
+
+int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2);
+
+#endif /* _PARSE_EVENTS_H */
diff --git a/tools/lib/traceevent/event-utils.h b/tools/lib/traceevent/event-utils.h
new file mode 100644
index 000000000000..08296383d1e6
--- /dev/null
+++ b/tools/lib/traceevent/event-utils.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#ifndef __UTIL_H
+#define __UTIL_H
+
+#include <ctype.h>
+
+/* Can be overridden */
+void die(const char *fmt, ...);
+void *malloc_or_die(unsigned int size);
+void warning(const char *fmt, ...);
+void pr_stat(const char *fmt, ...);
+void vpr_stat(const char *fmt, va_list ap);
+
+/* Always available */
+void __die(const char *fmt, ...);
+void __warning(const char *fmt, ...);
+void __pr_stat(const char *fmt, ...);
+
+void __vdie(const char *fmt, ...);
+void __vwarning(const char *fmt, ...);
+void __vpr_stat(const char *fmt, ...);
+
+static inline char *strim(char *string)
+{
+        char *ret;
+
+        if (!string)
+                return NULL;
+        while (*string) {
+                if (!isspace(*string))
+                        break;
+                string++;
+        }
+        ret = string;
+
+        string = ret + strlen(ret) - 1;
+        while (string > ret) {
+                if (!isspace(*string))
+                        break;
+                string--;
+        }
+        string[1] = 0;
+
+        return ret;
+}
+
+static inline int has_text(const char *text)
+{
+        if (!text)
+                return 0;
+
+        while (*text) {
+                if (!isspace(*text))
+                        return 1;
+                text++;
+        }
+
+        return 0;
+}
+
+#endif
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
new file mode 100644
index 000000000000..dfcfe2c131de
--- /dev/null
+++ b/tools/lib/traceevent/parse-filter.c
@@ -0,0 +1,2261 @@
+/*
+ * Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include "event-parse.h"
+#include "event-utils.h"
+
+#define COMM "COMM"
+
+static struct format_field comm = {
+        .name = "COMM",
+};
+
+struct event_list {
+        struct event_list       *next;
+        struct event_format     *event;
+};
+
+#define MAX_ERR_STR_SIZE 256
+
+static void show_error(char **error_str, const char *fmt, ...)
+{
+        unsigned long long index;
+        const char *input;
+        char *error;
+        va_list ap;
+        int len;
+        int i;
+
+        if (!error_str)
+                return;
+
+        input = pevent_get_input_buf();
+        index = pevent_get_input_buf_ptr();
+        len = input ? strlen(input) : 0;
+
+        error = malloc_or_die(MAX_ERR_STR_SIZE + (len*2) + 3);
+
+        if (len) {
+                strcpy(error, input);
+                error[len] = '\n';
+                for (i = 1; i < len && i < index; i++)
+                        error[len+i] = ' ';
+                error[len + i] = '^';
+                error[len + i + 1] = '\n';
+                len += i+2;
+        }
+
+        va_start(ap, fmt);
+        vsnprintf(error + len, MAX_ERR_STR_SIZE, fmt, ap);
+        va_end(ap);
+
+        *error_str = error;
+}
+
+static void free_token(char *token)
+{
+        pevent_free_token(token);
+}
+
+static enum event_type read_token(char **tok)
+{
+        enum event_type type;
+        char *token = NULL;
+
+        do {
+                free_token(token);
+                type = pevent_read_token(&token);
+        } while (type == EVENT_NEWLINE || type == EVENT_SPACE);
+
+        /* If token is = or ! check to see if the next char is ~ */
+        if (token &&
+            (strcmp(token, "=") == 0 || strcmp(token, "!") == 0) &&
+            pevent_peek_char() == '~') {
+                /* append it */
+                *tok = malloc(3);
+                sprintf(*tok, "%c%c", *token, '~');
+                free_token(token);
+                /* Now remove the '~' from the buffer */
+                pevent_read_token(&token);
+                free_token(token);
+        } else
+                *tok = token;
+
+        return type;
+}
+
+static int filter_cmp(const void *a, const void *b)
+{
+        const struct filter_type *ea = a;
+        const struct filter_type *eb = b;
+
+        if (ea->event_id < eb->event_id)
+                return -1;
+
+        if (ea->event_id > eb->event_id)
+                return 1;
+
+        return 0;
+}
+
+static struct filter_type *
+find_filter_type(struct event_filter *filter, int id)
+{
+        struct filter_type *filter_type;
+        struct filter_type key;
+
+        key.event_id = id;
+
+        filter_type = bsearch(&key, filter->event_filters,
+                              filter->filters,
+                              sizeof(*filter->event_filters),
+                              filter_cmp);
+
+        return filter_type;
+}
+
+static struct filter_type *
+add_filter_type(struct event_filter *filter, int id)
+{
+        struct filter_type *filter_type;
+        int i;
+
+        filter_type = find_filter_type(filter, 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");
+        }
+
+        for (i = 0; i < filter->filters; i++) {
+                if (filter->event_filters[i].event_id > id)
+                        break;
+        }
+
+        if (i < filter->filters)
+                memmove(&filter->event_filters[i+1],
+                        &filter->event_filters[i],
+                        sizeof(*filter->event_filters) *
+                        (filter->filters - i));
+
+        filter_type = &filter->event_filters[i];
+        filter_type->event_id = id;
+        filter_type->event = pevent_find_event(filter->pevent, id);
+        filter_type->filter = NULL;
+
+        filter->filters++;
+
+        return filter_type;
+}
+
+/**
+ * pevent_filter_alloc - create a new event filter
+ * @pevent: The pevent that this filter is associated with
+ */
+struct event_filter *pevent_filter_alloc(struct pevent *pevent)
+{
+        struct event_filter *filter;
+
+        filter = malloc_or_die(sizeof(*filter));
+        memset(filter, 0, sizeof(*filter));
+        filter->pevent = pevent;
+        pevent_ref(pevent);
+
+        return filter;
+}
+
+static struct filter_arg *allocate_arg(void)
+{
+        struct filter_arg *arg;
+
+        arg = malloc_or_die(sizeof(*arg));
+        memset(arg, 0, sizeof(*arg));
+
+        return arg;
+}
+
+static void free_arg(struct filter_arg *arg)
+{
+        if (!arg)
+                return;
+
+        switch (arg->type) {
+        case FILTER_ARG_NONE:
+        case FILTER_ARG_BOOLEAN:
+        case FILTER_ARG_NUM:
+                break;
+
+        case FILTER_ARG_STR:
+                free(arg->str.val);
+                regfree(&arg->str.reg);
+                free(arg->str.buffer);
+                break;
+
+        case FILTER_ARG_OP:
+                free_arg(arg->op.left);
+                free_arg(arg->op.right);
+        default:
+                break;
+        }
+
+        free(arg);
+}
+
+static void add_event(struct event_list **events,
+                      struct event_format *event)
+{
+        struct event_list *list;
+
+        list = malloc_or_die(sizeof(*list));
+        list->next = *events;
+        *events = list;
+        list->event = event;
+}
+
+static int event_match(struct event_format *event,
+                       regex_t *sreg, regex_t *ereg)
+{
+        if (sreg) {
+                return !regexec(sreg, event->system, 0, NULL, 0) &&
+                        !regexec(ereg, event->name, 0, NULL, 0);
+        }
+
+        return !regexec(ereg, event->system, 0, NULL, 0) ||
+                !regexec(ereg, event->name, 0, NULL, 0);
+}
+
+static int
+find_event(struct pevent *pevent, struct event_list **events,
+           char *sys_name, char *event_name)
+{
+        struct event_format *event;
+        regex_t ereg;
+        regex_t sreg;
+        int match = 0;
+        char *reg;
+        int ret;
+        int i;
+
+        if (!event_name) {
+                /* if no name is given, then swap sys and name */
+                event_name = sys_name;
+                sys_name = NULL;
+        }
+
+        reg = malloc_or_die(strlen(event_name) + 3);
+        sprintf(reg, "^%s$", event_name);
+
+        ret = regcomp(&ereg, reg, REG_ICASE|REG_NOSUB);
+        free(reg);
+
+        if (ret)
+                return -1;
+
+        if (sys_name) {
+                reg = malloc_or_die(strlen(sys_name) + 3);
+                sprintf(reg, "^%s$", sys_name);
+                ret = regcomp(&sreg, reg, REG_ICASE|REG_NOSUB);
+                free(reg);
+                if (ret) {
+                        regfree(&ereg);
+                        return -1;
+                }
+        }
+
+        for (i = 0; i < pevent->nr_events; i++) {
+                event = pevent->events[i];
+                if (event_match(event, sys_name ? &sreg : NULL, &ereg)) {
+                        match = 1;
+                        add_event(events, event);
+                }
+        }
+
+        regfree(&ereg);
+        if (sys_name)
+                regfree(&sreg);
+
+        if (!match)
+                return -1;
+
+        return 0;
+}
+
+static void free_events(struct event_list *events)
+{
+        struct event_list *event;
+
+        while (events) {
+                event = events;
+                events = events->next;
+                free(event);
+        }
+}
+
+static struct filter_arg *
+create_arg_item(struct event_format *event, const char *token,
+                enum event_type type, char **error_str)
+{
+        struct format_field *field;
+        struct filter_arg *arg;
+
+        arg = allocate_arg();
+
+        switch (type) {
+
+        case EVENT_SQUOTE:
+        case EVENT_DQUOTE:
+                arg->type = FILTER_ARG_VALUE;
+                arg->value.type =
+                        type == EVENT_DQUOTE ? FILTER_STRING : FILTER_CHAR;
+                arg->value.str = strdup(token);
+                if (!arg->value.str)
+                        die("malloc string");
+                break;
+        case EVENT_ITEM:
+                /* if it is a number, then convert it */
+                if (isdigit(token[0])) {
+                        arg->type = FILTER_ARG_VALUE;
+                        arg->value.type = FILTER_NUMBER;
+                        arg->value.val = strtoull(token, NULL, 0);
+                        break;
+                }
+                /* Consider this a field */
+                field = pevent_find_any_field(event, token);
+                if (!field) {
+                        if (strcmp(token, COMM) != 0) {
+                                /* not a field, Make it false */
+                                arg->type = FILTER_ARG_BOOLEAN;
+                                arg->boolean.value = FILTER_FALSE;
+                                break;
+                        }
+                        /* If token is 'COMM' then it is special */
+                        field = &comm;
+                }
+                arg->type = FILTER_ARG_FIELD;
+                arg->field.field = field;
+                break;
+        default:
+                free_arg(arg);
+                show_error(error_str, "expected a value but found %s",
+                           token);
+                return NULL;
+        }
+        return arg;
+}
+
+static struct filter_arg *
+create_arg_op(enum filter_op_type btype)
+{
+        struct filter_arg *arg;
+
+        arg = allocate_arg();
+        arg->type = FILTER_ARG_OP;
+        arg->op.type = btype;
+
+        return arg;
+}
+
+static struct filter_arg *
+create_arg_exp(enum filter_exp_type etype)
+{
+        struct filter_arg *arg;
+
+        arg = allocate_arg();
+        arg->type = FILTER_ARG_EXP;
+        arg->op.type = etype;
+
+        return arg;
+}
+
+static struct filter_arg *
+create_arg_cmp(enum filter_exp_type etype)
+{
+        struct filter_arg *arg;
+
+        arg = allocate_arg();
+        /* Use NUM and change if necessary */
+        arg->type = FILTER_ARG_NUM;
+        arg->op.type = etype;
+
+        return arg;
+}
+
+static int add_right(struct filter_arg *op, struct filter_arg *arg,
+                     char **error_str)
+{
+        struct filter_arg *left;
+        char *str;
+        int op_type;
+        int ret;
+
+        switch (op->type) {
+        case FILTER_ARG_EXP:
+                if (op->exp.right)
+                        goto out_fail;
+                op->exp.right = arg;
+                break;
+
+        case FILTER_ARG_OP:
+                if (op->op.right)
+                        goto out_fail;
+                op->op.right = arg;
+                break;
+
+        case FILTER_ARG_NUM:
+                if (op->op.right)
+                        goto out_fail;
+                /*
+                 * The arg must be num, str, or field
+                 */
+                switch (arg->type) {
+                case FILTER_ARG_VALUE:
+                case FILTER_ARG_FIELD:
+                        break;
+                default:
+                        show_error(error_str,
+                                   "Illegal rvalue");
+                        return -1;
+                }
+
+                /*
+                 * Depending on the type, we may need to
+                 * convert this to a string or regex.
+                 */
+                switch (arg->value.type) {
+                case FILTER_CHAR:
+                        /*
+                         * A char should be converted to number if
+                         * the string is 1 byte, and the compare
+                         * is not a REGEX.
+                         */
+                        if (strlen(arg->value.str) == 1 &&
+                            op->num.type != FILTER_CMP_REGEX &&
+                            op->num.type != FILTER_CMP_NOT_REGEX) {
+                                arg->value.type = FILTER_NUMBER;
+                                goto do_int;
+                        }
+                        /* fall through */
+                case FILTER_STRING:
+
+                        /* convert op to a string arg */
+                        op_type = op->num.type;
+                        left = op->num.left;
+                        str = arg->value.str;
+
+                        /* reset the op for the new field */
+                        memset(op, 0, sizeof(*op));
+
+                        /*
+                         * If left arg was a field not found then
+                         * NULL the entire op.
+                         */
+                        if (left->type == FILTER_ARG_BOOLEAN) {
+                                free_arg(left);
+                                free_arg(arg);
+                                op->type = FILTER_ARG_BOOLEAN;
+                                op->boolean.value = FILTER_FALSE;
+                                break;
+                        }
+
+                        /* Left arg must be a field */
+                        if (left->type != FILTER_ARG_FIELD) {
+                                show_error(error_str,
+                                           "Illegal lvalue for string comparison");
+                                return -1;
+                        }
+
+                        /* Make sure this is a valid string compare */
+                        switch (op_type) {
+                        case FILTER_CMP_EQ:
+                                op_type = FILTER_CMP_MATCH;
+                                break;
+                        case FILTER_CMP_NE:
+                                op_type = FILTER_CMP_NOT_MATCH;
+                                break;
+
+                        case FILTER_CMP_REGEX:
+                        case FILTER_CMP_NOT_REGEX:
+                                ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);
+                                if (ret) {
+                                        show_error(error_str,
+                                                   "RegEx '%s' did not compute",
+                                                   str);
+                                        return -1;
+                                }
+                                break;
+                        default:
+                                show_error(error_str,
+                                           "Illegal comparison for string");
+                                return -1;
+                        }
+
+                        op->type = FILTER_ARG_STR;
+                        op->str.type = op_type;
+                        op->str.field = left->field.field;
+                        op->str.val = strdup(str);
+                        if (!op->str.val)
+                                die("malloc string");
+                        /*
+                         * Need a buffer to copy data for tests
+                         */
+                        op->str.buffer = malloc_or_die(op->str.field->size + 1);
+                        /* Null terminate this buffer */
+                        op->str.buffer[op->str.field->size] = 0;
+
+                        /* We no longer have left or right args */
+                        free_arg(arg);
+                        free_arg(left);
+
+                        break;
+
+                case FILTER_NUMBER:
+
+ do_int:
+                        switch (op->num.type) {
+                        case FILTER_CMP_REGEX:
+                        case FILTER_CMP_NOT_REGEX:
+                                show_error(error_str,
+                                           "Op not allowed with integers");
+                                return -1;
+
+                        default:
+                                break;
+                        }
+
+                        /* numeric compare */
+                        op->num.right = arg;
+                        break;
+                default:
+                        goto out_fail;
+                }
+                break;
+        default:
+                goto out_fail;
+        }
+
+        return 0;
+
+ out_fail:
+        show_error(error_str,
+                   "Syntax error");
+        return -1;
+}
+
+static struct filter_arg *
+rotate_op_right(struct filter_arg *a, struct filter_arg *b)
+{
+        struct filter_arg *arg;
+
+        arg = a->op.right;
+        a->op.right = b;
+        return arg;
+}
+
+static int add_left(struct filter_arg *op, struct filter_arg *arg)
+{
+        switch (op->type) {
+        case FILTER_ARG_EXP:
+                if (arg->type == FILTER_ARG_OP)
+                        arg = rotate_op_right(arg, op);
+                op->exp.left = arg;
+                break;
+
+        case FILTER_ARG_OP:
+                op->op.left = arg;
+                break;
+        case FILTER_ARG_NUM:
+                if (arg->type == FILTER_ARG_OP)
+                        arg = rotate_op_right(arg, op);
+
+                /* left arg of compares must be a field */
+                if (arg->type != FILTER_ARG_FIELD &&
+                    arg->type != FILTER_ARG_BOOLEAN)
+                        return -1;
+                op->num.left = arg;
+                break;
+        default:
+                return -1;
+        }
+        return 0;
+}
+
+enum op_type {
+        OP_NONE,
+        OP_BOOL,
+        OP_NOT,
+        OP_EXP,
+        OP_CMP,
+};
+
+static enum op_type process_op(const char *token,
+                               enum filter_op_type *btype,
+                               enum filter_cmp_type *ctype,
+                               enum filter_exp_type *etype)
+{
+        *btype = FILTER_OP_NOT;
+        *etype = FILTER_EXP_NONE;
+        *ctype = FILTER_CMP_NONE;
+
+        if (strcmp(token, "&&") == 0)
+                *btype = FILTER_OP_AND;
+        else if (strcmp(token, "||") == 0)
+                *btype = FILTER_OP_OR;
+        else if (strcmp(token, "!") == 0)
+                return OP_NOT;
+
+        if (*btype != FILTER_OP_NOT)
+                return OP_BOOL;
+
+        /* Check for value expressions */
+        if (strcmp(token, "+") == 0) {
+                *etype = FILTER_EXP_ADD;
+        } else if (strcmp(token, "-") == 0) {
+                *etype = FILTER_EXP_SUB;
+        } else if (strcmp(token, "*") == 0) {
+                *etype = FILTER_EXP_MUL;
+        } else if (strcmp(token, "/") == 0) {
+                *etype = FILTER_EXP_DIV;
+        } else if (strcmp(token, "%") == 0) {
+                *etype = FILTER_EXP_MOD;
+        } else if (strcmp(token, ">>") == 0) {
+                *etype = FILTER_EXP_RSHIFT;
+        } else if (strcmp(token, "<<") == 0) {
+                *etype = FILTER_EXP_LSHIFT;
+        } else if (strcmp(token, "&") == 0) {
+                *etype = FILTER_EXP_AND;
+        } else if (strcmp(token, "|") == 0) {
+                *etype = FILTER_EXP_OR;
+        } else if (strcmp(token, "^") == 0) {
+                *etype = FILTER_EXP_XOR;
+        } else if (strcmp(token, "~") == 0)
+                *etype = FILTER_EXP_NOT;
+
+        if (*etype != FILTER_EXP_NONE)
+                return OP_EXP;
+
+        /* Check for compares */
+        if (strcmp(token, "==") == 0)
+                *ctype = FILTER_CMP_EQ;
+        else if (strcmp(token, "!=") == 0)
+                *ctype = FILTER_CMP_NE;
+        else if (strcmp(token, "<") == 0)
+                *ctype = FILTER_CMP_LT;
+        else if (strcmp(token, ">") == 0)
+                *ctype = FILTER_CMP_GT;
+        else if (strcmp(token, "<=") == 0)
+                *ctype = FILTER_CMP_LE;
+        else if (strcmp(token, ">=") == 0)
+                *ctype = FILTER_CMP_GE;
+        else if (strcmp(token, "=~") == 0)
+                *ctype = FILTER_CMP_REGEX;
+        else if (strcmp(token, "!~") == 0)
+                *ctype = FILTER_CMP_NOT_REGEX;
+        else
+                return OP_NONE;
+
+        return OP_CMP;
+}
+
+static int check_op_done(struct filter_arg *arg)
+{
+        switch (arg->type) {
+        case FILTER_ARG_EXP:
+                return arg->exp.right != NULL;
+
+        case FILTER_ARG_OP:
+                return arg->op.right != NULL;
+
+        case FILTER_ARG_NUM:
+                return arg->num.right != NULL;
+
+        case FILTER_ARG_STR:
+                /* A string conversion is always done */
+                return 1;
+
+        case FILTER_ARG_BOOLEAN:
+                /* field not found, is ok */
+                return 1;
+
+        default:
+                return 0;
+        }
+}
+
+enum filter_vals {
+        FILTER_VAL_NORM,
+        FILTER_VAL_FALSE,
+        FILTER_VAL_TRUE,
+};
+
+void reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
+                  struct filter_arg *arg)
+{
+        struct filter_arg *other_child;
+        struct filter_arg **ptr;
+
+        if (parent->type != FILTER_ARG_OP &&
+            arg->type != FILTER_ARG_OP)
+                die("can not reparent other than OP");
+
+        /* Get the sibling */
+        if (old_child->op.right == arg) {
+                ptr = &old_child->op.right;
+                other_child = old_child->op.left;
+        } else if (old_child->op.left == arg) {
+                ptr = &old_child->op.left;
+                other_child = old_child->op.right;
+        } else
+                die("Error in reparent op, find other child");
+
+        /* Detach arg from old_child */
+        *ptr = NULL;
+
+        /* Check for root */
+        if (parent == old_child) {
+                free_arg(other_child);
+                *parent = *arg;
+                /* Free arg without recussion */
+                free(arg);
+                return;
+        }
+
+        if (parent->op.right == old_child)
+                ptr = &parent->op.right;
+        else if (parent->op.left == old_child)
+                ptr = &parent->op.left;
+        else
+                die("Error in reparent op");
+        *ptr = arg;
+
+        free_arg(old_child);
+}
+
+enum filter_vals test_arg(struct filter_arg *parent, struct filter_arg *arg)
+{
+        enum filter_vals lval, rval;
+
+        switch (arg->type) {
+
+                /* bad case */
+        case FILTER_ARG_BOOLEAN:
+                return FILTER_VAL_FALSE + arg->boolean.value;
+
+                /* good cases: */
+        case FILTER_ARG_STR:
+        case FILTER_ARG_VALUE:
+        case FILTER_ARG_FIELD:
+                return FILTER_VAL_NORM;
+
+        case FILTER_ARG_EXP:
+                lval = test_arg(arg, arg->exp.left);
+                if (lval != FILTER_VAL_NORM)
+                        return lval;
+                rval = test_arg(arg, arg->exp.right);
+                if (rval != FILTER_VAL_NORM)
+                        return rval;
+                return FILTER_VAL_NORM;
+
+        case FILTER_ARG_NUM:
+                lval = test_arg(arg, arg->num.left);
+                if (lval != FILTER_VAL_NORM)
+                        return lval;
+                rval = test_arg(arg, arg->num.right);
+                if (rval != FILTER_VAL_NORM)
+                        return rval;
+                return FILTER_VAL_NORM;
+
+        case FILTER_ARG_OP:
+                if (arg->op.type != FILTER_OP_NOT) {
+                        lval = test_arg(arg, arg->op.left);
+                        switch (lval) {
+                        case FILTER_VAL_NORM:
+                                break;
+                        case FILTER_VAL_TRUE:
+                                if (arg->op.type == FILTER_OP_OR)
+                                        return FILTER_VAL_TRUE;
+                                rval = test_arg(arg, arg->op.right);
+                                if (rval != FILTER_VAL_NORM)
+                                        return rval;
+
+                                reparent_op_arg(parent, arg, arg->op.right);
+                                return FILTER_VAL_NORM;
+
+                        case FILTER_VAL_FALSE:
+                                if (arg->op.type == FILTER_OP_AND)
+                                        return FILTER_VAL_FALSE;
+                                rval = test_arg(arg, arg->op.right);
+                                if (rval != FILTER_VAL_NORM)
+                                        return rval;
+
+                                reparent_op_arg(parent, arg, arg->op.right);
+                                return FILTER_VAL_NORM;
+                        }
+                }
+
+                rval = test_arg(arg, arg->op.right);
+                switch (rval) {
+                case FILTER_VAL_NORM:
+                        break;
+                case FILTER_VAL_TRUE:
+                        if (arg->op.type == FILTER_OP_OR)
+                                return FILTER_VAL_TRUE;
+                        if (arg->op.type == FILTER_OP_NOT)
+                                return FILTER_VAL_FALSE;
+
+                        reparent_op_arg(parent, arg, arg->op.left);
+                        return FILTER_VAL_NORM;
+
+                case FILTER_VAL_FALSE:
+                        if (arg->op.type == FILTER_OP_AND)
+                                return FILTER_VAL_FALSE;
+                        if (arg->op.type == FILTER_OP_NOT)
+                                return FILTER_VAL_TRUE;
+
+                        reparent_op_arg(parent, arg, arg->op.left);
+                        return FILTER_VAL_NORM;
+                }
+
+                return FILTER_VAL_NORM;
+        default:
+                die("bad arg in filter tree");
+        }
+        return FILTER_VAL_NORM;
+}
+
+/* Remove any unknown event fields */
+static struct filter_arg *collapse_tree(struct filter_arg *arg)
+{
+        enum filter_vals ret;
+
+        ret = test_arg(arg, arg);
+        switch (ret) {
+        case FILTER_VAL_NORM:
+                return arg;
+
+        case FILTER_VAL_TRUE:
+        case FILTER_VAL_FALSE:
+                free_arg(arg);
+                arg = allocate_arg();
+                arg->type = FILTER_ARG_BOOLEAN;
+                arg->boolean.value = ret == FILTER_VAL_TRUE;
+        }
+
+        return arg;
+}
+
+static int
+process_filter(struct event_format *event, struct filter_arg **parg,
+               char **error_str, int not)
+{
+        enum event_type type;
+        char *token = NULL;
+        struct filter_arg *current_op = NULL;
+        struct filter_arg *current_exp = NULL;
+        struct filter_arg *left_item = NULL;
+        struct filter_arg *arg = NULL;
+        enum op_type op_type;
+        enum filter_op_type btype;
+        enum filter_exp_type etype;
+        enum filter_cmp_type ctype;
+        int ret;
+
+        *parg = NULL;
+
+        do {
+                free(token);
+                type = read_token(&token);
+                switch (type) {
+                case EVENT_SQUOTE:
+                case EVENT_DQUOTE:
+                case EVENT_ITEM:
+                        arg = create_arg_item(event, token, type, error_str);
+                        if (!arg)
+                                goto fail;
+                        if (!left_item)
+                                left_item = arg;
+                        else if (current_exp) {
+                                ret = add_right(current_exp, arg, error_str);
+                                if (ret < 0)
+                                        goto fail;
+                                left_item = NULL;
+                                /* Not's only one one expression */
+                                if (not) {
+                                        arg = NULL;
+                                        if (current_op)
+                                                goto fail_print;
+                                        free(token);
+                                        *parg = current_exp;
+                                        return 0;
+                                }
+                        } else
+                                goto fail_print;
+                        arg = NULL;
+                        break;
+
+                case EVENT_DELIM:
+                        if (*token == ',') {
+                                show_error(error_str,
+                                           "Illegal token ','");
+                                goto fail;
+                        }
+
+                        if (*token == '(') {
+                                if (left_item) {
+                                        show_error(error_str,
+                                                   "Open paren can not come after item");
+                                        goto fail;
+                                }
+                                if (current_exp) {
+                                        show_error(error_str,
+                                                   "Open paren can not come after expression");
+                                        goto fail;
+                                }
+
+                                ret = process_filter(event, &arg, error_str, 0);
+                                if (ret != 1) {
+                                        if (ret == 0)
+                                                show_error(error_str,
+                                                           "Unbalanced number of '('");
+                                        goto fail;
+                                }
+                                ret = 0;
+
+                                /* A not wants just one expression */
+                                if (not) {
+                                        if (current_op)
+                                                goto fail_print;
+                                        *parg = arg;
+                                        return 0;
+                                }
+
+                                if (current_op)
+                                        ret = add_right(current_op, arg, error_str);
+                                else
+                                        current_exp = arg;
+
+                                if (ret < 0)
+                                        goto fail;
+
+                        } else { /* ')' */
+                                if (!current_op && !current_exp)
+                                        goto fail_print;
+
+                                /* Make sure everything is finished at this level */
+                                if (current_exp && !check_op_done(current_exp))
+                                        goto fail_print;
+                                if (current_op && !check_op_done(current_op))
+                                        goto fail_print;
+
+                                if (current_op)
+                                        *parg = current_op;
+                                else
+                                        *parg = current_exp;
+                                return 1;
+                        }
+                        break;
+
+                case EVENT_OP:
+                        op_type = process_op(token, &btype, &ctype, &etype);
+
+                        /* All expect a left arg except for NOT */
+                        switch (op_type) {
+                        case OP_BOOL:
+                                /* Logic ops need a left expression */
+                                if (!current_exp && !current_op)
+                                        goto fail_print;
+                                /* fall through */
+                        case OP_NOT:
+                                /* logic only processes ops and exp */
+                                if (left_item)
+                                        goto fail_print;
+                                break;
+                        case OP_EXP:
+                        case OP_CMP:
+                                if (!left_item)
+                                        goto fail_print;
+                                break;
+                        case OP_NONE:
+                                show_error(error_str,
+                                           "Unknown op token %s", token);
+                                goto fail;
+                        }
+
+                        ret = 0;
+                        switch (op_type) {
+                        case OP_BOOL:
+                                arg = create_arg_op(btype);
+                                if (current_op)
+                                        ret = add_left(arg, current_op);
+                                else
+                                        ret = add_left(arg, current_exp);
+                                current_op = arg;
+                                current_exp = NULL;
+                                break;
+
+                        case OP_NOT:
+                                arg = create_arg_op(btype);
+                                if (current_op)
+                                        ret = add_right(current_op, arg, error_str);
+                                if (ret < 0)
+                                        goto fail;
+                                current_exp = arg;
+                                ret = process_filter(event, &arg, error_str, 1);
+                                if (ret < 0)
+                                        goto fail;
+                                ret = add_right(current_exp, arg, error_str);
+                                if (ret < 0)
+                                        goto fail;
+                                break;
+
+                        case OP_EXP:
+                        case OP_CMP:
+                                if (op_type == OP_EXP)
+                                        arg = create_arg_exp(etype);
+                                else
+                                        arg = create_arg_cmp(ctype);
+
+                                if (current_op)
+                                        ret = add_right(current_op, arg, error_str);
+                                if (ret < 0)
+                                        goto fail;
+                                ret = add_left(arg, left_item);
+                                if (ret < 0) {
+                                        arg = NULL;
+                                        goto fail_print;
+                                }
+                                current_exp = arg;
+                                break;
+                        default:
+                                break;
+                        }
+                        arg = NULL;
+                        if (ret < 0)
+                                goto fail_print;
+                        break;
+                case EVENT_NONE:
+                        break;
+                default:
+                        goto fail_print;
+                }
+        } while (type != EVENT_NONE);
+
+        if (!current_op && !current_exp)
+                goto fail_print;
+
+        if (!current_op)
+                current_op = current_exp;
+
+        current_op = collapse_tree(current_op);
+
+        *parg = current_op;
+
+        return 0;
+
+ fail_print:
+        show_error(error_str, "Syntax error");
+ fail:
+        free_arg(current_op);
+        free_arg(current_exp);
+        free_arg(arg);
+        free(token);
+        return -1;
+}
+
+static int
+process_event(struct event_format *event, const char *filter_str,
+              struct filter_arg **parg, char **error_str)
+{
+        int ret;
+
+        pevent_buffer_init(filter_str, strlen(filter_str));
+
+        ret = process_filter(event, parg, error_str, 0);
+        if (ret == 1) {
+                show_error(error_str,
+                           "Unbalanced number of ')'");
+                return -1;
+        }
+        if (ret < 0)
+                return ret;
+
+        /* If parg is NULL, then make it into FALSE */
+        if (!*parg) {
+                *parg = allocate_arg();
+                (*parg)->type = FILTER_ARG_BOOLEAN;
+                (*parg)->boolean.value = FILTER_FALSE;
+        }
+
+        return 0;
+}
+
+static int filter_event(struct event_filter *filter,
+                        struct event_format *event,
+                        const char *filter_str, char **error_str)
+{
+        struct filter_type *filter_type;
+        struct filter_arg *arg;
+        int ret;
+
+        if (filter_str) {
+                ret = process_event(event, filter_str, &arg, error_str);
+                if (ret < 0)
+                        return ret;
+
+        } else {
+                /* just add a TRUE arg */
+                arg = allocate_arg();
+                arg->type = FILTER_ARG_BOOLEAN;
+                arg->boolean.value = FILTER_TRUE;
+        }
+
+        filter_type = add_filter_type(filter, event->id);
+        if (filter_type->filter)
+                free_arg(filter_type->filter);
+        filter_type->filter = arg;
+
+        return 0;
+}
+
+/**
+ * pevent_filter_add_filter_str - add a new filter
+ * @filter: the event filter to add to
+ * @filter_str: the filter string that contains the filter
+ * @error_str: string containing reason for failed filter
+ *
+ * Returns 0 if the filter was successfully added
+ *   -1 if there was an error.
+ *
+ * On error, if @error_str points to a string pointer,
+ * it is set to the reason that the filter failed.
+ * This string must be freed with "free".
+ */
+int pevent_filter_add_filter_str(struct event_filter *filter,
+                                 const char *filter_str,
+                                 char **error_str)
+{
+        struct pevent *pevent = filter->pevent;
+        struct event_list *event;
+        struct event_list *events = NULL;
+        const char *filter_start;
+        const char *next_event;
+        char *this_event;
+        char *event_name = NULL;
+        char *sys_name = NULL;
+        char *sp;
+        int rtn = 0;
+        int len;
+        int ret;
+
+        /* clear buffer to reset show error */
+        pevent_buffer_init("", 0);
+
+        if (error_str)
+                *error_str = NULL;
+
+        filter_start = strchr(filter_str, ':');
+        if (filter_start)
+                len = filter_start - filter_str;
+        else
+                len = strlen(filter_str);
+
+
+        do {
+                next_event = strchr(filter_str, ',');
+                if (next_event &&
+                    (!filter_start || next_event < filter_start))
+                        len = next_event - filter_str;
+                else if (filter_start)
+                        len = filter_start - filter_str;
+                else
+                        len = strlen(filter_str);
+
+                this_event = malloc_or_die(len + 1);
+                memcpy(this_event, filter_str, len);
+                this_event[len] = 0;
+
+                if (next_event)
+                        next_event++;
+
+                filter_str = next_event;
+
+                sys_name = strtok_r(this_event, "/", &sp);
+                event_name = strtok_r(NULL, "/", &sp);
+
+                if (!sys_name) {
+                        show_error(error_str, "No filter found");
+                        /* This can only happen when events is NULL, but still */
+                        free_events(events);
+                        free(this_event);
+                        return -1;
+                }
+
+                /* Find this event */
+                ret = find_event(pevent, &events, strim(sys_name), strim(event_name));
+                if (ret < 0) {
+                        if (event_name)
+                                show_error(error_str,
+                                           "No event found under '%s.%s'",
+                                           sys_name, event_name);
+                        else
+                                show_error(error_str,
+                                           "No event found under '%s'",
+                                           sys_name);
+                        free_events(events);
+                        free(this_event);
+                        return -1;
+                }
+                free(this_event);
+        } while (filter_str);
+
+        /* Skip the ':' */
+        if (filter_start)
+                filter_start++;
+
+        /* filter starts here */
+        for (event = events; event; event = event->next) {
+                ret = filter_event(filter, event->event, filter_start,
+                                   error_str);
+                /* Failures are returned if a parse error happened */
+                if (ret < 0)
+                        rtn = ret;
+
+                if (ret >= 0 && pevent->test_filters) {
+                        char *test;
+                        test = pevent_filter_make_string(filter, event->event->id);
+                        printf(" '%s: %s'\n", event->event->name, test);
+                        free(test);
+                }
+        }
+
+        free_events(events);
+
+        if (rtn >= 0 && pevent->test_filters)
+                exit(0);
+
+        return rtn;
+}
+
+static void free_filter_type(struct filter_type *filter_type)
+{
+        free_arg(filter_type->filter);
+}
+
+/**
+ * pevent_filter_remove_event - remove a filter for an event
+ * @filter: the event filter to remove from
+ * @event_id: the event to remove a filter for
+ *
+ * Removes the filter saved for an event defined by @event_id
+ * from the @filter.
+ *
+ * Returns 1: if an event was removed
+ *   0: if the event was not found
+ */
+int pevent_filter_remove_event(struct event_filter *filter,
+                               int event_id)
+{
+        struct filter_type *filter_type;
+        unsigned long len;
+
+        if (!filter->filters)
+                return 0;
+
+        filter_type = find_filter_type(filter, event_id);
+
+        if (!filter_type)
+                return 0;
+
+        free_filter_type(filter_type);
+
+        /* The filter_type points into the event_filters array */
+        len = (unsigned long)(filter->event_filters + filter->filters) -
+                (unsigned long)(filter_type + 1);
+
+        memmove(filter_type, filter_type + 1, len);
+        filter->filters--;
+
+        memset(&filter->event_filters[filter->filters], 0,
+               sizeof(*filter_type));
+
+        return 1;
+}
+
+/**
+ * pevent_filter_reset - clear all filters in a filter
+ * @filter: the event filter to reset
+ *
+ * Removes all filters from a filter and resets it.
+ */
+void pevent_filter_reset(struct event_filter *filter)
+{
+        int i;
+
+        for (i = 0; i < filter->filters; i++)
+                free_filter_type(&filter->event_filters[i]);
+
+        free(filter->event_filters);
+        filter->filters = 0;
+        filter->event_filters = NULL;
+}
+
+void pevent_filter_free(struct event_filter *filter)
+{
+        pevent_unref(filter->pevent);
+
+        pevent_filter_reset(filter);
+
+        free(filter);
+}
+
+static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg);
+
+static int copy_filter_type(struct event_filter *filter,
+                             struct event_filter *source,
+                             struct filter_type *filter_type)
+{
+        struct filter_arg *arg;
+        struct event_format *event;
+        const char *sys;
+        const char *name;
+        char *str;
+
+        /* Can't assume that the pevent's are the same */
+        sys = filter_type->event->system;
+        name = filter_type->event->name;
+        event = pevent_find_event_by_name(filter->pevent, sys, name);
+        if (!event)
+                return -1;
+
+        str = arg_to_str(source, filter_type->filter);
+        if (!str)
+                return -1;
+
+        if (strcmp(str, "TRUE") == 0 || strcmp(str, "FALSE") == 0) {
+                /* Add trivial event */
+                arg = allocate_arg();
+                arg->type = FILTER_ARG_BOOLEAN;
+                if (strcmp(str, "TRUE") == 0)
+                        arg->boolean.value = 1;
+                else
+                        arg->boolean.value = 0;
+
+                filter_type = add_filter_type(filter, event->id);
+                filter_type->filter = arg;
+
+                free(str);
+                return 0;
+        }
+
+        filter_event(filter, event, str, NULL);
+        free(str);
+
+        return 0;
+}
+
+/**
+ * pevent_filter_copy - copy a filter using another filter
+ * @dest - the filter to copy to
+ * @source - the filter to copy from
+ *
+ * Returns 0 on success and -1 if not all filters were copied
+ */
+int pevent_filter_copy(struct event_filter *dest, struct event_filter *source)
+{
+        int ret = 0;
+        int i;
+
+        pevent_filter_reset(dest);
+
+        for (i = 0; i < source->filters; i++) {
+                if (copy_filter_type(dest, source, &source->event_filters[i]))
+                        ret = -1;
+        }
+        return ret;
+}
+
+
+/**
+ * pevent_update_trivial - update the trivial filters with the given filter
+ * @dest - the filter to update
+ * @source - the filter as the source of the update
+ * @type - the type of trivial filter to update.
+ *
+ * Scan dest for trivial events matching @type to replace with the source.
+ *
+ * Returns 0 on success and -1 if there was a problem updating, but
+ *   events may have still been updated on error.
+ */
+int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
+                          enum filter_trivial_type type)
+{
+        struct pevent *src_pevent;
+        struct pevent *dest_pevent;
+        struct event_format *event;
+        struct filter_type *filter_type;
+        struct filter_arg *arg;
+        char *str;
+        int i;
+
+        src_pevent = source->pevent;
+        dest_pevent = dest->pevent;
+
+        /* Do nothing if either of the filters has nothing to filter */
+        if (!dest->filters || !source->filters)
+                return 0;
+
+        for (i = 0; i < dest->filters; i++) {
+                filter_type = &dest->event_filters[i];
+                arg = filter_type->filter;
+                if (arg->type != FILTER_ARG_BOOLEAN)
+                        continue;
+                if ((arg->boolean.value && type == FILTER_TRIVIAL_FALSE) ||
+                    (!arg->boolean.value && type == FILTER_TRIVIAL_TRUE))
+                        continue;
+
+                event = filter_type->event;
+
+                if (src_pevent != dest_pevent) {
+                        /* do a look up */
+                        event = pevent_find_event_by_name(src_pevent,
+                                                          event->system,
+                                                          event->name);
+                        if (!event)
+                                return -1;
+                }
+
+                str = pevent_filter_make_string(source, event->id);
+                if (!str)
+                        continue;
+
+                /* Don't bother if the filter is trivial too */
+                if (strcmp(str, "TRUE") != 0 && strcmp(str, "FALSE") != 0)
+                        filter_event(dest, event, str, NULL);
+                free(str);
+        }
+        return 0;
+}
+
+/**
+ * pevent_filter_clear_trivial - clear TRUE and FALSE filters
+ * @filter: the filter to remove trivial filters from
+ * @type: remove only true, false, or both
+ *
+ * Removes filters that only contain a TRUE or FALES boolean arg.
+ */
+void pevent_filter_clear_trivial(struct event_filter *filter,
+                                 enum filter_trivial_type type)
+{
+        struct filter_type *filter_type;
+        int count = 0;
+        int *ids;
+        int i;
+
+        if (!filter->filters)
+                return;
+
+        /*
+         * Two steps, first get all ids with trivial filters.
+         *  then remove those ids.
+         */
+        for (i = 0; i < filter->filters; i++) {
+                filter_type = &filter->event_filters[i];
+                if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
+                        continue;
+                switch (type) {
+                case FILTER_TRIVIAL_FALSE:
+                        if (filter_type->filter->boolean.value)
+                                continue;
+                case FILTER_TRIVIAL_TRUE:
+                        if (!filter_type->filter->boolean.value)
+                                continue;
+                default:
+                        break;
+                }
+                if (count)
+                        ids = realloc(ids, sizeof(*ids) * (count + 1));
+                else
+                        ids = malloc(sizeof(*ids));
+                if (!ids)
+                        die("Can't allocate ids");
+                ids[count++] = filter_type->event_id;
+        }
+
+        if (!count)
+                return;
+
+        for (i = 0; i < count; i++)
+                pevent_filter_remove_event(filter, ids[i]);
+
+        free(ids);
+}
+
+/**
+ * pevent_filter_event_has_trivial - return true event contains trivial filter
+ * @filter: the filter with the information
+ * @event_id: the id of the event to test
+ * @type: trivial type to test for (TRUE, FALSE, EITHER)
+ *
+ * Returns 1 if the event contains a matching trivial type
+ *  otherwise 0.
+ */
+int pevent_filter_event_has_trivial(struct event_filter *filter,
+                                    int event_id,
+                                    enum filter_trivial_type type)
+{
+        struct filter_type *filter_type;
+
+        if (!filter->filters)
+                return 0;
+
+        filter_type = find_filter_type(filter, event_id);
+
+        if (!filter_type)
+                return 0;
+
+        if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
+                return 0;
+
+        switch (type) {
+        case FILTER_TRIVIAL_FALSE:
+                return !filter_type->filter->boolean.value;
+
+        case FILTER_TRIVIAL_TRUE:
+                return filter_type->filter->boolean.value;
+        default:
+                return 1;
+        }
+}
+
+static int test_filter(struct event_format *event,
+                       struct filter_arg *arg, struct pevent_record *record);
+
+static const char *
+get_comm(struct event_format *event, struct pevent_record *record)
+{
+        const char *comm;
+        int pid;
+
+        pid = pevent_data_pid(event->pevent, record);
+        comm = pevent_data_comm_from_pid(event->pevent, pid);
+        return comm;
+}
+
+static unsigned long long
+get_value(struct event_format *event,
+          struct format_field *field, struct pevent_record *record)
+{
+        unsigned long long val;
+
+        /* Handle our dummy "comm" field */
+        if (field == &comm) {
+                const char *name;
+
+                name = get_comm(event, record);
+                return (unsigned long)name;
+        }
+
+        pevent_read_number_field(field, record->data, &val);
+
+        if (!(field->flags & FIELD_IS_SIGNED))
+                return val;
+
+        switch (field->size) {
+        case 1:
+                return (char)val;
+        case 2:
+                return (short)val;
+        case 4:
+                return (int)val;
+        case 8:
+                return (long long)val;
+        }
+        return val;
+}
+
+static unsigned long long
+get_arg_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record);
+
+static unsigned long long
+get_exp_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record)
+{
+        unsigned long long lval, rval;
+
+        lval = get_arg_value(event, arg->exp.left, record);
+        rval = get_arg_value(event, arg->exp.right, record);
+
+        switch (arg->exp.type) {
+        case FILTER_EXP_ADD:
+                return lval + rval;
+
+        case FILTER_EXP_SUB:
+                return lval - rval;
+
+        case FILTER_EXP_MUL:
+                return lval * rval;
+
+        case FILTER_EXP_DIV:
+                return lval / rval;
+
+        case FILTER_EXP_MOD:
+                return lval % rval;
+
+        case FILTER_EXP_RSHIFT:
+                return lval >> rval;
+
+        case FILTER_EXP_LSHIFT:
+                return lval << rval;
+
+        case FILTER_EXP_AND:
+                return lval & rval;
+
+        case FILTER_EXP_OR:
+                return lval | rval;
+
+        case FILTER_EXP_XOR:
+                return lval ^ rval;
+
+        case FILTER_EXP_NOT:
+        default:
+                die("error in exp");
+        }
+        return 0;
+}
+
+static unsigned long long
+get_arg_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record)
+{
+        switch (arg->type) {
+        case FILTER_ARG_FIELD:
+                return get_value(event, arg->field.field, record);
+
+        case FILTER_ARG_VALUE:
+                if (arg->value.type != FILTER_NUMBER)
+                        die("must have number field!");
+                return arg->value.val;
+
+        case FILTER_ARG_EXP:
+                return get_exp_value(event, arg, record);
+
+        default:
+                die("oops in filter");
+        }
+        return 0;
+}
+
+static int test_num(struct event_format *event,
+                    struct filter_arg *arg, struct pevent_record *record)
+{
+        unsigned long long lval, rval;
+
+        lval = get_arg_value(event, arg->num.left, record);
+        rval = get_arg_value(event, arg->num.right, record);
+
+        switch (arg->num.type) {
+        case FILTER_CMP_EQ:
+                return lval == rval;
+
+        case FILTER_CMP_NE:
+                return lval != rval;
+
+        case FILTER_CMP_GT:
+                return lval > rval;
+
+        case FILTER_CMP_LT:
+                return lval < rval;
+
+        case FILTER_CMP_GE:
+                return lval >= rval;
+
+        case FILTER_CMP_LE:
+                return lval <= rval;
+
+        default:
+                /* ?? */
+                return 0;
+        }
+}
+
+static const char *get_field_str(struct filter_arg *arg, struct pevent_record *record)
+{
+        const char *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;
+        }
+        return val;
+}
+
+static int test_str(struct event_format *event,
+                    struct filter_arg *arg, struct pevent_record *record)
+{
+        const char *val;
+
+        if (arg->str.field == &comm)
+                val = get_comm(event, record);
+        else
+                val = get_field_str(arg, record);
+
+        switch (arg->str.type) {
+        case FILTER_CMP_MATCH:
+                return strcmp(val, arg->str.val) == 0;
+
+        case FILTER_CMP_NOT_MATCH:
+                return strcmp(val, arg->str.val) != 0;
+
+        case FILTER_CMP_REGEX:
+                /* Returns zero on match */
+                return !regexec(&arg->str.reg, val, 0, NULL, 0);
+
+        case FILTER_CMP_NOT_REGEX:
+                return regexec(&arg->str.reg, val, 0, NULL, 0);
+
+        default:
+                /* ?? */
+                return 0;
+        }
+}
+
+static int test_op(struct event_format *event,
+                   struct filter_arg *arg, struct pevent_record *record)
+{
+        switch (arg->op.type) {
+        case FILTER_OP_AND:
+                return test_filter(event, arg->op.left, record) &&
+                        test_filter(event, arg->op.right, record);
+
+        case FILTER_OP_OR:
+                return test_filter(event, arg->op.left, record) ||
+                        test_filter(event, arg->op.right, record);
+
+        case FILTER_OP_NOT:
+                return !test_filter(event, arg->op.right, record);
+
+        default:
+                /* ?? */
+                return 0;
+        }
+}
+
+static int test_filter(struct event_format *event,
+                       struct filter_arg *arg, struct pevent_record *record)
+{
+        switch (arg->type) {
+        case FILTER_ARG_BOOLEAN:
+                /* easy case */
+                return arg->boolean.value;
+
+        case FILTER_ARG_OP:
+                return test_op(event, arg, record);
+
+        case FILTER_ARG_NUM:
+                return test_num(event, arg, record);
+
+        case FILTER_ARG_STR:
+                return test_str(event, arg, record);
+
+        case FILTER_ARG_EXP:
+        case FILTER_ARG_VALUE:
+        case FILTER_ARG_FIELD:
+                /*
+                 * Expressions, fields and values evaluate
+                 * to true if they return non zero
+                 */
+                return !!get_arg_value(event, arg, record);
+
+        default:
+                die("oops!");
+                /* ?? */
+                return 0;
+        }
+}
+
+/**
+ * pevent_event_filtered - return true if event has filter
+ * @filter: filter struct with filter information
+ * @event_id: event id to test if filter exists
+ *
+ * Returns 1 if filter found for @event_id
+ *   otherwise 0;
+ */
+int pevent_event_filtered(struct event_filter *filter,
+                          int event_id)
+{
+        struct filter_type *filter_type;
+
+        if (!filter->filters)
+                return 0;
+
+        filter_type = find_filter_type(filter, event_id);
+
+        return filter_type ? 1 : 0;
+}
+
+/**
+ * pevent_filter_match - test if a record matches a filter
+ * @filter: filter struct with filter information
+ * @record: the record to test against the filter
+ *
+ * Returns:
+ *  1 - filter found for event and @record matches
+ *  0 - filter found for event and @record does not match
+ * -1 - no filter found for @record's event
+ * -2 - if no filters exist
+ */
+int pevent_filter_match(struct event_filter *filter,
+                        struct pevent_record *record)
+{
+        struct pevent *pevent = filter->pevent;
+        struct filter_type *filter_type;
+        int event_id;
+
+        if (!filter->filters)
+                return FILTER_NONE;
+
+        event_id = pevent_data_type(pevent, record);
+
+        filter_type = find_filter_type(filter, event_id);
+
+        if (!filter_type)
+                return FILTER_NOEXIST;
+
+        return test_filter(filter_type->event, filter_type->filter, record) ?
+                FILTER_MATCH : FILTER_MISS;
+}
+
+static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *str = NULL;
+        char *left = NULL;
+        char *right = NULL;
+        char *op = NULL;
+        int left_val = -1;
+        int right_val = -1;
+        int val;
+        int len;
+
+        switch (arg->op.type) {
+        case FILTER_OP_AND:
+                op = "&&";
+                /* fall through */
+        case FILTER_OP_OR:
+                if (!op)
+                        op = "||";
+
+                left = arg_to_str(filter, arg->op.left);
+                right = arg_to_str(filter, arg->op.right);
+                if (!left || !right)
+                        break;
+
+                /* Try to consolidate boolean values */
+                if (strcmp(left, "TRUE") == 0)
+                        left_val = 1;
+                else if (strcmp(left, "FALSE") == 0)
+                        left_val = 0;
+
+                if (strcmp(right, "TRUE") == 0)
+                        right_val = 1;
+                else if (strcmp(right, "FALSE") == 0)
+                        right_val = 0;
+
+                if (left_val >= 0) {
+                        if ((arg->op.type == FILTER_OP_AND && !left_val) ||
+                            (arg->op.type == FILTER_OP_OR && left_val)) {
+                                /* Just return left value */
+                                str = left;
+                                left = NULL;
+                                break;
+                        }
+                        if (right_val >= 0) {
+                                /* just evaluate this. */
+                                val = 0;
+                                switch (arg->op.type) {
+                                case FILTER_OP_AND:
+                                        val = left_val && right_val;
+                                        break;
+                                case FILTER_OP_OR:
+                                        val = left_val || right_val;
+                                        break;
+                                default:
+                                        break;
+                                }
+                                str = malloc_or_die(6);
+                                if (val)
+                                        strcpy(str, "TRUE");
+                                else
+                                        strcpy(str, "FALSE");
+                                break;
+                        }
+                }
+                if (right_val >= 0) {
+                        if ((arg->op.type == FILTER_OP_AND && !right_val) ||
+                            (arg->op.type == FILTER_OP_OR && right_val)) {
+                                /* Just return right value */
+                                str = right;
+                                right = NULL;
+                                break;
+                        }
+                        /* The right value is meaningless */
+                        str = left;
+                        left = NULL;
+                        break;
+                }
+
+                len = strlen(left) + strlen(right) + strlen(op) + 10;
+                str = malloc_or_die(len);
+                snprintf(str, len, "(%s) %s (%s)",
+                         left, op, right);
+                break;
+
+        case FILTER_OP_NOT:
+                op = "!";
+                right = arg_to_str(filter, arg->op.right);
+                if (!right)
+                        break;
+
+                /* See if we can consolidate */
+                if (strcmp(right, "TRUE") == 0)
+                        right_val = 1;
+                else if (strcmp(right, "FALSE") == 0)
+                        right_val = 0;
+                if (right_val >= 0) {
+                        /* just return the opposite */
+                        str = malloc_or_die(6);
+                        if (right_val)
+                                strcpy(str, "FALSE");
+                        else
+                                strcpy(str, "TRUE");
+                        break;
+                }
+                len = strlen(right) + strlen(op) + 3;
+                str = malloc_or_die(len);
+                snprintf(str, len, "%s(%s)", op, right);
+                break;
+
+        default:
+                /* ?? */
+                break;
+        }
+        free(left);
+        free(right);
+        return str;
+}
+
+static char *val_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *str;
+
+        str = malloc_or_die(30);
+
+        snprintf(str, 30, "%lld", arg->value.val);
+
+        return str;
+}
+
+static char *field_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        return strdup(arg->field.field->name);
+}
+
+static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *lstr;
+        char *rstr;
+        char *op;
+        char *str;
+        int len;
+
+        lstr = arg_to_str(filter, arg->exp.left);
+        rstr = arg_to_str(filter, arg->exp.right);
+
+        switch (arg->exp.type) {
+        case FILTER_EXP_ADD:
+                op = "+";
+                break;
+        case FILTER_EXP_SUB:
+                op = "-";
+                break;
+        case FILTER_EXP_MUL:
+                op = "*";
+                break;
+        case FILTER_EXP_DIV:
+                op = "/";
+                break;
+        case FILTER_EXP_MOD:
+                op = "%";
+                break;
+        case FILTER_EXP_RSHIFT:
+                op = ">>";
+                break;
+        case FILTER_EXP_LSHIFT:
+                op = "<<";
+                break;
+        case FILTER_EXP_AND:
+                op = "&";
+                break;
+        case FILTER_EXP_OR:
+                op = "|";
+                break;
+        case FILTER_EXP_XOR:
+                op = "^";
+                break;
+        default:
+                die("oops in exp");
+        }
+
+        len = strlen(op) + strlen(lstr) + strlen(rstr) + 4;
+        str = malloc_or_die(len);
+        snprintf(str, len, "%s %s %s", lstr, op, rstr);
+        free(lstr);
+        free(rstr);
+
+        return str;
+}
+
+static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *lstr;
+        char *rstr;
+        char *str = NULL;
+        char *op = NULL;
+        int len;
+
+        lstr = arg_to_str(filter, arg->num.left);
+        rstr = arg_to_str(filter, arg->num.right);
+
+        switch (arg->num.type) {
+        case FILTER_CMP_EQ:
+                op = "==";
+                /* fall through */
+        case FILTER_CMP_NE:
+                if (!op)
+                        op = "!=";
+                /* fall through */
+        case FILTER_CMP_GT:
+                if (!op)
+                        op = ">";
+                /* fall through */
+        case FILTER_CMP_LT:
+                if (!op)
+                        op = "<";
+                /* fall through */
+        case FILTER_CMP_GE:
+                if (!op)
+                        op = ">=";
+                /* fall through */
+        case FILTER_CMP_LE:
+                if (!op)
+                        op = "<=";
+
+                len = strlen(lstr) + strlen(op) + strlen(rstr) + 4;
+                str = malloc_or_die(len);
+                sprintf(str, "%s %s %s", lstr, op, rstr);
+
+                break;
+
+        default:
+                /* ?? */
+                break;
+        }
+
+        free(lstr);
+        free(rstr);
+        return str;
+}
+
+static char *str_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *str = NULL;
+        char *op = NULL;
+        int len;
+
+        switch (arg->str.type) {
+        case FILTER_CMP_MATCH:
+                op = "==";
+                /* fall through */
+        case FILTER_CMP_NOT_MATCH:
+                if (!op)
+                        op = "!=";
+                /* fall through */
+        case FILTER_CMP_REGEX:
+                if (!op)
+                        op = "=~";
+                /* fall through */
+        case FILTER_CMP_NOT_REGEX:
+                if (!op)
+                        op = "!~";
+
+                len = strlen(arg->str.field->name) + strlen(op) +
+                        strlen(arg->str.val) + 6;
+                str = malloc_or_die(len);
+                snprintf(str, len, "%s %s \"%s\"",
+                         arg->str.field->name,
+                         op, arg->str.val);
+                break;
+
+        default:
+                /* ?? */
+                break;
+        }
+        return str;
+}
+
+static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg)
+{
+        char *str;
+
+        switch (arg->type) {
+        case FILTER_ARG_BOOLEAN:
+                str = malloc_or_die(6);
+                if (arg->boolean.value)
+                        strcpy(str, "TRUE");
+                else
+                        strcpy(str, "FALSE");
+                return str;
+
+        case FILTER_ARG_OP:
+                return op_to_str(filter, arg);
+
+        case FILTER_ARG_NUM:
+                return num_to_str(filter, arg);
+
+        case FILTER_ARG_STR:
+                return str_to_str(filter, arg);
+
+        case FILTER_ARG_VALUE:
+                return val_to_str(filter, arg);
+
+        case FILTER_ARG_FIELD:
+                return field_to_str(filter, arg);
+
+        case FILTER_ARG_EXP:
+                return exp_to_str(filter, arg);
+
+        default:
+                /* ?? */
+                return NULL;
+        }
+
+}
+
+/**
+ * pevent_filter_make_string - return a string showing the filter
+ * @filter: filter struct with filter information
+ * @event_id: the event id to return the filter string with
+ *
+ * Returns a string that displays the filter contents.
+ *  This string must be freed with free(str).
+ *  NULL is returned if no filter is found.
+ */
+char *
+pevent_filter_make_string(struct event_filter *filter, int event_id)
+{
+        struct filter_type *filter_type;
+
+        if (!filter->filters)
+                return NULL;
+
+        filter_type = find_filter_type(filter, event_id);
+
+        if (!filter_type)
+                return NULL;
+
+        return arg_to_str(filter, filter_type->filter);
+}
+
+/**
+ * pevent_filter_compare - compare two filters and return if they are the same
+ * @filter1: Filter to compare with @filter2
+ * @filter2: Filter to compare with @filter1
+ *
+ * Returns:
+ *  1 if the two filters hold the same content.
+ *  0 if they do not.
+ */
+int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2)
+{
+        struct filter_type *filter_type1;
+        struct filter_type *filter_type2;
+        char *str1, *str2;
+        int result;
+        int i;
+
+        /* Do the easy checks first */
+        if (filter1->filters != filter2->filters)
+                return 0;
+        if (!filter1->filters && !filter2->filters)
+                return 1;
+
+        /*
+         * Now take a look at each of the events to see if they have the same
+         * filters to them.
+         */
+        for (i = 0; i < filter1->filters; i++) {
+                filter_type1 = &filter1->event_filters[i];
+                filter_type2 = find_filter_type(filter2, filter_type1->event_id);
+                if (!filter_type2)
+                        break;
+                if (filter_type1->filter->type != filter_type2->filter->type)
+                        break;
+                switch (filter_type1->filter->type) {
+                case FILTER_TRIVIAL_FALSE:
+                case FILTER_TRIVIAL_TRUE:
+                        /* trivial types just need the type compared */
+                        continue;
+                default:
+                        break;
+                }
+                /* 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;
+                free(str1);
+                free(str2);
+                if (result)
+                        break;
+        }
+
+        if (i < filter1->filters)
+                return 0;
+        return 1;
+}
+
diff --git a/tools/lib/traceevent/parse-utils.c b/tools/lib/traceevent/parse-utils.c
new file mode 100644
index 000000000000..f023a133abb6
--- /dev/null
+++ b/tools/lib/traceevent/parse-utils.c
@@ -0,0 +1,110 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#define __weak __attribute__((weak))
+
+void __vdie(const char *fmt, va_list ap)
+{
+        int ret = errno;
+
+        if (errno)
+                perror("trace-cmd");
+        else
+                ret = -1;
+
+        fprintf(stderr, "  ");
+        vfprintf(stderr, fmt, ap);
+
+        fprintf(stderr, "\n");
+        exit(ret);
+}
+
+void __die(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vdie(fmt, ap);
+        va_end(ap);
+}
+
+void __weak die(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vdie(fmt, ap);
+        va_end(ap);
+}
+
+void __vwarning(const char *fmt, va_list ap)
+{
+        if (errno)
+                perror("trace-cmd");
+        errno = 0;
+
+        fprintf(stderr, "  ");
+        vfprintf(stderr, fmt, ap);
+
+        fprintf(stderr, "\n");
+}
+
+void __warning(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vwarning(fmt, ap);
+        va_end(ap);
+}
+
+void __weak warning(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vwarning(fmt, ap);
+        va_end(ap);
+}
+
+void __vpr_stat(const char *fmt, va_list ap)
+{
+        vprintf(fmt, ap);
+        printf("\n");
+}
+
+void __pr_stat(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vpr_stat(fmt, ap);
+        va_end(ap);
+}
+
+void __weak vpr_stat(const char *fmt, va_list ap)
+{
+        __vpr_stat(fmt, ap);
+}
+
+void __weak pr_stat(const char *fmt, ...)
+{
+        va_list ap;
+
+        va_start(ap, fmt);
+        __vpr_stat(fmt, ap);
+        va_end(ap);
+}
+
+void __weak *malloc_or_die(unsigned int size)
+{
+        void *data;
+
+        data = malloc(size);
+        if (!data)
+                die("malloc");
+        return data;
+}
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
new file mode 100644
index 000000000000..b1ccc923e8a5
--- /dev/null
+++ b/tools/lib/traceevent/trace-seq.c
@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License (not later!)
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "event-parse.h"
+#include "event-utils.h"
+
+/*
+ * The TRACE_SEQ_POISON is to catch the use of using
+ * a trace_seq structure after it was destroyed.
+ */
+#define TRACE_SEQ_POISON        ((void *)0xdeadbeef)
+#define TRACE_SEQ_CHECK(s)                                              \
+do {                                                                    \
+        if ((s)->buffer == TRACE_SEQ_POISON)                    \
+                die("Usage of trace_seq after it was destroyed");       \
+} while (0)
+
+/**
+ * trace_seq_init - initialize the trace_seq structure
+ * @s: a pointer to the trace_seq structure to initialize
+ */
+void trace_seq_init(struct trace_seq *s)
+{
+        s->len = 0;
+        s->readpos = 0;
+        s->buffer_size = TRACE_SEQ_BUF_SIZE;
+        s->buffer = malloc_or_die(s->buffer_size);
+}
+
+/**
+ * trace_seq_destroy - free up memory of a trace_seq
+ * @s: a pointer to the trace_seq to free the buffer
+ *
+ * Only frees the buffer, not the trace_seq struct itself.
+ */
+void trace_seq_destroy(struct trace_seq *s)
+{
+        if (!s)
+                return;
+        TRACE_SEQ_CHECK(s);
+        free(s->buffer);
+        s->buffer = TRACE_SEQ_POISON;
+}
+
+static void expand_buffer(struct trace_seq *s)
+{
+        s->buffer_size += TRACE_SEQ_BUF_SIZE;
+        s->buffer = realloc(s->buffer, s->buffer_size);
+        if (!s->buffer)
+                die("Can't allocate trace_seq buffer memory");
+}
+
+/**
+ * trace_seq_printf - sequence printing of trace information
+ * @s: trace sequence descriptor
+ * @fmt: printf format string
+ *
+ * It returns 0 if the trace oversizes the buffer's free
+ * space, 1 otherwise.
+ *
+ * The tracer may use either sequence operations or its own
+ * copy to user routines. To simplify formating of a trace
+ * trace_seq_printf is used to store strings into a special
+ * buffer (@s). Then the output may be either used by
+ * the sequencer or pulled into another buffer.
+ */
+int
+trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
+{
+        va_list ap;
+        int len;
+        int ret;
+
+        TRACE_SEQ_CHECK(s);
+
+ try_again:
+        len = (s->buffer_size - 1) - s->len;
+
+        va_start(ap, fmt);
+        ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
+        va_end(ap);
+
+        if (ret >= len) {
+                expand_buffer(s);
+                goto try_again;
+        }
+
+        s->len += ret;
+
+        return 1;
+}
+
+/**
+ * trace_seq_vprintf - sequence printing of trace information
+ * @s: trace sequence descriptor
+ * @fmt: printf format string
+ *
+ * The tracer may use either sequence operations or its own
+ * copy to user routines. To simplify formating of a trace
+ * trace_seq_printf is used to store strings into a special
+ * buffer (@s). Then the output may be either used by
+ * the sequencer or pulled into another buffer.
+ */
+int
+trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
+{
+        int len;
+        int ret;
+
+        TRACE_SEQ_CHECK(s);
+
+ try_again:
+        len = (s->buffer_size - 1) - s->len;
+
+        ret = vsnprintf(s->buffer + s->len, len, fmt, args);
+
+        if (ret >= len) {
+                expand_buffer(s);
+                goto try_again;
+        }
+
+        s->len += ret;
+
+        return len;
+}
+
+/**
+ * trace_seq_puts - trace sequence printing of simple string
+ * @s: trace sequence descriptor
+ * @str: simple string to record
+ *
+ * The tracer may use either the sequence operations or its own
+ * copy to user routines. This function records a simple string
+ * into a special buffer (@s) for later retrieval by a sequencer
+ * or other mechanism.
+ */
+int trace_seq_puts(struct trace_seq *s, const char *str)
+{
+        int len;
+
+        TRACE_SEQ_CHECK(s);
+
+        len = strlen(str);
+
+        while (len > ((s->buffer_size - 1) - s->len))
+                expand_buffer(s);
+
+        memcpy(s->buffer + s->len, str, len);
+        s->len += len;
+
+        return len;
+}
+
+int trace_seq_putc(struct trace_seq *s, unsigned char c)
+{
+        TRACE_SEQ_CHECK(s);
+
+        while (s->len >= (s->buffer_size - 1))
+                expand_buffer(s);
+
+        s->buffer[s->len++] = c;
+
+        return 1;
+}
+
+void trace_seq_terminate(struct trace_seq *s)
+{
+        TRACE_SEQ_CHECK(s);
+
+        /* There's always one character left on the buffer */
+        s->buffer[s->len] = 0;
+}
+
+int trace_seq_do_printf(struct trace_seq *s)
+{
+        TRACE_SEQ_CHECK(s);
+        return printf("%.*s", s->len, s->buffer);
+}
diff --git a/tools/perf/Documentation/perf-evlist.txt b/tools/perf/Documentation/perf-evlist.txt
index 0507ec7bad71..15217345c2fa 100644
--- a/tools/perf/Documentation/perf-evlist.txt
+++ b/tools/perf/Documentation/perf-evlist.txt
@@ -20,6 +20,14 @@ OPTIONS
 --input=::
         Input file name. (default: perf.data unless stdin is a fifo)
 
+-F::
+--freq=::
+        Show just the sample frequency used for each event.
+
+-v::
+--verbose=::
+        Show all fields.
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-list[1],
diff --git a/tools/perf/Documentation/perf-probe.txt b/tools/perf/Documentation/perf-probe.txt
index 2780d9ce48bf..b715cb71592b 100644
--- a/tools/perf/Documentation/perf-probe.txt
+++ b/tools/perf/Documentation/perf-probe.txt
@@ -77,7 +77,8 @@ OPTIONS
 
 -F::
 --funcs::
-        Show available functions in given module or kernel.
+        Show available functions in given module or kernel. With -x/--exec,
+        can also list functions in a user space executable / shared library.
 
 --filter=FILTER::
         (Only for --vars and --funcs) Set filter. FILTER is a combination of glob
@@ -98,6 +99,15 @@ OPTIONS
 --max-probes::
         Set the maximum number of probe points for an event. Default is 128.
 
+-x::
+--exec=PATH::
+        Specify path to the executable or shared library file for user
+        space tracing. Can also be used with --funcs option.
+
+In absence of -m/-x options, perf probe checks if the first argument after
+the options is an absolute path name. If its an absolute path, perf probe
+uses it as a target module/target user space binary to probe.
+
 PROBE SYNTAX
 ------------
 Probe points are defined by following syntax.
@@ -182,6 +192,13 @@ Delete all probes on schedule().
 
  ./perf probe --del='schedule*'
 
+Add probes at zfree() function on /bin/zsh
+
+ ./perf probe -x /bin/zsh zfree or ./perf probe /bin/zsh zfree
+
+Add probes at malloc() function on libc
+
+ ./perf probe -x /lib/libc.so.6 malloc or ./perf probe /lib/libc.so.6 malloc
 
 SEE ALSO
 --------
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index a1386b2fff00..b38a1f9ad460 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -168,7 +168,7 @@ following filters are defined:
         - any:  any type of branches
         - any_call: any function call or system call
         - any_ret: any function return or system call return
-        - any_ind: any indirect branch
+        - ind_call: any indirect branch
         - u:  only when the branch target is at the user level
         - k: only when the branch target is in the kernel
         - hv: only when the target is at the hypervisor level
diff --git a/tools/perf/Documentation/perfconfig.example b/tools/perf/Documentation/perfconfig.example
index d1448668f4d4..767ea2436e1c 100644
--- a/tools/perf/Documentation/perfconfig.example
+++ b/tools/perf/Documentation/perfconfig.example
@@ -6,6 +6,7 @@
         normal = black, lightgray
         selected = lightgray, magenta
         code = blue, lightgray
+        addr = magenta, lightgray
 
 [tui]
 
@@ -18,3 +19,11 @@
 
         # Default, disable using /dev/null
         dir = /root/.debug
+
+[annotate]
+
+        # Defaults
+        hide_src_code = false
+        use_offset = true
+        jump_arrows = true
+        show_nr_jumps = false
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 92271d32bc30..0eee64cfe9a0 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -1,18 +1,10 @@
-ifeq ("$(origin O)", "command line")
-        OUTPUT := $(O)/
-endif
+include ../scripts/Makefile.include
 
 # The default target of this Makefile is...
 all:
 
 include config/utilities.mak
 
-ifneq ($(OUTPUT),)
-# check that the output directory actually exists
-OUTDIR := $(shell cd $(OUTPUT) && /bin/pwd)
-$(if $(OUTDIR),, $(error output directory "$(OUTPUT)" does not exist))
-endif
-
 # Define V to have a more verbose compile.
 #
 # Define O to save output files in a separate directory.
@@ -84,39 +76,20 @@ ifneq ($(WERROR),0)
         CFLAGS_WERROR := -Werror
 endif
 
-#
-# Include saner warnings here, which can catch bugs:
-#
-
-EXTRA_WARNINGS := -Wformat
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-security
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wformat-y2k
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wshadow
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Winit-self
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wpacked
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wredundant-decls
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-aliasing=3
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-default
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wswitch-enum
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wno-system-headers
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wundef
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wwrite-strings
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wbad-function-cast
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-declarations
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wmissing-prototypes
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wnested-externs
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wold-style-definition
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wstrict-prototypes
-EXTRA_WARNINGS := $(EXTRA_WARNINGS) -Wdeclaration-after-statement
-
 ifeq ("$(origin DEBUG)", "command line")
   PERF_DEBUG = $(DEBUG)
 endif
 ifndef PERF_DEBUG
-  CFLAGS_OPTIMIZE = -O6
+  CFLAGS_OPTIMIZE = -O6 -D_FORTIFY_SOURCE=2
+endif
+
+ifdef PARSER_DEBUG
+        PARSER_DEBUG_BISON  := -t
+        PARSER_DEBUG_FLEX   := -d
+        PARSER_DEBUG_CFLAGS := -DPARSER_DEBUG
 endif
 
-CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
+CFLAGS = -fno-omit-frame-pointer -ggdb3 -Wall -Wextra -std=gnu99 $(CFLAGS_WERROR) $(CFLAGS_OPTIMIZE) $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) $(PARSER_DEBUG_CFLAGS)
 EXTLIBS = -lpthread -lrt -lelf -lm
 ALL_CFLAGS = $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
 ALL_LDFLAGS = $(LDFLAGS)
@@ -182,7 +155,7 @@ endif
 
 ### --- END CONFIGURATION SECTION ---
 
-BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)/util -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
@@ -211,6 +184,17 @@ $(OUTPUT)python/perf.so: $(PYRF_OBJS) $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
 
 SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
 
+TRACE_EVENT_DIR = ../lib/traceevent/
+
+ifeq ("$(origin O)", "command line")
+        TE_PATH=$(OUTPUT)/
+else
+        TE_PATH=$(TRACE_EVENT_DIR)/
+endif
+
+LIBTRACEEVENT = $(TE_PATH)libtraceevent.a
+TE_LIB := -L$(TE_PATH) -ltraceevent
+
 #
 # Single 'perf' binary right now:
 #
@@ -238,10 +222,10 @@ FLEX = flex
 BISON= bison
 
 $(OUTPUT)util/parse-events-flex.c: util/parse-events.l
-        $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
+        $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/parse-events-flex.h $(PARSER_DEBUG_FLEX) -t util/parse-events.l > $(OUTPUT)util/parse-events-flex.c
 
 $(OUTPUT)util/parse-events-bison.c: util/parse-events.y
-        $(QUIET_BISON)$(BISON) -v util/parse-events.y -d -o $(OUTPUT)util/parse-events-bison.c
+        $(QUIET_BISON)$(BISON) -v util/parse-events.y -d $(PARSER_DEBUG_BISON) -o $(OUTPUT)util/parse-events-bison.c
 
 $(OUTPUT)util/pmu-flex.c: util/pmu.l
         $(QUIET_FLEX)$(FLEX) --header-file=$(OUTPUT)util/pmu-flex.h -t util/pmu.l > $(OUTPUT)util/pmu-flex.c
@@ -333,6 +317,8 @@ LIB_H += util/cpumap.h
 LIB_H += util/top.h
 LIB_H += $(ARCH_INCLUDE)
 LIB_H += util/cgroup.h
+LIB_H += $(TRACE_EVENT_DIR)event-parse.h
+LIB_H += util/target.h
 
 LIB_OBJS += $(OUTPUT)util/abspath.o
 LIB_OBJS += $(OUTPUT)util/alias.o
@@ -352,6 +338,7 @@ LIB_OBJS += $(OUTPUT)util/help.o
 LIB_OBJS += $(OUTPUT)util/levenshtein.o
 LIB_OBJS += $(OUTPUT)util/parse-options.o
 LIB_OBJS += $(OUTPUT)util/parse-events.o
+LIB_OBJS += $(OUTPUT)util/parse-events-test.o
 LIB_OBJS += $(OUTPUT)util/path.o
 LIB_OBJS += $(OUTPUT)util/rbtree.o
 LIB_OBJS += $(OUTPUT)util/bitmap.o
@@ -394,6 +381,7 @@ LIB_OBJS += $(OUTPUT)util/util.o
 LIB_OBJS += $(OUTPUT)util/xyarray.o
 LIB_OBJS += $(OUTPUT)util/cpumap.o
 LIB_OBJS += $(OUTPUT)util/cgroup.o
+LIB_OBJS += $(OUTPUT)util/target.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
 
@@ -429,7 +417,7 @@ BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
 BUILTIN_OBJS += $(OUTPUT)builtin-test.o
 BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
 
-PERFLIBS = $(LIB_FILE)
+PERFLIBS = $(LIB_FILE) $(LIBTRACEEVENT)
 
 # Files needed for the python binding, perf.so
 # pyrf is just an internal name needed for all those wrappers.
@@ -506,22 +494,23 @@ else
                 # Fedora has /usr/include/slang/slang.h, but ubuntu /usr/include/slang.h
                 BASIC_CFLAGS += -I/usr/include/slang
                 EXTLIBS += -lnewt -lslang
-                LIB_OBJS += $(OUTPUT)util/ui/setup.o
-                LIB_OBJS += $(OUTPUT)util/ui/browser.o
-                LIB_OBJS += $(OUTPUT)util/ui/browsers/annotate.o
-                LIB_OBJS += $(OUTPUT)util/ui/browsers/hists.o
-                LIB_OBJS += $(OUTPUT)util/ui/browsers/map.o
-                LIB_OBJS += $(OUTPUT)util/ui/helpline.o
-                LIB_OBJS += $(OUTPUT)util/ui/progress.o
-                LIB_OBJS += $(OUTPUT)util/ui/util.o
-                LIB_H += util/ui/browser.h
-                LIB_H += util/ui/browsers/map.h
-                LIB_H += util/ui/helpline.h
-                LIB_H += util/ui/keysyms.h
-                LIB_H += util/ui/libslang.h
-                LIB_H += util/ui/progress.h
-                LIB_H += util/ui/util.h
-                LIB_H += util/ui/ui.h
+                LIB_OBJS += $(OUTPUT)ui/setup.o
+                LIB_OBJS += $(OUTPUT)ui/browser.o
+                LIB_OBJS += $(OUTPUT)ui/browsers/annotate.o
+                LIB_OBJS += $(OUTPUT)ui/browsers/hists.o
+                LIB_OBJS += $(OUTPUT)ui/browsers/map.o
+                LIB_OBJS += $(OUTPUT)ui/helpline.o
+                LIB_OBJS += $(OUTPUT)ui/progress.o
+                LIB_OBJS += $(OUTPUT)ui/util.o
+                LIB_OBJS += $(OUTPUT)ui/tui/setup.o
+                LIB_H += ui/browser.h
+                LIB_H += ui/browsers/map.h
+                LIB_H += ui/helpline.h
+                LIB_H += ui/keysyms.h
+                LIB_H += ui/libslang.h
+                LIB_H += ui/progress.h
+                LIB_H += ui/util.h
+                LIB_H += ui/ui.h
         endif
 endif
 
@@ -535,7 +524,12 @@ else
         else
                 BASIC_CFLAGS += $(shell pkg-config --cflags gtk+-2.0)
                 EXTLIBS += $(shell pkg-config --libs gtk+-2.0)
-                LIB_OBJS += $(OUTPUT)util/gtk/browser.o
+                LIB_OBJS += $(OUTPUT)ui/gtk/browser.o
+                LIB_OBJS += $(OUTPUT)ui/gtk/setup.o
+                # Make sure that it'd be included only once.
+                ifneq ($(findstring -DNO_NEWT_SUPPORT,$(BASIC_CFLAGS)),)
+                        LIB_OBJS += $(OUTPUT)ui/setup.o
+                endif
         endif
 endif
 
@@ -678,18 +672,6 @@ else
         endif
 endif
 
-ifneq ($(findstring $(MAKEFLAGS),s),s)
-ifndef V
-        QUIET_CC       = @echo '   ' CC $@;
-        QUIET_AR       = @echo '   ' AR $@;
-        QUIET_LINK     = @echo '   ' LINK $@;
-        QUIET_MKDIR    = @echo '   ' MKDIR $@;
-        QUIET_GEN      = @echo '   ' GEN $@;
-        QUIET_FLEX     = @echo '   ' FLEX $@;
-        QUIET_BISON    = @echo '   ' BISON $@;
-endif
-endif
-
 ifdef ASCIIDOC8
         export ASCIIDOC8
 endif
@@ -800,16 +782,16 @@ $(OUTPUT)util/exec_cmd.o: util/exec_cmd.c $(OUTPUT)PERF-CFLAGS
 $(OUTPUT)util/config.o: util/config.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DETC_PERFCONFIG='"$(ETC_PERFCONFIG_SQ)"' $<
 
-$(OUTPUT)util/ui/browser.o: util/ui/browser.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)ui/browser.o: ui/browser.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-$(OUTPUT)util/ui/browsers/annotate.o: util/ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)ui/browsers/annotate.o: ui/browsers/annotate.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-$(OUTPUT)util/ui/browsers/hists.o: util/ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)ui/browsers/hists.o: ui/browsers/hists.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
-$(OUTPUT)util/ui/browsers/map.o: util/ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
+$(OUTPUT)ui/browsers/map.o: ui/browsers/map.c $(OUTPUT)PERF-CFLAGS
         $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) -DENABLE_SLFUTURE_CONST $<
 
 $(OUTPUT)util/rbtree.o: ../../lib/rbtree.c $(OUTPUT)PERF-CFLAGS
@@ -844,6 +826,10 @@ $(sort $(dir $(DIRECTORY_DEPS))):
 $(LIB_FILE): $(LIB_OBJS)
         $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
 
+# libtraceevent.a
+$(LIBTRACEEVENT):
+        $(QUIET_SUBDIR0)$(TRACE_EVENT_DIR) $(QUIET_SUBDIR1) $(COMMAND_O) libtraceevent.a
+
 help:
         @echo 'Perf make targets:'
         @echo '  doc            - make *all* documentation (see below)'
@@ -990,6 +976,6 @@ clean:
         $(RM) $(OUTPUT)util/*-{bison,flex}*
         $(python-clean)
 
-.PHONY: all install clean strip
+.PHONY: all install clean strip $(LIBTRACEEVENT)
 .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell
 .PHONY: .FORCE-PERF-VERSION-FILE TAGS tags cscope .FORCE-PERF-CFLAGS
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 806e0a286634..67522cf87405 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -215,7 +215,7 @@ static int __cmd_annotate(struct perf_annotate *ann)
         }
 
         if (total_nr_samples == 0) {
-                ui__warning("The %s file has no samples!\n", session->filename);
+                ui__error("The %s file has no samples!\n", session->filename);
                 goto out_delete;
         }
 out_delete:
diff --git a/tools/perf/builtin-buildid-list.c b/tools/perf/builtin-buildid-list.c
index 52480467e9ff..6b2bcfbde150 100644
--- a/tools/perf/builtin-buildid-list.c
+++ b/tools/perf/builtin-buildid-list.c
@@ -84,7 +84,11 @@ static int perf_session__list_build_ids(void)
         if (filename__fprintf_build_id(session->filename, stdout))
                 goto out;
 
-        if (with_hits)
+        /*
+         * in pipe-mode, the only way to get the buildids is to parse
+         * the record stream. Buildids are stored as RECORD_HEADER_BUILD_ID
+         */
+        if (with_hits || session->fd_pipe)
                 perf_session__process_events(session, &build_id__mark_dso_hit_ops);
 
         perf_session__fprintf_dsos_buildid(session, stdout, with_hits);
diff --git a/tools/perf/builtin-evlist.c b/tools/perf/builtin-evlist.c
index 26760322c4f4..acd78dc28341 100644
--- a/tools/perf/builtin-evlist.c
+++ b/tools/perf/builtin-evlist.c
@@ -15,9 +15,40 @@
 #include "util/parse-options.h"
 #include "util/session.h"
 
-static const char *input_name;
+struct perf_attr_details {
+        bool freq;
+        bool verbose;
+};
+
+static int comma_printf(bool *first, const char *fmt, ...)
+{
+        va_list args;
+        int ret = 0;
+
+        if (!*first) {
+                ret += printf(",");
+        } else {
+                ret += printf(":");
+                *first = false;
+        }
+
+        va_start(args, fmt);
+        ret += vprintf(fmt, args);
+        va_end(args);
+        return ret;
+}
+
+static int __if_print(bool *first, const char *field, u64 value)
+{
+        if (value == 0)
+                return 0;
+
+        return comma_printf(first, " %s: %" PRIu64, field, value);
+}
+
+#define if_print(field) __if_print(&first, #field, pos->attr.field)
 
-static int __cmd_evlist(void)
+static int __cmd_evlist(const char *input_name, struct perf_attr_details *details)
 {
         struct perf_session *session;
         struct perf_evsel *pos;
@@ -26,8 +57,52 @@ static int __cmd_evlist(void)
         if (session == NULL)
                 return -ENOMEM;
 
-        list_for_each_entry(pos, &session->evlist->entries, node)
-                printf("%s\n", event_name(pos));
+        list_for_each_entry(pos, &session->evlist->entries, node) {
+                bool first = true;
+
+                printf("%s", event_name(pos));
+
+                if (details->verbose || details->freq) {
+                        comma_printf(&first, " sample_freq=%" PRIu64,
+                                     (u64)pos->attr.sample_freq);
+                }
+
+                if (details->verbose) {
+                        if_print(type);
+                        if_print(config);
+                        if_print(config1);
+                        if_print(config2);
+                        if_print(size);
+                        if_print(sample_type);
+                        if_print(read_format);
+                        if_print(disabled);
+                        if_print(inherit);
+                        if_print(pinned);
+                        if_print(exclusive);
+                        if_print(exclude_user);
+                        if_print(exclude_kernel);
+                        if_print(exclude_hv);
+                        if_print(exclude_idle);
+                        if_print(mmap);
+                        if_print(comm);
+                        if_print(freq);
+                        if_print(inherit_stat);
+                        if_print(enable_on_exec);
+                        if_print(task);
+                        if_print(watermark);
+                        if_print(precise_ip);
+                        if_print(mmap_data);
+                        if_print(sample_id_all);
+                        if_print(exclude_host);
+                        if_print(exclude_guest);
+                        if_print(__reserved_1);
+                        if_print(wakeup_events);
+                        if_print(bp_type);
+                        if_print(branch_sample_type);
+                }
+
+                putchar('\n');
+        }
 
         perf_session__delete(session);
         return 0;
@@ -38,17 +113,23 @@ static const char * const evlist_usage[] = {
         NULL
 };
 
-static const struct option options[] = {
-        OPT_STRING('i', "input", &input_name, "file",
-                    "input file name"),
-        OPT_END()
-};
-
 int cmd_evlist(int argc, const char **argv, const char *prefix __used)
 {
+        struct perf_attr_details details = { .verbose = false, };
+        const char *input_name = NULL;
+        const struct option options[] = {
+                OPT_STRING('i', "input", &input_name, "file",
+                            "Input file name"),
+                OPT_BOOLEAN('F', "freq", &details.freq,
+                            "Show the sample frequency"),
+                OPT_BOOLEAN('v', "verbose", &details.verbose,
+                            "Show all event attr details"),
+                OPT_END()
+        };
+
         argc = parse_options(argc, argv, options, evlist_usage, 0);
         if (argc)
                 usage_with_options(evlist_usage, options);
 
-        return __cmd_evlist();
+        return __cmd_evlist(input_name, &details);
 }
diff --git a/tools/perf/builtin-inject.c b/tools/perf/builtin-inject.c
index 09c106193e65..3beab489afc5 100644
--- a/tools/perf/builtin-inject.c
+++ b/tools/perf/builtin-inject.c
@@ -60,6 +60,11 @@ static int perf_event__repipe_tracing_data_synth(union perf_event *event,
 static int perf_event__repipe_attr(union perf_event *event,
                                    struct perf_evlist **pevlist __used)
 {
+        int ret;
+        ret = perf_event__process_attr(event, pevlist);
+        if (ret)
+                return ret;
+
         return perf_event__repipe_synth(NULL, event, NULL);
 }
 
diff --git a/tools/perf/builtin-kmem.c b/tools/perf/builtin-kmem.c
index 39104c0beea3..547af48deb4f 100644
--- a/tools/perf/builtin-kmem.c
+++ b/tools/perf/builtin-kmem.c
@@ -192,7 +192,7 @@ static void insert_caller_stat(unsigned long call_site,
 }
 
 static void process_alloc_event(void *data,
-                                struct event *event,
+                                struct event_format *event,
                                 int cpu,
                                 u64 timestamp __used,
                                 struct thread *thread __used,
@@ -253,7 +253,7 @@ static struct alloc_stat *search_alloc_stat(unsigned long ptr,
 }
 
 static void process_free_event(void *data,
-                               struct event *event,
+                               struct event_format *event,
                                int cpu,
                                u64 timestamp __used,
                                struct thread *thread __used)
@@ -281,7 +281,7 @@ static void process_free_event(void *data,
 static void process_raw_event(union perf_event *raw_event __used, void *data,
                               int cpu, u64 timestamp, struct thread *thread)
 {
-        struct event *event;
+        struct event_format *event;
         int type;
 
         type = trace_parse_common_type(data);
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 12c814838993..fd53319de20d 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -356,25 +356,25 @@ struct trace_release_event {
 
 struct trace_lock_handler {
         void (*acquire_event)(struct trace_acquire_event *,
-                              struct event *,
+                              struct event_format *,
                               int cpu,
                               u64 timestamp,
                               struct thread *thread);
 
         void (*acquired_event)(struct trace_acquired_event *,
-                               struct event *,
+                               struct event_format *,
                                int cpu,
                                u64 timestamp,
                                struct thread *thread);
 
         void (*contended_event)(struct trace_contended_event *,
-                                struct event *,
+                                struct event_format *,
                                 int cpu,
                                 u64 timestamp,
                                 struct thread *thread);
 
         void (*release_event)(struct trace_release_event *,
-                              struct event *,
+                              struct event_format *,
                               int cpu,
                               u64 timestamp,
                               struct thread *thread);
@@ -416,7 +416,7 @@ enum acquire_flags {
 
 static void
 report_lock_acquire_event(struct trace_acquire_event *acquire_event,
-                        struct event *__event __used,
+                        struct event_format *__event __used,
                         int cpu __used,
                         u64 timestamp __used,
                         struct thread *thread __used)
@@ -480,7 +480,7 @@ end:
 
 static void
 report_lock_acquired_event(struct trace_acquired_event *acquired_event,
-                         struct event *__event __used,
+                         struct event_format *__event __used,
                          int cpu __used,
                          u64 timestamp __used,
                          struct thread *thread __used)
@@ -536,7 +536,7 @@ end:
 
 static void
 report_lock_contended_event(struct trace_contended_event *contended_event,
-                          struct event *__event __used,
+                          struct event_format *__event __used,
                           int cpu __used,
                           u64 timestamp __used,
                           struct thread *thread __used)
@@ -583,7 +583,7 @@ end:
 
 static void
 report_lock_release_event(struct trace_release_event *release_event,
-                        struct event *__event __used,
+                        struct event_format *__event __used,
                         int cpu __used,
                         u64 timestamp __used,
                         struct thread *thread __used)
@@ -647,7 +647,7 @@ static struct trace_lock_handler *trace_handler;
 
 static void
 process_lock_acquire_event(void *data,
-                           struct event *event __used,
+                           struct event_format *event __used,
                            int cpu __used,
                            u64 timestamp __used,
                            struct thread *thread __used)
@@ -666,7 +666,7 @@ process_lock_acquire_event(void *data,
 
 static void
 process_lock_acquired_event(void *data,
-                            struct event *event __used,
+                            struct event_format *event __used,
                             int cpu __used,
                             u64 timestamp __used,
                             struct thread *thread __used)
@@ -684,7 +684,7 @@ process_lock_acquired_event(void *data,
 
 static void
 process_lock_contended_event(void *data,
-                             struct event *event __used,
+                             struct event_format *event __used,
                              int cpu __used,
                              u64 timestamp __used,
                              struct thread *thread __used)
@@ -702,7 +702,7 @@ process_lock_contended_event(void *data,
 
 static void
 process_lock_release_event(void *data,
-                           struct event *event __used,
+                           struct event_format *event __used,
                            int cpu __used,
                            u64 timestamp __used,
                            struct thread *thread __used)
@@ -721,7 +721,7 @@ process_lock_release_event(void *data,
 static void
 process_raw_event(void *data, int cpu, u64 timestamp, struct thread *thread)
 {
-        struct event *event;
+        struct event_format *event;
         int type;
 
         type = trace_parse_common_type(data);
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 4935c09dd5b5..e215ae61b2ae 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -54,6 +54,7 @@ static struct {
         bool show_ext_vars;
         bool show_funcs;
         bool mod_events;
+        bool uprobes;
         int nevents;
         struct perf_probe_event events[MAX_PROBES];
         struct strlist *dellist;
@@ -75,6 +76,8 @@ static int parse_probe_event(const char *str)
                 return -1;
         }
 
+        pev->uprobes = params.uprobes;
+
         /* Parse a perf-probe command into event */
         ret = parse_perf_probe_command(str, pev);
         pr_debug("%d arguments\n", pev->nargs);
@@ -82,21 +85,58 @@ static int parse_probe_event(const char *str)
         return ret;
 }
 
+static int set_target(const char *ptr)
+{
+        int found = 0;
+        const char *buf;
+
+        /*
+         * The first argument after options can be an absolute path
+         * to an executable / library or kernel module.
+         *
+         * TODO: Support relative path, and $PATH, $LD_LIBRARY_PATH,
+         * short module name.
+         */
+        if (!params.target && ptr && *ptr == '/') {
+                params.target = ptr;
+                found = 1;
+                buf = ptr + (strlen(ptr) - 3);
+
+                if (strcmp(buf, ".ko"))
+                        params.uprobes = true;
+
+        }
+
+        return found;
+}
+
 static int parse_probe_event_argv(int argc, const char **argv)
 {
-        int i, len, ret;
+        int i, len, ret, found_target;
         char *buf;
 
+        found_target = set_target(argv[0]);
+        if (found_target && argc == 1)
+                return 0;
+
         /* Bind up rest arguments */
         len = 0;
-        for (i = 0; i < argc; i++)
+        for (i = 0; i < argc; i++) {
+                if (i == 0 && found_target)
+                        continue;
+
                 len += strlen(argv[i]) + 1;
+        }
         buf = zalloc(len + 1);
         if (buf == NULL)
                 return -ENOMEM;
         len = 0;
-        for (i = 0; i < argc; i++)
+        for (i = 0; i < argc; i++) {
+                if (i == 0 && found_target)
+                        continue;
+
                 len += sprintf(&buf[len], "%s ", argv[i]);
+        }
         params.mod_events = true;
         ret = parse_probe_event(buf);
         free(buf);
@@ -125,6 +165,28 @@ static int opt_del_probe_event(const struct option *opt __used,
         return 0;
 }
 
+static int opt_set_target(const struct option *opt, const char *str,
+                        int unset __used)
+{
+        int ret = -ENOENT;
+
+        if  (str && !params.target) {
+                if (!strcmp(opt->long_name, "exec"))
+                        params.uprobes = true;
+#ifdef DWARF_SUPPORT
+                else if (!strcmp(opt->long_name, "module"))
+                        params.uprobes = false;
+#endif
+                else
+                        return ret;
+
+                params.target = str;
+                ret = 0;
+        }
+
+        return ret;
+}
+
 #ifdef DWARF_SUPPORT
 static int opt_show_lines(const struct option *opt __used,
                           const char *str, int unset __used)
@@ -246,9 +308,9 @@ static const struct option options[] = {
                    "file", "vmlinux pathname"),
         OPT_STRING('s', "source", &symbol_conf.source_prefix,
                    "directory", "path to kernel source"),
-        OPT_STRING('m', "module", &params.target,
-                   "modname|path",
-                   "target module name (for online) or path (for offline)"),
+        OPT_CALLBACK('m', "module", NULL, "modname|path",
+                "target module name (for online) or path (for offline)",
+                opt_set_target),
 #endif
         OPT__DRY_RUN(&probe_event_dry_run),
         OPT_INTEGER('\0', "max-probes", &params.max_probe_points,
@@ -260,6 +322,8 @@ static const struct option options[] = {
                      "\t\t\t(default: \"" DEFAULT_VAR_FILTER "\" for --vars,\n"
                      "\t\t\t \"" DEFAULT_FUNC_FILTER "\" for --funcs)",
                      opt_set_filter),
+        OPT_CALLBACK('x', "exec", NULL, "executable|path",
+                        "target executable name or path", opt_set_target),
         OPT_END()
 };
 
@@ -310,6 +374,10 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
                         pr_err("  Error: Don't use --list with --funcs.\n");
                         usage_with_options(probe_usage, options);
                 }
+                if (params.uprobes) {
+                        pr_warning("  Error: Don't use --list with --exec.\n");
+                        usage_with_options(probe_usage, options);
+                }
                 ret = show_perf_probe_events();
                 if (ret < 0)
                         pr_err("  Error: Failed to show event list. (%d)\n",
@@ -333,8 +401,8 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
                 if (!params.filter)
                         params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
                                                        NULL);
-                ret = show_available_funcs(params.target,
-                                           params.filter);
+                ret = show_available_funcs(params.target, params.filter,
+                                        params.uprobes);
                 strfilter__delete(params.filter);
                 if (ret < 0)
                         pr_err("  Error: Failed to show functions."
@@ -343,7 +411,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
         }
 
 #ifdef DWARF_SUPPORT
-        if (params.show_lines) {
+        if (params.show_lines && !params.uprobes) {
                 if (params.mod_events) {
                         pr_err("  Error: Don't use --line with"
                                " --add/--del.\n");
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index be4e1eee782e..f95840d04e4c 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -44,7 +44,6 @@ struct perf_record {
         struct perf_evlist      *evlist;
         struct perf_session     *session;
         const char              *progname;
-        const char              *uid_str;
         int                     output;
         unsigned int            page_size;
         int                     realtime_prio;
@@ -218,7 +217,7 @@ try_again:
                         if (err == EPERM || err == EACCES) {
                                 ui__error_paranoid();
                                 exit(EXIT_FAILURE);
-                        } else if (err ==  ENODEV && opts->cpu_list) {
+                        } else if (err ==  ENODEV && opts->target.cpu_list) {
                                 die("No such device - did you specify"
                                         " an out-of-range profile CPU?\n");
                         } else if (err == EINVAL) {
@@ -243,9 +242,13 @@ try_again:
                         /*
                          * If it's cycles then fall back to hrtimer
                          * based cpu-clock-tick sw counter, which
-                         * is always available even if no PMU support:
+                         * is always available even if no PMU support.
+                         *
+                         * PPC returns ENXIO until 2.6.37 (behavior changed
+                         * with commit b0a873e).
                          */
-                        if (attr->type == PERF_TYPE_HARDWARE
+                        if ((err == ENOENT || err == ENXIO)
+                                        && attr->type == PERF_TYPE_HARDWARE
                                         && attr->config == PERF_COUNT_HW_CPU_CYCLES) {
 
                                 if (verbose)
@@ -253,11 +256,15 @@ try_again:
                                                     "trying to fall back to cpu-clock-ticks\n");
                                 attr->type = PERF_TYPE_SOFTWARE;
                                 attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                                if (pos->name) {
+                                        free(pos->name);
+                                        pos->name = NULL;
+                                }
                                 goto try_again;
                         }
 
                         if (err == ENOENT) {
-                                ui__warning("The %s event is not supported.\n",
+                                ui__error("The %s event is not supported.\n",
                                             event_name(pos));
                                 exit(EXIT_FAILURE);
                         }
@@ -389,7 +396,7 @@ static void perf_record__mmap_read_all(struct perf_record *rec)
                         perf_record__mmap_read(rec, &rec->evlist->mmap[i]);
         }
 
-        if (perf_header__has_feat(&rec->session->header, HEADER_TRACE_INFO))
+        if (perf_header__has_feat(&rec->session->header, HEADER_TRACING_DATA))
                 write_output(rec, &finished_round_event, sizeof(finished_round_event));
 }
 
@@ -471,7 +478,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 
         if (!have_tracepoints(&evsel_list->entries))
-                perf_header__clear_feat(&session->header, HEADER_TRACE_INFO);
+                perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 
         if (!rec->opts.branch_stack)
                 perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
@@ -578,7 +585,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                 perf_session__process_machines(session, tool,
                                                perf_event__synthesize_guest_os);
 
-        if (!opts->system_wide)
+        if (!opts->target.system_wide)
                 perf_event__synthesize_thread_map(tool, evsel_list->threads,
                                                   process_synthesized_event,
                                                   machine);
@@ -746,7 +753,10 @@ static struct perf_record record = {
                 .mmap_pages          = UINT_MAX,
                 .user_freq           = UINT_MAX,
                 .user_interval       = ULLONG_MAX,
-                .freq                = 1000,
+                .freq                = 4000,
+                .target              = {
+                        .uses_mmap   = true,
+                },
         },
         .write_mode = WRITE_FORCE,
         .file_new   = true,
@@ -765,9 +775,9 @@ const struct option record_options[] = {
                      parse_events_option),
         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
                      "event filter", parse_filter),
-        OPT_STRING('p', "pid", &record.opts.target_pid, "pid",
+        OPT_STRING('p', "pid", &record.opts.target.pid, "pid",
                     "record events on existing process id"),
-        OPT_STRING('t', "tid", &record.opts.target_tid, "tid",
+        OPT_STRING('t', "tid", &record.opts.target.tid, "tid",
                     "record events on existing thread id"),
         OPT_INTEGER('r', "realtime", &record.realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
@@ -775,11 +785,11 @@ const struct option record_options[] = {
                     "collect data without buffering"),
         OPT_BOOLEAN('R', "raw-samples", &record.opts.raw_samples,
                     "collect raw sample records from all opened counters"),
-        OPT_BOOLEAN('a', "all-cpus", &record.opts.system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &record.opts.target.system_wide,
                             "system-wide collection from all CPUs"),
         OPT_BOOLEAN('A', "append", &record.append_file,
                             "append to the output file to do incremental profiling"),
-        OPT_STRING('C', "cpu", &record.opts.cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &record.opts.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
         OPT_BOOLEAN('f', "force", &record.force,
                         "overwrite existing data file (deprecated)"),
@@ -813,7 +823,8 @@ const struct option record_options[] = {
         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
                      "monitor event in cgroup name only",
                      parse_cgroups),
-        OPT_STRING('u', "uid", &record.uid_str, "user", "user to profile"),
+        OPT_STRING('u', "uid", &record.opts.target.uid_str, "user",
+                   "user to profile"),
 
         OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
                      "branch any", "sample any taken branches",
@@ -831,6 +842,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         struct perf_evsel *pos;
         struct perf_evlist *evsel_list;
         struct perf_record *rec = &record;
+        char errbuf[BUFSIZ];
 
         perf_header__set_cmdline(argc, argv);
 
@@ -842,13 +854,12 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 
         argc = parse_options(argc, argv, record_options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && !rec->opts.target_pid && !rec->opts.target_tid &&
-                !rec->opts.system_wide && !rec->opts.cpu_list && !rec->uid_str)
+        if (!argc && perf_target__none(&rec->opts.target))
                 usage_with_options(record_usage, record_options);
 
         if (rec->force && rec->append_file) {
-                fprintf(stderr, "Can't overwrite and append at the same time."
-                                " You need to choose between -f and -A");
+                ui__error("Can't overwrite and append at the same time."
+                          " You need to choose between -f and -A");
                 usage_with_options(record_usage, record_options);
         } else if (rec->append_file) {
                 rec->write_mode = WRITE_APPEND;
@@ -856,9 +867,9 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 rec->write_mode = WRITE_FORCE;
         }
 
-        if (nr_cgroups && !rec->opts.system_wide) {
-                fprintf(stderr, "cgroup monitoring only available in"
-                        " system-wide mode\n");
+        if (nr_cgroups && !rec->opts.target.system_wide) {
+                ui__error("cgroup monitoring only available in"
+                          " system-wide mode\n");
                 usage_with_options(record_usage, record_options);
         }
 
@@ -883,17 +894,25 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 goto out_symbol_exit;
         }
 
-        rec->opts.uid = parse_target_uid(rec->uid_str, rec->opts.target_tid,
-                                         rec->opts.target_pid);
-        if (rec->uid_str != NULL && rec->opts.uid == UINT_MAX - 1)
-                goto out_free_fd;
+        err = perf_target__validate(&rec->opts.target);
+        if (err) {
+                perf_target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
+                ui__warning("%s", errbuf);
+        }
+
+        err = perf_target__parse_uid(&rec->opts.target);
+        if (err) {
+                int saved_errno = errno;
 
-        if (rec->opts.target_pid)
-                rec->opts.target_tid = rec->opts.target_pid;
+                perf_target__strerror(&rec->opts.target, err, errbuf, BUFSIZ);
+                ui__error("%s", errbuf);
+
+                err = -saved_errno;
+                goto out_free_fd;
+        }
 
-        if (perf_evlist__create_maps(evsel_list, rec->opts.target_pid,
-                                     rec->opts.target_tid, rec->opts.uid,
-                                     rec->opts.cpu_list) < 0)
+        err = -ENOMEM;
+        if (perf_evlist__create_maps(evsel_list, &rec->opts.target) < 0)
                 usage_with_options(record_usage, record_options);
 
         list_for_each_entry(pos, &evsel_list->entries, node) {
@@ -914,7 +933,7 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         else if (rec->opts.freq) {
                 rec->opts.default_interval = rec->opts.freq;
         } else {
-                fprintf(stderr, "frequency and count are zero, aborting\n");
+                ui__error("frequency and count are zero, aborting\n");
                 err = -EINVAL;
                 goto out_free_fd;
         }
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index cdae9b2db1cc..8c767c6bca91 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -251,13 +251,13 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
 
         if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
-                        ui__warning("Selected --sort parent, but no "
+                        ui__error("Selected --sort parent, but no "
                                     "callchain data. Did you call "
                                     "'perf record' without -g?\n");
                         return -EINVAL;
                 }
                 if (symbol_conf.use_callchain) {
-                        ui__warning("Selected -g but no callchain data. Did "
+                        ui__error("Selected -g but no callchain data. Did "
                                     "you call 'perf record' without -g?\n");
                         return -1;
                 }
@@ -266,17 +266,15 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
                    !symbol_conf.use_callchain) {
                         symbol_conf.use_callchain = true;
                         if (callchain_register_param(&callchain_param) < 0) {
-                                ui__warning("Can't register callchain "
-                                            "params.\n");
+                                ui__error("Can't register callchain params.\n");
                                 return -EINVAL;
                         }
         }
 
         if (sort__branch_mode == 1) {
                 if (!(self->sample_type & PERF_SAMPLE_BRANCH_STACK)) {
-                        fprintf(stderr, "selected -b but no branch data."
-                                        " Did you call perf record without"
-                                        " -b?\n");
+                        ui__error("Selected -b but no branch data. "
+                                  "Did you call perf record without -b?\n");
                         return -1;
                 }
         }
@@ -296,12 +294,15 @@ static size_t hists__fprintf_nr_sample_events(struct hists *self,
 {
         size_t ret;
         char unit;
-        unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
+        unsigned long nr_samples = self->stats.nr_events[PERF_RECORD_SAMPLE];
+        u64 nr_events = self->stats.total_period;
 
-        nr_events = convert_unit(nr_events, &unit);
-        ret = fprintf(fp, "# Events: %lu%c", nr_events, unit);
+        nr_samples = convert_unit(nr_samples, &unit);
+        ret = fprintf(fp, "# Samples: %lu%c", nr_samples, unit);
         if (evname != NULL)
-                ret += fprintf(fp, " %s", evname);
+                ret += fprintf(fp, " of event '%s'", evname);
+
+        ret += fprintf(fp, "\n# Event count (approx.): %" PRIu64, nr_events);
         return ret + fprintf(fp, "\n#\n");
 }
 
@@ -417,7 +418,7 @@ static int __cmd_report(struct perf_report *rep)
         }
 
         if (nr_samples == 0) {
-                ui__warning("The %s file has no samples!\n", session->filename);
+                ui__error("The %s file has no samples!\n", session->filename);
                 goto out_delete;
         }
 
@@ -680,14 +681,10 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
 
         }
 
-        if (strcmp(report.input_name, "-") != 0) {
-                if (report.use_gtk)
-                        perf_gtk_setup_browser(argc, argv, true);
-                else
-                        setup_browser(true);
-        } else {
+        if (strcmp(report.input_name, "-") != 0)
+                setup_browser(true);
+        else
                 use_browser = 0;
-        }
 
         /*
          * Only in the newt browser we are doing integrated annotation,
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index 1cad3af4bf4c..b125e07eb399 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -728,34 +728,34 @@ struct trace_migrate_task_event {
 struct trace_sched_handler {
         void (*switch_event)(struct trace_switch_event *,
                              struct machine *,
-                             struct event *,
+                             struct event_format *,
                              int cpu,
                              u64 timestamp,
                              struct thread *thread);
 
         void (*runtime_event)(struct trace_runtime_event *,
                               struct machine *,
-                              struct event *,
+                              struct event_format *,
                               int cpu,
                               u64 timestamp,
                               struct thread *thread);
 
         void (*wakeup_event)(struct trace_wakeup_event *,
                              struct machine *,
-                             struct event *,
+                             struct event_format *,
                              int cpu,
                              u64 timestamp,
                              struct thread *thread);
 
         void (*fork_event)(struct trace_fork_event *,
-                           struct event *,
+                           struct event_format *,
                            int cpu,
                            u64 timestamp,
                            struct thread *thread);
 
         void (*migrate_task_event)(struct trace_migrate_task_event *,
                            struct machine *machine,
-                           struct event *,
+                           struct event_format *,
                            int cpu,
                            u64 timestamp,
                            struct thread *thread);
@@ -765,7 +765,7 @@ struct trace_sched_handler {
 static void
 replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
                     struct machine *machine __used,
-                    struct event *event,
+                    struct event_format *event,
                     int cpu __used,
                     u64 timestamp __used,
                     struct thread *thread __used)
@@ -792,7 +792,7 @@ static u64 cpu_last_switched[MAX_CPUS];
 static void
 replay_switch_event(struct trace_switch_event *switch_event,
                     struct machine *machine __used,
-                    struct event *event,
+                    struct event_format *event,
                     int cpu,
                     u64 timestamp,
                     struct thread *thread __used)
@@ -835,7 +835,7 @@ replay_switch_event(struct trace_switch_event *switch_event,
 
 static void
 replay_fork_event(struct trace_fork_event *fork_event,
-                  struct event *event,
+                  struct event_format *event,
                   int cpu __used,
                   u64 timestamp __used,
                   struct thread *thread __used)
@@ -944,7 +944,7 @@ static void thread_atoms_insert(struct thread *thread)
 
 static void
 latency_fork_event(struct trace_fork_event *fork_event __used,
-                   struct event *event __used,
+                   struct event_format *event __used,
                    int cpu __used,
                    u64 timestamp __used,
                    struct thread *thread __used)
@@ -1026,7 +1026,7 @@ add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
 static void
 latency_switch_event(struct trace_switch_event *switch_event,
                      struct machine *machine,
-                     struct event *event __used,
+                     struct event_format *event __used,
                      int cpu,
                      u64 timestamp,
                      struct thread *thread __used)
@@ -1079,7 +1079,7 @@ latency_switch_event(struct trace_switch_event *switch_event,
 static void
 latency_runtime_event(struct trace_runtime_event *runtime_event,
                      struct machine *machine,
-                     struct event *event __used,
+                     struct event_format *event __used,
                      int cpu,
                      u64 timestamp,
                      struct thread *this_thread __used)
@@ -1102,7 +1102,7 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
 static void
 latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
                      struct machine *machine,
-                     struct event *__event __used,
+                     struct event_format *__event __used,
                      int cpu __used,
                      u64 timestamp,
                      struct thread *thread __used)
@@ -1150,7 +1150,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
 static void
 latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
                      struct machine *machine,
-                     struct event *__event __used,
+                     struct event_format *__event __used,
                      int cpu __used,
                      u64 timestamp,
                      struct thread *thread __used)
@@ -1361,7 +1361,7 @@ static struct trace_sched_handler *trace_handler;
 
 static void
 process_sched_wakeup_event(struct perf_tool *tool __used,
-                           struct event *event,
+                           struct event_format *event,
                            struct perf_sample *sample,
                            struct machine *machine,
                            struct thread *thread)
@@ -1398,7 +1398,7 @@ static char next_shortname2 = '0';
 static void
 map_switch_event(struct trace_switch_event *switch_event,
                  struct machine *machine,
-                 struct event *event __used,
+                 struct event_format *event __used,
                  int this_cpu,
                  u64 timestamp,
                  struct thread *thread __used)
@@ -1476,7 +1476,7 @@ map_switch_event(struct trace_switch_event *switch_event,
 
 static void
 process_sched_switch_event(struct perf_tool *tool __used,
-                           struct event *event,
+                           struct event_format *event,
                            struct perf_sample *sample,
                            struct machine *machine,
                            struct thread *thread)
@@ -1512,7 +1512,7 @@ process_sched_switch_event(struct perf_tool *tool __used,
 
 static void
 process_sched_runtime_event(struct perf_tool *tool __used,
-                            struct event *event,
+                            struct event_format *event,
                             struct perf_sample *sample,
                             struct machine *machine,
                             struct thread *thread)
@@ -1532,7 +1532,7 @@ process_sched_runtime_event(struct perf_tool *tool __used,
 
 static void
 process_sched_fork_event(struct perf_tool *tool __used,
-                         struct event *event,
+                         struct event_format *event,
                          struct perf_sample *sample,
                          struct machine *machine __used,
                          struct thread *thread)
@@ -1554,7 +1554,7 @@ process_sched_fork_event(struct perf_tool *tool __used,
 
 static void
 process_sched_exit_event(struct perf_tool *tool __used,
-                         struct event *event,
+                         struct event_format *event,
                          struct perf_sample *sample __used,
                          struct machine *machine __used,
                          struct thread *thread __used)
@@ -1565,7 +1565,7 @@ process_sched_exit_event(struct perf_tool *tool __used,
 
 static void
 process_sched_migrate_task_event(struct perf_tool *tool __used,
-                                 struct event *event,
+                                 struct event_format *event,
                                  struct perf_sample *sample,
                                  struct machine *machine,
                                  struct thread *thread)
@@ -1586,7 +1586,7 @@ process_sched_migrate_task_event(struct perf_tool *tool __used,
                                                   sample->time, thread);
 }
 
-typedef void (*tracepoint_handler)(struct perf_tool *tool, struct event *event,
+typedef void (*tracepoint_handler)(struct perf_tool *tool, struct event_format *event,
                                    struct perf_sample *sample,
                                    struct machine *machine,
                                    struct thread *thread);
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index d4ce733b9eba..8e395a538eb9 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -261,7 +261,7 @@ static void print_sample_start(struct perf_sample *sample,
                                struct perf_event_attr *attr)
 {
         int type;
-        struct event *event;
+        struct event_format *event;
         const char *evname = NULL;
         unsigned long secs;
         unsigned long usecs;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 1e5e9b270f5e..62ae30d34fa6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -173,24 +173,23 @@ static struct perf_event_attr very_very_detailed_attrs[] = {
 
 
 
-struct perf_evlist              *evsel_list;
+static struct perf_evlist       *evsel_list;
 
-static bool                     system_wide                     =  false;
-static int                      run_idx                         =  0;
+static struct perf_target       target = {
+        .uid    = UINT_MAX,
+};
 
+static int                      run_idx                         =  0;
 static int                      run_count                       =  1;
 static bool                     no_inherit                      = false;
 static bool                     scale                           =  true;
 static bool                     no_aggr                         = false;
-static const char               *target_pid;
-static const char               *target_tid;
 static pid_t                    child_pid                       = -1;
 static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
 static bool                     sync_run                        =  false;
 static bool                     big_num                         =  true;
 static int                      big_num_opt                     =  -1;
-static const char               *cpu_list;
 static const char               *csv_sep                        = NULL;
 static bool                     csv_output                      = false;
 static bool                     group                           = false;
@@ -265,18 +264,18 @@ static double stddev_stats(struct stats *stats)
         return sqrt(variance_mean);
 }
 
-struct stats                    runtime_nsecs_stats[MAX_NR_CPUS];
-struct stats                    runtime_cycles_stats[MAX_NR_CPUS];
-struct stats                    runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
-struct stats                    runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
-struct stats                    runtime_branches_stats[MAX_NR_CPUS];
-struct stats                    runtime_cacherefs_stats[MAX_NR_CPUS];
-struct stats                    runtime_l1_dcache_stats[MAX_NR_CPUS];
-struct stats                    runtime_l1_icache_stats[MAX_NR_CPUS];
-struct stats                    runtime_ll_cache_stats[MAX_NR_CPUS];
-struct stats                    runtime_itlb_cache_stats[MAX_NR_CPUS];
-struct stats                    runtime_dtlb_cache_stats[MAX_NR_CPUS];
-struct stats                    walltime_nsecs_stats;
+static struct stats runtime_nsecs_stats[MAX_NR_CPUS];
+static struct stats runtime_cycles_stats[MAX_NR_CPUS];
+static struct stats runtime_stalled_cycles_front_stats[MAX_NR_CPUS];
+static struct stats runtime_stalled_cycles_back_stats[MAX_NR_CPUS];
+static struct stats runtime_branches_stats[MAX_NR_CPUS];
+static struct stats runtime_cacherefs_stats[MAX_NR_CPUS];
+static struct stats runtime_l1_dcache_stats[MAX_NR_CPUS];
+static struct stats runtime_l1_icache_stats[MAX_NR_CPUS];
+static struct stats runtime_ll_cache_stats[MAX_NR_CPUS];
+static struct stats runtime_itlb_cache_stats[MAX_NR_CPUS];
+static struct stats runtime_dtlb_cache_stats[MAX_NR_CPUS];
+static struct stats walltime_nsecs_stats;
 
 static int create_perf_stat_counter(struct perf_evsel *evsel,
                                     struct perf_evsel *first)
@@ -299,15 +298,15 @@ retry:
         if (exclude_guest_missing)
                 evsel->attr.exclude_guest = evsel->attr.exclude_host = 0;
 
-        if (system_wide) {
+        if (perf_target__has_cpu(&target)) {
                 ret = perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
-                                                group, group_fd);
+                                               group, group_fd);
                 if (ret)
                         goto check_ret;
                 return 0;
         }
 
-        if (!target_pid && !target_tid && (!group || evsel == first)) {
+        if (!perf_target__has_task(&target) && (!group || evsel == first)) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
@@ -471,7 +470,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                         exit(-1);
                 }
 
-                if (!target_tid && !target_pid && !system_wide)
+                if (perf_target__none(&target))
                         evsel_list->threads->map[0] = child_pid;
 
                 /*
@@ -506,7 +505,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                                 error("You may not have permission to collect %sstats.\n"
                                       "\t Consider tweaking"
                                       " /proc/sys/kernel/perf_event_paranoid or running as root.",
-                                      system_wide ? "system-wide " : "");
+                                      target.system_wide ? "system-wide " : "");
                         } else {
                                 error("open_counter returned with %d (%s). "
                                       "/bin/dmesg may provide additional information.\n",
@@ -998,14 +997,14 @@ static void print_stat(int argc, const char **argv)
         if (!csv_output) {
                 fprintf(output, "\n");
                 fprintf(output, " Performance counter stats for ");
-                if (!target_pid && !target_tid) {
+                if (!perf_target__has_task(&target)) {
                         fprintf(output, "\'%s", argv[0]);
                         for (i = 1; i < argc; i++)
                                 fprintf(output, " %s", argv[i]);
-                } else if (target_pid)
-                        fprintf(output, "process id \'%s", target_pid);
+                } else if (target.pid)
+                        fprintf(output, "process id \'%s", target.pid);
                 else
-                        fprintf(output, "thread id \'%s", target_tid);
+                        fprintf(output, "thread id \'%s", target.tid);
 
                 fprintf(output, "\'");
                 if (run_count > 1)
@@ -1079,11 +1078,11 @@ static const struct option options[] = {
                      "event filter", parse_filter),
         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
                     "child tasks do not inherit counters"),
-        OPT_STRING('p', "pid", &target_pid, "pid",
+        OPT_STRING('p', "pid", &target.pid, "pid",
                    "stat events on existing process id"),
-        OPT_STRING('t', "tid", &target_tid, "tid",
+        OPT_STRING('t', "tid", &target.tid, "tid",
                    "stat events on existing thread id"),
-        OPT_BOOLEAN('a', "all-cpus", &system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &target.system_wide,
                     "system-wide collection from all CPUs"),
         OPT_BOOLEAN('g', "group", &group,
                     "put the counters into a counter group"),
@@ -1102,7 +1101,7 @@ static const struct option options[] = {
         OPT_CALLBACK_NOOPT('B', "big-num", NULL, NULL, 
                            "print large numbers with thousands\' separators",
                            stat__set_big_num),
-        OPT_STRING('C', "cpu", &cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &target.cpu_list, "cpu",
                     "list of cpus to monitor in system-wide"),
         OPT_BOOLEAN('A', "no-aggr", &no_aggr,
                     "disable CPU count aggregation"),
@@ -1220,13 +1219,13 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         } else if (big_num_opt == 0) /* User passed --no-big-num */
                 big_num = false;
 
-        if (!argc && !target_pid && !target_tid)
+        if (!argc && !perf_target__has_task(&target))
                 usage_with_options(stat_usage, options);
         if (run_count <= 0)
                 usage_with_options(stat_usage, options);
 
         /* no_aggr, cgroup are for system-wide only */
-        if ((no_aggr || nr_cgroups) && !system_wide) {
+        if ((no_aggr || nr_cgroups) && !perf_target__has_cpu(&target)) {
                 fprintf(stderr, "both cgroup and no-aggregation "
                         "modes only available in system-wide mode\n");
 
@@ -1236,23 +1235,14 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         if (add_default_attributes())
                 goto out;
 
-        if (target_pid)
-                target_tid = target_pid;
+        perf_target__validate(&target);
 
-        evsel_list->threads = thread_map__new_str(target_pid,
-                                                  target_tid, UINT_MAX);
-        if (evsel_list->threads == NULL) {
-                pr_err("Problems finding threads of monitor\n");
-                usage_with_options(stat_usage, options);
-        }
-
-        if (system_wide)
-                evsel_list->cpus = cpu_map__new(cpu_list);
-        else
-                evsel_list->cpus = cpu_map__dummy_new();
+        if (perf_evlist__create_maps(evsel_list, &target) < 0) {
+                if (perf_target__has_task(&target))
+                        pr_err("Problems finding threads of monitor\n");
+                if (perf_target__has_cpu(&target))
+                        perror("failed to parse CPUs map");
 
-        if (evsel_list->cpus == NULL) {
-                perror("failed to parse CPUs map");
                 usage_with_options(stat_usage, options);
                 return -1;
         }
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 223ffdcc0fd8..5a8727c08757 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -604,556 +604,6 @@ out_free_threads:
 #undef nsyscalls
 }
 
-#define TEST_ASSERT_VAL(text, cond) \
-do { \
-        if (!(cond)) { \
-                pr_debug("FAILED %s:%d %s\n", __FILE__, __LINE__, text); \
-                return -1; \
-        } \
-} while (0)
-
-static int test__checkevent_tracepoint(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_TRACEPOINT == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong sample_type",
-                (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU) ==
-                evsel->attr.sample_type);
-        TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
-        return 0;
-}
-
-static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
-{
-        struct perf_evsel *evsel;
-
-        TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
-
-        list_for_each_entry(evsel, &evlist->entries, node) {
-                TEST_ASSERT_VAL("wrong type",
-                        PERF_TYPE_TRACEPOINT == evsel->attr.type);
-                TEST_ASSERT_VAL("wrong sample_type",
-                        (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU)
-                        == evsel->attr.sample_type);
-                TEST_ASSERT_VAL("wrong sample_period",
-                        1 == evsel->attr.sample_period);
-        }
-        return 0;
-}
-
-static int test__checkevent_raw(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_RAW == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config", 0x1a == evsel->attr.config);
-        return 0;
-}
-
-static int test__checkevent_numeric(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", 1 == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
-        return 0;
-}
-
-static int test__checkevent_symbolic_name(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_HARDWARE == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config",
-                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
-        return 0;
-}
-
-static int test__checkevent_symbolic_name_config(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_HARDWARE == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config",
-                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
-        TEST_ASSERT_VAL("wrong period",
-                        100000 == evsel->attr.sample_period);
-        TEST_ASSERT_VAL("wrong config1",
-                        0 == evsel->attr.config1);
-        TEST_ASSERT_VAL("wrong config2",
-                        1 == evsel->attr.config2);
-        return 0;
-}
-
-static int test__checkevent_symbolic_alias(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_SOFTWARE == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config",
-                        PERF_COUNT_SW_PAGE_FAULTS == evsel->attr.config);
-        return 0;
-}
-
-static int test__checkevent_genhw(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_HW_CACHE == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config", (1 << 16) == evsel->attr.config);
-        return 0;
-}
-
-static int test__checkevent_breakpoint(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_breakpoint_x(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_X == evsel->attr.bp_type);
-        TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->attr.bp_len);
-        return 0;
-}
-
-static int test__checkevent_breakpoint_r(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 == evsel->attr.bp_type);
-        TEST_ASSERT_VAL("wrong bp_len",
-                        HW_BREAKPOINT_LEN_4 == evsel->attr.bp_len);
-        return 0;
-}
-
-static int test__checkevent_breakpoint_w(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_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,
-                                              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);
-
-        return test__checkevent_tracepoint(evlist);
-}
-
-static int
-test__checkevent_tracepoint_multi_modifier(struct perf_evlist *evlist)
-{
-        struct perf_evsel *evsel;
-
-        TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
-
-        list_for_each_entry(evsel, &evlist->entries, 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);
-        }
-
-        return test__checkevent_tracepoint_multi(evlist);
-}
-
-static int test__checkevent_raw_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);
-
-        return test__checkevent_raw(evlist);
-}
-
-static int test__checkevent_numeric_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);
-
-        return test__checkevent_numeric(evlist);
-}
-
-static int test__checkevent_symbolic_name_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);
-
-        return test__checkevent_symbolic_name(evlist);
-}
-
-static int test__checkevent_exclude_host_modifier(struct perf_evlist *evlist)
-{
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
-
-        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
-        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
-
-        return test__checkevent_symbolic_name(evlist);
-}
-
-static int test__checkevent_exclude_guest_modifier(struct perf_evlist *evlist)
-{
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
-
-        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
-        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
-
-        return test__checkevent_symbolic_name(evlist);
-}
-
-static int test__checkevent_symbolic_alias_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);
-
-        return test__checkevent_symbolic_alias(evlist);
-}
-
-static int test__checkevent_genhw_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);
-
-        return test__checkevent_genhw(evlist);
-}
-
-static int test__checkevent_breakpoint_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);
-
-        return test__checkevent_breakpoint(evlist);
-}
-
-static int test__checkevent_breakpoint_x_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);
-
-        return test__checkevent_breakpoint_x(evlist);
-}
-
-static int test__checkevent_breakpoint_r_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);
-
-        return test__checkevent_breakpoint_r(evlist);
-}
-
-static int test__checkevent_breakpoint_w_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);
-
-        return test__checkevent_breakpoint_w(evlist);
-}
-
-static int test__checkevent_pmu(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_RAW == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config",    10 == evsel->attr.config);
-        TEST_ASSERT_VAL("wrong config1",    1 == evsel->attr.config1);
-        TEST_ASSERT_VAL("wrong config2",    3 == evsel->attr.config2);
-        TEST_ASSERT_VAL("wrong period",  1000 == evsel->attr.sample_period);
-
-        return 0;
-}
-
-static int test__checkevent_list(struct perf_evlist *evlist)
-{
-        struct perf_evsel *evsel;
-
-        TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
-
-        /* r1 */
-        evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
-        TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
-        TEST_ASSERT_VAL("wrong config1", 0 == evsel->attr.config1);
-        TEST_ASSERT_VAL("wrong config2", 0 == evsel->attr.config2);
-        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);
-
-        /* syscalls:sys_enter_open:k */
-        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
-        TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong sample_type",
-                (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU) ==
-                evsel->attr.sample_type);
-        TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
-        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);
-
-        /* 1:1:hp */
-        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
-        TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
-        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
-        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);
-
-        return 0;
-}
-
-static struct test__event_st {
-        const char *name;
-        __u32 type;
-        int (*check)(struct perf_evlist *evlist);
-} test__events[] = {
-        {
-                .name  = "syscalls:sys_enter_open",
-                .check = test__checkevent_tracepoint,
-        },
-        {
-                .name  = "syscalls:*",
-                .check = test__checkevent_tracepoint_multi,
-        },
-        {
-                .name  = "r1a",
-                .check = test__checkevent_raw,
-        },
-        {
-                .name  = "1:1",
-                .check = test__checkevent_numeric,
-        },
-        {
-                .name  = "instructions",
-                .check = test__checkevent_symbolic_name,
-        },
-        {
-                .name  = "cycles/period=100000,config2/",
-                .check = test__checkevent_symbolic_name_config,
-        },
-        {
-                .name  = "faults",
-                .check = test__checkevent_symbolic_alias,
-        },
-        {
-                .name  = "L1-dcache-load-miss",
-                .check = test__checkevent_genhw,
-        },
-        {
-                .name  = "mem:0",
-                .check = test__checkevent_breakpoint,
-        },
-        {
-                .name  = "mem:0:x",
-                .check = test__checkevent_breakpoint_x,
-        },
-        {
-                .name  = "mem:0:r",
-                .check = test__checkevent_breakpoint_r,
-        },
-        {
-                .name  = "mem:0:w",
-                .check = test__checkevent_breakpoint_w,
-        },
-        {
-                .name  = "syscalls:sys_enter_open:k",
-                .check = test__checkevent_tracepoint_modifier,
-        },
-        {
-                .name  = "syscalls:*:u",
-                .check = test__checkevent_tracepoint_multi_modifier,
-        },
-        {
-                .name  = "r1a:kp",
-                .check = test__checkevent_raw_modifier,
-        },
-        {
-                .name  = "1:1:hp",
-                .check = test__checkevent_numeric_modifier,
-        },
-        {
-                .name  = "instructions:h",
-                .check = test__checkevent_symbolic_name_modifier,
-        },
-        {
-                .name  = "faults:u",
-                .check = test__checkevent_symbolic_alias_modifier,
-        },
-        {
-                .name  = "L1-dcache-load-miss:kp",
-                .check = test__checkevent_genhw_modifier,
-        },
-        {
-                .name  = "mem:0:u",
-                .check = test__checkevent_breakpoint_modifier,
-        },
-        {
-                .name  = "mem:0:x:k",
-                .check = test__checkevent_breakpoint_x_modifier,
-        },
-        {
-                .name  = "mem:0:r:hp",
-                .check = test__checkevent_breakpoint_r_modifier,
-        },
-        {
-                .name  = "mem:0:w:up",
-                .check = test__checkevent_breakpoint_w_modifier,
-        },
-        {
-                .name  = "cpu/config=10,config1,config2=3,period=1000/u",
-                .check = test__checkevent_pmu,
-        },
-        {
-                .name  = "r1,syscalls:sys_enter_open:k,1:1:hp",
-                .check = test__checkevent_list,
-        },
-        {
-                .name  = "instructions:G",
-                .check = test__checkevent_exclude_host_modifier,
-        },
-        {
-                .name  = "instructions:H",
-                .check = test__checkevent_exclude_guest_modifier,
-        },
-};
-
-#define TEST__EVENTS_CNT (sizeof(test__events) / sizeof(struct test__event_st))
-
-static int test__parse_events(void)
-{
-        struct perf_evlist *evlist;
-        u_int i;
-        int ret = 0;
-
-        for (i = 0; i < TEST__EVENTS_CNT; i++) {
-                struct test__event_st *e = &test__events[i];
-
-                evlist = perf_evlist__new(NULL, NULL);
-                if (evlist == NULL)
-                        break;
-
-                ret = parse_events(evlist, e->name, 0);
-                if (ret) {
-                        pr_debug("failed to parse event '%s', err %d\n",
-                                 e->name, ret);
-                        break;
-                }
-
-                ret = e->check(evlist);
-                perf_evlist__delete(evlist);
-                if (ret)
-                        break;
-        }
-
-        return ret;
-}
-
 static int sched__get_first_possible_cpu(pid_t pid, cpu_set_t **maskp,
                                          size_t *sizep)
 {
@@ -1195,6 +645,10 @@ realloc:
 static int test__PERF_RECORD(void)
 {
         struct perf_record_opts opts = {
+                .target = {
+                        .uid = UINT_MAX,
+                        .uses_mmap = true,
+                },
                 .no_delay   = true,
                 .freq       = 10,
                 .mmap_pages = 256,
@@ -1237,8 +691,7 @@ static int test__PERF_RECORD(void)
          * perf_evlist__prepare_workload we'll fill in the only thread
          * we're monitoring, the one forked there.
          */
-        err = perf_evlist__create_maps(evlist, opts.target_pid,
-                                       opts.target_tid, UINT_MAX, opts.cpu_list);
+        err = perf_evlist__create_maps(evlist, &opts.target);
         if (err < 0) {
                 pr_debug("Not enough memory to create thread/cpu maps\n");
                 goto out_delete_evlist;
@@ -1579,8 +1032,6 @@ static int __test__rdpmc(void)
         sa.sa_sigaction = segfault_handler;
         sigaction(SIGSEGV, &sa, NULL);
 
-        fprintf(stderr, "\n\n");
-
         fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
         if (fd < 0) {
                 die("Error: sys_perf_event_open() syscall returned "
@@ -1605,7 +1056,7 @@ static int __test__rdpmc(void)
                 loops *= 10;
 
                 delta = now - stamp;
-                fprintf(stderr, "%14d: %14Lu\n", n, (long long)delta);
+                pr_debug("%14d: %14Lu\n", n, (long long)delta);
 
                 delta_sum += delta;
         }
@@ -1613,7 +1064,7 @@ static int __test__rdpmc(void)
         munmap(addr, page_size);
         close(fd);
 
-        fprintf(stderr, "   ");
+        pr_debug("   ");
 
         if (!delta_sum)
                 return -1;
@@ -1674,7 +1125,7 @@ static struct test {
         },
         {
                 .desc = "parse events tests",
-                .func = test__parse_events,
+                .func = parse_events__test,
         },
 #if defined(__x86_64__) || defined(__i386__)
         {
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 8ef59f8262bb..871b540293e1 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -588,7 +588,7 @@ static void *display_thread_tui(void *arg)
          * via --uid.
          */
         list_for_each_entry(pos, &top->evlist->entries, node)
-                pos->hists.uid_filter_str = top->uid_str;
+                pos->hists.uid_filter_str = top->target.uid_str;
 
         perf_evlist__tui_browse_hists(top->evlist, help,
                                       perf_top__sort_new_samples,
@@ -900,6 +900,9 @@ static void perf_top__start_counters(struct perf_top *top)
                         attr->read_format |= PERF_FORMAT_ID;
                 }
 
+                if (perf_target__has_cpu(&top->target))
+                        attr->sample_type |= PERF_SAMPLE_CPU;
+
                 if (symbol_conf.use_callchain)
                         attr->sample_type |= PERF_SAMPLE_CALLCHAIN;
 
@@ -948,20 +951,24 @@ try_again:
 
                                 attr->type = PERF_TYPE_SOFTWARE;
                                 attr->config = PERF_COUNT_SW_CPU_CLOCK;
+                                if (counter->name) {
+                                        free(counter->name);
+                                        counter->name = NULL;
+                                }
                                 goto try_again;
                         }
 
                         if (err == ENOENT) {
-                                ui__warning("The %s event is not supported.\n",
+                                ui__error("The %s event is not supported.\n",
                                             event_name(counter));
                                 goto out_err;
                         } else if (err == EMFILE) {
-                                ui__warning("Too many events are opened.\n"
+                                ui__error("Too many events are opened.\n"
                                             "Try again after reducing the number of events\n");
                                 goto out_err;
                         }
 
-                        ui__warning("The sys_perf_event_open() syscall "
+                        ui__error("The sys_perf_event_open() syscall "
                                     "returned with %d (%s).  /bin/dmesg "
                                     "may provide additional information.\n"
                                     "No CONFIG_PERF_EVENTS=y kernel support "
@@ -971,7 +978,7 @@ try_again:
         }
 
         if (perf_evlist__mmap(evlist, top->mmap_pages, false) < 0) {
-                ui__warning("Failed to mmap with %d (%s)\n",
+                ui__error("Failed to mmap with %d (%s)\n",
                             errno, strerror(errno));
                 goto out_err;
         }
@@ -987,12 +994,12 @@ static int perf_top__setup_sample_type(struct perf_top *top)
 {
         if (!top->sort_has_symbols) {
                 if (symbol_conf.use_callchain) {
-                        ui__warning("Selected -g but \"sym\" not present in --sort/-s.");
+                        ui__error("Selected -g but \"sym\" not present in --sort/-s.");
                         return -EINVAL;
                 }
         } else if (!top->dont_use_callchains && callchain_param.mode != CHAIN_NONE) {
                 if (callchain_register_param(&callchain_param) < 0) {
-                        ui__warning("Can't register callchain params.\n");
+                        ui__error("Can't register callchain params.\n");
                         return -EINVAL;
                 }
         }
@@ -1016,7 +1023,7 @@ static int __cmd_top(struct perf_top *top)
         if (ret)
                 goto out_delete;
 
-        if (top->target_tid || top->uid != UINT_MAX)
+        if (perf_target__has_task(&top->target))
                 perf_event__synthesize_thread_map(&top->tool, top->evlist->threads,
                                                   perf_event__process,
                                                   &top->session->host_machine);
@@ -1034,7 +1041,7 @@ static int __cmd_top(struct perf_top *top)
 
         if (pthread_create(&thread, NULL, (use_browser > 0 ? display_thread_tui :
                                                             display_thread), top)) {
-                printf("Could not create display thread.\n");
+                ui__error("Could not create display thread.\n");
                 exit(-1);
         }
 
@@ -1043,7 +1050,7 @@ static int __cmd_top(struct perf_top *top)
 
                 param.sched_priority = top->realtime_prio;
                 if (sched_setscheduler(0, SCHED_FIFO, &param)) {
-                        printf("Could not set realtime priority.\n");
+                        ui__error("Could not set realtime priority.\n");
                         exit(-1);
                 }
         }
@@ -1150,14 +1157,17 @@ static const char * const top_usage[] = {
 int cmd_top(int argc, const char **argv, const char *prefix __used)
 {
         struct perf_evsel *pos;
-        int status = -ENOMEM;
+        int status;
+        char errbuf[BUFSIZ];
         struct perf_top top = {
                 .count_filter        = 5,
                 .delay_secs          = 2,
-                .uid                 = UINT_MAX,
-                .freq                = 1000, /* 1 KHz */
+                .freq                = 4000, /* 4 KHz */
                 .mmap_pages          = 128,
                 .sym_pcnt_filter     = 5,
+                .target              = {
+                        .uses_mmap   = true,
+                },
         };
         char callchain_default_opt[] = "fractal,0.5,callee";
         const struct option options[] = {
@@ -1166,13 +1176,13 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                      parse_events_option),
         OPT_INTEGER('c', "count", &top.default_interval,
                     "event period to sample"),
-        OPT_STRING('p', "pid", &top.target_pid, "pid",
+        OPT_STRING('p', "pid", &top.target.pid, "pid",
                     "profile events on existing process id"),
-        OPT_STRING('t', "tid", &top.target_tid, "tid",
+        OPT_STRING('t', "tid", &top.target.tid, "tid",
                     "profile events on existing thread id"),
-        OPT_BOOLEAN('a', "all-cpus", &top.system_wide,
+        OPT_BOOLEAN('a', "all-cpus", &top.target.system_wide,
                             "system-wide collection from all CPUs"),
-        OPT_STRING('C', "cpu", &top.cpu_list, "cpu",
+        OPT_STRING('C', "cpu", &top.target.cpu_list, "cpu",
                     "list of cpus to monitor"),
         OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
                    "file", "vmlinux pathname"),
@@ -1227,7 +1237,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                     "Display raw encoding of assembly instructions (default)"),
         OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
-        OPT_STRING('u', "uid", &top.uid_str, "user", "user to profile"),
+        OPT_STRING('u', "uid", &top.target.uid_str, "user", "user to profile"),
         OPT_END()
         };
 
@@ -1253,27 +1263,32 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 
         setup_browser(false);
 
-        top.uid = parse_target_uid(top.uid_str, top.target_tid, top.target_pid);
-        if (top.uid_str != NULL && top.uid == UINT_MAX - 1)
-                goto out_delete_evlist;
+        status = perf_target__validate(&top.target);
+        if (status) {
+                perf_target__strerror(&top.target, status, errbuf, BUFSIZ);
+                ui__warning("%s", errbuf);
+        }
 
-        /* CPU and PID are mutually exclusive */
-        if (top.target_tid && top.cpu_list) {
-                printf("WARNING: PID switch overriding CPU\n");
-                sleep(1);
-                top.cpu_list = NULL;
+        status = perf_target__parse_uid(&top.target);
+        if (status) {
+                int saved_errno = errno;
+
+                perf_target__strerror(&top.target, status, errbuf, BUFSIZ);
+                ui__error("%s", errbuf);
+
+                status = -saved_errno;
+                goto out_delete_evlist;
         }
 
-        if (top.target_pid)
-                top.target_tid = top.target_pid;
+        if (perf_target__none(&top.target))
+                top.target.system_wide = true;
 
-        if (perf_evlist__create_maps(top.evlist, top.target_pid,
-                                     top.target_tid, top.uid, top.cpu_list) < 0)
+        if (perf_evlist__create_maps(top.evlist, &top.target) < 0)
                 usage_with_options(top_usage, options);
 
         if (!top.evlist->nr_entries &&
             perf_evlist__add_default(top.evlist) < 0) {
-                pr_err("Not enough memory for event selector list\n");
+                ui__error("Not enough memory for event selector list\n");
                 return -ENOMEM;
         }
 
@@ -1290,7 +1305,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         else if (top.freq) {
                 top.default_interval = top.freq;
         } else {
-                fprintf(stderr, "frequency and count are zero, aborting\n");
+                ui__error("frequency and count are zero, aborting\n");
                 exit(EXIT_FAILURE);
         }
 
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 89e3355ab173..f960ccb2edc6 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -207,10 +207,10 @@ extern const char perf_version_string[];
 
 void pthread__unblock_sigwinch(void);
 
+#include "util/target.h"
+
 struct perf_record_opts {
-        const char   *target_pid;
-        const char   *target_tid;
-        uid_t        uid;
+        struct perf_target target;
         bool         call_graph;
         bool         group;
         bool         inherit_stat;
@@ -223,15 +223,13 @@ struct perf_record_opts {
         bool         sample_time;
         bool         sample_id_all_missing;
         bool         exclude_guest_missing;
-        bool         system_wide;
         bool         period;
         unsigned int freq;
         unsigned int mmap_pages;
         unsigned int user_freq;
-        int          branch_stack;
+        u64          branch_stack;
         u64          default_interval;
         u64          user_interval;
-        const char   *cpu_list;
 };
 
 #endif
diff --git a/tools/perf/util/ui/browser.c b/tools/perf/ui/browser.c
index 556829124b02..1818a531f1d3 100644
--- a/tools/perf/util/ui/browser.c
+++ b/tools/perf/ui/browser.c
@@ -27,21 +27,24 @@ static int ui_browser__percent_color(struct ui_browser *browser,
         return HE_COLORSET_NORMAL;
 }
 
-void ui_browser__set_color(struct ui_browser *self __used, int color)
+int ui_browser__set_color(struct ui_browser *browser, int color)
 {
+        int ret = browser->current_color;
+        browser->current_color = color;
         SLsmg_set_color(color);
+        return ret;
 }
 
-void ui_browser__set_percent_color(struct ui_browser *self,
+void ui_browser__set_percent_color(struct ui_browser *browser,
                                    double percent, bool current)
 {
-         int color = ui_browser__percent_color(self, percent, current);
-         ui_browser__set_color(self, color);
+         int color = ui_browser__percent_color(browser, percent, current);
+         ui_browser__set_color(browser, color);
 }
 
-void ui_browser__gotorc(struct ui_browser *self, int y, int x)
+void ui_browser__gotorc(struct ui_browser *browser, int y, int x)
 {
-        SLsmg_gotorc(self->y + y, self->x + x);
+        SLsmg_gotorc(browser->y + y, browser->x + x);
 }
 
 static struct list_head *
@@ -70,23 +73,23 @@ ui_browser__list_head_filter_prev_entries(struct ui_browser *browser,
         return NULL;
 }
 
-void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
+void ui_browser__list_head_seek(struct ui_browser *browser, off_t offset, int whence)
 {
-        struct list_head *head = self->entries;
+        struct list_head *head = browser->entries;
         struct list_head *pos;
 
-        if (self->nr_entries == 0)
+        if (browser->nr_entries == 0)
                 return;
 
         switch (whence) {
         case SEEK_SET:
-                pos = ui_browser__list_head_filter_entries(self, head->next);
+                pos = ui_browser__list_head_filter_entries(browser, head->next);
                 break;
         case SEEK_CUR:
-                pos = self->top;
+                pos = browser->top;
                 break;
         case SEEK_END:
-                pos = ui_browser__list_head_filter_prev_entries(self, head->prev);
+                pos = ui_browser__list_head_filter_prev_entries(browser, head->prev);
                 break;
         default:
                 return;
@@ -96,18 +99,18 @@ void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whenc
 
         if (offset > 0) {
                 while (offset-- != 0)
-                        pos = ui_browser__list_head_filter_entries(self, pos->next);
+                        pos = ui_browser__list_head_filter_entries(browser, pos->next);
         } else {
                 while (offset++ != 0)
-                        pos = ui_browser__list_head_filter_prev_entries(self, pos->prev);
+                        pos = ui_browser__list_head_filter_prev_entries(browser, pos->prev);
         }
 
-        self->top = pos;
+        browser->top = pos;
 }
 
-void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
+void ui_browser__rb_tree_seek(struct ui_browser *browser, off_t offset, int whence)
 {
-        struct rb_root *root = self->entries;
+        struct rb_root *root = browser->entries;
         struct rb_node *nd;
 
         switch (whence) {
@@ -115,7 +118,7 @@ void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
                 nd = rb_first(root);
                 break;
         case SEEK_CUR:
-                nd = self->top;
+                nd = browser->top;
                 break;
         case SEEK_END:
                 nd = rb_last(root);
@@ -132,23 +135,23 @@ void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
                         nd = rb_prev(nd);
         }
 
-        self->top = nd;
+        browser->top = nd;
 }
 
-unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
+unsigned int ui_browser__rb_tree_refresh(struct ui_browser *browser)
 {
         struct rb_node *nd;
         int row = 0;
 
-        if (self->top == NULL)
-                self->top = rb_first(self->entries);
+        if (browser->top == NULL)
+                browser->top = rb_first(browser->entries);
 
-        nd = self->top;
+        nd = browser->top;
 
         while (nd != NULL) {
-                ui_browser__gotorc(self, row, 0);
-                self->write(self, nd, row);
-                if (++row == self->height)
+                ui_browser__gotorc(browser, row, 0);
+                browser->write(browser, nd, row);
+                if (++row == browser->height)
                         break;
                 nd = rb_next(nd);
         }
@@ -156,17 +159,17 @@ unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
         return row;
 }
 
-bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
+bool ui_browser__is_current_entry(struct ui_browser *browser, unsigned row)
 {
-        return self->top_idx + row == self->index;
+        return browser->top_idx + row == browser->index;
 }
 
-void ui_browser__refresh_dimensions(struct ui_browser *self)
+void ui_browser__refresh_dimensions(struct ui_browser *browser)
 {
-        self->width = SLtt_Screen_Cols - 1;
-        self->height = SLtt_Screen_Rows - 2;
-        self->y = 1;
-        self->x = 0;
+        browser->width = SLtt_Screen_Cols - 1;
+        browser->height = SLtt_Screen_Rows - 2;
+        browser->y = 1;
+        browser->x = 0;
 }
 
 void ui_browser__handle_resize(struct ui_browser *browser)
@@ -222,10 +225,10 @@ bool ui_browser__dialog_yesno(struct ui_browser *browser, const char *text)
         return key == K_ENTER || toupper(key) == 'Y';
 }
 
-void ui_browser__reset_index(struct ui_browser *self)
+void ui_browser__reset_index(struct ui_browser *browser)
 {
-        self->index = self->top_idx = 0;
-        self->seek(self, 0, SEEK_SET);
+        browser->index = browser->top_idx = 0;
+        browser->seek(browser, 0, SEEK_SET);
 }
 
 void __ui_browser__show_title(struct ui_browser *browser, const char *title)
@@ -242,26 +245,26 @@ void ui_browser__show_title(struct ui_browser *browser, const char *title)
         pthread_mutex_unlock(&ui__lock);
 }
 
-int ui_browser__show(struct ui_browser *self, const char *title,
+int ui_browser__show(struct ui_browser *browser, const char *title,
                      const char *helpline, ...)
 {
         int err;
         va_list ap;
 
-        ui_browser__refresh_dimensions(self);
+        ui_browser__refresh_dimensions(browser);
 
         pthread_mutex_lock(&ui__lock);
-        __ui_browser__show_title(self, title);
+        __ui_browser__show_title(browser, title);
 
-        self->title = title;
-        free(self->helpline);
-        self->helpline = NULL;
+        browser->title = title;
+        free(browser->helpline);
+        browser->helpline = NULL;
 
         va_start(ap, helpline);
-        err = vasprintf(&self->helpline, helpline, ap);
+        err = vasprintf(&browser->helpline, helpline, ap);
         va_end(ap);
         if (err > 0)
-                ui_helpline__push(self->helpline);
+                ui_helpline__push(browser->helpline);
         pthread_mutex_unlock(&ui__lock);
         return err ? 0 : -1;
 }
@@ -347,7 +350,7 @@ void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries)
         browser->seek(browser, browser->top_idx, SEEK_SET);
 }
 
-int ui_browser__run(struct ui_browser *self, int delay_secs)
+int ui_browser__run(struct ui_browser *browser, int delay_secs)
 {
         int err, key;
 
@@ -355,7 +358,7 @@ int ui_browser__run(struct ui_browser *self, int delay_secs)
                 off_t offset;
 
                 pthread_mutex_lock(&ui__lock);
-                err = __ui_browser__refresh(self);
+                err = __ui_browser__refresh(browser);
                 SLsmg_refresh();
                 pthread_mutex_unlock(&ui__lock);
                 if (err < 0)
@@ -365,18 +368,18 @@ int ui_browser__run(struct ui_browser *self, int delay_secs)
 
                 if (key == K_RESIZE) {
                         ui__refresh_dimensions(false);
-                        ui_browser__refresh_dimensions(self);
-                        __ui_browser__show_title(self, self->title);
-                        ui_helpline__puts(self->helpline);
+                        ui_browser__refresh_dimensions(browser);
+                        __ui_browser__show_title(browser, browser->title);
+                        ui_helpline__puts(browser->helpline);
                         continue;
                 }
 
-                if (self->use_navkeypressed && !self->navkeypressed) {
+                if (browser->use_navkeypressed && !browser->navkeypressed) {
                         if (key == K_DOWN || key == K_UP ||
                             key == K_PGDN || key == K_PGUP ||
                             key == K_HOME || key == K_END ||
                             key == ' ') {
-                                self->navkeypressed = true;
+                                browser->navkeypressed = true;
                                 continue;
                         } else
                                 return key;
@@ -384,59 +387,59 @@ int ui_browser__run(struct ui_browser *self, int delay_secs)
 
                 switch (key) {
                 case K_DOWN:
-                        if (self->index == self->nr_entries - 1)
+                        if (browser->index == browser->nr_entries - 1)
                                 break;
-                        ++self->index;
-                        if (self->index == self->top_idx + self->height) {
-                                ++self->top_idx;
-                                self->seek(self, +1, SEEK_CUR);
+                        ++browser->index;
+                        if (browser->index == browser->top_idx + browser->height) {
+                                ++browser->top_idx;
+                                browser->seek(browser, +1, SEEK_CUR);
                         }
                         break;
                 case K_UP:
-                        if (self->index == 0)
+                        if (browser->index == 0)
                                 break;
-                        --self->index;
-                        if (self->index < self->top_idx) {
-                                --self->top_idx;
-                                self->seek(self, -1, SEEK_CUR);
+                        --browser->index;
+                        if (browser->index < browser->top_idx) {
+                                --browser->top_idx;
+                                browser->seek(browser, -1, SEEK_CUR);
                         }
                         break;
                 case K_PGDN:
                 case ' ':
-                        if (self->top_idx + self->height > self->nr_entries - 1)
+                        if (browser->top_idx + browser->height > browser->nr_entries - 1)
                                 break;
 
-                        offset = self->height;
-                        if (self->index + offset > self->nr_entries - 1)
-                                offset = self->nr_entries - 1 - self->index;
-                        self->index += offset;
-                        self->top_idx += offset;
-                        self->seek(self, +offset, SEEK_CUR);
+                        offset = browser->height;
+                        if (browser->index + offset > browser->nr_entries - 1)
+                                offset = browser->nr_entries - 1 - browser->index;
+                        browser->index += offset;
+                        browser->top_idx += offset;
+                        browser->seek(browser, +offset, SEEK_CUR);
                         break;
                 case K_PGUP:
-                        if (self->top_idx == 0)
+                        if (browser->top_idx == 0)
                                 break;
 
-                        if (self->top_idx < self->height)
-                                offset = self->top_idx;
+                        if (browser->top_idx < browser->height)
+                                offset = browser->top_idx;
                         else
-                                offset = self->height;
+                                offset = browser->height;
 
-                        self->index -= offset;
-                        self->top_idx -= offset;
-                        self->seek(self, -offset, SEEK_CUR);
+                        browser->index -= offset;
+                        browser->top_idx -= offset;
+                        browser->seek(browser, -offset, SEEK_CUR);
                         break;
                 case K_HOME:
-                        ui_browser__reset_index(self);
+                        ui_browser__reset_index(browser);
                         break;
                 case K_END:
-                        offset = self->height - 1;
-                        if (offset >= self->nr_entries)
-                                offset = self->nr_entries - 1;
+                        offset = browser->height - 1;
+                        if (offset >= browser->nr_entries)
+                                offset = browser->nr_entries - 1;
 
-                        self->index = self->nr_entries - 1;
-                        self->top_idx = self->index - offset;
-                        self->seek(self, -offset, SEEK_END);
+                        browser->index = browser->nr_entries - 1;
+                        browser->top_idx = browser->index - offset;
+                        browser->seek(browser, -offset, SEEK_END);
                         break;
                 default:
                         return key;
@@ -445,22 +448,22 @@ int ui_browser__run(struct ui_browser *self, int delay_secs)
         return -1;
 }
 
-unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
+unsigned int ui_browser__list_head_refresh(struct ui_browser *browser)
 {
         struct list_head *pos;
-        struct list_head *head = self->entries;
+        struct list_head *head = browser->entries;
         int row = 0;
 
-        if (self->top == NULL || self->top == self->entries)
-                self->top = ui_browser__list_head_filter_entries(self, head->next);
+        if (browser->top == NULL || browser->top == browser->entries)
+                browser->top = ui_browser__list_head_filter_entries(browser, head->next);
 
-        pos = self->top;
+        pos = browser->top;
 
         list_for_each_from(pos, head) {
-                if (!self->filter || !self->filter(self, pos)) {
-                        ui_browser__gotorc(self, row, 0);
-                        self->write(self, pos, row);
-                        if (++row == self->height)
+                if (!browser->filter || !browser->filter(browser, pos)) {
+                        ui_browser__gotorc(browser, row, 0);
+                        browser->write(browser, pos, row);
+                        if (++row == browser->height)
                                 break;
                 }
         }
@@ -503,6 +506,12 @@ static struct ui_browser__colorset {
                 .bg       = "default",
         },
         {
+                .colorset = HE_COLORSET_ADDR,
+                .name     = "addr",
+                .fg       = "magenta",
+                .bg       = "default",
+        },
+        {
                 .name = NULL,
         }
 };
@@ -584,6 +593,111 @@ unsigned int ui_browser__argv_refresh(struct ui_browser *browser)
         return row;
 }
 
+void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
+                         u16 start, u16 end)
+{
+        SLsmg_set_char_set(1);
+        ui_browser__gotorc(browser, start, column);
+        SLsmg_draw_vline(end - start + 1);
+        SLsmg_set_char_set(0);
+}
+
+void ui_browser__write_graph(struct ui_browser *browser __used, int graph)
+{
+        SLsmg_set_char_set(1);
+        SLsmg_write_char(graph);
+        SLsmg_set_char_set(0);
+}
+
+static void __ui_browser__line_arrow_up(struct ui_browser *browser,
+                                        unsigned int column,
+                                        u64 start, u64 end)
+{
+        unsigned int row, end_row;
+
+        SLsmg_set_char_set(1);
+
+        if (start < browser->top_idx + browser->height) {
+                row = start - browser->top_idx;
+                ui_browser__gotorc(browser, row, column);
+                SLsmg_write_char(SLSMG_LLCORN_CHAR);
+                ui_browser__gotorc(browser, row, column + 1);
+                SLsmg_draw_hline(2);
+
+                if (row-- == 0)
+                        goto out;
+        } else
+                row = browser->height - 1;
+
+        if (end > browser->top_idx)
+                end_row = end - browser->top_idx;
+        else
+                end_row = 0;
+
+        ui_browser__gotorc(browser, end_row, column);
+        SLsmg_draw_vline(row - end_row + 1);
+
+        ui_browser__gotorc(browser, end_row, column);
+        if (end >= browser->top_idx) {
+                SLsmg_write_char(SLSMG_ULCORN_CHAR);
+                ui_browser__gotorc(browser, end_row, column + 1);
+                SLsmg_write_char(SLSMG_HLINE_CHAR);
+                ui_browser__gotorc(browser, end_row, column + 2);
+                SLsmg_write_char(SLSMG_RARROW_CHAR);
+        }
+out:
+        SLsmg_set_char_set(0);
+}
+
+static void __ui_browser__line_arrow_down(struct ui_browser *browser,
+                                          unsigned int column,
+                                          u64 start, u64 end)
+{
+        unsigned int row, end_row;
+
+        SLsmg_set_char_set(1);
+
+        if (start >= browser->top_idx) {
+                row = start - browser->top_idx;
+                ui_browser__gotorc(browser, row, column);
+                SLsmg_write_char(SLSMG_ULCORN_CHAR);
+                ui_browser__gotorc(browser, row, column + 1);
+                SLsmg_draw_hline(2);
+
+                if (row++ == 0)
+                        goto out;
+        } else
+                row = 0;
+
+        if (end >= browser->top_idx + browser->height)
+                end_row = browser->height - 1;
+        else
+                end_row = end - browser->top_idx;;
+
+        ui_browser__gotorc(browser, row, column);
+        SLsmg_draw_vline(end_row - row + 1);
+
+        ui_browser__gotorc(browser, end_row, column);
+        if (end < browser->top_idx + browser->height) {
+                SLsmg_write_char(SLSMG_LLCORN_CHAR);
+                ui_browser__gotorc(browser, end_row, column + 1);
+                SLsmg_write_char(SLSMG_HLINE_CHAR);
+                ui_browser__gotorc(browser, end_row, column + 2);
+                SLsmg_write_char(SLSMG_RARROW_CHAR);
+        }
+out:
+        SLsmg_set_char_set(0);
+}
+
+void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
+                              u64 start, u64 end)
+{
+        if (start > end)
+                __ui_browser__line_arrow_up(browser, column, start, end);
+        else
+                __ui_browser__line_arrow_down(browser, column, start, end);
+}
+
 void ui_browser__init(void)
 {
         int i = 0;
@@ -594,4 +708,6 @@ void ui_browser__init(void)
                 struct ui_browser__colorset *c = &ui_browser__colorsets[i++];
                 sltt_set_color(c->colorset, c->name, c->fg, c->bg);
         }
+
+        annotate_browser__init();
 }
diff --git a/tools/perf/util/ui/browser.h b/tools/perf/ui/browser.h
index 6ee82f60feaf..af70314605e5 100644
--- a/tools/perf/util/ui/browser.h
+++ b/tools/perf/ui/browser.h
@@ -10,11 +10,13 @@
 #define HE_COLORSET_NORMAL      52
 #define HE_COLORSET_SELECTED    53
 #define HE_COLORSET_CODE        54
+#define HE_COLORSET_ADDR        55
 
 struct ui_browser {
         u64           index, top_idx;
         void          *top, *entries;
         u16           y, x, width, height;
+        int           current_color;
         void          *priv;
         const char    *title;
         char          *helpline;
@@ -27,7 +29,7 @@ struct ui_browser {
         bool          use_navkeypressed;
 };
 
-void ui_browser__set_color(struct ui_browser *self, int color);
+int  ui_browser__set_color(struct ui_browser *browser, int color);
 void ui_browser__set_percent_color(struct ui_browser *self,
                                    double percent, bool current);
 bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row);
@@ -35,6 +37,9 @@ void ui_browser__refresh_dimensions(struct ui_browser *self);
 void ui_browser__reset_index(struct ui_browser *self);
 
 void ui_browser__gotorc(struct ui_browser *self, int y, int x);
+void ui_browser__write_graph(struct ui_browser *browser, int graph);
+void __ui_browser__line_arrow(struct ui_browser *browser, unsigned int column,
+                              u64 start, u64 end);
 void __ui_browser__show_title(struct ui_browser *browser, const char *title);
 void ui_browser__show_title(struct ui_browser *browser, const char *title);
 int ui_browser__show(struct ui_browser *self, const char *title,
@@ -44,6 +49,8 @@ int ui_browser__refresh(struct ui_browser *self);
 int ui_browser__run(struct ui_browser *browser, int delay_secs);
 void ui_browser__update_nr_entries(struct ui_browser *browser, u32 nr_entries);
 void ui_browser__handle_resize(struct ui_browser *browser);
+void __ui_browser__vline(struct ui_browser *browser, unsigned int column,
+                         u16 start, u16 end);
 
 int ui_browser__warning(struct ui_browser *browser, int timeout,
                         const char *format, ...);
@@ -62,4 +69,5 @@ void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whenc
 unsigned int ui_browser__list_head_refresh(struct ui_browser *self);
 
 void ui_browser__init(void);
+void annotate_browser__init(void);
 #endif /* _PERF_UI_BROWSER_H_ */
diff --git a/tools/perf/ui/browsers/annotate.c b/tools/perf/ui/browsers/annotate.c
new file mode 100644
index 000000000000..4deea6aaf927
--- /dev/null
+++ b/tools/perf/ui/browsers/annotate.c
@@ -0,0 +1,951 @@
+#include "../../util/util.h"
+#include "../browser.h"
+#include "../helpline.h"
+#include "../libslang.h"
+#include "../ui.h"
+#include "../util.h"
+#include "../../util/annotate.h"
+#include "../../util/hist.h"
+#include "../../util/sort.h"
+#include "../../util/symbol.h"
+#include <pthread.h>
+#include <newt.h>
+
+struct browser_disasm_line {
+        struct rb_node  rb_node;
+        double          percent;
+        u32             idx;
+        int             idx_asm;
+        int             jump_sources;
+};
+
+static struct annotate_browser_opt {
+        bool hide_src_code,
+             use_offset,
+             jump_arrows,
+             show_nr_jumps;
+} annotate_browser__opts = {
+        .use_offset     = true,
+        .jump_arrows    = true,
+};
+
+struct annotate_browser {
+        struct ui_browser b;
+        struct rb_root    entries;
+        struct rb_node    *curr_hot;
+        struct disasm_line        *selection;
+        struct disasm_line  **offsets;
+        u64                 start;
+        int                 nr_asm_entries;
+        int                 nr_entries;
+        int                 max_jump_sources;
+        int                 nr_jumps;
+        bool                searching_backwards;
+        u8                  addr_width;
+        u8                  jumps_width;
+        u8                  target_width;
+        u8                  min_addr_width;
+        u8                  max_addr_width;
+        char                search_bf[128];
+};
+
+static inline struct browser_disasm_line *disasm_line__browser(struct disasm_line *dl)
+{
+        return (struct browser_disasm_line *)(dl + 1);
+}
+
+static bool disasm_line__filter(struct ui_browser *browser __used, void *entry)
+{
+        if (annotate_browser__opts.hide_src_code) {
+                struct disasm_line *dl = list_entry(entry, struct disasm_line, node);
+                return dl->offset == -1;
+        }
+
+        return false;
+}
+
+static int annotate_browser__jumps_percent_color(struct annotate_browser *browser,
+                                                 int nr, bool current)
+{
+        if (current && (!browser->b.use_navkeypressed || browser->b.navkeypressed))
+                return HE_COLORSET_SELECTED;
+        if (nr == browser->max_jump_sources)
+                return HE_COLORSET_TOP;
+        if (nr > 1)
+                return HE_COLORSET_MEDIUM;
+        return HE_COLORSET_NORMAL;
+}
+
+static int annotate_browser__set_jumps_percent_color(struct annotate_browser *browser,
+                                                     int nr, bool current)
+{
+         int color = annotate_browser__jumps_percent_color(browser, nr, current);
+         return ui_browser__set_color(&browser->b, color);
+}
+
+static void annotate_browser__write(struct ui_browser *browser, void *entry, int row)
+{
+        struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
+        struct disasm_line *dl = list_entry(entry, struct disasm_line, node);
+        struct browser_disasm_line *bdl = disasm_line__browser(dl);
+        bool current_entry = ui_browser__is_current_entry(browser, row);
+        bool change_color = (!annotate_browser__opts.hide_src_code &&
+                             (!current_entry || (browser->use_navkeypressed &&
+                                                 !browser->navkeypressed)));
+        int width = browser->width, printed;
+        char bf[256];
+
+        if (dl->offset != -1 && bdl->percent != 0.0) {
+                ui_browser__set_percent_color(browser, bdl->percent, current_entry);
+                slsmg_printf("%6.2f ", bdl->percent);
+        } else {
+                ui_browser__set_percent_color(browser, 0, current_entry);
+                slsmg_write_nstring(" ", 7);
+        }
+
+        SLsmg_write_char(' ');
+
+        /* The scroll bar isn't being used */
+        if (!browser->navkeypressed)
+                width += 1;
+
+        if (!*dl->line)
+                slsmg_write_nstring(" ", width - 7);
+        else if (dl->offset == -1) {
+                printed = scnprintf(bf, sizeof(bf), "%*s  ",
+                                    ab->addr_width, " ");
+                slsmg_write_nstring(bf, printed);
+                slsmg_write_nstring(dl->line, width - printed - 6);
+        } else {
+                u64 addr = dl->offset;
+                int color = -1;
+
+                if (!annotate_browser__opts.use_offset)
+                        addr += ab->start;
+
+                if (!annotate_browser__opts.use_offset) {
+                        printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);
+                } else {
+                        if (bdl->jump_sources) {
+                                if (annotate_browser__opts.show_nr_jumps) {
+                                        int prev;
+                                        printed = scnprintf(bf, sizeof(bf), "%*d ",
+                                                            ab->jumps_width,
+                                                            bdl->jump_sources);
+                                        prev = annotate_browser__set_jumps_percent_color(ab, bdl->jump_sources,
+                                                                                         current_entry);
+                                        slsmg_write_nstring(bf, printed);
+                                        ui_browser__set_color(browser, prev);
+                                }
+
+                                printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
+                                                    ab->target_width, addr);
+                        } else {
+                                printed = scnprintf(bf, sizeof(bf), "%*s  ",
+                                                    ab->addr_width, " ");
+                        }
+                }
+
+                if (change_color)
+                        color = ui_browser__set_color(browser, HE_COLORSET_ADDR);
+                slsmg_write_nstring(bf, printed);
+                if (change_color)
+                        ui_browser__set_color(browser, color);
+                if (dl->ins && dl->ins->ops->scnprintf) {
+                        if (ins__is_jump(dl->ins)) {
+                                bool fwd = dl->ops.target.offset > (u64)dl->offset;
+
+                                ui_browser__write_graph(browser, fwd ? SLSMG_DARROW_CHAR :
+                                                                    SLSMG_UARROW_CHAR);
+                                SLsmg_write_char(' ');
+                        } else if (ins__is_call(dl->ins)) {
+                                ui_browser__write_graph(browser, SLSMG_RARROW_CHAR);
+                                SLsmg_write_char(' ');
+                        } else {
+                                slsmg_write_nstring(" ", 2);
+                        }
+                } else {
+                        if (strcmp(dl->name, "retq")) {
+                                slsmg_write_nstring(" ", 2);
+                        } else {
+                                ui_browser__write_graph(browser, SLSMG_LARROW_CHAR);
+                                SLsmg_write_char(' ');
+                        }
+                }
+
+                disasm_line__scnprintf(dl, bf, sizeof(bf), !annotate_browser__opts.use_offset);
+                slsmg_write_nstring(bf, width - 10 - printed);
+        }
+
+        if (current_entry)
+                ab->selection = dl;
+}
+
+static void annotate_browser__draw_current_jump(struct ui_browser *browser)
+{
+        struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
+        struct disasm_line *cursor = ab->selection, *target;
+        struct browser_disasm_line *btarget, *bcursor;
+        unsigned int from, to;
+
+        if (!cursor || !cursor->ins || !ins__is_jump(cursor->ins) ||
+            !disasm_line__has_offset(cursor))
+                return;
+
+        target = ab->offsets[cursor->ops.target.offset];
+        if (!target)
+                return;
+
+        bcursor = disasm_line__browser(cursor);
+        btarget = disasm_line__browser(target);
+
+        if (annotate_browser__opts.hide_src_code) {
+                from = bcursor->idx_asm;
+                to = btarget->idx_asm;
+        } else {
+                from = (u64)bcursor->idx;
+                to = (u64)btarget->idx;
+        }
+
+        ui_browser__set_color(browser, HE_COLORSET_CODE);
+        __ui_browser__line_arrow(browser, 9 + ab->addr_width, from, to);
+}
+
+static unsigned int annotate_browser__refresh(struct ui_browser *browser)
+{
+        int ret = ui_browser__list_head_refresh(browser);
+
+        if (annotate_browser__opts.jump_arrows)
+                annotate_browser__draw_current_jump(browser);
+
+        ui_browser__set_color(browser, HE_COLORSET_NORMAL);
+        __ui_browser__vline(browser, 7, 0, browser->height - 1);
+        return ret;
+}
+
+static double disasm_line__calc_percent(struct disasm_line *dl, struct symbol *sym, int evidx)
+{
+        double percent = 0.0;
+
+        if (dl->offset != -1) {
+                int len = sym->end - sym->start;
+                unsigned int hits = 0;
+                struct annotation *notes = symbol__annotation(sym);
+                struct source_line *src_line = notes->src->lines;
+                struct sym_hist *h = annotation__histogram(notes, evidx);
+                s64 offset = dl->offset;
+                struct disasm_line *next;
+
+                next = disasm__get_next_ip_line(&notes->src->source, dl);
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (src_line) {
+                                percent += src_line[offset].percent;
+                        } else
+                                hits += h->addr[offset];
+
+                        ++offset;
+                }
+                /*
+                 * If the percentage wasn't already calculated in
+                 * symbol__get_source_line, do it now:
+                 */
+                if (src_line == NULL && h->sum)
+                        percent = 100.0 * hits / h->sum;
+        }
+
+        return percent;
+}
+
+static void disasm_rb_tree__insert(struct rb_root *root, struct browser_disasm_line *bdl)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct browser_disasm_line *l;
+
+        while (*p != NULL) {
+                parent = *p;
+                l = rb_entry(parent, struct browser_disasm_line, rb_node);
+                if (bdl->percent < l->percent)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&bdl->rb_node, parent, p);
+        rb_insert_color(&bdl->rb_node, root);
+}
+
+static void annotate_browser__set_top(struct annotate_browser *browser,
+                                      struct disasm_line *pos, u32 idx)
+{
+        unsigned back;
+
+        ui_browser__refresh_dimensions(&browser->b);
+        back = browser->b.height / 2;
+        browser->b.top_idx = browser->b.index = idx;
+
+        while (browser->b.top_idx != 0 && back != 0) {
+                pos = list_entry(pos->node.prev, struct disasm_line, node);
+
+                if (disasm_line__filter(&browser->b, &pos->node))
+                        continue;
+
+                --browser->b.top_idx;
+                --back;
+        }
+
+        browser->b.top = pos;
+        browser->b.navkeypressed = true;
+}
+
+static void annotate_browser__set_rb_top(struct annotate_browser *browser,
+                                         struct rb_node *nd)
+{
+        struct browser_disasm_line *bpos;
+        struct disasm_line *pos;
+        u32 idx;
+
+        bpos = rb_entry(nd, struct browser_disasm_line, rb_node);
+        pos = ((struct disasm_line *)bpos) - 1;
+        idx = bpos->idx;
+        if (annotate_browser__opts.hide_src_code)
+                idx = bpos->idx_asm;
+        annotate_browser__set_top(browser, pos, idx);
+        browser->curr_hot = nd;
+}
+
+static void annotate_browser__calc_percent(struct annotate_browser *browser,
+                                           int evidx)
+{
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
+        struct annotation *notes = symbol__annotation(sym);
+        struct disasm_line *pos;
+
+        browser->entries = RB_ROOT;
+
+        pthread_mutex_lock(&notes->lock);
+
+        list_for_each_entry(pos, &notes->src->source, node) {
+                struct browser_disasm_line *bpos = disasm_line__browser(pos);
+                bpos->percent = disasm_line__calc_percent(pos, sym, evidx);
+                if (bpos->percent < 0.01) {
+                        RB_CLEAR_NODE(&bpos->rb_node);
+                        continue;
+                }
+                disasm_rb_tree__insert(&browser->entries, bpos);
+        }
+        pthread_mutex_unlock(&notes->lock);
+
+        browser->curr_hot = rb_last(&browser->entries);
+}
+
+static bool annotate_browser__toggle_source(struct annotate_browser *browser)
+{
+        struct disasm_line *dl;
+        struct browser_disasm_line *bdl;
+        off_t offset = browser->b.index - browser->b.top_idx;
+
+        browser->b.seek(&browser->b, offset, SEEK_CUR);
+        dl = list_entry(browser->b.top, struct disasm_line, node);
+        bdl = disasm_line__browser(dl);
+
+        if (annotate_browser__opts.hide_src_code) {
+                if (bdl->idx_asm < offset)
+                        offset = bdl->idx;
+
+                browser->b.nr_entries = browser->nr_entries;
+                annotate_browser__opts.hide_src_code = false;
+                browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                browser->b.top_idx = bdl->idx - offset;
+                browser->b.index = bdl->idx;
+        } else {
+                if (bdl->idx_asm < 0) {
+                        ui_helpline__puts("Only available for assembly lines.");
+                        browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                        return false;
+                }
+
+                if (bdl->idx_asm < offset)
+                        offset = bdl->idx_asm;
+
+                browser->b.nr_entries = browser->nr_asm_entries;
+                annotate_browser__opts.hide_src_code = true;
+                browser->b.seek(&browser->b, -offset, SEEK_CUR);
+                browser->b.top_idx = bdl->idx_asm - offset;
+                browser->b.index = bdl->idx_asm;
+        }
+
+        return true;
+}
+
+static void annotate_browser__init_asm_mode(struct annotate_browser *browser)
+{
+        ui_browser__reset_index(&browser->b);
+        browser->b.nr_entries = browser->nr_asm_entries;
+}
+
+static bool annotate_browser__callq(struct annotate_browser *browser,
+                                    int evidx, void (*timer)(void *arg),
+                                    void *arg, int delay_secs)
+{
+        struct map_symbol *ms = browser->b.priv;
+        struct disasm_line *dl = browser->selection;
+        struct symbol *sym = ms->sym;
+        struct annotation *notes;
+        struct symbol *target;
+        u64 ip;
+
+        if (!ins__is_call(dl->ins))
+                return false;
+
+        ip = ms->map->map_ip(ms->map, dl->ops.target.addr);
+        target = map__find_symbol(ms->map, ip, NULL);
+        if (target == NULL) {
+                ui_helpline__puts("The called function was not found.");
+                return true;
+        }
+
+        notes = symbol__annotation(target);
+        pthread_mutex_lock(&notes->lock);
+
+        if (notes->src == NULL && symbol__alloc_hist(target) < 0) {
+                pthread_mutex_unlock(&notes->lock);
+                ui__warning("Not enough memory for annotating '%s' symbol!\n",
+                            target->name);
+                return true;
+        }
+
+        pthread_mutex_unlock(&notes->lock);
+        symbol__tui_annotate(target, ms->map, evidx, timer, arg, delay_secs);
+        ui_browser__show_title(&browser->b, sym->name);
+        return true;
+}
+
+static
+struct disasm_line *annotate_browser__find_offset(struct annotate_browser *browser,
+                                          s64 offset, s64 *idx)
+{
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
+        struct annotation *notes = symbol__annotation(sym);
+        struct disasm_line *pos;
+
+        *idx = 0;
+        list_for_each_entry(pos, &notes->src->source, node) {
+                if (pos->offset == offset)
+                        return pos;
+                if (!disasm_line__filter(&browser->b, &pos->node))
+                        ++*idx;
+        }
+
+        return NULL;
+}
+
+static bool annotate_browser__jump(struct annotate_browser *browser)
+{
+        struct disasm_line *dl = browser->selection;
+        s64 idx;
+
+        if (!ins__is_jump(dl->ins))
+                return false;
+
+        dl = annotate_browser__find_offset(browser, dl->ops.target.offset, &idx);
+        if (dl == NULL) {
+                ui_helpline__puts("Invallid jump offset");
+                return true;
+        }
+
+        annotate_browser__set_top(browser, dl, idx);
+        
+        return true;
+}
+
+static
+struct disasm_line *annotate_browser__find_string(struct annotate_browser *browser,
+                                          char *s, s64 *idx)
+{
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
+        struct annotation *notes = symbol__annotation(sym);
+        struct disasm_line *pos = browser->selection;
+
+        *idx = browser->b.index;
+        list_for_each_entry_continue(pos, &notes->src->source, node) {
+                if (disasm_line__filter(&browser->b, &pos->node))
+                        continue;
+
+                ++*idx;
+
+                if (pos->line && strstr(pos->line, s) != NULL)
+                        return pos;
+        }
+
+        return NULL;
+}
+
+static bool __annotate_browser__search(struct annotate_browser *browser)
+{
+        struct disasm_line *dl;
+        s64 idx;
+
+        dl = annotate_browser__find_string(browser, browser->search_bf, &idx);
+        if (dl == NULL) {
+                ui_helpline__puts("String not found!");
+                return false;
+        }
+
+        annotate_browser__set_top(browser, dl, idx);
+        browser->searching_backwards = false;
+        return true;
+}
+
+static
+struct disasm_line *annotate_browser__find_string_reverse(struct annotate_browser *browser,
+                                                  char *s, s64 *idx)
+{
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
+        struct annotation *notes = symbol__annotation(sym);
+        struct disasm_line *pos = browser->selection;
+
+        *idx = browser->b.index;
+        list_for_each_entry_continue_reverse(pos, &notes->src->source, node) {
+                if (disasm_line__filter(&browser->b, &pos->node))
+                        continue;
+
+                --*idx;
+
+                if (pos->line && strstr(pos->line, s) != NULL)
+                        return pos;
+        }
+
+        return NULL;
+}
+
+static bool __annotate_browser__search_reverse(struct annotate_browser *browser)
+{
+        struct disasm_line *dl;
+        s64 idx;
+
+        dl = annotate_browser__find_string_reverse(browser, browser->search_bf, &idx);
+        if (dl == NULL) {
+                ui_helpline__puts("String not found!");
+                return false;
+        }
+
+        annotate_browser__set_top(browser, dl, idx);
+        browser->searching_backwards = true;
+        return true;
+}
+
+static bool annotate_browser__search_window(struct annotate_browser *browser,
+                                            int delay_secs)
+{
+        if (ui_browser__input_window("Search", "String: ", browser->search_bf,
+                                     "ENTER: OK, ESC: Cancel",
+                                     delay_secs * 2) != K_ENTER ||
+            !*browser->search_bf)
+                return false;
+
+        return true;
+}
+
+static bool annotate_browser__search(struct annotate_browser *browser, int delay_secs)
+{
+        if (annotate_browser__search_window(browser, delay_secs))
+                return __annotate_browser__search(browser);
+
+        return false;
+}
+
+static bool annotate_browser__continue_search(struct annotate_browser *browser,
+                                              int delay_secs)
+{
+        if (!*browser->search_bf)
+                return annotate_browser__search(browser, delay_secs);
+
+        return __annotate_browser__search(browser);
+}
+
+static bool annotate_browser__search_reverse(struct annotate_browser *browser,
+                                           int delay_secs)
+{
+        if (annotate_browser__search_window(browser, delay_secs))
+                return __annotate_browser__search_reverse(browser);
+
+        return false;
+}
+
+static
+bool annotate_browser__continue_search_reverse(struct annotate_browser *browser,
+                                               int delay_secs)
+{
+        if (!*browser->search_bf)
+                return annotate_browser__search_reverse(browser, delay_secs);
+
+        return __annotate_browser__search_reverse(browser);
+}
+
+static void annotate_browser__update_addr_width(struct annotate_browser *browser)
+{
+        if (annotate_browser__opts.use_offset)
+                browser->target_width = browser->min_addr_width;
+        else
+                browser->target_width = browser->max_addr_width;
+
+        browser->addr_width = browser->target_width;
+
+        if (annotate_browser__opts.show_nr_jumps)
+                browser->addr_width += browser->jumps_width + 1;
+}
+
+static int annotate_browser__run(struct annotate_browser *browser, int evidx,
+                                 void(*timer)(void *arg),
+                                 void *arg, int delay_secs)
+{
+        struct rb_node *nd = NULL;
+        struct map_symbol *ms = browser->b.priv;
+        struct symbol *sym = ms->sym;
+        const char *help = "Press 'h' for help on key bindings";
+        int key;
+
+        if (ui_browser__show(&browser->b, sym->name, help) < 0)
+                return -1;
+
+        annotate_browser__calc_percent(browser, evidx);
+
+        if (browser->curr_hot) {
+                annotate_browser__set_rb_top(browser, browser->curr_hot);
+                browser->b.navkeypressed = false;
+        }
+
+        nd = browser->curr_hot;
+
+        while (1) {
+                key = ui_browser__run(&browser->b, delay_secs);
+
+                if (delay_secs != 0) {
+                        annotate_browser__calc_percent(browser, evidx);
+                        /*
+                         * Current line focus got out of the list of most active
+                         * lines, NULL it so that if TAB|UNTAB is pressed, we
+                         * move to curr_hot (current hottest line).
+                         */
+                        if (nd != NULL && RB_EMPTY_NODE(nd))
+                                nd = NULL;
+                }
+
+                switch (key) {
+                case K_TIMER:
+                        if (timer != NULL)
+                                timer(arg);
+
+                        if (delay_secs != 0)
+                                symbol__annotate_decay_histogram(sym, evidx);
+                        continue;
+                case K_TAB:
+                        if (nd != NULL) {
+                                nd = rb_prev(nd);
+                                if (nd == NULL)
+                                        nd = rb_last(&browser->entries);
+                        } else
+                                nd = browser->curr_hot;
+                        break;
+                case K_UNTAB:
+                        if (nd != NULL)
+                                nd = rb_next(nd);
+                                if (nd == NULL)
+                                        nd = rb_first(&browser->entries);
+                        else
+                                nd = browser->curr_hot;
+                        break;
+                case K_F1:
+                case 'h':
+                        ui_browser__help_window(&browser->b,
+                "UP/DOWN/PGUP\n"
+                "PGDN/SPACE    Navigate\n"
+                "q/ESC/CTRL+C  Exit\n\n"
+                "->            Go to target\n"
+                "<-            Exit\n"
+                "h             Cycle thru hottest instructions\n"
+                "j             Toggle showing jump to target arrows\n"
+                "J             Toggle showing number of jump sources on targets\n"
+                "n             Search next string\n"
+                "o             Toggle disassembler output/simplified view\n"
+                "s             Toggle source code view\n"
+                "/             Search string\n"
+                "?             Search previous string\n");
+                        continue;
+                case 'H':
+                        nd = browser->curr_hot;
+                        break;
+                case 's':
+                        if (annotate_browser__toggle_source(browser))
+                                ui_helpline__puts(help);
+                        continue;
+                case 'o':
+                        annotate_browser__opts.use_offset = !annotate_browser__opts.use_offset;
+                        annotate_browser__update_addr_width(browser);
+                        continue;
+                case 'j':
+                        annotate_browser__opts.jump_arrows = !annotate_browser__opts.jump_arrows;
+                        continue;
+                case 'J':
+                        annotate_browser__opts.show_nr_jumps = !annotate_browser__opts.show_nr_jumps;
+                        annotate_browser__update_addr_width(browser);
+                        continue;
+                case '/':
+                        if (annotate_browser__search(browser, delay_secs)) {
+show_help:
+                                ui_helpline__puts(help);
+                        }
+                        continue;
+                case 'n':
+                        if (browser->searching_backwards ?
+                            annotate_browser__continue_search_reverse(browser, delay_secs) :
+                            annotate_browser__continue_search(browser, delay_secs))
+                                goto show_help;
+                        continue;
+                case '?':
+                        if (annotate_browser__search_reverse(browser, delay_secs))
+                                goto show_help;
+                        continue;
+                case 'D': {
+                        static int seq;
+                        ui_helpline__pop();
+                        ui_helpline__fpush("%d: nr_ent=%d, height=%d, idx=%d, top_idx=%d, nr_asm_entries=%d",
+                                           seq++, browser->b.nr_entries,
+                                           browser->b.height,
+                                           browser->b.index,
+                                           browser->b.top_idx,
+                                           browser->nr_asm_entries);
+                }
+                        continue;
+                case K_ENTER:
+                case K_RIGHT:
+                        if (browser->selection == NULL)
+                                ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
+                        else if (browser->selection->offset == -1)
+                                ui_helpline__puts("Actions are only available for assembly lines.");
+                        else if (!browser->selection->ins) {
+                                if (strcmp(browser->selection->name, "retq"))
+                                        goto show_sup_ins;
+                                goto out;
+                        } else if (!(annotate_browser__jump(browser) ||
+                                     annotate_browser__callq(browser, evidx, timer, arg, delay_secs))) {
+show_sup_ins:
+                                ui_helpline__puts("Actions are only available for 'callq', 'retq' & jump instructions.");
+                        }
+                        continue;
+                case K_LEFT:
+                case K_ESC:
+                case 'q':
+                case CTRL('c'):
+                        goto out;
+                default:
+                        continue;
+                }
+
+                if (nd != NULL)
+                        annotate_browser__set_rb_top(browser, nd);
+        }
+out:
+        ui_browser__hide(&browser->b);
+        return key;
+}
+
+int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
+                             void(*timer)(void *arg), void *arg, int delay_secs)
+{
+        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx,
+                                    timer, arg, delay_secs);
+}
+
+static void annotate_browser__mark_jump_targets(struct annotate_browser *browser,
+                                                size_t size)
+{
+        u64 offset;
+
+        for (offset = 0; offset < size; ++offset) {
+                struct disasm_line *dl = browser->offsets[offset], *dlt;
+                struct browser_disasm_line *bdlt;
+
+                if (!dl || !dl->ins || !ins__is_jump(dl->ins) ||
+                    !disasm_line__has_offset(dl))
+                        continue;
+
+                if (dl->ops.target.offset >= size) {
+                        ui__error("jump to after symbol!\n"
+                                  "size: %zx, jump target: %" PRIx64,
+                                  size, dl->ops.target.offset);
+                        continue;
+                }
+
+                dlt = browser->offsets[dl->ops.target.offset];
+                /*
+                 * FIXME: Oops, no jump target? Buggy disassembler? Or do we
+                 * have to adjust to the previous offset?
+                 */
+                if (dlt == NULL)
+                        continue;
+
+                bdlt = disasm_line__browser(dlt);
+                if (++bdlt->jump_sources > browser->max_jump_sources)
+                        browser->max_jump_sources = bdlt->jump_sources;
+
+                ++browser->nr_jumps;
+        }
+                
+}
+
+static inline int width_jumps(int n)
+{
+        if (n >= 100)
+                return 5;
+        if (n / 10)
+                return 2;
+        return 1;
+}
+
+int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
+                         void(*timer)(void *arg), void *arg,
+                         int delay_secs)
+{
+        struct disasm_line *pos, *n;
+        struct annotation *notes;
+        const size_t size = symbol__size(sym);
+        struct map_symbol ms = {
+                .map = map,
+                .sym = sym,
+        };
+        struct annotate_browser browser = {
+                .b = {
+                        .refresh = annotate_browser__refresh,
+                        .seek    = ui_browser__list_head_seek,
+                        .write   = annotate_browser__write,
+                        .filter  = disasm_line__filter,
+                        .priv    = &ms,
+                        .use_navkeypressed = true,
+                },
+        };
+        int ret = -1;
+
+        if (sym == NULL)
+                return -1;
+
+        if (map->dso->annotate_warned)
+                return -1;
+
+        browser.offsets = zalloc(size * sizeof(struct disasm_line *));
+        if (browser.offsets == NULL) {
+                ui__error("Not enough memory!");
+                return -1;
+        }
+
+        if (symbol__annotate(sym, map, sizeof(struct browser_disasm_line)) < 0) {
+                ui__error("%s", ui_helpline__last_msg);
+                goto out_free_offsets;
+        }
+
+        ui_helpline__push("Press <- or ESC to exit");
+
+        notes = symbol__annotation(sym);
+        browser.start = map__rip_2objdump(map, sym->start);
+
+        list_for_each_entry(pos, &notes->src->source, node) {
+                struct browser_disasm_line *bpos;
+                size_t line_len = strlen(pos->line);
+
+                if (browser.b.width < line_len)
+                        browser.b.width = line_len;
+                bpos = disasm_line__browser(pos);
+                bpos->idx = browser.nr_entries++;
+                if (pos->offset != -1) {
+                        bpos->idx_asm = browser.nr_asm_entries++;
+                        /*
+                         * FIXME: short term bandaid to cope with assembly
+                         * routines that comes with labels in the same column
+                         * as the address in objdump, sigh.
+                         *
+                         * E.g. copy_user_generic_unrolled
+                         */
+                        if (pos->offset < (s64)size)
+                                browser.offsets[pos->offset] = pos;
+                } else
+                        bpos->idx_asm = -1;
+        }
+
+        annotate_browser__mark_jump_targets(&browser, size);
+
+        browser.addr_width = browser.target_width = browser.min_addr_width = hex_width(size);
+        browser.max_addr_width = hex_width(sym->end);
+        browser.jumps_width = width_jumps(browser.max_jump_sources);
+        browser.b.nr_entries = browser.nr_entries;
+        browser.b.entries = &notes->src->source,
+        browser.b.width += 18; /* Percentage */
+
+        if (annotate_browser__opts.hide_src_code)
+                annotate_browser__init_asm_mode(&browser);
+
+        annotate_browser__update_addr_width(&browser);
+
+        ret = annotate_browser__run(&browser, evidx, timer, arg, delay_secs);
+        list_for_each_entry_safe(pos, n, &notes->src->source, node) {
+                list_del(&pos->node);
+                disasm_line__free(pos);
+        }
+
+out_free_offsets:
+        free(browser.offsets);
+        return ret;
+}
+
+#define ANNOTATE_CFG(n) \
+        { .name = #n, .value = &annotate_browser__opts.n, }
+        
+/*
+ * Keep the entries sorted, they are bsearch'ed
+ */
+static struct annotate__config {
+        const char *name;
+        bool *value;
+} annotate__configs[] = {
+        ANNOTATE_CFG(hide_src_code),
+        ANNOTATE_CFG(jump_arrows),
+        ANNOTATE_CFG(show_nr_jumps),
+        ANNOTATE_CFG(use_offset),
+};
+
+#undef ANNOTATE_CFG
+
+static int annotate_config__cmp(const void *name, const void *cfgp)
+{
+        const struct annotate__config *cfg = cfgp;
+
+        return strcmp(name, cfg->name);
+}
+
+static int annotate__config(const char *var, const char *value, void *data __used)
+{
+        struct annotate__config *cfg;
+        const char *name;
+
+        if (prefixcmp(var, "annotate.") != 0)
+                return 0;
+
+        name = var + 9;
+        cfg = bsearch(name, annotate__configs, ARRAY_SIZE(annotate__configs),
+                      sizeof(struct annotate__config), annotate_config__cmp);
+
+        if (cfg == NULL)
+                return -1;
+
+        *cfg->value = perf_config_bool(name, value);
+        return 0;
+}
+
+void annotate_browser__init(void)
+{
+        perf_config(annotate__config, NULL);
+}
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 2f83e5dc9967..53f6697d014e 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -5,12 +5,12 @@
 #include <newt.h>
 #include <linux/rbtree.h>
 
-#include "../../evsel.h"
-#include "../../evlist.h"
-#include "../../hist.h"
-#include "../../pstack.h"
-#include "../../sort.h"
-#include "../../util.h"
+#include "../../util/evsel.h"
+#include "../../util/evlist.h"
+#include "../../util/hist.h"
+#include "../../util/pstack.h"
+#include "../../util/sort.h"
+#include "../../util/util.h"
 
 #include "../browser.h"
 #include "../helpline.h"
@@ -26,21 +26,21 @@ struct hist_browser {
         bool                 has_symbols;
 };
 
-static int hists__browser_title(struct hists *self, char *bf, size_t size,
+static int hists__browser_title(struct hists *hists, char *bf, size_t size,
                                 const char *ev_name);
 
-static void hist_browser__refresh_dimensions(struct hist_browser *self)
+static void hist_browser__refresh_dimensions(struct hist_browser *browser)
 {
         /* 3 == +/- toggle symbol before actual hist_entry rendering */
-        self->b.width = 3 + (hists__sort_list_width(self->hists) +
+        browser->b.width = 3 + (hists__sort_list_width(browser->hists) +
                              sizeof("[k]"));
 }
 
-static void hist_browser__reset(struct hist_browser *self)
+static void hist_browser__reset(struct hist_browser *browser)
 {
-        self->b.nr_entries = self->hists->nr_entries;
-        hist_browser__refresh_dimensions(self);
-        ui_browser__reset_index(&self->b);
+        browser->b.nr_entries = browser->hists->nr_entries;
+        hist_browser__refresh_dimensions(browser);
+        ui_browser__reset_index(&browser->b);
 }
 
 static char tree__folded_sign(bool unfolded)
@@ -48,32 +48,32 @@ static char tree__folded_sign(bool unfolded)
         return unfolded ? '-' : '+';
 }
 
-static char map_symbol__folded(const struct map_symbol *self)
+static char map_symbol__folded(const struct map_symbol *ms)
 {
-        return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
+        return ms->has_children ? tree__folded_sign(ms->unfolded) : ' ';
 }
 
-static char hist_entry__folded(const struct hist_entry *self)
+static char hist_entry__folded(const struct hist_entry *he)
 {
-        return map_symbol__folded(&self->ms);
+        return map_symbol__folded(&he->ms);
 }
 
-static char callchain_list__folded(const struct callchain_list *self)
+static char callchain_list__folded(const struct callchain_list *cl)
 {
-        return map_symbol__folded(&self->ms);
+        return map_symbol__folded(&cl->ms);
 }
 
-static void map_symbol__set_folding(struct map_symbol *self, bool unfold)
+static void map_symbol__set_folding(struct map_symbol *ms, bool unfold)
 {
-        self->unfolded = unfold ? self->has_children : false;
+        ms->unfolded = unfold ? ms->has_children : false;
 }
 
-static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
+static int callchain_node__count_rows_rb_tree(struct callchain_node *node)
 {
         int n = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
                 struct callchain_list *chain;
                 char folded_sign = ' '; /* No children */
@@ -123,23 +123,23 @@ static int callchain__count_rows(struct rb_root *chain)
         return n;
 }
 
-static bool map_symbol__toggle_fold(struct map_symbol *self)
+static bool map_symbol__toggle_fold(struct map_symbol *ms)
 {
-        if (!self)
+        if (!ms)
                 return false;
 
-        if (!self->has_children)
+        if (!ms->has_children)
                 return false;
 
-        self->unfolded = !self->unfolded;
+        ms->unfolded = !ms->unfolded;
         return true;
 }
 
-static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
+static void callchain_node__init_have_children_rb_tree(struct callchain_node *node)
 {
-        struct rb_node *nd = rb_first(&self->rb_root);
+        struct rb_node *nd = rb_first(&node->rb_root);
 
-        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
                 struct callchain_list *chain;
                 bool first = true;
@@ -158,49 +158,49 @@ static void callchain_node__init_have_children_rb_tree(struct callchain_node *se
         }
 }
 
-static void callchain_node__init_have_children(struct callchain_node *self)
+static void callchain_node__init_have_children(struct callchain_node *node)
 {
         struct callchain_list *chain;
 
-        list_for_each_entry(chain, &self->val, list)
-                chain->ms.has_children = !RB_EMPTY_ROOT(&self->rb_root);
+        list_for_each_entry(chain, &node->val, list)
+                chain->ms.has_children = !RB_EMPTY_ROOT(&node->rb_root);
 
-        callchain_node__init_have_children_rb_tree(self);
+        callchain_node__init_have_children_rb_tree(node);
 }
 
-static void callchain__init_have_children(struct rb_root *self)
+static void callchain__init_have_children(struct rb_root *root)
 {
         struct rb_node *nd;
 
-        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(root); nd; nd = rb_next(nd)) {
                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
                 callchain_node__init_have_children(node);
         }
 }
 
-static void hist_entry__init_have_children(struct hist_entry *self)
+static void hist_entry__init_have_children(struct hist_entry *he)
 {
-        if (!self->init_have_children) {
-                self->ms.has_children = !RB_EMPTY_ROOT(&self->sorted_chain);
-                callchain__init_have_children(&self->sorted_chain);
-                self->init_have_children = true;
+        if (!he->init_have_children) {
+                he->ms.has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
+                callchain__init_have_children(&he->sorted_chain);
+                he->init_have_children = true;
         }
 }
 
-static bool hist_browser__toggle_fold(struct hist_browser *self)
+static bool hist_browser__toggle_fold(struct hist_browser *browser)
 {
-        if (map_symbol__toggle_fold(self->selection)) {
-                struct hist_entry *he = self->he_selection;
+        if (map_symbol__toggle_fold(browser->selection)) {
+                struct hist_entry *he = browser->he_selection;
 
                 hist_entry__init_have_children(he);
-                self->hists->nr_entries -= he->nr_rows;
+                browser->hists->nr_entries -= he->nr_rows;
 
                 if (he->ms.unfolded)
                         he->nr_rows = callchain__count_rows(&he->sorted_chain);
                 else
                         he->nr_rows = 0;
-                self->hists->nr_entries += he->nr_rows;
-                self->b.nr_entries = self->hists->nr_entries;
+                browser->hists->nr_entries += he->nr_rows;
+                browser->b.nr_entries = browser->hists->nr_entries;
 
                 return true;
         }
@@ -209,12 +209,12 @@ static bool hist_browser__toggle_fold(struct hist_browser *self)
         return false;
 }
 
-static int callchain_node__set_folding_rb_tree(struct callchain_node *self, bool unfold)
+static int callchain_node__set_folding_rb_tree(struct callchain_node *node, bool unfold)
 {
         int n = 0;
         struct rb_node *nd;
 
-        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&node->rb_root); nd; nd = rb_next(nd)) {
                 struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
                 struct callchain_list *chain;
                 bool has_children = false;
@@ -263,37 +263,37 @@ static int callchain__set_folding(struct rb_root *chain, bool unfold)
         return n;
 }
 
-static void hist_entry__set_folding(struct hist_entry *self, bool unfold)
+static void hist_entry__set_folding(struct hist_entry *he, bool unfold)
 {
-        hist_entry__init_have_children(self);
-        map_symbol__set_folding(&self->ms, unfold);
+        hist_entry__init_have_children(he);
+        map_symbol__set_folding(&he->ms, unfold);
 
-        if (self->ms.has_children) {
-                int n = callchain__set_folding(&self->sorted_chain, unfold);
-                self->nr_rows = unfold ? n : 0;
+        if (he->ms.has_children) {
+                int n = callchain__set_folding(&he->sorted_chain, unfold);
+                he->nr_rows = unfold ? n : 0;
         } else
-                self->nr_rows = 0;
+                he->nr_rows = 0;
 }
 
-static void hists__set_folding(struct hists *self, bool unfold)
+static void hists__set_folding(struct hists *hists, bool unfold)
 {
         struct rb_node *nd;
 
-        self->nr_entries = 0;
+        hists->nr_entries = 0;
 
-        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
+        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
                 hist_entry__set_folding(he, unfold);
-                self->nr_entries += 1 + he->nr_rows;
+                hists->nr_entries += 1 + he->nr_rows;
         }
 }
 
-static void hist_browser__set_folding(struct hist_browser *self, bool unfold)
+static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 {
-        hists__set_folding(self->hists, unfold);
-        self->b.nr_entries = self->hists->nr_entries;
+        hists__set_folding(browser->hists, unfold);
+        browser->b.nr_entries = browser->hists->nr_entries;
         /* Go to the start, we may be way after valid entries after a collapse */
-        ui_browser__reset_index(&self->b);
+        ui_browser__reset_index(&browser->b);
 }
 
 static void ui_browser__warn_lost_events(struct ui_browser *browser)
@@ -305,64 +305,64 @@ static void ui_browser__warn_lost_events(struct ui_browser *browser)
                 "Or reduce the sampling frequency.");
 }
 
-static int hist_browser__run(struct hist_browser *self, const char *ev_name,
+static int hist_browser__run(struct hist_browser *browser, const char *ev_name,
                              void(*timer)(void *arg), void *arg, int delay_secs)
 {
         int key;
         char title[160];
 
-        self->b.entries = &self->hists->entries;
-        self->b.nr_entries = self->hists->nr_entries;
+        browser->b.entries = &browser->hists->entries;
+        browser->b.nr_entries = browser->hists->nr_entries;
 
-        hist_browser__refresh_dimensions(self);
-        hists__browser_title(self->hists, title, sizeof(title), ev_name);
+        hist_browser__refresh_dimensions(browser);
+        hists__browser_title(browser->hists, title, sizeof(title), ev_name);
 
-        if (ui_browser__show(&self->b, title,
+        if (ui_browser__show(&browser->b, title,
                              "Press '?' for help on key bindings") < 0)
                 return -1;
 
         while (1) {
-                key = ui_browser__run(&self->b, delay_secs);
+                key = ui_browser__run(&browser->b, delay_secs);
 
                 switch (key) {
                 case K_TIMER:
                         timer(arg);
-                        ui_browser__update_nr_entries(&self->b, self->hists->nr_entries);
+                        ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
 
-                        if (self->hists->stats.nr_lost_warned !=
-                            self->hists->stats.nr_events[PERF_RECORD_LOST]) {
-                                self->hists->stats.nr_lost_warned =
-                                        self->hists->stats.nr_events[PERF_RECORD_LOST];
-                                ui_browser__warn_lost_events(&self->b);
+                        if (browser->hists->stats.nr_lost_warned !=
+                            browser->hists->stats.nr_events[PERF_RECORD_LOST]) {
+                                browser->hists->stats.nr_lost_warned =
+                                        browser->hists->stats.nr_events[PERF_RECORD_LOST];
+                                ui_browser__warn_lost_events(&browser->b);
                         }
 
-                        hists__browser_title(self->hists, title, sizeof(title), ev_name);
-                        ui_browser__show_title(&self->b, title);
+                        hists__browser_title(browser->hists, title, sizeof(title), ev_name);
+                        ui_browser__show_title(&browser->b, title);
                         continue;
                 case 'D': { /* Debug */
                         static int seq;
-                        struct hist_entry *h = rb_entry(self->b.top,
+                        struct hist_entry *h = rb_entry(browser->b.top,
                                                         struct hist_entry, rb_node);
                         ui_helpline__pop();
                         ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
-                                           seq++, self->b.nr_entries,
-                                           self->hists->nr_entries,
-                                           self->b.height,
-                                           self->b.index,
-                                           self->b.top_idx,
+                                           seq++, browser->b.nr_entries,
+                                           browser->hists->nr_entries,
+                                           browser->b.height,
+                                           browser->b.index,
+                                           browser->b.top_idx,
                                            h->row_offset, h->nr_rows);
                 }
                         break;
                 case 'C':
                         /* Collapse the whole world. */
-                        hist_browser__set_folding(self, false);
+                        hist_browser__set_folding(browser, false);
                         break;
                 case 'E':
                         /* Expand the whole world. */
-                        hist_browser__set_folding(self, true);
+                        hist_browser__set_folding(browser, true);
                         break;
                 case K_ENTER:
-                        if (hist_browser__toggle_fold(self))
+                        if (hist_browser__toggle_fold(browser))
                                 break;
                         /* fall thru */
                 default:
@@ -370,23 +370,23 @@ static int hist_browser__run(struct hist_browser *self, const char *ev_name,
                 }
         }
 out:
-        ui_browser__hide(&self->b);
+        ui_browser__hide(&browser->b);
         return key;
 }
 
-static char *callchain_list__sym_name(struct callchain_list *self,
+static char *callchain_list__sym_name(struct callchain_list *cl,
                                       char *bf, size_t bfsize)
 {
-        if (self->ms.sym)
-                return self->ms.sym->name;
+        if (cl->ms.sym)
+                return cl->ms.sym->name;
 
-        snprintf(bf, bfsize, "%#" PRIx64, self->ip);
+        snprintf(bf, bfsize, "%#" PRIx64, cl->ip);
         return bf;
 }
 
 #define LEVEL_OFFSET_STEP 3
 
-static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
+static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *browser,
                                                      struct callchain_node *chain_node,
                                                      u64 total, int level,
                                                      unsigned short row,
@@ -444,21 +444,21 @@ static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
                         }
 
                         color = HE_COLORSET_NORMAL;
-                        width = self->b.width - (offset + extra_offset + 2);
-                        if (ui_browser__is_current_entry(&self->b, row)) {
-                                self->selection = &chain->ms;
+                        width = browser->b.width - (offset + extra_offset + 2);
+                        if (ui_browser__is_current_entry(&browser->b, row)) {
+                                browser->selection = &chain->ms;
                                 color = HE_COLORSET_SELECTED;
                                 *is_current_entry = true;
                         }
 
-                        ui_browser__set_color(&self->b, color);
-                        ui_browser__gotorc(&self->b, row, 0);
+                        ui_browser__set_color(&browser->b, color);
+                        ui_browser__gotorc(&browser->b, row, 0);
                         slsmg_write_nstring(" ", offset + extra_offset);
                         slsmg_printf("%c ", folded_sign);
                         slsmg_write_nstring(str, width);
                         free(alloc_str);
 
-                        if (++row == self->b.height)
+                        if (++row == browser->b.height)
                                 goto out;
 do_next:
                         if (folded_sign == '+')
@@ -467,11 +467,11 @@ do_next:
 
                 if (folded_sign == '-') {
                         const int new_level = level + (extra_offset ? 2 : 1);
-                        row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
+                        row += hist_browser__show_callchain_node_rb_tree(browser, child, new_total,
                                                                          new_level, row, row_offset,
                                                                          is_current_entry);
                 }
-                if (row == self->b.height)
+                if (row == browser->b.height)
                         goto out;
                 node = next;
         }
@@ -479,7 +479,7 @@ out:
         return row - first_row;
 }
 
-static int hist_browser__show_callchain_node(struct hist_browser *self,
+static int hist_browser__show_callchain_node(struct hist_browser *browser,
                                              struct callchain_node *node,
                                              int level, unsigned short row,
                                              off_t *row_offset,
@@ -488,7 +488,7 @@ static int hist_browser__show_callchain_node(struct hist_browser *self,
         struct callchain_list *chain;
         int first_row = row,
              offset = level * LEVEL_OFFSET_STEP,
-             width = self->b.width - offset;
+             width = browser->b.width - offset;
         char folded_sign = ' ';
 
         list_for_each_entry(chain, &node->val, list) {
@@ -503,26 +503,26 @@ static int hist_browser__show_callchain_node(struct hist_browser *self,
                 }
 
                 color = HE_COLORSET_NORMAL;
-                if (ui_browser__is_current_entry(&self->b, row)) {
-                        self->selection = &chain->ms;
+                if (ui_browser__is_current_entry(&browser->b, row)) {
+                        browser->selection = &chain->ms;
                         color = HE_COLORSET_SELECTED;
                         *is_current_entry = true;
                 }
 
                 s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
-                ui_browser__gotorc(&self->b, row, 0);
-                ui_browser__set_color(&self->b, color);
+                ui_browser__gotorc(&browser->b, row, 0);
+                ui_browser__set_color(&browser->b, color);
                 slsmg_write_nstring(" ", offset);
                 slsmg_printf("%c ", folded_sign);
                 slsmg_write_nstring(s, width - 2);
 
-                if (++row == self->b.height)
+                if (++row == browser->b.height)
                         goto out;
         }
 
         if (folded_sign == '-')
-                row += hist_browser__show_callchain_node_rb_tree(self, node,
-                                                                 self->hists->stats.total_period,
+                row += hist_browser__show_callchain_node_rb_tree(browser, node,
+                                                                 browser->hists->stats.total_period,
                                                                  level + 1, row,
                                                                  row_offset,
                                                                  is_current_entry);
@@ -530,7 +530,7 @@ out:
         return row - first_row;
 }
 
-static int hist_browser__show_callchain(struct hist_browser *self,
+static int hist_browser__show_callchain(struct hist_browser *browser,
                                         struct rb_root *chain,
                                         int level, unsigned short row,
                                         off_t *row_offset,
@@ -542,31 +542,31 @@ static int hist_browser__show_callchain(struct hist_browser *self,
         for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
                 struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
 
-                row += hist_browser__show_callchain_node(self, node, level,
+                row += hist_browser__show_callchain_node(browser, node, level,
                                                          row, row_offset,
                                                          is_current_entry);
-                if (row == self->b.height)
+                if (row == browser->b.height)
                         break;
         }
 
         return row - first_row;
 }
 
-static int hist_browser__show_entry(struct hist_browser *self,
+static int hist_browser__show_entry(struct hist_browser *browser,
                                     struct hist_entry *entry,
                                     unsigned short row)
 {
         char s[256];
         double percent;
         int printed = 0;
-        int width = self->b.width - 6; /* The percentage */
+        int width = browser->b.width - 6; /* The percentage */
         char folded_sign = ' ';
-        bool current_entry = ui_browser__is_current_entry(&self->b, row);
+        bool current_entry = ui_browser__is_current_entry(&browser->b, row);
         off_t row_offset = entry->row_offset;
 
         if (current_entry) {
-                self->he_selection = entry;
-                self->selection = &entry->ms;
+                browser->he_selection = entry;
+                browser->selection = &entry->ms;
         }
 
         if (symbol_conf.use_callchain) {
@@ -575,11 +575,11 @@ static int hist_browser__show_entry(struct hist_browser *self,
         }
 
         if (row_offset == 0) {
-                hist_entry__snprintf(entry, s, sizeof(s), self->hists);
-                percent = (entry->period * 100.0) / self->hists->stats.total_period;
+                hist_entry__snprintf(entry, s, sizeof(s), browser->hists);
+                percent = (entry->period * 100.0) / browser->hists->stats.total_period;
 
-                ui_browser__set_percent_color(&self->b, percent, current_entry);
-                ui_browser__gotorc(&self->b, row, 0);
+                ui_browser__set_percent_color(&browser->b, percent, current_entry);
+                ui_browser__gotorc(&browser->b, row, 0);
                 if (symbol_conf.use_callchain) {
                         slsmg_printf("%c ", folded_sign);
                         width -= 2;
@@ -588,11 +588,11 @@ static int hist_browser__show_entry(struct hist_browser *self,
                 slsmg_printf(" %5.2f%%", percent);
 
                 /* The scroll bar isn't being used */
-                if (!self->b.navkeypressed)
+                if (!browser->b.navkeypressed)
                         width += 1;
 
-                if (!current_entry || !self->b.navkeypressed)
-                        ui_browser__set_color(&self->b, HE_COLORSET_NORMAL);
+                if (!current_entry || !browser->b.navkeypressed)
+                        ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
 
                 if (symbol_conf.show_nr_samples) {
                         slsmg_printf(" %11u", entry->nr_events);
@@ -610,12 +610,12 @@ static int hist_browser__show_entry(struct hist_browser *self,
         } else
                 --row_offset;
 
-        if (folded_sign == '-' && row != self->b.height) {
-                printed += hist_browser__show_callchain(self, &entry->sorted_chain,
+        if (folded_sign == '-' && row != browser->b.height) {
+                printed += hist_browser__show_callchain(browser, &entry->sorted_chain,
                                                         1, row, &row_offset,
                                                         &current_entry);
                 if (current_entry)
-                        self->he_selection = entry;
+                        browser->he_selection = entry;
         }
 
         return printed;
@@ -631,22 +631,22 @@ static void ui_browser__hists_init_top(struct ui_browser *browser)
         }
 }
 
-static unsigned int hist_browser__refresh(struct ui_browser *self)
+static unsigned int hist_browser__refresh(struct ui_browser *browser)
 {
         unsigned row = 0;
         struct rb_node *nd;
-        struct hist_browser *hb = container_of(self, struct hist_browser, b);
+        struct hist_browser *hb = container_of(browser, struct hist_browser, b);
 
-        ui_browser__hists_init_top(self);
+        ui_browser__hists_init_top(browser);
 
-        for (nd = self->top; nd; nd = rb_next(nd)) {
+        for (nd = browser->top; nd; nd = rb_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
                 if (h->filtered)
                         continue;
 
                 row += hist_browser__show_entry(hb, h, row);
-                if (row == self->height)
+                if (row == browser->height)
                         break;
         }
 
@@ -679,27 +679,27 @@ static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
         return NULL;
 }
 
-static void ui_browser__hists_seek(struct ui_browser *self,
+static void ui_browser__hists_seek(struct ui_browser *browser,
                                    off_t offset, int whence)
 {
         struct hist_entry *h;
         struct rb_node *nd;
         bool first = true;
 
-        if (self->nr_entries == 0)
+        if (browser->nr_entries == 0)
                 return;
 
-        ui_browser__hists_init_top(self);
+        ui_browser__hists_init_top(browser);
 
         switch (whence) {
         case SEEK_SET:
-                nd = hists__filter_entries(rb_first(self->entries));
+                nd = hists__filter_entries(rb_first(browser->entries));
                 break;
         case SEEK_CUR:
-                nd = self->top;
+                nd = browser->top;
                 goto do_offset;
         case SEEK_END:
-                nd = hists__filter_prev_entries(rb_last(self->entries));
+                nd = hists__filter_prev_entries(rb_last(browser->entries));
                 first = false;
                 break;
         default:
@@ -710,7 +710,7 @@ static void ui_browser__hists_seek(struct ui_browser *self,
          * Moves not relative to the first visible entry invalidates its
          * row_offset:
          */
-        h = rb_entry(self->top, struct hist_entry, rb_node);
+        h = rb_entry(browser->top, struct hist_entry, rb_node);
         h->row_offset = 0;
 
         /*
@@ -738,7 +738,7 @@ do_offset:
                                 } else {
                                         h->row_offset += offset;
                                         offset = 0;
-                                        self->top = nd;
+                                        browser->top = nd;
                                         break;
                                 }
                         }
@@ -746,7 +746,7 @@ do_offset:
                         if (nd == NULL)
                                 break;
                         --offset;
-                        self->top = nd;
+                        browser->top = nd;
                 } while (offset != 0);
         } else if (offset < 0) {
                 while (1) {
@@ -759,7 +759,7 @@ do_offset:
                                         } else {
                                                 h->row_offset += offset;
                                                 offset = 0;
-                                                self->top = nd;
+                                                browser->top = nd;
                                                 break;
                                         }
                                 } else {
@@ -769,7 +769,7 @@ do_offset:
                                         } else {
                                                 h->row_offset = h->nr_rows + offset;
                                                 offset = 0;
-                                                self->top = nd;
+                                                browser->top = nd;
                                                 break;
                                         }
                                 }
@@ -779,7 +779,7 @@ do_offset:
                         if (nd == NULL)
                                 break;
                         ++offset;
-                        self->top = nd;
+                        browser->top = nd;
                         if (offset == 0) {
                                 /*
                                  * Last unfiltered hist_entry, check if it is
@@ -794,7 +794,7 @@ do_offset:
                         first = false;
                 }
         } else {
-                self->top = nd;
+                browser->top = nd;
                 h = rb_entry(nd, struct hist_entry, rb_node);
                 h->row_offset = 0;
         }
@@ -802,52 +802,56 @@ do_offset:
 
 static struct hist_browser *hist_browser__new(struct hists *hists)
 {
-        struct hist_browser *self = zalloc(sizeof(*self));
+        struct hist_browser *browser = zalloc(sizeof(*browser));
 
-        if (self) {
-                self->hists = hists;
-                self->b.refresh = hist_browser__refresh;
-                self->b.seek = ui_browser__hists_seek;
-                self->b.use_navkeypressed = true;
+        if (browser) {
+                browser->hists = hists;
+                browser->b.refresh = hist_browser__refresh;
+                browser->b.seek = ui_browser__hists_seek;
+                browser->b.use_navkeypressed = true;
                 if (sort__branch_mode == 1)
-                        self->has_symbols = sort_sym_from.list.next != NULL;
+                        browser->has_symbols = sort_sym_from.list.next != NULL;
                 else
-                        self->has_symbols = sort_sym.list.next != NULL;
+                        browser->has_symbols = sort_sym.list.next != NULL;
         }
 
-        return self;
+        return browser;
 }
 
-static void hist_browser__delete(struct hist_browser *self)
+static void hist_browser__delete(struct hist_browser *browser)
 {
-        free(self);
+        free(browser);
 }
 
-static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
+static struct hist_entry *hist_browser__selected_entry(struct hist_browser *browser)
 {
-        return self->he_selection;
+        return browser->he_selection;
 }
 
-static struct thread *hist_browser__selected_thread(struct hist_browser *self)
+static struct thread *hist_browser__selected_thread(struct hist_browser *browser)
 {
-        return self->he_selection->thread;
+        return browser->he_selection->thread;
 }
 
-static int hists__browser_title(struct hists *self, char *bf, size_t size,
+static int hists__browser_title(struct hists *hists, char *bf, size_t size,
                                 const char *ev_name)
 {
         char unit;
         int printed;
-        const struct dso *dso = self->dso_filter;
-        const struct thread *thread = self->thread_filter;
-        unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
+        const struct dso *dso = hists->dso_filter;
+        const struct thread *thread = hists->thread_filter;
+        unsigned long nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
+        u64 nr_events = hists->stats.total_period;
+
+        nr_samples = convert_unit(nr_samples, &unit);
+        printed = scnprintf(bf, size,
+                           "Samples: %lu%c of event '%s', Event count (approx.): %lu",
+                           nr_samples, unit, ev_name, nr_events);
 
-        nr_events = convert_unit(nr_events, &unit);
-        printed = scnprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
 
-        if (self->uid_filter_str)
+        if (hists->uid_filter_str)
                 printed += snprintf(bf + printed, size - printed,
-                                    ", UID: %s", self->uid_filter_str);
+                                    ", UID: %s", hists->uid_filter_str);
         if (thread)
                 printed += scnprintf(bf + printed, size - printed,
                                     ", Thread: %s(%d)",
@@ -875,8 +879,8 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     void(*timer)(void *arg), void *arg,
                                     int delay_secs)
 {
-        struct hists *self = &evsel->hists;
-        struct hist_browser *browser = hist_browser__new(self);
+        struct hists *hists = &evsel->hists;
+        struct hist_browser *browser = hist_browser__new(hists);
         struct branch_info *bi;
         struct pstack *fstack;
         char *options[16];
@@ -937,13 +941,13 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         goto zoom_dso;
                 case 't':
                         goto zoom_thread;
-                case 's':
+                case '/':
                         if (ui_browser__input_window("Symbol to show",
                                         "Please enter the name of symbol you want to see",
                                         buf, "ENTER: OK, ESC: Cancel",
                                         delay_secs * 2) == K_ENTER) {
-                                self->symbol_filter_str = *buf ? buf : NULL;
-                                hists__filter_by_symbol(self);
+                                hists->symbol_filter_str = *buf ? buf : NULL;
+                                hists__filter_by_symbol(hists);
                                 hist_browser__reset(browser);
                         }
                         continue;
@@ -965,7 +969,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"
-                                        "s             Filter symbol by name");
+                                        "/             Filter symbol by name");
                         continue;
                 case K_ENTER:
                 case K_RIGHT:
@@ -1124,7 +1128,7 @@ zoom_out_dso:
                                 sort_dso.elide = true;
                                 pstack__push(fstack, &browser->hists->dso_filter);
                         }
-                        hists__filter_by_dso(self);
+                        hists__filter_by_dso(hists);
                         hist_browser__reset(browser);
                 } else if (choice == zoom_thread) {
 zoom_thread:
@@ -1142,7 +1146,7 @@ zoom_out_thread:
                                 sort_thread.elide = true;
                                 pstack__push(fstack, &browser->hists->thread_filter);
                         }
-                        hists__filter_by_thread(self);
+                        hists__filter_by_thread(hists);
                         hist_browser__reset(browser);
                 }
         }
diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/ui/browsers/map.c
index eca6575abfd0..98851d55a53e 100644
--- a/tools/perf/util/ui/browsers/map.c
+++ b/tools/perf/ui/browsers/map.c
@@ -5,9 +5,9 @@
 #include <sys/ttydefaults.h>
 #include <string.h>
 #include <linux/bitops.h>
-#include "../../util.h"
-#include "../../debug.h"
-#include "../../symbol.h"
+#include "../../util/util.h"
+#include "../../util/debug.h"
+#include "../../util/symbol.h"
 #include "../browser.h"
 #include "../helpline.h"
 #include "map.h"
diff --git a/tools/perf/util/ui/browsers/map.h b/tools/perf/ui/browsers/map.h
index df8581a43e17..df8581a43e17 100644
--- a/tools/perf/util/ui/browsers/map.h
+++ b/tools/perf/ui/browsers/map.h
diff --git a/tools/perf/util/gtk/browser.c b/tools/perf/ui/gtk/browser.c
index 258352a2356c..0656c381a89c 100644
--- a/tools/perf/util/gtk/browser.c
+++ b/tools/perf/ui/gtk/browser.c
@@ -9,24 +9,13 @@
 
 #define MAX_COLUMNS                     32
 
-void perf_gtk_setup_browser(int argc, const char *argv[],
-                            bool fallback_to_pager __used)
-{
-        gtk_init(&argc, (char ***)&argv);
-}
-
-void perf_gtk_exit_browser(bool wait_for_ok __used)
-{
-        gtk_main_quit();
-}
-
-static void perf_gtk_signal(int sig)
+static void perf_gtk__signal(int sig)
 {
         psignal(sig, "perf");
         gtk_main_quit();
 }
 
-static void perf_gtk_resize_window(GtkWidget *window)
+static void perf_gtk__resize_window(GtkWidget *window)
 {
         GdkRectangle rect;
         GdkScreen *screen;
@@ -46,7 +35,7 @@ static void perf_gtk_resize_window(GtkWidget *window)
         gtk_window_resize(GTK_WINDOW(window), width, height);
 }
 
-static void perf_gtk_show_hists(GtkWidget *window, struct hists *hists)
+static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 {
         GType col_types[MAX_COLUMNS];
         GtkCellRenderer *renderer;
@@ -142,11 +131,11 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
         GtkWidget *notebook;
         GtkWidget *window;
 
-        signal(SIGSEGV, perf_gtk_signal);
-        signal(SIGFPE,  perf_gtk_signal);
-        signal(SIGINT,  perf_gtk_signal);
-        signal(SIGQUIT, perf_gtk_signal);
-        signal(SIGTERM, perf_gtk_signal);
+        signal(SIGSEGV, perf_gtk__signal);
+        signal(SIGFPE,  perf_gtk__signal);
+        signal(SIGINT,  perf_gtk__signal);
+        signal(SIGQUIT, perf_gtk__signal);
+        signal(SIGTERM, perf_gtk__signal);
 
         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 
@@ -168,7 +157,7 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
                                                         GTK_POLICY_AUTOMATIC,
                                                         GTK_POLICY_AUTOMATIC);
 
-                perf_gtk_show_hists(scrolled_window, hists);
+                perf_gtk__show_hists(scrolled_window, hists);
 
                 tab_label = gtk_label_new(evname);
 
@@ -179,7 +168,7 @@ int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist,
 
         gtk_widget_show_all(window);
 
-        perf_gtk_resize_window(window);
+        perf_gtk__resize_window(window);
 
         gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
 
diff --git a/tools/perf/util/gtk/gtk.h b/tools/perf/ui/gtk/gtk.h
index 75177ee04032..75177ee04032 100644
--- a/tools/perf/util/gtk/gtk.h
+++ b/tools/perf/ui/gtk/gtk.h
diff --git a/tools/perf/ui/gtk/setup.c b/tools/perf/ui/gtk/setup.c
new file mode 100644
index 000000000000..829529957766
--- /dev/null
+++ b/tools/perf/ui/gtk/setup.c
@@ -0,0 +1,12 @@
+#include "gtk.h"
+#include "../../util/cache.h"
+
+int perf_gtk__init(void)
+{
+        return gtk_init_check(NULL, NULL) ? 0 : -1;
+}
+
+void perf_gtk__exit(bool wait_for_ok __used)
+{
+        gtk_main_quit();
+}
diff --git a/tools/perf/util/ui/helpline.c b/tools/perf/ui/helpline.c
index 2f950c2641c8..2f950c2641c8 100644
--- a/tools/perf/util/ui/helpline.c
+++ b/tools/perf/ui/helpline.c
diff --git a/tools/perf/util/ui/helpline.h b/tools/perf/ui/helpline.h
index 7bab6b34e35e..7bab6b34e35e 100644
--- a/tools/perf/util/ui/helpline.h
+++ b/tools/perf/ui/helpline.h
diff --git a/tools/perf/util/ui/keysyms.h b/tools/perf/ui/keysyms.h
index 809eca5707fa..809eca5707fa 100644
--- a/tools/perf/util/ui/keysyms.h
+++ b/tools/perf/ui/keysyms.h
diff --git a/tools/perf/util/ui/libslang.h b/tools/perf/ui/libslang.h
index 4d54b6450f5b..4d54b6450f5b 100644
--- a/tools/perf/util/ui/libslang.h
+++ b/tools/perf/ui/libslang.h
diff --git a/tools/perf/util/ui/progress.c b/tools/perf/ui/progress.c
index 13aa64e50e11..13aa64e50e11 100644
--- a/tools/perf/util/ui/progress.c
+++ b/tools/perf/ui/progress.c
diff --git a/tools/perf/util/ui/progress.h b/tools/perf/ui/progress.h
index d9c205b59aa1..d9c205b59aa1 100644
--- a/tools/perf/util/ui/progress.h
+++ b/tools/perf/ui/progress.h
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
new file mode 100644
index 000000000000..791fb15ce350
--- /dev/null
+++ b/tools/perf/ui/setup.c
@@ -0,0 +1,46 @@
+#include "../cache.h"
+#include "../debug.h"
+
+
+void setup_browser(bool fallback_to_pager)
+{
+        if (!isatty(1) || dump_trace)
+                use_browser = 0;
+
+        /* default to TUI */
+        if (use_browser < 0)
+                use_browser = 1;
+
+        switch (use_browser) {
+        case 2:
+                if (perf_gtk__init() == 0)
+                        break;
+                /* fall through */
+        case 1:
+                use_browser = 1;
+                if (ui__init() == 0)
+                        break;
+                /* fall through */
+        default:
+                use_browser = 0;
+                if (fallback_to_pager)
+                        setup_pager();
+                break;
+        }
+}
+
+void exit_browser(bool wait_for_ok)
+{
+        switch (use_browser) {
+        case 2:
+                perf_gtk__exit(wait_for_ok);
+                break;
+
+        case 1:
+                ui__exit(wait_for_ok);
+                break;
+
+        default:
+                break;
+        }
+}
diff --git a/tools/perf/util/ui/setup.c b/tools/perf/ui/tui/setup.c
index 85a69faa09aa..d33e943ac434 100644
--- a/tools/perf/util/ui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -2,14 +2,14 @@
 #include <signal.h>
 #include <stdbool.h>
 
-#include "../cache.h"
-#include "../debug.h"
-#include "browser.h"
-#include "helpline.h"
-#include "ui.h"
-#include "util.h"
-#include "libslang.h"
-#include "keysyms.h"
+#include "../../util/cache.h"
+#include "../../util/debug.h"
+#include "../browser.h"
+#include "../helpline.h"
+#include "../ui.h"
+#include "../util.h"
+#include "../libslang.h"
+#include "../keysyms.h"
 
 pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
@@ -93,45 +93,26 @@ static void newt_suspend(void *d __used)
         newtResume();
 }
 
-static int ui__init(void)
-{
-        int err = SLkp_init();
-
-        if (err < 0)
-                goto out;
-
-        SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
-out:
-        return err;
-}
-
-static void ui__exit(void)
-{
-        SLtt_set_cursor_visibility(1);
-        SLsmg_refresh();
-        SLsmg_reset_smg();
-        SLang_reset_tty();
-}
-
 static void ui__signal(int sig)
 {
-        ui__exit();
+        ui__exit(false);
         psignal(sig, "perf");
         exit(0);
 }
 
-void setup_browser(bool fallback_to_pager)
+int ui__init(void)
 {
-        if (!isatty(1) || !use_browser || dump_trace) {
-                use_browser = 0;
-                if (fallback_to_pager)
-                        setup_pager();
-                return;
-        }
+        int err;
 
-        use_browser = 1;
         newtInit();
-        ui__init();
+        err = SLkp_init();
+        if (err < 0) {
+                pr_err("TUI initialization failed.\n");
+                goto out;
+        }
+
+        SLkp_define_keysym((char *)"^(kB)", SL_KEY_UNTAB);
+
         newtSetSuspendCallback(newt_suspend, NULL);
         ui_helpline__init();
         ui_browser__init();
@@ -141,15 +122,19 @@ void setup_browser(bool fallback_to_pager)
         signal(SIGINT, ui__signal);
         signal(SIGQUIT, ui__signal);
         signal(SIGTERM, ui__signal);
+out:
+        return err;
 }
 
-void exit_browser(bool wait_for_ok)
+void ui__exit(bool wait_for_ok)
 {
-        if (use_browser > 0) {
-                if (wait_for_ok)
-                        ui__question_window("Fatal Error",
-                                            ui_helpline__last_msg,
-                                            "Press any key...", 0);
-                ui__exit();
-        }
+        if (wait_for_ok)
+                ui__question_window("Fatal Error",
+                                    ui_helpline__last_msg,
+                                    "Press any key...", 0);
+
+        SLtt_set_cursor_visibility(1);
+        SLsmg_refresh();
+        SLsmg_reset_smg();
+        SLang_reset_tty();
 }
diff --git a/tools/perf/util/ui/ui.h b/tools/perf/ui/ui.h
index 7b67045479f6..7b67045479f6 100644
--- a/tools/perf/util/ui/ui.h
+++ b/tools/perf/ui/ui.h
diff --git a/tools/perf/util/ui/util.c b/tools/perf/ui/util.c
index ad4374a16bb0..ad4374a16bb0 100644
--- a/tools/perf/util/ui/util.c
+++ b/tools/perf/ui/util.c
diff --git a/tools/perf/util/ui/util.h b/tools/perf/ui/util.h
index 2d1738bd71c8..2d1738bd71c8 100644
--- a/tools/perf/util/ui/util.h
+++ b/tools/perf/ui/util.h
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 08c6d138a655..8069dfb5ba77 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -18,6 +18,403 @@
 
 const char      *disassembler_style;
 
+static struct ins *ins__find(const char *name);
+static int disasm_line__parse(char *line, char **namep, char **rawp);
+
+static void ins__delete(struct ins_operands *ops)
+{
+        free(ops->source.raw);
+        free(ops->source.name);
+        free(ops->target.raw);
+        free(ops->target.name);
+}
+
+static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
+                              struct ins_operands *ops)
+{
+        return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw);
+}
+
+int ins__scnprintf(struct ins *ins, char *bf, size_t size,
+                  struct ins_operands *ops)
+{
+        if (ins->ops->scnprintf)
+                return ins->ops->scnprintf(ins, bf, size, ops);
+
+        return ins__raw_scnprintf(ins, bf, size, ops);
+}
+
+static int call__parse(struct ins_operands *ops)
+{
+        char *endptr, *tok, *name;
+
+        ops->target.addr = strtoull(ops->raw, &endptr, 16);
+
+        name = strchr(endptr, '<');
+        if (name == NULL)
+                goto indirect_call;
+
+        name++;
+
+        tok = strchr(name, '>');
+        if (tok == NULL)
+                return -1;
+
+        *tok = '\0';
+        ops->target.name = strdup(name);
+        *tok = '>';
+
+        return ops->target.name == NULL ? -1 : 0;
+
+indirect_call:
+        tok = strchr(endptr, '(');
+        if (tok != NULL) {
+                ops->target.addr = 0;
+                return 0;
+        }
+
+        tok = strchr(endptr, '*');
+        if (tok == NULL)
+                return -1;
+
+        ops->target.addr = strtoull(tok + 1, NULL, 16);
+        return 0;
+}
+
+static int call__scnprintf(struct ins *ins, char *bf, size_t size,
+                           struct ins_operands *ops)
+{
+        if (ops->target.name)
+                return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->target.name);
+
+        if (ops->target.addr == 0)
+                return ins__raw_scnprintf(ins, bf, size, ops);
+
+        return scnprintf(bf, size, "%-6.6s *%" PRIx64, ins->name, ops->target.addr);
+}
+
+static struct ins_ops call_ops = {
+        .parse     = call__parse,
+        .scnprintf = call__scnprintf,
+};
+
+bool ins__is_call(const struct ins *ins)
+{
+        return ins->ops == &call_ops;
+}
+
+static int jump__parse(struct ins_operands *ops)
+{
+        const char *s = strchr(ops->raw, '+');
+
+        ops->target.addr = strtoll(ops->raw, NULL, 16);
+
+        if (s++ != NULL)
+                ops->target.offset = strtoll(s, NULL, 16);
+        else
+                ops->target.offset = UINT64_MAX;
+
+        return 0;
+}
+
+static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
+                           struct ins_operands *ops)
+{
+        return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset);
+}
+
+static struct ins_ops jump_ops = {
+        .parse     = jump__parse,
+        .scnprintf = jump__scnprintf,
+};
+
+bool ins__is_jump(const struct ins *ins)
+{
+        return ins->ops == &jump_ops;
+}
+
+static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
+{
+        char *endptr, *name, *t;
+
+        if (strstr(raw, "(%rip)") == NULL)
+                return 0;
+
+        *addrp = strtoull(comment, &endptr, 16);
+        name = strchr(endptr, '<');
+        if (name == NULL)
+                return -1;
+
+        name++;
+
+        t = strchr(name, '>');
+        if (t == NULL)
+                return 0;
+
+        *t = '\0';
+        *namep = strdup(name);
+        *t = '>';
+
+        return 0;
+}
+
+static int lock__parse(struct ins_operands *ops)
+{
+        char *name;
+
+        ops->locked.ops = zalloc(sizeof(*ops->locked.ops));
+        if (ops->locked.ops == NULL)
+                return 0;
+
+        if (disasm_line__parse(ops->raw, &name, &ops->locked.ops->raw) < 0)
+                goto out_free_ops;
+
+        ops->locked.ins = ins__find(name);
+        if (ops->locked.ins == NULL)
+                goto out_free_ops;
+
+        if (!ops->locked.ins->ops)
+                return 0;
+
+        if (ops->locked.ins->ops->parse)
+                ops->locked.ins->ops->parse(ops->locked.ops);
+
+        return 0;
+
+out_free_ops:
+        free(ops->locked.ops);
+        ops->locked.ops = NULL;
+        return 0;
+}
+
+static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
+                           struct ins_operands *ops)
+{
+        int printed;
+
+        if (ops->locked.ins == NULL)
+                return ins__raw_scnprintf(ins, bf, size, ops);
+
+        printed = scnprintf(bf, size, "%-6.6s ", ins->name);
+        return printed + ins__scnprintf(ops->locked.ins, bf + printed,
+                                        size - printed, ops->locked.ops);
+}
+
+static void lock__delete(struct ins_operands *ops)
+{
+        free(ops->locked.ops);
+        free(ops->target.raw);
+        free(ops->target.name);
+}
+
+static struct ins_ops lock_ops = {
+        .free      = lock__delete,
+        .parse     = lock__parse,
+        .scnprintf = lock__scnprintf,
+};
+
+static int mov__parse(struct ins_operands *ops)
+{
+        char *s = strchr(ops->raw, ','), *target, *comment, prev;
+
+        if (s == NULL)
+                return -1;
+
+        *s = '\0';
+        ops->source.raw = strdup(ops->raw);
+        *s = ',';
+        
+        if (ops->source.raw == NULL)
+                return -1;
+
+        target = ++s;
+
+        while (s[0] != '\0' && !isspace(s[0]))
+                ++s;
+        prev = *s;
+        *s = '\0';
+
+        ops->target.raw = strdup(target);
+        *s = prev;
+
+        if (ops->target.raw == NULL)
+                goto out_free_source;
+
+        comment = strchr(s, '#');
+        if (comment == NULL)
+                return 0;
+
+        while (comment[0] != '\0' && isspace(comment[0]))
+                ++comment;
+
+        comment__symbol(ops->source.raw, comment, &ops->source.addr, &ops->source.name);
+        comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
+
+        return 0;
+
+out_free_source:
+        free(ops->source.raw);
+        ops->source.raw = NULL;
+        return -1;
+}
+
+static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
+                           struct ins_operands *ops)
+{
+        return scnprintf(bf, size, "%-6.6s %s,%s", ins->name,
+                         ops->source.name ?: ops->source.raw,
+                         ops->target.name ?: ops->target.raw);
+}
+
+static struct ins_ops mov_ops = {
+        .parse     = mov__parse,
+        .scnprintf = mov__scnprintf,
+};
+
+static int dec__parse(struct ins_operands *ops)
+{
+        char *target, *comment, *s, prev;
+
+        target = s = ops->raw;
+
+        while (s[0] != '\0' && !isspace(s[0]))
+                ++s;
+        prev = *s;
+        *s = '\0';
+
+        ops->target.raw = strdup(target);
+        *s = prev;
+
+        if (ops->target.raw == NULL)
+                return -1;
+
+        comment = strchr(s, '#');
+        if (comment == NULL)
+                return 0;
+
+        while (comment[0] != '\0' && isspace(comment[0]))
+                ++comment;
+
+        comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
+
+        return 0;
+}
+
+static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
+                           struct ins_operands *ops)
+{
+        return scnprintf(bf, size, "%-6.6s %s", ins->name,
+                         ops->target.name ?: ops->target.raw);
+}
+
+static struct ins_ops dec_ops = {
+        .parse     = dec__parse,
+        .scnprintf = dec__scnprintf,
+};
+
+static int nop__scnprintf(struct ins *ins __used, char *bf, size_t size,
+                          struct ins_operands *ops __used)
+{
+        return scnprintf(bf, size, "%-6.6s", "nop");
+}
+
+static struct ins_ops nop_ops = {
+        .scnprintf = nop__scnprintf,
+};
+
+/*
+ * Must be sorted by name!
+ */
+static struct ins instructions[] = {
+        { .name = "add",   .ops  = &mov_ops, },
+        { .name = "addl",  .ops  = &mov_ops, },
+        { .name = "addq",  .ops  = &mov_ops, },
+        { .name = "addw",  .ops  = &mov_ops, },
+        { .name = "and",   .ops  = &mov_ops, },
+        { .name = "bts",   .ops  = &mov_ops, },
+        { .name = "call",  .ops  = &call_ops, },
+        { .name = "callq", .ops  = &call_ops, },
+        { .name = "cmp",   .ops  = &mov_ops, },
+        { .name = "cmpb",  .ops  = &mov_ops, },
+        { .name = "cmpl",  .ops  = &mov_ops, },
+        { .name = "cmpq",  .ops  = &mov_ops, },
+        { .name = "cmpw",  .ops  = &mov_ops, },
+        { .name = "cmpxch", .ops  = &mov_ops, },
+        { .name = "dec",   .ops  = &dec_ops, },
+        { .name = "decl",  .ops  = &dec_ops, },
+        { .name = "imul",  .ops  = &mov_ops, },
+        { .name = "inc",   .ops  = &dec_ops, },
+        { .name = "incl",  .ops  = &dec_ops, },
+        { .name = "ja",    .ops  = &jump_ops, },
+        { .name = "jae",   .ops  = &jump_ops, },
+        { .name = "jb",    .ops  = &jump_ops, },
+        { .name = "jbe",   .ops  = &jump_ops, },
+        { .name = "jc",    .ops  = &jump_ops, },
+        { .name = "jcxz",  .ops  = &jump_ops, },
+        { .name = "je",    .ops  = &jump_ops, },
+        { .name = "jecxz", .ops  = &jump_ops, },
+        { .name = "jg",    .ops  = &jump_ops, },
+        { .name = "jge",   .ops  = &jump_ops, },
+        { .name = "jl",    .ops  = &jump_ops, },
+        { .name = "jle",   .ops  = &jump_ops, },
+        { .name = "jmp",   .ops  = &jump_ops, },
+        { .name = "jmpq",  .ops  = &jump_ops, },
+        { .name = "jna",   .ops  = &jump_ops, },
+        { .name = "jnae",  .ops  = &jump_ops, },
+        { .name = "jnb",   .ops  = &jump_ops, },
+        { .name = "jnbe",  .ops  = &jump_ops, },
+        { .name = "jnc",   .ops  = &jump_ops, },
+        { .name = "jne",   .ops  = &jump_ops, },
+        { .name = "jng",   .ops  = &jump_ops, },
+        { .name = "jnge",  .ops  = &jump_ops, },
+        { .name = "jnl",   .ops  = &jump_ops, },
+        { .name = "jnle",  .ops  = &jump_ops, },
+        { .name = "jno",   .ops  = &jump_ops, },
+        { .name = "jnp",   .ops  = &jump_ops, },
+        { .name = "jns",   .ops  = &jump_ops, },
+        { .name = "jnz",   .ops  = &jump_ops, },
+        { .name = "jo",    .ops  = &jump_ops, },
+        { .name = "jp",    .ops  = &jump_ops, },
+        { .name = "jpe",   .ops  = &jump_ops, },
+        { .name = "jpo",   .ops  = &jump_ops, },
+        { .name = "jrcxz", .ops  = &jump_ops, },
+        { .name = "js",    .ops  = &jump_ops, },
+        { .name = "jz",    .ops  = &jump_ops, },
+        { .name = "lea",   .ops  = &mov_ops, },
+        { .name = "lock",  .ops  = &lock_ops, },
+        { .name = "mov",   .ops  = &mov_ops, },
+        { .name = "movb",  .ops  = &mov_ops, },
+        { .name = "movdqa",.ops  = &mov_ops, },
+        { .name = "movl",  .ops  = &mov_ops, },
+        { .name = "movq",  .ops  = &mov_ops, },
+        { .name = "movslq", .ops  = &mov_ops, },
+        { .name = "movzbl", .ops  = &mov_ops, },
+        { .name = "movzwl", .ops  = &mov_ops, },
+        { .name = "nop",   .ops  = &nop_ops, },
+        { .name = "nopl",  .ops  = &nop_ops, },
+        { .name = "nopw",  .ops  = &nop_ops, },
+        { .name = "or",    .ops  = &mov_ops, },
+        { .name = "orl",   .ops  = &mov_ops, },
+        { .name = "test",  .ops  = &mov_ops, },
+        { .name = "testb", .ops  = &mov_ops, },
+        { .name = "testl", .ops  = &mov_ops, },
+        { .name = "xadd",  .ops  = &mov_ops, },
+};
+
+static int ins__cmp(const void *name, const void *insp)
+{
+        const struct ins *ins = insp;
+
+        return strcmp(name, ins->name);
+}
+
+static struct ins *ins__find(const char *name)
+{
+        const int nmemb = ARRAY_SIZE(instructions);
+
+        return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__cmp);
+}
+
 int symbol__annotate_init(struct map *map __used, struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
@@ -28,7 +425,7 @@ int symbol__annotate_init(struct map *map __used, struct symbol *sym)
 int symbol__alloc_hist(struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
-        const size_t size = sym->end - sym->start + 1;
+        const size_t size = symbol__size(sym);
         size_t sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
 
         notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
@@ -78,31 +475,110 @@ int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
         return 0;
 }
 
-static struct objdump_line *objdump_line__new(s64 offset, char *line, size_t privsize)
+static void disasm_line__init_ins(struct disasm_line *dl)
+{
+        dl->ins = ins__find(dl->name);
+
+        if (dl->ins == NULL)
+                return;
+
+        if (!dl->ins->ops)
+                return;
+
+        if (dl->ins->ops->parse)
+                dl->ins->ops->parse(&dl->ops);
+}
+
+static int disasm_line__parse(char *line, char **namep, char **rawp)
+{
+        char *name = line, tmp;
+
+        while (isspace(name[0]))
+                ++name;
+
+        if (name[0] == '\0')
+                return -1;
+
+        *rawp = name + 1;
+
+        while ((*rawp)[0] != '\0' && !isspace((*rawp)[0]))
+                ++*rawp;
+
+        tmp = (*rawp)[0];
+        (*rawp)[0] = '\0';
+        *namep = strdup(name);
+
+        if (*namep == NULL)
+                goto out_free_name;
+
+        (*rawp)[0] = tmp;
+
+        if ((*rawp)[0] != '\0') {
+                (*rawp)++;
+                while (isspace((*rawp)[0]))
+                        ++(*rawp);
+        }
+
+        return 0;
+
+out_free_name:
+        free(*namep);
+        *namep = NULL;
+        return -1;
+}
+
+static struct disasm_line *disasm_line__new(s64 offset, char *line, size_t privsize)
 {
-        struct objdump_line *self = malloc(sizeof(*self) + privsize);
+        struct disasm_line *dl = zalloc(sizeof(*dl) + privsize);
 
-        if (self != NULL) {
-                self->offset = offset;
-                self->line = line;
+        if (dl != NULL) {
+                dl->offset = offset;
+                dl->line = strdup(line);
+                if (dl->line == NULL)
+                        goto out_delete;
+
+                if (offset != -1) {
+                        if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0)
+                                goto out_free_line;
+
+                        disasm_line__init_ins(dl);
+                }
         }
 
-        return self;
+        return dl;
+
+out_free_line:
+        free(dl->line);
+out_delete:
+        free(dl);
+        return NULL;
+}
+
+void disasm_line__free(struct disasm_line *dl)
+{
+        free(dl->line);
+        free(dl->name);
+        if (dl->ins && dl->ins->ops->free)
+                dl->ins->ops->free(&dl->ops);
+        else
+                ins__delete(&dl->ops);
+        free(dl);
 }
 
-void objdump_line__free(struct objdump_line *self)
+int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw)
 {
-        free(self->line);
-        free(self);
+        if (raw || !dl->ins)
+                return scnprintf(bf, size, "%-6.6s %s", dl->name, dl->ops.raw);
+
+        return ins__scnprintf(dl->ins, bf, size, &dl->ops);
 }
 
-static void objdump__add_line(struct list_head *head, struct objdump_line *line)
+static void disasm__add(struct list_head *head, struct disasm_line *line)
 {
         list_add_tail(&line->node, head);
 }
 
-struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
-                                               struct objdump_line *pos)
+struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos)
 {
         list_for_each_entry_continue(pos, head, node)
                 if (pos->offset >= 0)
@@ -111,15 +587,14 @@ struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
         return NULL;
 }
 
-static int objdump_line__print(struct objdump_line *oline, struct symbol *sym,
-                               int evidx, u64 len, int min_pcnt,
-                               int printed, int max_lines,
-                               struct objdump_line *queue)
+static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
+                      int evidx, u64 len, int min_pcnt, int printed,
+                      int max_lines, struct disasm_line *queue)
 {
         static const char *prev_line;
         static const char *prev_color;
 
-        if (oline->offset != -1) {
+        if (dl->offset != -1) {
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
@@ -127,10 +602,11 @@ static int objdump_line__print(struct objdump_line *oline, struct symbol *sym,
                 struct annotation *notes = symbol__annotation(sym);
                 struct source_line *src_line = notes->src->lines;
                 struct sym_hist *h = annotation__histogram(notes, evidx);
-                s64 offset = oline->offset;
-                struct objdump_line *next;
+                s64 offset = dl->offset;
+                const u64 addr = start + offset;
+                struct disasm_line *next;
 
-                next = objdump__get_next_ip_line(&notes->src->source, oline);
+                next = disasm__get_next_ip_line(&notes->src->source, dl);
 
                 while (offset < (s64)len &&
                        (next == NULL || offset < next->offset)) {
@@ -155,9 +631,9 @@ static int objdump_line__print(struct objdump_line *oline, struct symbol *sym,
 
                 if (queue != NULL) {
                         list_for_each_entry_from(queue, &notes->src->source, node) {
-                                if (queue == oline)
+                                if (queue == dl)
                                         break;
-                                objdump_line__print(queue, sym, evidx, len,
+                                disasm_line__print(queue, sym, start, evidx, len,
                                                     0, 0, 1, NULL);
                         }
                 }
@@ -180,17 +656,18 @@ static int objdump_line__print(struct objdump_line *oline, struct symbol *sym,
 
                 color_fprintf(stdout, color, " %7.2f", percent);
                 printf(" :      ");
-                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", oline->line);
+                color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
+                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
         } else if (max_lines && printed >= max_lines)
                 return 1;
         else {
                 if (queue)
                         return -1;
 
-                if (!*oline->line)
+                if (!*dl->line)
                         printf("         :\n");
                 else
-                        printf("         :      %s\n", oline->line);
+                        printf("         :      %s\n", dl->line);
         }
 
         return 0;
@@ -200,8 +677,8 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                                       FILE *file, size_t privsize)
 {
         struct annotation *notes = symbol__annotation(sym);
-        struct objdump_line *objdump_line;
-        char *line = NULL, *tmp, *tmp2, *c;
+        struct disasm_line *dl;
+        char *line = NULL, *parsed_line, *tmp, *tmp2, *c;
         size_t line_len;
         s64 line_ip, offset = -1;
 
@@ -219,6 +696,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                 *c = 0;
 
         line_ip = -1;
+        parsed_line = line;
 
         /*
          * Strip leading spaces:
@@ -246,14 +724,17 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                 offset = line_ip - start;
                 if (offset < 0 || (u64)line_ip > end)
                         offset = -1;
+                else
+                        parsed_line = tmp2 + 1;
         }
 
-        objdump_line = objdump_line__new(offset, line, privsize);
-        if (objdump_line == NULL) {
-                free(line);
+        dl = disasm_line__new(offset, parsed_line, privsize);
+        free(line);
+
+        if (dl == NULL)
                 return -1;
-        }
-        objdump__add_line(&notes->src->source, objdump_line);
+
+        disasm__add(&notes->src->source, dl);
 
         return 0;
 }
@@ -476,7 +957,7 @@ static void symbol__annotate_hits(struct symbol *sym, int evidx)
 {
         struct annotation *notes = symbol__annotation(sym);
         struct sym_hist *h = annotation__histogram(notes, evidx);
-        u64 len = sym->end - sym->start, offset;
+        u64 len = symbol__size(sym), offset;
 
         for (offset = 0; offset < len; ++offset)
                 if (h->addr[offset] != 0)
@@ -492,7 +973,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
         struct dso *dso = map->dso;
         const char *filename = dso->long_name, *d_filename;
         struct annotation *notes = symbol__annotation(sym);
-        struct objdump_line *pos, *queue = NULL;
+        struct disasm_line *pos, *queue = NULL;
+        u64 start = map__rip_2objdump(map, sym->start);
         int printed = 2, queue_len = 0;
         int more = 0;
         u64 len;
@@ -502,7 +984,7 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
         else
                 d_filename = basename(filename);
 
-        len = sym->end - sym->start;
+        len = symbol__size(sym);
 
         printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
         printf("------------------------------------------------\n");
@@ -516,8 +998,9 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                         queue_len = 0;
                 }
 
-                switch (objdump_line__print(pos, sym, evidx, len, min_pcnt,
-                                            printed, max_lines, queue)) {
+                switch (disasm_line__print(pos, sym, start, evidx, len,
+                                            min_pcnt, printed, max_lines,
+                                            queue)) {
                 case 0:
                         ++printed;
                         if (context) {
@@ -561,7 +1044,7 @@ void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
 {
         struct annotation *notes = symbol__annotation(sym);
         struct sym_hist *h = annotation__histogram(notes, evidx);
-        int len = sym->end - sym->start, offset;
+        int len = symbol__size(sym), offset;
 
         h->sum = 0;
         for (offset = 0; offset < len; ++offset) {
@@ -570,14 +1053,42 @@ void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
         }
 }
 
-void objdump_line_list__purge(struct list_head *head)
+void disasm__purge(struct list_head *head)
 {
-        struct objdump_line *pos, *n;
+        struct disasm_line *pos, *n;
 
         list_for_each_entry_safe(pos, n, head, node) {
                 list_del(&pos->node);
-                objdump_line__free(pos);
+                disasm_line__free(pos);
+        }
+}
+
+static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp)
+{
+        size_t printed;
+
+        if (dl->offset == -1)
+                return fprintf(fp, "%s\n", dl->line);
+
+        printed = fprintf(fp, "%#" PRIx64 " %s", dl->offset, dl->name);
+
+        if (dl->ops.raw[0] != '\0') {
+                printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ",
+                                   dl->ops.raw);
         }
+
+        return printed + fprintf(fp, "\n");
+}
+
+size_t disasm__fprintf(struct list_head *head, FILE *fp)
+{
+        struct disasm_line *pos;
+        size_t printed = 0;
+
+        list_for_each_entry(pos, head, node)
+                printed += disasm_line__fprintf(pos, fp);
+
+        return printed;
 }
 
 int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
@@ -592,7 +1103,7 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
         if (symbol__annotate(sym, map, 0) < 0)
                 return -1;
 
-        len = sym->end - sym->start;
+        len = symbol__size(sym);
 
         if (print_lines) {
                 symbol__get_source_line(sym, map, evidx, &source_line,
@@ -605,7 +1116,7 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
         if (print_lines)
                 symbol__free_source_line(sym, len);
 
-        objdump_line_list__purge(&symbol__annotation(sym)->src->source);
+        disasm__purge(&symbol__annotation(sym)->src->source);
 
         return 0;
 }
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index efa5dc82bfae..78a5692dd718 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -2,20 +2,69 @@
 #define __PERF_ANNOTATE_H
 
 #include <stdbool.h>
+#include <stdint.h>
 #include "types.h"
 #include "symbol.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 
-struct objdump_line {
-        struct list_head node;
-        s64              offset;
-        char             *line;
+struct ins;
+
+struct ins_operands {
+        char    *raw;
+        struct {
+                char    *raw;
+                char    *name;
+                u64     addr;
+                u64     offset;
+        } target;
+        union {
+                struct {
+                        char    *raw;
+                        char    *name;
+                        u64     addr;
+                } source;
+                struct {
+                        struct ins *ins;
+                        struct ins_operands *ops;
+                } locked;
+        };
 };
 
-void objdump_line__free(struct objdump_line *self);
-struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
-                                               struct objdump_line *pos);
+struct ins_ops {
+        void (*free)(struct ins_operands *ops);
+        int (*parse)(struct ins_operands *ops);
+        int (*scnprintf)(struct ins *ins, char *bf, size_t size,
+                         struct ins_operands *ops);
+};
+
+struct ins {
+        const char     *name;
+        struct ins_ops *ops;
+};
+
+bool ins__is_jump(const struct ins *ins);
+bool ins__is_call(const struct ins *ins);
+int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops);
+
+struct disasm_line {
+        struct list_head    node;
+        s64                 offset;
+        char                *line;
+        char                *name;
+        struct ins          *ins;
+        struct ins_operands ops;
+};
+
+static inline bool disasm_line__has_offset(const struct disasm_line *dl)
+{
+        return dl->ops.target.offset != UINT64_MAX;
+}
+
+void disasm_line__free(struct disasm_line *dl);
+struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos);
+int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw);
+size_t disasm__fprintf(struct list_head *head, FILE *fp);
 
 struct sym_hist {
         u64             sum;
@@ -32,7 +81,7 @@ struct source_line {
  *
  * @histogram: Array of addr hit histograms per event being monitored
  * @lines: If 'print_lines' is specified, per source code line percentages
- * @source: source parsed from objdump -dS
+ * @source: source parsed from a disassembler like objdump -dS
  *
  * lines is allocated, percentages calculated and all sorted by percentage
  * when the annotation is about to be presented, so the percentages are for
@@ -82,7 +131,7 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                             int context);
 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
-void objdump_line_list__purge(struct list_head *head);
+void disasm__purge(struct list_head *head);
 
 int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
                          bool print_lines, bool full_paths, int min_pcnt,
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index dff9c7a725f4..fd9a5944b627 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -65,6 +65,8 @@ struct perf_tool build_id__mark_dso_hit_ops = {
         .mmap   = perf_event__process_mmap,
         .fork   = perf_event__process_task,
         .exit   = perf_event__exit_del_thread,
+        .attr            = perf_event__process_attr,
+        .build_id        = perf_event__process_build_id,
 };
 
 char *dso__build_id_filename(struct dso *self, char *bf, size_t size)
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 8dd224df3e54..cff18c617d13 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -33,7 +33,7 @@ extern int pager_use_color;
 
 extern int use_browser;
 
-#ifdef NO_NEWT_SUPPORT
+#if defined(NO_NEWT_SUPPORT) && defined(NO_GTK2_SUPPORT)
 static inline void setup_browser(bool fallback_to_pager)
 {
         if (fallback_to_pager)
@@ -43,19 +43,29 @@ static inline void exit_browser(bool wait_for_ok __used) {}
 #else
 void setup_browser(bool fallback_to_pager);
 void exit_browser(bool wait_for_ok);
+
+#ifdef NO_NEWT_SUPPORT
+static inline int ui__init(void)
+{
+        return -1;
+}
+static inline void ui__exit(bool wait_for_ok __used) {}
+#else
+int ui__init(void);
+void ui__exit(bool wait_for_ok);
 #endif
 
 #ifdef NO_GTK2_SUPPORT
-static inline void perf_gtk_setup_browser(int argc __used, const char *argv[] __used, bool fallback_to_pager)
+static inline int perf_gtk__init(void)
 {
-        if (fallback_to_pager)
-                setup_pager();
+        return -1;
 }
-static inline void perf_gtk_exit_browser(bool wait_for_ok __used) {}
+static inline void perf_gtk__exit(bool wait_for_ok __used) {}
 #else
-void perf_gtk_setup_browser(int argc, const char *argv[], bool fallback_to_pager);
-void perf_gtk_exit_browser(bool wait_for_ok);
+int perf_gtk__init(void);
+void perf_gtk__exit(bool wait_for_ok);
 #endif
+#endif /* NO_NEWT_SUPPORT && NO_GTK2_SUPPORT */
 
 char *alias_lookup(const char *alias);
 int split_cmdline(char *cmdline, const char ***argv);
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 0deac6a14b65..6faa3a18bfbd 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -120,7 +120,7 @@ static char *parse_value(void)
 
 static inline int iskeychar(int c)
 {
-        return isalnum(c) || c == '-';
+        return isalnum(c) || c == '-' || c == '_';
 }
 
 static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 26817daa2961..efb1fce259a4 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -11,6 +11,7 @@
 #include "event.h"
 #include "debug.h"
 #include "util.h"
+#include "target.h"
 
 int verbose;
 bool dump_trace = false, quiet = false;
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index f2ce88d04f54..6bebe7f0a20c 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -26,7 +26,7 @@ static inline void ui_progress__update(u64 curr __used, u64 total __used,
 #else
 extern char ui_helpline__last_msg[];
 int ui_helpline__show_help(const char *format, va_list ap);
-#include "ui/progress.h"
+#include "../ui/progress.h"
 int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
 #endif
 
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 1986d8051bd1..4ac5f5ae4ce9 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -11,6 +11,7 @@
 #include <poll.h>
 #include "cpumap.h"
 #include "thread_map.h"
+#include "target.h"
 #include "evlist.h"
 #include "evsel.h"
 #include <unistd.h>
@@ -599,18 +600,21 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         return perf_evlist__mmap_per_cpu(evlist, prot, mask);
 }
 
-int perf_evlist__create_maps(struct perf_evlist *evlist, const char *target_pid,
-                             const char *target_tid, uid_t uid, const char *cpu_list)
+int perf_evlist__create_maps(struct perf_evlist *evlist,
+                             struct perf_target *target)
 {
-        evlist->threads = thread_map__new_str(target_pid, target_tid, uid);
+        evlist->threads = thread_map__new_str(target->pid, target->tid,
+                                              target->uid);
 
         if (evlist->threads == NULL)
                 return -1;
 
-        if (uid != UINT_MAX || (cpu_list == NULL && target_tid))
+        if (perf_target__has_task(target))
+                evlist->cpus = cpu_map__dummy_new();
+        else if (!perf_target__has_cpu(target) && !target->uses_mmap)
                 evlist->cpus = cpu_map__dummy_new();
         else
-                evlist->cpus = cpu_map__new(cpu_list);
+                evlist->cpus = cpu_map__new(target->cpu_list);
 
         if (evlist->cpus == NULL)
                 goto out_delete_threads;
@@ -827,7 +831,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 exit(-1);
         }
 
-        if (!opts->system_wide && !opts->target_tid && !opts->target_pid)
+        if (perf_target__none(&opts->target))
                 evlist->threads->map[0] = evlist->workload.pid;
 
         close(child_ready_pipe[1]);
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 21f1c9e57f13..58abb63ac13a 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -106,8 +106,8 @@ static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
         evlist->threads = threads;
 }
 
-int perf_evlist__create_maps(struct perf_evlist *evlist, const char *target_pid,
-                             const char *tid, uid_t uid, const char *cpu_list);
+int perf_evlist__create_maps(struct perf_evlist *evlist,
+                             struct perf_target *target);
 void perf_evlist__delete_maps(struct perf_evlist *evlist);
 int perf_evlist__set_filters(struct perf_evlist *evlist);
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 8c13dbcb84b9..91d19138f3ec 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -14,6 +14,8 @@
 #include "util.h"
 #include "cpumap.h"
 #include "thread_map.h"
+#include "target.h"
+#include "../../include/linux/perf_event.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))
@@ -63,12 +65,102 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
+static const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
+        "cycles",
+        "instructions",
+        "cache-references",
+        "cache-misses",
+        "branches",
+        "branch-misses",
+        "bus-cycles",
+        "stalled-cycles-frontend",
+        "stalled-cycles-backend",
+        "ref-cycles",
+};
+
+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];
+
+        return "unknown-hardware";
+}
+
+static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int colon = 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++;                        \
+                        r += scnprintf(bf + r, size - r, "%c", mod);    \
+                } } while(0)
+
+        if (attr->exclude_kernel || attr->exclude_user || attr->exclude_hv) {
+                MOD_PRINT(kernel, 'k');
+                MOD_PRINT(user, 'u');
+                MOD_PRINT(hv, 'h');
+                exclude_guest_default = true;
+        }
+
+        if (attr->precise_ip) {
+                if (!colon)
+                        colon = r++;
+                r += scnprintf(bf + r, size - r, "%.*s", attr->precise_ip, "ppp");
+                exclude_guest_default = true;
+        }
+
+        if (attr->exclude_host || attr->exclude_guest == exclude_guest_default) {
+                MOD_PRINT(host, 'H');
+                MOD_PRINT(guest, 'G');
+        }
+#undef MOD_PRINT
+        if (colon)
+                bf[colon] = ':';
+        return r;
+}
+
+int perf_evsel__name(struct perf_evsel *evsel, char *bf, size_t size)
+{
+        int ret;
+
+        switch (evsel->attr.type) {
+        case PERF_TYPE_RAW:
+                ret = scnprintf(bf, size, "raw 0x%" PRIx64, evsel->attr.config);
+                break;
+
+        case PERF_TYPE_HARDWARE:
+                ret = perf_evsel__hw_name(evsel, bf, size);
+                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;
+}
+
 void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
                         struct perf_evsel *first)
 {
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
+        attr->disabled = 1;
         attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
         attr->inherit       = !opts->no_inherit;
         attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
@@ -106,15 +198,15 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
         if (opts->call_graph)
                 attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
 
-        if (opts->system_wide)
+        if (perf_target__has_cpu(&opts->target))
                 attr->sample_type       |= PERF_SAMPLE_CPU;
 
         if (opts->period)
                 attr->sample_type       |= PERF_SAMPLE_PERIOD;
 
         if (!opts->sample_id_all_missing &&
-            (opts->sample_time || opts->system_wide ||
-             !opts->no_inherit || opts->cpu_list))
+            (opts->sample_time || !opts->no_inherit ||
+             perf_target__has_cpu(&opts->target)))
                 attr->sample_type       |= PERF_SAMPLE_TIME;
 
         if (opts->raw_samples) {
@@ -135,9 +227,8 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
         attr->mmap = track;
         attr->comm = track;
 
-        if (!opts->target_pid && !opts->target_tid && !opts->system_wide &&
+        if (perf_target__none(&opts->target) &&
             (!opts->group || evsel == first)) {
-                attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 }
@@ -461,10 +552,7 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
          * used for cross-endian analysis. See git commit 65014ab3
          * for why this goofiness is needed.
          */
-        union {
-                u64 val64;
-                u32 val32[2];
-        } u;
+        union u64_swap u;
 
         memset(data, 0, sizeof(*data));
         data->cpu = data->pid = data->tid = -1;
@@ -607,10 +695,7 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
          * used for cross-endian analysis. See git commit 65014ab3
          * for why this goofiness is needed.
          */
-        union {
-                u64 val64;
-                u32 val32[2];
-        } u;
+        union u64_swap u;
 
         array = event->sample.array;
 
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 3d6b3e4cb66b..4ba8b564e6f4 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -83,6 +83,9 @@ 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);
+
 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);
 int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index c0b70c697a36..2dd5edf161b7 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -31,21 +31,16 @@ static const char **header_argv;
 
 int perf_header__push_event(u64 id, const char *name)
 {
+        struct perf_trace_event_type *nevents;
+
         if (strlen(name) > MAX_EVENT_NAME)
                 pr_warning("Event %s will be truncated\n", name);
 
-        if (!events) {
-                events = malloc(sizeof(struct perf_trace_event_type));
-                if (events == NULL)
-                        return -ENOMEM;
-        } else {
-                struct perf_trace_event_type *nevents;
+        nevents = realloc(events, (event_count + 1) * sizeof(*events));
+        if (nevents == NULL)
+                return -ENOMEM;
+        events = nevents;
 
-                nevents = realloc(events, (event_count + 1) * sizeof(*events));
-                if (nevents == NULL)
-                        return -ENOMEM;
-                events = nevents;
-        }
         memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
         events[event_count].event_id = id;
         strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
@@ -442,7 +437,7 @@ static bool perf_session__read_build_ids(struct perf_session *session, bool with
         return ret;
 }
 
-static int write_trace_info(int fd, struct perf_header *h __used,
+static int write_tracing_data(int fd, struct perf_header *h __used,
                             struct perf_evlist *evlist)
 {
         return read_tracing_data(fd, &evlist->entries);
@@ -1477,7 +1472,7 @@ out:
         return err;
 }
 
-static int process_trace_info(struct perf_file_section *section __unused,
+static int process_tracing_data(struct perf_file_section *section __unused,
                               struct perf_header *ph __unused,
                               int feat __unused, int fd)
 {
@@ -1513,11 +1508,11 @@ struct feature_ops {
                 .full_only = true }
 
 /* feature_ops not implemented: */
-#define print_trace_info                NULL
-#define print_build_id                  NULL
+#define print_tracing_data      NULL
+#define print_build_id          NULL
 
 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
-        FEAT_OPP(HEADER_TRACE_INFO,     trace_info),
+        FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
         FEAT_OPP(HEADER_BUILD_ID,       build_id),
         FEAT_OPA(HEADER_HOSTNAME,       hostname),
         FEAT_OPA(HEADER_OSRELEASE,      osrelease),
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 21a6be09c129..2d42b3e1826f 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -12,7 +12,7 @@
 enum {
         HEADER_RESERVED         = 0,    /* always cleared */
         HEADER_FIRST_FEATURE    = 1,
-        HEADER_TRACE_INFO       = 1,
+        HEADER_TRACING_DATA     = 1,
         HEADER_BUILD_ID,
 
         HEADER_HOSTNAME,
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 9f6d630d5316..1293b5ebea4d 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -599,7 +599,7 @@ static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
         if (chain->ms.sym)
                 ret += fprintf(fp, "%s\n", chain->ms.sym->name);
         else
-                ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
+                ret += fprintf(fp, "0x%0" PRIx64 "\n", chain->ip);
 
         return ret;
 }
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 2cae9df40e04..cfc64e293f90 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -138,7 +138,7 @@ static inline int hist_entry__tui_annotate(struct hist_entry *self __used,
 #define K_LEFT -1
 #define K_RIGHT -2
 #else
-#include "ui/keysyms.h"
+#include "../ui/keysyms.h"
 int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
                              void(*timer)(void *arg), void *arg, int delay_secs);
 
diff --git a/tools/perf/util/parse-events-test.c b/tools/perf/util/parse-events-test.c
new file mode 100644
index 000000000000..76b98e2a587d
--- /dev/null
+++ b/tools/perf/util/parse-events-test.c
@@ -0,0 +1,625 @@
+
+#include "parse-events.h"
+#include "evsel.h"
+#include "evlist.h"
+#include "sysfs.h"
+#include "../../../include/linux/hw_breakpoint.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 int test__checkevent_tracepoint(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_TRACEPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong sample_type",
+                (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU) ==
+                evsel->attr.sample_type);
+        TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
+        return 0;
+}
+
+static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                TEST_ASSERT_VAL("wrong type",
+                        PERF_TYPE_TRACEPOINT == evsel->attr.type);
+                TEST_ASSERT_VAL("wrong sample_type",
+                        (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU)
+                        == evsel->attr.sample_type);
+                TEST_ASSERT_VAL("wrong sample_period",
+                        1 == evsel->attr.sample_period);
+        }
+        return 0;
+}
+
+static int test__checkevent_raw(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_RAW == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 0x1a == evsel->attr.config);
+        return 0;
+}
+
+static int test__checkevent_numeric(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", 1 == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
+        return 0;
+}
+
+static int test__checkevent_symbolic_name(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_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        return 0;
+}
+
+static int test__checkevent_symbolic_name_config(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_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong period",
+                        100000 == evsel->attr.sample_period);
+        TEST_ASSERT_VAL("wrong config1",
+                        0 == evsel->attr.config1);
+        TEST_ASSERT_VAL("wrong config2",
+                        1 == evsel->attr.config2);
+        return 0;
+}
+
+static int test__checkevent_symbolic_alias(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_SOFTWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_SW_PAGE_FAULTS == evsel->attr.config);
+        return 0;
+}
+
+static int test__checkevent_genhw(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_HW_CACHE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", (1 << 16) == evsel->attr.config);
+        return 0;
+}
+
+static int test__checkevent_breakpoint(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_breakpoint_x(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_X == evsel->attr.bp_type);
+        TEST_ASSERT_VAL("wrong bp_len", sizeof(long) == evsel->attr.bp_len);
+        return 0;
+}
+
+static int test__checkevent_breakpoint_r(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 == evsel->attr.bp_type);
+        TEST_ASSERT_VAL("wrong bp_len",
+                        HW_BREAKPOINT_LEN_4 == evsel->attr.bp_len);
+        return 0;
+}
+
+static int test__checkevent_breakpoint_w(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_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,
+                                              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);
+
+        return test__checkevent_tracepoint(evlist);
+}
+
+static int
+test__checkevent_tracepoint_multi_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        TEST_ASSERT_VAL("wrong number of entries", evlist->nr_entries > 1);
+
+        list_for_each_entry(evsel, &evlist->entries, 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);
+        }
+
+        return test__checkevent_tracepoint_multi(evlist);
+}
+
+static int test__checkevent_raw_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);
+
+        return test__checkevent_raw(evlist);
+}
+
+static int test__checkevent_numeric_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);
+
+        return test__checkevent_numeric(evlist);
+}
+
+static int test__checkevent_symbolic_name_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);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__checkevent_exclude_host_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__checkevent_exclude_guest_modifier(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel = list_entry(evlist->entries.next,
+                                              struct perf_evsel, node);
+
+        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+
+        return test__checkevent_symbolic_name(evlist);
+}
+
+static int test__checkevent_symbolic_alias_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);
+
+        return test__checkevent_symbolic_alias(evlist);
+}
+
+static int test__checkevent_genhw_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);
+
+        return test__checkevent_genhw(evlist);
+}
+
+static int test__checkevent_breakpoint_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);
+
+        return test__checkevent_breakpoint(evlist);
+}
+
+static int test__checkevent_breakpoint_x_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);
+
+        return test__checkevent_breakpoint_x(evlist);
+}
+
+static int test__checkevent_breakpoint_r_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);
+
+        return test__checkevent_breakpoint_r(evlist);
+}
+
+static int test__checkevent_breakpoint_w_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);
+
+        return test__checkevent_breakpoint_w(evlist);
+}
+
+static int test__checkevent_pmu(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_RAW == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",    10 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong config1",    1 == evsel->attr.config1);
+        TEST_ASSERT_VAL("wrong config2",    3 == evsel->attr.config2);
+        TEST_ASSERT_VAL("wrong period",  1000 == evsel->attr.sample_period);
+
+        return 0;
+}
+
+static int test__checkevent_list(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
+
+        /* r1 */
+        evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong config1", 0 == evsel->attr.config1);
+        TEST_ASSERT_VAL("wrong config2", 0 == evsel->attr.config2);
+        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);
+
+        /* syscalls:sys_enter_open:k */
+        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong sample_type",
+                (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME | PERF_SAMPLE_CPU) ==
+                evsel->attr.sample_type);
+        TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
+        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);
+
+        /* 1:1:hp */
+        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
+        TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
+        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);
+
+        return 0;
+}
+
+static int test__checkevent_pmu_name(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel;
+
+        /* cpu/config=1,name=krava1/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"));
+
+        /* cpu/config=2/" */
+        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"));
+
+        return 0;
+}
+
+struct test__event_st {
+        const char *name;
+        __u32 type;
+        int (*check)(struct perf_evlist *evlist);
+};
+
+static struct test__event_st test__events[] = {
+        [0] = {
+                .name  = "syscalls:sys_enter_open",
+                .check = test__checkevent_tracepoint,
+        },
+        [1] = {
+                .name  = "syscalls:*",
+                .check = test__checkevent_tracepoint_multi,
+        },
+        [2] = {
+                .name  = "r1a",
+                .check = test__checkevent_raw,
+        },
+        [3] = {
+                .name  = "1:1",
+                .check = test__checkevent_numeric,
+        },
+        [4] = {
+                .name  = "instructions",
+                .check = test__checkevent_symbolic_name,
+        },
+        [5] = {
+                .name  = "cycles/period=100000,config2/",
+                .check = test__checkevent_symbolic_name_config,
+        },
+        [6] = {
+                .name  = "faults",
+                .check = test__checkevent_symbolic_alias,
+        },
+        [7] = {
+                .name  = "L1-dcache-load-miss",
+                .check = test__checkevent_genhw,
+        },
+        [8] = {
+                .name  = "mem:0",
+                .check = test__checkevent_breakpoint,
+        },
+        [9] = {
+                .name  = "mem:0:x",
+                .check = test__checkevent_breakpoint_x,
+        },
+        [10] = {
+                .name  = "mem:0:r",
+                .check = test__checkevent_breakpoint_r,
+        },
+        [11] = {
+                .name  = "mem:0:w",
+                .check = test__checkevent_breakpoint_w,
+        },
+        [12] = {
+                .name  = "syscalls:sys_enter_open:k",
+                .check = test__checkevent_tracepoint_modifier,
+        },
+        [13] = {
+                .name  = "syscalls:*:u",
+                .check = test__checkevent_tracepoint_multi_modifier,
+        },
+        [14] = {
+                .name  = "r1a:kp",
+                .check = test__checkevent_raw_modifier,
+        },
+        [15] = {
+                .name  = "1:1:hp",
+                .check = test__checkevent_numeric_modifier,
+        },
+        [16] = {
+                .name  = "instructions:h",
+                .check = test__checkevent_symbolic_name_modifier,
+        },
+        [17] = {
+                .name  = "faults:u",
+                .check = test__checkevent_symbolic_alias_modifier,
+        },
+        [18] = {
+                .name  = "L1-dcache-load-miss:kp",
+                .check = test__checkevent_genhw_modifier,
+        },
+        [19] = {
+                .name  = "mem:0:u",
+                .check = test__checkevent_breakpoint_modifier,
+        },
+        [20] = {
+                .name  = "mem:0:x:k",
+                .check = test__checkevent_breakpoint_x_modifier,
+        },
+        [21] = {
+                .name  = "mem:0:r:hp",
+                .check = test__checkevent_breakpoint_r_modifier,
+        },
+        [22] = {
+                .name  = "mem:0:w:up",
+                .check = test__checkevent_breakpoint_w_modifier,
+        },
+        [23] = {
+                .name  = "r1,syscalls:sys_enter_open:k,1:1:hp",
+                .check = test__checkevent_list,
+        },
+        [24] = {
+                .name  = "instructions:G",
+                .check = test__checkevent_exclude_host_modifier,
+        },
+        [25] = {
+                .name  = "instructions:H",
+                .check = test__checkevent_exclude_guest_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",
+                .check = test__checkevent_pmu,
+        },
+        [1] = {
+                .name  = "cpu/config=1,name=krava/u,cpu/config=2/u",
+                .check = test__checkevent_pmu_name,
+        },
+};
+
+#define TEST__EVENTS_PMU_CNT (sizeof(test__events_pmu) / \
+                              sizeof(struct test__event_st))
+
+static int test(struct test__event_st *e)
+{
+        struct perf_evlist *evlist;
+        int ret;
+
+        evlist = perf_evlist__new(NULL, NULL);
+        if (evlist == NULL)
+                return -ENOMEM;
+
+        ret = parse_events(evlist, e->name, 0);
+        if (ret) {
+                pr_debug("failed to parse event '%s', err %d\n",
+                         e->name, ret);
+                return ret;
+        }
+
+        ret = e->check(evlist);
+        perf_evlist__delete(evlist);
+
+        return ret;
+}
+
+static int test_events(struct test__event_st *events, unsigned cnt)
+{
+        int ret = 0;
+        unsigned i;
+
+        for (i = 0; i < cnt; i++) {
+                struct test__event_st *e = &events[i];
+
+                pr_debug("running test %d '%s'\n", i, e->name);
+                ret = test(e);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+
+static int test_pmu(void)
+{
+        struct stat st;
+        char path[PATH_MAX];
+        int ret;
+
+        snprintf(path, PATH_MAX, "%s/bus/event_source/devices/cpu/format/",
+                 sysfs_find_mountpoint());
+
+        ret = stat(path, &st);
+        if (ret)
+                pr_debug("ommiting PMU cpu tests\n");
+        return !ret;
+}
+
+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);
+
+        return ret;
+}
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 5b3a0ef4e232..05dbc8b3c767 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -23,8 +23,10 @@ struct event_symbol {
         const char      *alias;
 };
 
-int parse_events_parse(struct list_head *list, struct list_head *list_tmp,
-                       int *idx);
+#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
@@ -60,19 +62,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 *hw_event_names[PERF_COUNT_HW_MAX] = {
-        "cycles",
-        "instructions",
-        "cache-references",
-        "cache-misses",
-        "branches",
-        "branch-misses",
-        "bus-cycles",
-        "stalled-cycles-frontend",
-        "stalled-cycles-backend",
-        "ref-cycles",
-};
-
 static const char *sw_event_names[PERF_COUNT_SW_MAX] = {
         "cpu-clock",
         "task-clock",
@@ -298,6 +287,16 @@ 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;
 
@@ -315,9 +314,7 @@ const char *__event_name(int type, u64 config)
 
         switch (type) {
         case PERF_TYPE_HARDWARE:
-                if (config < PERF_COUNT_HW_MAX && hw_event_names[config])
-                        return hw_event_names[config];
-                return "unknown-hardware";
+                return __perf_evsel__hw_name(config);
 
         case PERF_TYPE_HW_CACHE: {
                 u8 cache_type, cache_op, cache_result;
@@ -355,20 +352,30 @@ const char *__event_name(int type, u64 config)
         return "unknown";
 }
 
-static int add_event(struct list_head *list, int *idx,
+static int add_event(struct list_head **_list, int *idx,
                      struct perf_event_attr *attr, char *name)
 {
         struct perf_evsel *evsel;
+        struct list_head *list = *_list;
+
+        if (!list) {
+                list = malloc(sizeof(*list));
+                if (!list)
+                        return -ENOMEM;
+                INIT_LIST_HEAD(list);
+        }
 
         event_attr_init(attr);
 
         evsel = perf_evsel__new(attr, (*idx)++);
-        if (!evsel)
+        if (!evsel) {
+                free(list);
                 return -ENOMEM;
-
-        list_add_tail(&evsel->node, list);
+        }
 
         evsel->name = strdup(name);
+        list_add_tail(&evsel->node, list);
+        *_list = list;
         return 0;
 }
 
@@ -390,7 +397,7 @@ static int parse_aliases(char *str, const char *names[][MAX_ALIASES], int size)
         return -1;
 }
 
-int parse_events_add_cache(struct list_head *list, int *idx,
+int parse_events_add_cache(struct list_head **list, int *idx,
                            char *type, char *op_result1, char *op_result2)
 {
         struct perf_event_attr attr;
@@ -451,7 +458,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
         return add_event(list, idx, &attr, name);
 }
 
-static int add_tracepoint(struct list_head *list, int *idx,
+static int add_tracepoint(struct list_head **list, int *idx,
                           char *sys_name, char *evt_name)
 {
         struct perf_event_attr attr;
@@ -488,7 +495,7 @@ static int add_tracepoint(struct list_head *list, int *idx,
         return add_event(list, idx, &attr, name);
 }
 
-static int add_tracepoint_multi(struct list_head *list, int *idx,
+static int add_tracepoint_multi(struct list_head **list, int *idx,
                                 char *sys_name, char *evt_name)
 {
         char evt_path[MAXPATHLEN];
@@ -519,7 +526,7 @@ static int add_tracepoint_multi(struct list_head *list, int *idx,
         return ret;
 }
 
-int parse_events_add_tracepoint(struct list_head *list, int *idx,
+int parse_events_add_tracepoint(struct list_head **list, int *idx,
                                 char *sys, char *event)
 {
         int ret;
@@ -563,7 +570,7 @@ parse_breakpoint_type(const char *type, struct perf_event_attr *attr)
         return 0;
 }
 
-int parse_events_add_breakpoint(struct list_head *list, int *idx,
+int parse_events_add_breakpoint(struct list_head **list, int *idx,
                                 void *ptr, char *type)
 {
         struct perf_event_attr attr;
@@ -593,17 +600,27 @@ int parse_events_add_breakpoint(struct list_head *list, int *idx,
 static int config_term(struct perf_event_attr *attr,
                        struct parse_events__term *term)
 {
-        switch (term->type) {
+#define CHECK_TYPE_VAL(type)                                    \
+do {                                                            \
+        if (PARSE_EVENTS__TERM_TYPE_ ## type != term->type_val) \
+                return -EINVAL;                                 \
+} while (0)
+
+        switch (term->type_term) {
         case PARSE_EVENTS__TERM_TYPE_CONFIG:
+                CHECK_TYPE_VAL(NUM);
                 attr->config = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_CONFIG1:
+                CHECK_TYPE_VAL(NUM);
                 attr->config1 = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_CONFIG2:
+                CHECK_TYPE_VAL(NUM);
                 attr->config2 = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
+                CHECK_TYPE_VAL(NUM);
                 attr->sample_period = term->val.num;
                 break;
         case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
@@ -612,10 +629,15 @@ static int config_term(struct perf_event_attr *attr,
                  * attr->branch_sample_type = term->val.num;
                  */
                 break;
+        case PARSE_EVENTS__TERM_TYPE_NAME:
+                CHECK_TYPE_VAL(STR);
+                break;
         default:
                 return -EINVAL;
         }
+
         return 0;
+#undef CHECK_TYPE_VAL
 }
 
 static int config_attr(struct perf_event_attr *attr,
@@ -630,7 +652,7 @@ static int config_attr(struct perf_event_attr *attr,
         return 0;
 }
 
-int parse_events_add_numeric(struct list_head *list, int *idx,
+int parse_events_add_numeric(struct list_head **list, int *idx,
                              unsigned long type, unsigned long config,
                              struct list_head *head_config)
 {
@@ -648,7 +670,24 @@ int parse_events_add_numeric(struct list_head *list, int *idx,
                          (char *) __event_name(type, config));
 }
 
-int parse_events_add_pmu(struct list_head *list, int *idx,
+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)
+{
+        struct parse_events__term *term;
+
+        list_for_each_entry(term, head_terms, list)
+                if (parse_events__is_name_term(term))
+                        return term->val.str;
+
+        return (char *) __event_name(PERF_TYPE_RAW, attr->config);
+}
+
+int parse_events_add_pmu(struct list_head **list, int *idx,
                          char *name, struct list_head *head_config)
 {
         struct perf_event_attr attr;
@@ -669,7 +708,8 @@ int parse_events_add_pmu(struct list_head *list, int *idx,
         if (perf_pmu__config(pmu, &attr, head_config))
                 return -EINVAL;
 
-        return add_event(list, idx, &attr, (char *) "pmu");
+        return add_event(list, idx, &attr,
+                         pmu_event_name(&attr, head_config));
 }
 
 void parse_events_update_lists(struct list_head *list_event,
@@ -681,7 +721,7 @@ void parse_events_update_lists(struct list_head *list_event,
          * list, for next event definition.
          */
         list_splice_tail(list_event, list_all);
-        INIT_LIST_HEAD(list_event);
+        free(list_event);
 }
 
 int parse_events_modifier(struct list_head *list, char *str)
@@ -756,10 +796,14 @@ int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
 
         buffer = parse_events__scan_string(str);
 
-        ret = parse_events_parse(&list, &list_tmp, &idx);
+#ifdef PARSER_DEBUG
+        parse_events_debug = 1;
+#endif
+        ret = parse_events_parse(&list, &idx);
 
         parse_events__flush_buffer(buffer);
         parse_events__delete_buffer(buffer);
+        parse_events_lex_destroy();
 
         if (!ret) {
                 int entries = idx - evlist->nr_entries;
@@ -1015,11 +1059,12 @@ void print_events(const char *event_glob)
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term)
 {
-        return term->type <= PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX;
+        return term->type_term != PARSE_EVENTS__TERM_TYPE_USER;
 }
 
-int parse_events__new_term(struct parse_events__term **_term, int type,
-                           char *config, char *str, long num)
+static int new_term(struct parse_events__term **_term, int type_val,
+                    int type_term, char *config,
+                    char *str, long num)
 {
         struct parse_events__term *term;
 
@@ -1028,15 +1073,11 @@ int parse_events__new_term(struct parse_events__term **_term, int type,
                 return -ENOMEM;
 
         INIT_LIST_HEAD(&term->list);
-        term->type = type;
+        term->type_val  = type_val;
+        term->type_term = type_term;
         term->config = config;
 
-        switch (type) {
-        case PARSE_EVENTS__TERM_TYPE_CONFIG:
-        case PARSE_EVENTS__TERM_TYPE_CONFIG1:
-        case PARSE_EVENTS__TERM_TYPE_CONFIG2:
-        case PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD:
-        case PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE:
+        switch (type_val) {
         case PARSE_EVENTS__TERM_TYPE_NUM:
                 term->val.num = num;
                 break;
@@ -1051,6 +1092,20 @@ int parse_events__new_term(struct parse_events__term **_term, int type,
         return 0;
 }
 
+int parse_events__term_num(struct parse_events__term **term,
+                           int type_term, char *config, long num)
+{
+        return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
+                        config, NULL, num);
+}
+
+int parse_events__term_str(struct parse_events__term **term,
+                           int type_term, char *config, char *str)
+{
+        return new_term(term, PARSE_EVENTS__TERM_TYPE_STR, type_term,
+                        config, str, 0);
+}
+
 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 ca069f893381..8cac57ab4ee6 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -4,7 +4,11 @@
  * Parse symbolic events/counts passed in as options:
  */
 
+#include <linux/list.h>
+#include <stdbool.h>
+#include "types.h"
 #include "../../../include/linux/perf_event.h"
+#include "types.h"
 
 struct list_head;
 struct perf_evsel;
@@ -34,16 +38,18 @@ extern int parse_filter(const struct option *opt, const char *str, int unset);
 #define EVENTS_HELP_MAX (128*1024)
 
 enum {
+        PARSE_EVENTS__TERM_TYPE_NUM,
+        PARSE_EVENTS__TERM_TYPE_STR,
+};
+
+enum {
+        PARSE_EVENTS__TERM_TYPE_USER,
         PARSE_EVENTS__TERM_TYPE_CONFIG,
         PARSE_EVENTS__TERM_TYPE_CONFIG1,
         PARSE_EVENTS__TERM_TYPE_CONFIG2,
+        PARSE_EVENTS__TERM_TYPE_NAME,
         PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD,
         PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
-        PARSE_EVENTS__TERM_TYPE_NUM,
-        PARSE_EVENTS__TERM_TYPE_STR,
-
-        PARSE_EVENTS__TERM_TYPE_HARDCODED_MAX =
-                PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE,
 };
 
 struct parse_events__term {
@@ -52,35 +58,34 @@ struct parse_events__term {
                 char *str;
                 long  num;
         } val;
-        int type;
-
+        int type_val;
+        int type_term;
         struct list_head list;
 };
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term);
-int parse_events__new_term(struct parse_events__term **term, int type,
-                           char *config, char *str, long num);
+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);
 void parse_events__free_terms(struct list_head *terms);
-int parse_events_modifier(struct list_head *list __used, char *str __used);
-int parse_events_add_tracepoint(struct list_head *list, int *idx,
+int parse_events_modifier(struct list_head *list, char *str);
+int parse_events_add_tracepoint(struct list_head **list, int *idx,
                                 char *sys, char *event);
-int parse_events_add_raw(struct perf_evlist *evlist, unsigned long config,
-                         unsigned long config1, unsigned long config2,
-                         char *mod);
-int parse_events_add_numeric(struct list_head *list, int *idx,
+int parse_events_add_numeric(struct list_head **list, int *idx,
                              unsigned long type, unsigned long config,
                              struct list_head *head_config);
-int parse_events_add_cache(struct list_head *list, int *idx,
+int parse_events_add_cache(struct list_head **list, int *idx,
                            char *type, char *op_result1, char *op_result2);
-int parse_events_add_breakpoint(struct list_head *list, int *idx,
+int parse_events_add_breakpoint(struct list_head **list, int *idx,
                                 void *ptr, char *type);
-int parse_events_add_pmu(struct list_head *list, int *idx,
+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,
-                        struct list_head *list_event,
                         int *idx, char const *msg);
+int parse_events__test(void);
 
 void print_events(const char *event_glob);
 void print_events_type(u8 type);
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 1fcf1bbc5458..618a8e788399 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -1,5 +1,6 @@
 
 %option prefix="parse_events_"
+%option stack
 
 %{
 #include <errno.h>
@@ -50,6 +51,8 @@ static int term(int type)
 
 %}
 
+%x mem
+
 num_dec         [0-9]+
 num_hex         0x[a-fA-F0-9]+
 num_raw_hex     [a-fA-F0-9]+
@@ -102,16 +105,16 @@ misses|miss				{ return str(PE_NAME_CACHE_OP_RESULT); }
 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); }
 
-mem:                    { return PE_PREFIX_MEM; }
+mem:                    { BEGIN(mem); return PE_PREFIX_MEM; }
 r{num_raw_hex}          { return raw(); }
 {num_dec}               { return value(10); }
 {num_hex}               { return value(16); }
 
 {modifier_event}        { return str(PE_MODIFIER_EVENT); }
-{modifier_bp}           { return str(PE_MODIFIER_BP); }
 {name}                  { return str(PE_NAME); }
 "/"                     { return '/'; }
 -                       { return '-'; }
@@ -119,6 +122,25 @@ r{num_raw_hex}		{ return raw(); }
 :                       { return ':'; }
 =                       { return '='; }
 
+<mem>{
+{modifier_bp}           { return str(PE_MODIFIER_BP); }
+:                       { return ':'; }
+{num_dec}               { return value(10); }
+{num_hex}               { return value(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); }
+        /*
+         * We destroy the scanner after reaching EOF,
+         * but anyway just to be sure get back to INIT state.
+         */
+<<EOF>>                 { BEGIN(INITIAL); }
+}
+
 %%
 
 int parse_events_wrap(void)
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index d9637da7333c..362cc59332ae 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -1,7 +1,6 @@
 
 %name-prefix "parse_events_"
 %parse-param {struct list_head *list_all}
-%parse-param {struct list_head *list_event}
 %parse-param {int *idx}
 
 %{
@@ -41,6 +40,14 @@ do { \
 %type <str> PE_MODIFIER_BP
 %type <head> event_config
 %type <term> event_term
+%type <head> event_pmu
+%type <head> event_legacy_symbol
+%type <head> event_legacy_cache
+%type <head> event_legacy_mem
+%type <head> event_legacy_tracepoint
+%type <head> event_legacy_numeric
+%type <head> event_legacy_raw
+%type <head> event_def
 
 %union
 {
@@ -62,13 +69,13 @@ event_def PE_MODIFIER_EVENT
          * (there could be more events added for multiple tracepoint
          * definitions via '*?'.
          */
-        ABORT_ON(parse_events_modifier(list_event, $2));
-        parse_events_update_lists(list_event, list_all);
+        ABORT_ON(parse_events_modifier($1, $2));
+        parse_events_update_lists($1, list_all);
 }
 |
 event_def
 {
-        parse_events_update_lists(list_event, list_all);
+        parse_events_update_lists($1, list_all);
 }
 
 event_def: event_pmu |
@@ -82,71 +89,102 @@ event_def: event_pmu |
 event_pmu:
 PE_NAME '/' event_config '/'
 {
-        ABORT_ON(parse_events_add_pmu(list_event, idx, $1, $3));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_pmu(&list, idx, $1, $3));
         parse_events__free_terms($3);
+        $$ = list;
 }
 
 event_legacy_symbol:
 PE_VALUE_SYM '/' event_config '/'
 {
+        struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(list_event, idx, type, config, $3));
+        ABORT_ON(parse_events_add_numeric(&list, idx, type, config, $3));
         parse_events__free_terms($3);
+        $$ = list;
 }
 |
 PE_VALUE_SYM sep_slash_dc
 {
+        struct list_head *list = NULL;
         int type = $1 >> 16;
         int config = $1 & 255;
 
-        ABORT_ON(parse_events_add_numeric(list_event, idx, type, config, NULL));
+        ABORT_ON(parse_events_add_numeric(&list, idx, type, config, NULL));
+        $$ = list;
 }
 
 event_legacy_cache:
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT '-' PE_NAME_CACHE_OP_RESULT
 {
-        ABORT_ON(parse_events_add_cache(list_event, idx, $1, $3, $5));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_cache(&list, idx, $1, $3, $5));
+        $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE '-' PE_NAME_CACHE_OP_RESULT
 {
-        ABORT_ON(parse_events_add_cache(list_event, idx, $1, $3, NULL));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_cache(&list, idx, $1, $3, NULL));
+        $$ = list;
 }
 |
 PE_NAME_CACHE_TYPE
 {
-        ABORT_ON(parse_events_add_cache(list_event, idx, $1, NULL, NULL));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_cache(&list, idx, $1, NULL, NULL));
+        $$ = list;
 }
 
 event_legacy_mem:
 PE_PREFIX_MEM PE_VALUE ':' PE_MODIFIER_BP sep_dc
 {
-        ABORT_ON(parse_events_add_breakpoint(list_event, idx, (void *) $2, $4));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_breakpoint(&list, idx, (void *) $2, $4));
+        $$ = list;
 }
 |
 PE_PREFIX_MEM PE_VALUE sep_dc
 {
-        ABORT_ON(parse_events_add_breakpoint(list_event, idx, (void *) $2, NULL));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_breakpoint(&list, idx, (void *) $2, NULL));
+        $$ = list;
 }
 
 event_legacy_tracepoint:
 PE_NAME ':' PE_NAME
 {
-        ABORT_ON(parse_events_add_tracepoint(list_event, idx, $1, $3));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_tracepoint(&list, idx, $1, $3));
+        $$ = list;
 }
 
 event_legacy_numeric:
 PE_VALUE ':' PE_VALUE
 {
-        ABORT_ON(parse_events_add_numeric(list_event, idx, $1, $3, NULL));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_numeric(&list, idx, $1, $3, NULL));
+        $$ = list;
 }
 
 event_legacy_raw:
 PE_RAW
 {
-        ABORT_ON(parse_events_add_numeric(list_event, idx, PERF_TYPE_RAW, $1, NULL));
+        struct list_head *list = NULL;
+
+        ABORT_ON(parse_events_add_numeric(&list, idx, PERF_TYPE_RAW, $1, NULL));
+        $$ = list;
 }
 
 event_config:
@@ -176,8 +214,8 @@ PE_NAME '=' PE_NAME
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_STR,
-                 $1, $3, 0));
+        ABORT_ON(parse_events__term_str(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, $3));
         $$ = term;
 }
 |
@@ -185,8 +223,8 @@ PE_NAME '=' PE_VALUE
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
-                 $1, NULL, $3));
+        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, $3));
         $$ = term;
 }
 |
@@ -194,8 +232,16 @@ PE_NAME
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, PARSE_EVENTS__TERM_TYPE_NUM,
-                 $1, NULL, 1));
+        ABORT_ON(parse_events__term_num(&term, PARSE_EVENTS__TERM_TYPE_USER,
+                                        $1, 1));
+        $$ = term;
+}
+|
+PE_TERM '=' PE_NAME
+{
+        struct parse_events__term *term;
+
+        ABORT_ON(parse_events__term_str(&term, $1, NULL, $3));
         $$ = term;
 }
 |
@@ -203,7 +249,7 @@ PE_TERM '=' PE_VALUE
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, $3));
+        ABORT_ON(parse_events__term_num(&term, $1, NULL, $3));
         $$ = term;
 }
 |
@@ -211,7 +257,7 @@ PE_TERM
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__new_term(&term, $1, NULL, NULL, 1));
+        ABORT_ON(parse_events__term_num(&term, $1, NULL, 1));
         $$ = term;
 }
 
@@ -222,7 +268,6 @@ sep_slash_dc: '/' | ':' |
 %%
 
 void parse_events_error(struct list_head *list_all __used,
-                        struct list_head *list_event __used,
                         int *idx __used,
                         char const *msg __used)
 {
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index cb08a118e811..a119a5371699 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -225,7 +225,7 @@ static int pmu_config_term(struct list_head *formats,
         if (parse_events__is_hardcoded_term(term))
                 return 0;
 
-        if (term->type != PARSE_EVENTS__TERM_TYPE_NUM)
+        if (term->type_val != PARSE_EVENTS__TERM_TYPE_NUM)
                 return -EINVAL;
 
         format = pmu_find_format(formats, term->config);
@@ -246,6 +246,11 @@ static int pmu_config_term(struct list_head *formats,
                 return -EINVAL;
         }
 
+        /*
+         * XXX If we ever decide to go with string values for
+         * non-hardcoded terms, here's the place to translate
+         * them into value.
+         */
         *vp |= pmu_format_value(format->bits, term->val.num);
         return 0;
 }
@@ -253,9 +258,9 @@ static int pmu_config_term(struct list_head *formats,
 static int pmu_config(struct list_head *formats, struct perf_event_attr *attr,
                       struct list_head *head_terms)
 {
-        struct parse_events__term *term, *h;
+        struct parse_events__term *term;
 
-        list_for_each_entry_safe(term, h, head_terms, list)
+        list_for_each_entry(term, head_terms, list)
                 if (pmu_config_term(formats, attr, term))
                         return -EINVAL;
 
@@ -324,49 +329,58 @@ static struct test_format {
 /* Simulated users input. */
 static struct parse_events__term test_terms[] = {
         {
-                .config  = (char *) "krava01",
-                .val.num = 15,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava01",
+                .val.num   = 15,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava02",
-                .val.num = 170,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava02",
+                .val.num   = 170,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava03",
-                .val.num = 1,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava03",
+                .val.num   = 1,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava11",
-                .val.num = 27,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava11",
+                .val.num   = 27,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava12",
-                .val.num = 1,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava12",
+                .val.num   = 1,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava13",
-                .val.num = 2,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava13",
+                .val.num   = 2,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava21",
-                .val.num = 119,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava21",
+                .val.num   = 119,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava22",
-                .val.num = 11,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava22",
+                .val.num   = 11,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
         {
-                .config  = (char *) "krava23",
-                .val.num = 2,
-                .type    = PARSE_EVENTS__TERM_TYPE_NUM,
+                .config    = (char *) "krava23",
+                .val.num   = 2,
+                .type_val  = PARSE_EVENTS__TERM_TYPE_NUM,
+                .type_term = PARSE_EVENTS__TERM_TYPE_USER,
         },
 };
 #define TERMS_CNT (sizeof(test_terms) / sizeof(struct parse_events__term))
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 8a8ee64e72d1..59dccc98b554 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -44,6 +44,7 @@
 #include "trace-event.h"        /* For __unused */
 #include "probe-event.h"
 #include "probe-finder.h"
+#include "session.h"
 
 #define MAX_CMDLEN 256
 #define MAX_PROBE_ARGS 128
@@ -70,6 +71,8 @@ static int e_snprintf(char *str, size_t size, const char *format, ...)
 }
 
 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
+static int convert_name_to_addr(struct perf_probe_event *pev,
+                                const char *exec);
 static struct machine machine;
 
 /* Initialize symbol maps and path of vmlinux/modules */
@@ -170,6 +173,34 @@ const char *kernel_get_module_path(const char *module)
         return (dso) ? dso->long_name : NULL;
 }
 
+static int init_user_exec(void)
+{
+        int ret = 0;
+
+        symbol_conf.try_vmlinux_path = false;
+        symbol_conf.sort_by_name = true;
+        ret = symbol__init();
+
+        if (ret < 0)
+                pr_debug("Failed to init symbol map.\n");
+
+        return ret;
+}
+
+static int convert_to_perf_probe_point(struct probe_trace_point *tp,
+                                        struct perf_probe_point *pp)
+{
+        pp->function = strdup(tp->symbol);
+
+        if (pp->function == NULL)
+                return -ENOMEM;
+
+        pp->offset = tp->offset;
+        pp->retprobe = tp->retprobe;
+
+        return 0;
+}
+
 #ifdef DWARF_SUPPORT
 /* Open new debuginfo of given module */
 static struct debuginfo *open_debuginfo(const char *module)
@@ -224,10 +255,7 @@ static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
         if (ret <= 0) {
                 pr_debug("Failed to find corresponding probes from "
                          "debuginfo. Use kprobe event information.\n");
-                pp->function = strdup(tp->symbol);
-                if (pp->function == NULL)
-                        return -ENOMEM;
-                pp->offset = tp->offset;
+                return convert_to_perf_probe_point(tp, pp);
         }
         pp->retprobe = tp->retprobe;
 
@@ -275,9 +303,20 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                           int max_tevs, const char *target)
 {
         bool need_dwarf = perf_probe_event_need_dwarf(pev);
-        struct debuginfo *dinfo = open_debuginfo(target);
+        struct debuginfo *dinfo;
         int ntevs, ret = 0;
 
+        if (pev->uprobes) {
+                if (need_dwarf) {
+                        pr_warning("Debuginfo-analysis is not yet supported"
+                                        " with -x/--exec option.\n");
+                        return -ENOSYS;
+                }
+                return convert_name_to_addr(pev, target);
+        }
+
+        dinfo = open_debuginfo(target);
+
         if (!dinfo) {
                 if (need_dwarf) {
                         pr_warning("Failed to open debuginfo file.\n");
@@ -603,23 +642,22 @@ static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
                 pr_err("Failed to find symbol %s in kernel.\n", tp->symbol);
                 return -ENOENT;
         }
-        pp->function = strdup(tp->symbol);
-        if (pp->function == NULL)
-                return -ENOMEM;
-        pp->offset = tp->offset;
-        pp->retprobe = tp->retprobe;
 
-        return 0;
+        return convert_to_perf_probe_point(tp, pp);
 }
 
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                 struct probe_trace_event **tevs __unused,
-                                int max_tevs __unused, const char *mod __unused)
+                                int max_tevs __unused, const char *target)
 {
         if (perf_probe_event_need_dwarf(pev)) {
                 pr_warning("Debuginfo-analysis is not supported.\n");
                 return -ENOSYS;
         }
+
+        if (pev->uprobes)
+                return convert_name_to_addr(pev, target);
+
         return 0;
 }
 
@@ -1341,11 +1379,18 @@ char *synthesize_probe_trace_command(struct probe_trace_event *tev)
         if (buf == NULL)
                 return NULL;
 
-        len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s%s%s+%lu",
-                         tp->retprobe ? 'r' : 'p',
-                         tev->group, tev->event,
-                         tp->module ?: "", tp->module ? ":" : "",
-                         tp->symbol, tp->offset);
+        if (tev->uprobes)
+                len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s:%s",
+                                 tp->retprobe ? 'r' : 'p',
+                                 tev->group, tev->event,
+                                 tp->module, tp->symbol);
+        else
+                len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s%s%s+%lu",
+                                 tp->retprobe ? 'r' : 'p',
+                                 tev->group, tev->event,
+                                 tp->module ?: "", tp->module ? ":" : "",
+                                 tp->symbol, tp->offset);
+
         if (len <= 0)
                 goto error;
 
@@ -1364,7 +1409,7 @@ error:
 }
 
 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
-                                       struct perf_probe_event *pev)
+                               struct perf_probe_event *pev, bool is_kprobe)
 {
         char buf[64] = "";
         int i, ret;
@@ -1376,7 +1421,11 @@ static int convert_to_perf_probe_event(struct probe_trace_event *tev,
                 return -ENOMEM;
 
         /* Convert trace_point to probe_point */
-        ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
+        if (is_kprobe)
+                ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
+        else
+                ret = convert_to_perf_probe_point(&tev->point, &pev->point);
+
         if (ret < 0)
                 return ret;
 
@@ -1472,7 +1521,26 @@ static void clear_probe_trace_event(struct probe_trace_event *tev)
         memset(tev, 0, sizeof(*tev));
 }
 
-static int open_kprobe_events(bool readwrite)
+static void print_warn_msg(const char *file, bool is_kprobe)
+{
+
+        if (errno == ENOENT) {
+                const char *config;
+
+                if (!is_kprobe)
+                        config = "CONFIG_UPROBE_EVENTS";
+                else
+                        config = "CONFIG_KPROBE_EVENTS";
+
+                pr_warning("%s file does not exist - please rebuild kernel"
+                                " with %s.\n", file, config);
+        } else
+                pr_warning("Failed to open %s file: %s\n", file,
+                                strerror(errno));
+}
+
+static int open_probe_events(const char *trace_file, bool readwrite,
+                                bool is_kprobe)
 {
         char buf[PATH_MAX];
         const char *__debugfs;
@@ -1484,27 +1552,31 @@ static int open_kprobe_events(bool readwrite)
                 return -ENOENT;
         }
 
-        ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
+        ret = e_snprintf(buf, PATH_MAX, "%s/%s", __debugfs, trace_file);
         if (ret >= 0) {
                 pr_debug("Opening %s write=%d\n", buf, readwrite);
                 if (readwrite && !probe_event_dry_run)
                         ret = open(buf, O_RDWR, O_APPEND);
                 else
                         ret = open(buf, O_RDONLY, 0);
-        }
 
-        if (ret < 0) {
-                if (errno == ENOENT)
-                        pr_warning("kprobe_events file does not exist - please"
-                                 " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
-                else
-                        pr_warning("Failed to open kprobe_events file: %s\n",
-                                   strerror(errno));
+                if (ret < 0)
+                        print_warn_msg(buf, is_kprobe);
         }
         return ret;
 }
 
-/* Get raw string list of current kprobe_events */
+static int open_kprobe_events(bool readwrite)
+{
+        return open_probe_events("tracing/kprobe_events", readwrite, true);
+}
+
+static int open_uprobe_events(bool readwrite)
+{
+        return open_probe_events("tracing/uprobe_events", readwrite, false);
+}
+
+/* Get raw string list of current kprobe_events  or uprobe_events */
 static struct strlist *get_probe_trace_command_rawlist(int fd)
 {
         int ret, idx;
@@ -1569,36 +1641,26 @@ static int show_perf_probe_event(struct perf_probe_event *pev)
         return ret;
 }
 
-/* List up current perf-probe events */
-int show_perf_probe_events(void)
+static int __show_perf_probe_events(int fd, bool is_kprobe)
 {
-        int fd, ret;
+        int ret = 0;
         struct probe_trace_event tev;
         struct perf_probe_event pev;
         struct strlist *rawlist;
         struct str_node *ent;
 
-        setup_pager();
-        ret = init_vmlinux();
-        if (ret < 0)
-                return ret;
-
         memset(&tev, 0, sizeof(tev));
         memset(&pev, 0, sizeof(pev));
 
-        fd = open_kprobe_events(false);
-        if (fd < 0)
-                return fd;
-
         rawlist = get_probe_trace_command_rawlist(fd);
-        close(fd);
         if (!rawlist)
                 return -ENOENT;
 
         strlist__for_each(ent, rawlist) {
                 ret = parse_probe_trace_command(ent->s, &tev);
                 if (ret >= 0) {
-                        ret = convert_to_perf_probe_event(&tev, &pev);
+                        ret = convert_to_perf_probe_event(&tev, &pev,
+                                                                is_kprobe);
                         if (ret >= 0)
                                 ret = show_perf_probe_event(&pev);
                 }
@@ -1612,6 +1674,33 @@ int show_perf_probe_events(void)
         return ret;
 }
 
+/* List up current perf-probe events */
+int show_perf_probe_events(void)
+{
+        int fd, ret;
+
+        setup_pager();
+        fd = open_kprobe_events(false);
+
+        if (fd < 0)
+                return fd;
+
+        ret = init_vmlinux();
+        if (ret < 0)
+                return ret;
+
+        ret = __show_perf_probe_events(fd, true);
+        close(fd);
+
+        fd = open_uprobe_events(false);
+        if (fd >= 0) {
+                ret = __show_perf_probe_events(fd, false);
+                close(fd);
+        }
+
+        return ret;
+}
+
 /* Get current perf-probe event names */
 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 {
@@ -1717,7 +1806,11 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         const char *event, *group;
         struct strlist *namelist;
 
-        fd = open_kprobe_events(true);
+        if (pev->uprobes)
+                fd = open_uprobe_events(true);
+        else
+                fd = open_kprobe_events(true);
+
         if (fd < 0)
                 return fd;
         /* Get current event names */
@@ -1829,6 +1922,8 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
         tev->point.offset = pev->point.offset;
         tev->point.retprobe = pev->point.retprobe;
         tev->nargs = pev->nargs;
+        tev->uprobes = pev->uprobes;
+
         if (tev->nargs) {
                 tev->args = zalloc(sizeof(struct probe_trace_arg)
                                    * tev->nargs);
@@ -1859,6 +1954,9 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                 }
         }
 
+        if (pev->uprobes)
+                return 1;
+
         /* Currently just checking function name from symbol map */
         sym = __find_kernel_function_by_name(tev->point.symbol, NULL);
         if (!sym) {
@@ -1894,12 +1992,18 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
         int i, j, ret;
         struct __event_package *pkgs;
 
+        ret = 0;
         pkgs = zalloc(sizeof(struct __event_package) * npevs);
+
         if (pkgs == NULL)
                 return -ENOMEM;
 
-        /* Init vmlinux path */
-        ret = init_vmlinux();
+        if (!pevs->uprobes)
+                /* Init vmlinux path */
+                ret = init_vmlinux();
+        else
+                ret = init_user_exec();
+
         if (ret < 0) {
                 free(pkgs);
                 return ret;
@@ -1971,23 +2075,15 @@ error:
         return ret;
 }
 
-static int del_trace_probe_event(int fd, const char *group,
-                                  const char *event, struct strlist *namelist)
+static int del_trace_probe_event(int fd, const char *buf,
+                                                  struct strlist *namelist)
 {
-        char buf[128];
         struct str_node *ent, *n;
-        int found = 0, ret = 0;
-
-        ret = e_snprintf(buf, 128, "%s:%s", group, event);
-        if (ret < 0) {
-                pr_err("Failed to copy event.\n");
-                return ret;
-        }
+        int ret = -1;
 
         if (strpbrk(buf, "*?")) { /* Glob-exp */
                 strlist__for_each_safe(ent, n, namelist)
                         if (strglobmatch(ent->s, buf)) {
-                                found++;
                                 ret = __del_trace_probe_event(fd, ent);
                                 if (ret < 0)
                                         break;
@@ -1996,40 +2092,43 @@ static int del_trace_probe_event(int fd, const char *group,
         } else {
                 ent = strlist__find(namelist, buf);
                 if (ent) {
-                        found++;
                         ret = __del_trace_probe_event(fd, ent);
                         if (ret >= 0)
                                 strlist__remove(namelist, ent);
                 }
         }
-        if (found == 0 && ret >= 0)
-                pr_info("Info: Event \"%s\" does not exist.\n", buf);
 
         return ret;
 }
 
 int del_perf_probe_events(struct strlist *dellist)
 {
-        int fd, ret = 0;
+        int ret = -1, ufd = -1, kfd = -1;
+        char buf[128];
         const char *group, *event;
         char *p, *str;
         struct str_node *ent;
-        struct strlist *namelist;
-
-        fd = open_kprobe_events(true);
-        if (fd < 0)
-                return fd;
+        struct strlist *namelist = NULL, *unamelist = NULL;
 
         /* Get current event names */
-        namelist = get_probe_trace_event_names(fd, true);
-        if (namelist == NULL)
-                return -EINVAL;
+        kfd = open_kprobe_events(true);
+        if (kfd < 0)
+                return kfd;
+
+        namelist = get_probe_trace_event_names(kfd, true);
+        ufd = open_uprobe_events(true);
+
+        if (ufd >= 0)
+                unamelist = get_probe_trace_event_names(ufd, true);
+
+        if (namelist == NULL && unamelist == NULL)
+                goto error;
 
         strlist__for_each(ent, dellist) {
                 str = strdup(ent->s);
                 if (str == NULL) {
                         ret = -ENOMEM;
-                        break;
+                        goto error;
                 }
                 pr_debug("Parsing: %s\n", str);
                 p = strchr(str, ':');
@@ -2041,17 +2140,46 @@ int del_perf_probe_events(struct strlist *dellist)
                         group = "*";
                         event = str;
                 }
+
+                ret = e_snprintf(buf, 128, "%s:%s", group, event);
+                if (ret < 0) {
+                        pr_err("Failed to copy event.");
+                        free(str);
+                        goto error;
+                }
+
                 pr_debug("Group: %s, Event: %s\n", group, event);
-                ret = del_trace_probe_event(fd, group, event, namelist);
+
+                if (namelist)
+                        ret = del_trace_probe_event(kfd, buf, namelist);
+
+                if (unamelist && ret != 0)
+                        ret = del_trace_probe_event(ufd, buf, unamelist);
+
+                if (ret != 0)
+                        pr_info("Info: Event \"%s\" does not exist.\n", buf);
+
                 free(str);
-                if (ret < 0)
-                        break;
         }
-        strlist__delete(namelist);
-        close(fd);
+
+error:
+        if (kfd >= 0) {
+                if (namelist)
+                        strlist__delete(namelist);
+
+                close(kfd);
+        }
+
+        if (ufd >= 0) {
+                if (unamelist)
+                        strlist__delete(unamelist);
+
+                close(ufd);
+        }
 
         return ret;
 }
+
 /* TODO: don't use a global variable for filter ... */
 static struct strfilter *available_func_filter;
 
@@ -2068,30 +2196,152 @@ static int filter_available_functions(struct map *map __unused,
         return 1;
 }
 
-int show_available_funcs(const char *target, struct strfilter *_filter)
+static int __show_available_funcs(struct map *map)
+{
+        if (map__load(map, filter_available_functions)) {
+                pr_err("Failed to load map.\n");
+                return -EINVAL;
+        }
+        if (!dso__sorted_by_name(map->dso, map->type))
+                dso__sort_by_name(map->dso, map->type);
+
+        dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
+        return 0;
+}
+
+static int available_kernel_funcs(const char *module)
 {
         struct map *map;
         int ret;
 
-        setup_pager();
-
         ret = init_vmlinux();
         if (ret < 0)
                 return ret;
 
-        map = kernel_get_module_map(target);
+        map = kernel_get_module_map(module);
         if (!map) {
-                pr_err("Failed to find %s map.\n", (target) ? : "kernel");
+                pr_err("Failed to find %s map.\n", (module) ? : "kernel");
                 return -EINVAL;
         }
+        return __show_available_funcs(map);
+}
+
+static int available_user_funcs(const char *target)
+{
+        struct map *map;
+        int ret;
+
+        ret = init_user_exec();
+        if (ret < 0)
+                return ret;
+
+        map = dso__new_map(target);
+        ret = __show_available_funcs(map);
+        dso__delete(map->dso);
+        map__delete(map);
+        return ret;
+}
+
+int show_available_funcs(const char *target, struct strfilter *_filter,
+                                        bool user)
+{
+        setup_pager();
         available_func_filter = _filter;
+
+        if (!user)
+                return available_kernel_funcs(target);
+
+        return available_user_funcs(target);
+}
+
+/*
+ * uprobe_events only accepts address:
+ * Convert function and any offset to address
+ */
+static int convert_name_to_addr(struct perf_probe_event *pev, const char *exec)
+{
+        struct perf_probe_point *pp = &pev->point;
+        struct symbol *sym;
+        struct map *map = NULL;
+        char *function = NULL, *name = NULL;
+        int ret = -EINVAL;
+        unsigned long long vaddr = 0;
+
+        if (!pp->function) {
+                pr_warning("No function specified for uprobes");
+                goto out;
+        }
+
+        function = strdup(pp->function);
+        if (!function) {
+                pr_warning("Failed to allocate memory by strdup.\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        name = realpath(exec, NULL);
+        if (!name) {
+                pr_warning("Cannot find realpath for %s.\n", exec);
+                goto out;
+        }
+        map = dso__new_map(name);
+        if (!map) {
+                pr_warning("Cannot find appropriate DSO for %s.\n", exec);
+                goto out;
+        }
+        available_func_filter = strfilter__new(function, NULL);
         if (map__load(map, filter_available_functions)) {
                 pr_err("Failed to load map.\n");
-                return -EINVAL;
+                goto out;
         }
-        if (!dso__sorted_by_name(map->dso, map->type))
-                dso__sort_by_name(map->dso, map->type);
 
-        dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
-        return 0;
+        sym = map__find_symbol_by_name(map, function, NULL);
+        if (!sym) {
+                pr_warning("Cannot find %s in DSO %s\n", function, exec);
+                goto out;
+        }
+
+        if (map->start > sym->start)
+                vaddr = map->start;
+        vaddr += sym->start + pp->offset + map->pgoff;
+        pp->offset = 0;
+
+        if (!pev->event) {
+                pev->event = function;
+                function = NULL;
+        }
+        if (!pev->group) {
+                char *ptr1, *ptr2;
+
+                pev->group = zalloc(sizeof(char *) * 64);
+                ptr1 = strdup(basename(exec));
+                if (ptr1) {
+                        ptr2 = strpbrk(ptr1, "-._");
+                        if (ptr2)
+                                *ptr2 = '\0';
+                        e_snprintf(pev->group, 64, "%s_%s", PERFPROBE_GROUP,
+                                        ptr1);
+                        free(ptr1);
+                }
+        }
+        free(pp->function);
+        pp->function = zalloc(sizeof(char *) * MAX_PROBE_ARGS);
+        if (!pp->function) {
+                ret = -ENOMEM;
+                pr_warning("Failed to allocate memory by zalloc.\n");
+                goto out;
+        }
+        e_snprintf(pp->function, MAX_PROBE_ARGS, "0x%llx", vaddr);
+        ret = 0;
+
+out:
+        if (map) {
+                dso__delete(map->dso);
+                map__delete(map);
+        }
+        if (function)
+                free(function);
+        if (name)
+                free(name);
+        return ret;
 }
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index a7dee835f49c..f9f3de8b4220 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -7,7 +7,7 @@
 
 extern bool probe_event_dry_run;
 
-/* kprobe-tracer tracing point */
+/* kprobe-tracer and uprobe-tracer tracing point */
 struct probe_trace_point {
         char            *symbol;        /* Base symbol */
         char            *module;        /* Module name */
@@ -21,7 +21,7 @@ struct probe_trace_arg_ref {
         long                            offset; /* Offset value */
 };
 
-/* kprobe-tracer tracing argument */
+/* kprobe-tracer and uprobe-tracer tracing argument */
 struct probe_trace_arg {
         char                            *name;  /* Argument name */
         char                            *value; /* Base value */
@@ -29,12 +29,13 @@ struct probe_trace_arg {
         struct probe_trace_arg_ref      *ref;   /* Referencing offset */
 };
 
-/* kprobe-tracer tracing event (point + arg) */
+/* kprobe-tracer and uprobe-tracer tracing event (point + arg) */
 struct probe_trace_event {
         char                            *event; /* Event name */
         char                            *group; /* Group name */
         struct probe_trace_point        point;  /* Trace point */
         int                             nargs;  /* Number of args */
+        bool                            uprobes;        /* uprobes only */
         struct probe_trace_arg          *args;  /* Arguments */
 };
 
@@ -70,6 +71,7 @@ struct perf_probe_event {
         char                    *group; /* Group name */
         struct perf_probe_point point;  /* Probe point */
         int                     nargs;  /* Number of arguments */
+        bool                    uprobes;
         struct perf_probe_arg   *args;  /* Arguments */
 };
 
@@ -129,8 +131,8 @@ extern int show_line_range(struct line_range *lr, const char *module);
 extern int show_available_vars(struct perf_probe_event *pevs, int npevs,
                                int max_probe_points, const char *module,
                                struct strfilter *filter, bool externs);
-extern int show_available_funcs(const char *module, struct strfilter *filter);
-
+extern int show_available_funcs(const char *module, struct strfilter *filter,
+                                bool user);
 
 /* Maximum index number of event-name postfix */
 #define MAX_EVENT_INDEX 1024
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index e30749e38a9b..4c1b3d72a1d2 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -56,7 +56,7 @@ INTERP my_perl;
 #define FTRACE_MAX_EVENT                                \
         ((1 << (sizeof(unsigned short) * 8)) - 1)
 
-struct event *events[FTRACE_MAX_EVENT];
+struct event_format *events[FTRACE_MAX_EVENT];
 
 extern struct scripting_context *scripting_context;
 
@@ -181,7 +181,7 @@ static void define_flag_field(const char *ev_name,
         LEAVE;
 }
 
-static void define_event_symbols(struct event *event,
+static void define_event_symbols(struct event_format *event,
                                  const char *ev_name,
                                  struct print_arg *args)
 {
@@ -209,6 +209,8 @@ static void define_event_symbols(struct event *event,
                 define_symbolic_values(args->symbol.symbols, ev_name,
                                        cur_field_name);
                 break;
+        case PRINT_BSTRING:
+        case PRINT_DYNAMIC_ARRAY:
         case PRINT_STRING:
                 break;
         case PRINT_TYPE:
@@ -220,7 +222,9 @@ static void define_event_symbols(struct event *event,
                 define_event_symbols(event, ev_name, args->op.left);
                 define_event_symbols(event, ev_name, args->op.right);
                 break;
+        case PRINT_FUNC:
         default:
+                pr_err("Unsupported print arg type\n");
                 /* we should warn... */
                 return;
         }
@@ -229,10 +233,10 @@ static void define_event_symbols(struct event *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline struct event *find_cache_event(int type)
+static inline struct event_format *find_cache_event(int type)
 {
         static char ev_name[256];
-        struct event *event;
+        struct event_format *event;
 
         if (events[type])
                 return events[type];
@@ -258,7 +262,7 @@ static void perl_process_tracepoint(union perf_event *pevent __unused,
         static char handler[256];
         unsigned long long val;
         unsigned long s, ns;
-        struct event *event;
+        struct event_format *event;
         int type;
         int pid;
         int cpu = sample->cpu;
@@ -446,7 +450,7 @@ static int perl_stop_script(void)
 
 static int perl_generate_script(const char *outfile)
 {
-        struct event *event = NULL;
+        struct event_format *event = NULL;
         struct format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index c2623c6f9b51..acb9795286c4 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -37,7 +37,7 @@ PyMODINIT_FUNC initperf_trace_context(void);
 #define FTRACE_MAX_EVENT                                \
         ((1 << (sizeof(unsigned short) * 8)) - 1)
 
-struct event *events[FTRACE_MAX_EVENT];
+struct event_format *events[FTRACE_MAX_EVENT];
 
 #define MAX_FIELDS      64
 #define N_COMMON_FIELDS 7
@@ -136,7 +136,7 @@ static void define_field(enum print_arg_type field_type,
         Py_DECREF(t);
 }
 
-static void define_event_symbols(struct event *event,
+static void define_event_symbols(struct event_format *event,
                                  const char *ev_name,
                                  struct print_arg *args)
 {
@@ -178,6 +178,10 @@ static void define_event_symbols(struct event *event,
                 define_event_symbols(event, ev_name, args->op.right);
                 break;
         default:
+                /* gcc warns for these? */
+        case PRINT_BSTRING:
+        case PRINT_DYNAMIC_ARRAY:
+        case PRINT_FUNC:
                 /* we should warn... */
                 return;
         }
@@ -186,10 +190,10 @@ static void define_event_symbols(struct event *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline struct event *find_cache_event(int type)
+static inline struct event_format *find_cache_event(int type)
 {
         static char ev_name[256];
-        struct event *event;
+        struct event_format *event;
 
         if (events[type])
                 return events[type];
@@ -216,7 +220,7 @@ static void python_process_event(union perf_event *pevent __unused,
         struct format_field *field;
         unsigned long long val;
         unsigned long s, ns;
-        struct event *event;
+        struct event_format *event;
         unsigned n = 0;
         int type;
         int pid;
@@ -436,7 +440,7 @@ out:
 
 static int python_generate_script(const char *outfile)
 {
-        struct event *event = NULL;
+        struct event_format *event = NULL;
         struct format_field *f;
         char fname[PATH_MAX];
         int not_first, count;
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 1efd3bee6336..93d355d27109 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -481,6 +481,38 @@ static void perf_event__read_swap(union perf_event *event)
         event->read.id           = bswap_64(event->read.id);
 }
 
+static u8 revbyte(u8 b)
+{
+        int rev = (b >> 4) | ((b & 0xf) << 4);
+        rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
+        rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
+        return (u8) rev;
+}
+
+/*
+ * XXX this is hack in attempt to carry flags bitfield
+ * throught endian village. ABI says:
+ *
+ * Bit-fields are allocated from right to left (least to most significant)
+ * on little-endian implementations and from left to right (most to least
+ * significant) on big-endian implementations.
+ *
+ * The above seems to be byte specific, so we need to reverse each
+ * byte of the bitfield. 'Internet' also says this might be implementation
+ * specific and we probably need proper fix and carry perf_event_attr
+ * bitfield flags in separate data file FEAT_ section. Thought this seems
+ * to work for now.
+ */
+static void swap_bitfield(u8 *p, unsigned len)
+{
+        unsigned i;
+
+        for (i = 0; i < len; i++) {
+                *p = revbyte(*p);
+                p++;
+        }
+}
+
 /* exported for swapping attributes in file header */
 void perf_event__attr_swap(struct perf_event_attr *attr)
 {
@@ -494,6 +526,8 @@ void perf_event__attr_swap(struct perf_event_attr *attr)
         attr->bp_type           = bswap_32(attr->bp_type);
         attr->bp_addr           = bswap_64(attr->bp_addr);
         attr->bp_len            = bswap_64(attr->bp_len);
+
+        swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
 }
 
 static void perf_event__hdr_attr_swap(union perf_event *event)
@@ -1064,8 +1098,9 @@ volatile int session_done;
 static int __perf_session__process_pipe_events(struct perf_session *self,
                                                struct perf_tool *tool)
 {
-        union perf_event event;
-        uint32_t size;
+        union perf_event *event;
+        uint32_t size, cur_size = 0;
+        void *buf = NULL;
         int skip = 0;
         u64 head;
         int err;
@@ -1074,8 +1109,14 @@ static int __perf_session__process_pipe_events(struct perf_session *self,
         perf_tool__fill_defaults(tool);
 
         head = 0;
+        cur_size = sizeof(union perf_event);
+
+        buf = malloc(cur_size);
+        if (!buf)
+                return -errno;
 more:
-        err = readn(self->fd, &event, sizeof(struct perf_event_header));
+        event = buf;
+        err = readn(self->fd, event, sizeof(struct perf_event_header));
         if (err <= 0) {
                 if (err == 0)
                         goto done;
@@ -1085,13 +1126,23 @@ more:
         }
 
         if (self->header.needs_swap)
-                perf_event_header__bswap(&event.header);
+                perf_event_header__bswap(&event->header);
 
-        size = event.header.size;
+        size = event->header.size;
         if (size == 0)
                 size = 8;
 
-        p = &event;
+        if (size > cur_size) {
+                void *new = realloc(buf, size);
+                if (!new) {
+                        pr_err("failed to allocate memory to read event\n");
+                        goto out_err;
+                }
+                buf = new;
+                cur_size = size;
+                event = buf;
+        }
+        p = event;
         p += sizeof(struct perf_event_header);
 
         if (size - sizeof(struct perf_event_header)) {
@@ -1107,17 +1158,11 @@ more:
                 }
         }
 
-        if ((skip = perf_session__process_event(self, &event, tool, head)) < 0) {
-                dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
-                            head, event.header.size, event.header.type);
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
+        if ((skip = perf_session__process_event(self, event, tool, head)) < 0) {
+                pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
+                       head, event->header.size, event->header.type);
+                err = -EINVAL;
+                goto out_err;
         }
 
         head += size;
@@ -1130,6 +1175,7 @@ more:
 done:
         err = 0;
 out_err:
+        free(buf);
         perf_session__warn_about_errors(self, tool);
         perf_session_free_sample_buffers(self);
         return err;
@@ -1226,17 +1272,11 @@ more:
 
         if (size == 0 ||
             perf_session__process_event(session, event, tool, file_pos) < 0) {
-                dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
-                            file_offset + head, event->header.size,
-                            event->header.type);
-                /*
-                 * assume we lost track of the stream, check alignment, and
-                 * increment a single u64 in the hope to catch on again 'soon'.
-                 */
-                if (unlikely(head & 7))
-                        head &= ~7ULL;
-
-                size = 8;
+                pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
+                       file_offset + head, event->header.size,
+                       event->header.type);
+                err = -EINVAL;
+                goto out_err;
         }
 
         head += size;
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index ab9867b2b433..e2ba8858f3e1 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -2783,3 +2783,11 @@ int machine__load_vmlinux_path(struct machine *machine, enum map_type type,
 
         return ret;
 }
+
+struct map *dso__new_map(const char *name)
+{
+        struct dso *dso = dso__new(name);
+        struct map *map = map__new2(0, dso, MAP__FUNCTION);
+
+        return map;
+}
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index ac49ef208a5f..5649d63798cb 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -65,6 +65,11 @@ struct symbol {
 
 void symbol__delete(struct symbol *sym);
 
+static inline size_t symbol__size(const struct symbol *sym)
+{
+        return sym->end - sym->start + 1;
+}
+
 struct strlist;
 
 struct symbol_conf {
@@ -237,6 +242,7 @@ void dso__set_long_name(struct dso *dso, char *name);
 void dso__set_build_id(struct dso *dso, void *build_id);
 void dso__read_running_kernel_build_id(struct dso *dso,
                                        struct machine *machine);
+struct map *dso__new_map(const char *name);
 struct symbol *dso__find_symbol(struct dso *dso, enum map_type type,
                                 u64 addr);
 struct symbol *dso__find_symbol_by_name(struct dso *dso, enum map_type type,
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
new file mode 100644
index 000000000000..1064d5b148ad
--- /dev/null
+++ b/tools/perf/util/target.c
@@ -0,0 +1,142 @@
+/*
+ * Helper functions for handling target threads/cpus
+ *
+ * Copyright (C) 2012, LG Electronics, Namhyung Kim <namhyung.kim@lge.com>
+ *
+ * Released under the GPL v2.
+ */
+
+#include "target.h"
+#include "debug.h"
+
+#include <pwd.h>
+#include <string.h>
+
+
+enum perf_target_errno perf_target__validate(struct perf_target *target)
+{
+        enum perf_target_errno ret = PERF_ERRNO_TARGET__SUCCESS;
+
+        if (target->pid)
+                target->tid = target->pid;
+
+        /* CPU and PID are mutually exclusive */
+        if (target->tid && target->cpu_list) {
+                target->cpu_list = NULL;
+                if (ret == PERF_ERRNO_TARGET__SUCCESS)
+                        ret = PERF_ERRNO_TARGET__PID_OVERRIDE_CPU;
+        }
+
+        /* UID and PID are mutually exclusive */
+        if (target->tid && target->uid_str) {
+                target->uid_str = NULL;
+                if (ret == PERF_ERRNO_TARGET__SUCCESS)
+                        ret = PERF_ERRNO_TARGET__PID_OVERRIDE_UID;
+        }
+
+        /* UID and CPU are mutually exclusive */
+        if (target->uid_str && target->cpu_list) {
+                target->cpu_list = NULL;
+                if (ret == PERF_ERRNO_TARGET__SUCCESS)
+                        ret = PERF_ERRNO_TARGET__UID_OVERRIDE_CPU;
+        }
+
+        /* PID and SYSTEM are mutually exclusive */
+        if (target->tid && target->system_wide) {
+                target->system_wide = false;
+                if (ret == PERF_ERRNO_TARGET__SUCCESS)
+                        ret = PERF_ERRNO_TARGET__PID_OVERRIDE_SYSTEM;
+        }
+
+        /* UID and SYSTEM are mutually exclusive */
+        if (target->uid_str && target->system_wide) {
+                target->system_wide = false;
+                if (ret == PERF_ERRNO_TARGET__SUCCESS)
+                        ret = PERF_ERRNO_TARGET__UID_OVERRIDE_SYSTEM;
+        }
+
+        return ret;
+}
+
+enum perf_target_errno perf_target__parse_uid(struct perf_target *target)
+{
+        struct passwd pwd, *result;
+        char buf[1024];
+        const char *str = target->uid_str;
+
+        target->uid = UINT_MAX;
+        if (str == NULL)
+                return PERF_ERRNO_TARGET__SUCCESS;
+
+        /* Try user name first */
+        getpwnam_r(str, &pwd, buf, sizeof(buf), &result);
+
+        if (result == NULL) {
+                /*
+                 * The user name not found. Maybe it's a UID number.
+                 */
+                char *endptr;
+                int uid = strtol(str, &endptr, 10);
+
+                if (*endptr != '\0')
+                        return PERF_ERRNO_TARGET__INVALID_UID;
+
+                getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
+
+                if (result == NULL)
+                        return PERF_ERRNO_TARGET__USER_NOT_FOUND;
+        }
+
+        target->uid = result->pw_uid;
+        return PERF_ERRNO_TARGET__SUCCESS;
+}
+
+/*
+ * This must have a same ordering as the enum perf_target_errno.
+ */
+static const char *perf_target__error_str[] = {
+        "PID/TID switch overriding CPU",
+        "PID/TID switch overriding UID",
+        "UID switch overriding CPU",
+        "PID/TID switch overriding SYSTEM",
+        "UID switch overriding SYSTEM",
+        "Invalid User: %s",
+        "Problems obtaining information for user %s",
+};
+
+int perf_target__strerror(struct perf_target *target, int errnum,
+                          char *buf, size_t buflen)
+{
+        int idx;
+        const char *msg;
+
+        if (errnum >= 0) {
+                strerror_r(errnum, buf, buflen);
+                return 0;
+        }
+
+        if (errnum <  __PERF_ERRNO_TARGET__START ||
+            errnum >= __PERF_ERRNO_TARGET__END)
+                return -1;
+
+        idx = errnum - __PERF_ERRNO_TARGET__START;
+        msg = perf_target__error_str[idx];
+
+        switch (errnum) {
+        case PERF_ERRNO_TARGET__PID_OVERRIDE_CPU
+         ... PERF_ERRNO_TARGET__UID_OVERRIDE_SYSTEM:
+                snprintf(buf, buflen, "%s", msg);
+                break;
+
+        case PERF_ERRNO_TARGET__INVALID_UID:
+        case PERF_ERRNO_TARGET__USER_NOT_FOUND:
+                snprintf(buf, buflen, msg, target->uid_str);
+                break;
+
+        default:
+                /* cannot reach here */
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/target.h b/tools/perf/util/target.h
new file mode 100644
index 000000000000..a4be8575fda5
--- /dev/null
+++ b/tools/perf/util/target.h
@@ -0,0 +1,65 @@
+#ifndef _PERF_TARGET_H
+#define _PERF_TARGET_H
+
+#include <stdbool.h>
+#include <sys/types.h>
+
+struct perf_target {
+        const char   *pid;
+        const char   *tid;
+        const char   *cpu_list;
+        const char   *uid_str;
+        uid_t        uid;
+        bool         system_wide;
+        bool         uses_mmap;
+};
+
+enum perf_target_errno {
+        PERF_ERRNO_TARGET__SUCCESS              = 0,
+
+        /*
+         * Choose an arbitrary negative big number not to clash with standard
+         * errno since SUS requires the errno has distinct positive values.
+         * See 'Issue 6' in the link below.
+         *
+         * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
+         */
+        __PERF_ERRNO_TARGET__START              = -10000,
+
+
+        /* for perf_target__validate() */
+        PERF_ERRNO_TARGET__PID_OVERRIDE_CPU     = __PERF_ERRNO_TARGET__START,
+        PERF_ERRNO_TARGET__PID_OVERRIDE_UID,
+        PERF_ERRNO_TARGET__UID_OVERRIDE_CPU,
+        PERF_ERRNO_TARGET__PID_OVERRIDE_SYSTEM,
+        PERF_ERRNO_TARGET__UID_OVERRIDE_SYSTEM,
+
+        /* for perf_target__parse_uid() */
+        PERF_ERRNO_TARGET__INVALID_UID,
+        PERF_ERRNO_TARGET__USER_NOT_FOUND,
+
+        __PERF_ERRNO_TARGET__END,
+};
+
+enum perf_target_errno perf_target__validate(struct perf_target *target);
+enum perf_target_errno perf_target__parse_uid(struct perf_target *target);
+
+int perf_target__strerror(struct perf_target *target, int errnum, char *buf,
+                          size_t buflen);
+
+static inline bool perf_target__has_task(struct perf_target *target)
+{
+        return target->tid || target->pid || target->uid_str;
+}
+
+static inline bool perf_target__has_cpu(struct perf_target *target)
+{
+        return target->system_wide || target->cpu_list;
+}
+
+static inline bool perf_target__none(struct perf_target *target)
+{
+        return !perf_target__has_task(target) && !perf_target__has_cpu(target);
+}
+
+#endif /* _PERF_TARGET_H */
diff --git a/tools/perf/util/thread_map.c b/tools/perf/util/thread_map.c
index 84d9bd782004..9b5f856cc280 100644
--- a/tools/perf/util/thread_map.c
+++ b/tools/perf/util/thread_map.c
@@ -188,28 +188,27 @@ static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
                 nt = realloc(threads, (sizeof(*threads) +
                                        sizeof(pid_t) * total_tasks));
                 if (nt == NULL)
-                        goto out_free_threads;
+                        goto out_free_namelist;
 
                 threads = nt;
 
-                if (threads) {
-                        for (i = 0; i < items; i++)
-                                threads->map[j++] = atoi(namelist[i]->d_name);
-                        threads->nr = total_tasks;
-                }
-
-                for (i = 0; i < items; i++)
+                for (i = 0; i < items; i++) {
+                        threads->map[j++] = atoi(namelist[i]->d_name);
                         free(namelist[i]);
+                }
+                threads->nr = total_tasks;
                 free(namelist);
-
-                if (!threads)
-                        break;
         }
 
 out:
         strlist__delete(slist);
         return threads;
 
+out_free_namelist:
+        for (i = 0; i < items; i++)
+                free(namelist[i]);
+        free(namelist);
+
 out_free_threads:
         free(threads);
         threads = NULL;
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index 7da80f14418b..f718df8a3c59 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -6,7 +6,7 @@
 
 struct thread_map {
         int nr;
-        int map[];
+        pid_t map[];
 };
 
 struct thread_map *thread_map__new_by_pid(pid_t pid);
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 09fe579ccafb..abe0e8e95068 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -69,23 +69,24 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
 
         ret += SNPRINTF(bf + ret, size - ret, "], ");
 
-        if (top->target_pid)
+        if (top->target.pid)
                 ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %s",
-                                top->target_pid);
-        else if (top->target_tid)
+                                top->target.pid);
+        else if (top->target.tid)
                 ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %s",
-                                top->target_tid);
-        else if (top->uid_str != NULL)
+                                top->target.tid);
+        else if (top->target.uid_str != NULL)
                 ret += SNPRINTF(bf + ret, size - ret, " (uid: %s",
-                                top->uid_str);
+                                top->target.uid_str);
         else
                 ret += SNPRINTF(bf + ret, size - ret, " (all");
 
-        if (top->cpu_list)
+        if (top->target.cpu_list)
                 ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)",
-                                top->evlist->cpus->nr > 1 ? "s" : "", top->cpu_list);
+                                top->evlist->cpus->nr > 1 ? "s" : "",
+                                top->target.cpu_list);
         else {
-                if (top->target_tid)
+                if (top->target.tid)
                         ret += SNPRINTF(bf + ret, size - ret, ")");
                 else
                         ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)",
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index ce61cb2d1acf..33347ca89ee4 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -13,6 +13,7 @@ struct perf_session;
 struct perf_top {
         struct perf_tool   tool;
         struct perf_evlist *evlist;
+        struct perf_target target;
         /*
          * Symbols will be added here in perf_event__process_sample and will
          * get out after decayed.
@@ -23,10 +24,7 @@ struct perf_top {
         u64                guest_us_samples, guest_kernel_samples;
         int                print_entries, count_filter, delay_secs;
         int                freq;
-        const char         *target_pid, *target_tid;
-        uid_t              uid;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
-        bool               system_wide;
         bool               use_tui, use_stdio;
         bool               sort_has_symbols;
         bool               dont_use_callchains;
@@ -37,7 +35,6 @@ struct perf_top {
         bool               sample_id_all_missing;
         bool               exclude_guest_missing;
         bool               dump_symtab;
-        const char         *cpu_list;
         struct hist_entry  *sym_filter_entry;
         struct perf_evsel  *sym_evsel;
         struct perf_session *session;
@@ -47,7 +44,6 @@ struct perf_top {
         int                realtime_prio;
         int                sym_pcnt_filter;
         const char         *sym_filter;
-        const char         *uid_str;
 };
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index fc22cf5c605f..a8d81c35ef66 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -68,7 +68,7 @@ struct events {
 };
 
 
-void *malloc_or_die(unsigned int size)
+static void *malloc_or_die(unsigned int size)
 {
         void *data;
 
@@ -448,6 +448,8 @@ static void tracing_data_header(void)
         else
                 buf[0] = 0;
 
+        read_trace_init(buf[0], buf[0]);
+
         write_or_die(buf, 1);
 
         /* save size of long */
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index dfd1bd8371a4..df2fddbf0cd2 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -17,2169 +17,305 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- *  The parts for function graph printing was taken and modified from the
- *  Linux Kernel that were written by Frederic Weisbecker.
  */
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <ctype.h>
 #include <errno.h>
 
 #include "../perf.h"
 #include "util.h"
 #include "trace-event.h"
 
-int header_page_ts_offset;
-int header_page_ts_size;
-int header_page_size_offset;
 int header_page_size_size;
-int header_page_overwrite_offset;
-int header_page_overwrite_size;
+int header_page_ts_size;
 int header_page_data_offset;
-int header_page_data_size;
-
-bool latency_format;
-
-static char *input_buf;
-static unsigned long long input_buf_ptr;
-static unsigned long long input_buf_siz;
-
-static int cpus;
-static int long_size;
-static int is_flag_field;
-static int is_symbolic_field;
-
-static struct format_field *
-find_any_field(struct event *event, const char *name);
-
-static void init_input_buf(char *buf, unsigned long long size)
-{
-        input_buf = buf;
-        input_buf_siz = size;
-        input_buf_ptr = 0;
-}
-
-struct cmdline {
-        char *comm;
-        int pid;
-};
-
-static struct cmdline *cmdlines;
-static int cmdline_count;
-
-static int cmdline_cmp(const void *a, const void *b)
-{
-        const struct cmdline *ca = a;
-        const struct cmdline *cb = b;
-
-        if (ca->pid < cb->pid)
-                return -1;
-        if (ca->pid > cb->pid)
-                return 1;
-
-        return 0;
-}
 
-void parse_cmdlines(char *file, int size __unused)
-{
-        struct cmdline_list {
-                struct cmdline_list     *next;
-                char                    *comm;
-                int                     pid;
-        } *list = NULL, *item;
-        char *line;
-        char *next = NULL;
-        int i;
+struct pevent *perf_pevent;
+static struct pevent *pevent;
 
-        line = strtok_r(file, "\n", &next);
-        while (line) {
-                item = malloc_or_die(sizeof(*item));
-                sscanf(line, "%d %as", &item->pid,
-                       (float *)(void *)&item->comm); /* workaround gcc warning */
-                item->next = list;
-                list = item;
-                line = strtok_r(NULL, "\n", &next);
-                cmdline_count++;
-        }
-
-        cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count);
-
-        i = 0;
-        while (list) {
-                cmdlines[i].pid = list->pid;
-                cmdlines[i].comm = list->comm;
-                i++;
-                item = list;
-                list = list->next;
-                free(item);
-        }
-
-        qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp);
-}
-
-static struct func_map {
-        unsigned long long              addr;
-        char                            *func;
-        char                            *mod;
-} *func_list;
-static unsigned int func_count;
-
-static int func_cmp(const void *a, const void *b)
-{
-        const struct func_map *fa = a;
-        const struct func_map *fb = b;
-
-        if (fa->addr < fb->addr)
-                return -1;
-        if (fa->addr > fb->addr)
-                return 1;
-
-        return 0;
-}
-
-void parse_proc_kallsyms(char *file, unsigned int size __unused)
-{
-        struct func_list {
-                struct func_list        *next;
-                unsigned long long      addr;
-                char                    *func;
-                char                    *mod;
-        } *list = NULL, *item;
-        char *line;
-        char *next = NULL;
-        char *addr_str;
-        char ch;
-        int ret __used;
-        int i;
-
-        line = strtok_r(file, "\n", &next);
-        while (line) {
-                item = malloc_or_die(sizeof(*item));
-                item->mod = NULL;
-                ret = sscanf(line, "%as %c %as\t[%as",
-                             (float *)(void *)&addr_str, /* workaround gcc warning */
-                             &ch,
-                             (float *)(void *)&item->func,
-                             (float *)(void *)&item->mod);
-                item->addr = strtoull(addr_str, NULL, 16);
-                free(addr_str);
-
-                /* truncate the extra ']' */
-                if (item->mod)
-                        item->mod[strlen(item->mod) - 1] = 0;
-
-
-                item->next = list;
-                list = item;
-                line = strtok_r(NULL, "\n", &next);
-                func_count++;
-        }
-
-        func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1));
-
-        i = 0;
-        while (list) {
-                func_list[i].func = list->func;
-                func_list[i].addr = list->addr;
-                func_list[i].mod = list->mod;
-                i++;
-                item = list;
-                list = list->next;
-                free(item);
-        }
-
-        qsort(func_list, func_count, sizeof(*func_list), func_cmp);
-
-        /*
-         * Add a special record at the end.
-         */
-        func_list[func_count].func = NULL;
-        func_list[func_count].addr = 0;
-        func_list[func_count].mod = NULL;
-}
+bool latency_format;
 
-/*
- * We are searching for a record in between, not an exact
- * match.
- */
-static int func_bcmp(const void *a, const void *b)
+int read_trace_init(int file_bigendian, int host_bigendian)
 {
-        const struct func_map *fa = a;
-        const struct func_map *fb = b;
-
-        if ((fa->addr == fb->addr) ||
-
-            (fa->addr > fb->addr &&
-             fa->addr < (fb+1)->addr))
+        if (pevent)
                 return 0;
 
-        if (fa->addr < fb->addr)
-                return -1;
-
-        return 1;
-}
-
-static struct func_map *find_func(unsigned long long addr)
-{
-        struct func_map *func;
-        struct func_map key;
-
-        key.addr = addr;
-
-        func = bsearch(&key, func_list, func_count, sizeof(*func_list),
-                       func_bcmp);
-
-        return func;
-}
-
-void print_funcs(void)
-{
-        int i;
-
-        for (i = 0; i < (int)func_count; i++) {
-                printf("%016llx %s",
-                       func_list[i].addr,
-                       func_list[i].func);
-                if (func_list[i].mod)
-                        printf(" [%s]\n", func_list[i].mod);
-                else
-                        printf("\n");
-        }
-}
+        perf_pevent = pevent_alloc();
+        pevent = perf_pevent;
 
-static struct printk_map {
-        unsigned long long              addr;
-        char                            *printk;
-} *printk_list;
-static unsigned int printk_count;
-
-static int printk_cmp(const void *a, const void *b)
-{
-        const struct func_map *fa = a;
-        const struct func_map *fb = b;
-
-        if (fa->addr < fb->addr)
-                return -1;
-        if (fa->addr > fb->addr)
-                return 1;
+        pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
+        pevent_set_file_bigendian(pevent, file_bigendian);
+        pevent_set_host_bigendian(pevent, host_bigendian);
 
         return 0;
 }
 
-static struct printk_map *find_printk(unsigned long long addr)
-{
-        struct printk_map *printk;
-        struct printk_map key;
-
-        key.addr = addr;
-
-        printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list),
-                         printk_cmp);
-
-        return printk;
-}
-
-void parse_ftrace_printk(char *file, unsigned int size __unused)
-{
-        struct printk_list {
-                struct printk_list      *next;
-                unsigned long long      addr;
-                char                    *printk;
-        } *list = NULL, *item;
-        char *line;
-        char *next = NULL;
-        char *addr_str;
-        int i;
-
-        line = strtok_r(file, "\n", &next);
-        while (line) {
-                addr_str = strsep(&line, ":");
-                if (!line) {
-                        warning("error parsing print strings");
-                        break;
-                }
-                item = malloc_or_die(sizeof(*item));
-                item->addr = strtoull(addr_str, NULL, 16);
-                /* fmt still has a space, skip it */
-                item->printk = strdup(line+1);
-                item->next = list;
-                list = item;
-                line = strtok_r(NULL, "\n", &next);
-                printk_count++;
-        }
-
-        printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1);
-
-        i = 0;
-        while (list) {
-                printk_list[i].printk = list->printk;
-                printk_list[i].addr = list->addr;
-                i++;
-                item = list;
-                list = list->next;
-                free(item);
-        }
-
-        qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp);
-}
-
-void print_printk(void)
-{
-        int i;
-
-        for (i = 0; i < (int)printk_count; i++) {
-                printf("%016llx %s\n",
-                       printk_list[i].addr,
-                       printk_list[i].printk);
-        }
-}
-
-static struct event *alloc_event(void)
-{
-        struct event *event;
-
-        event = malloc_or_die(sizeof(*event));
-        memset(event, 0, sizeof(*event));
-
-        return event;
-}
-
-enum event_type {
-        EVENT_ERROR,
-        EVENT_NONE,
-        EVENT_SPACE,
-        EVENT_NEWLINE,
-        EVENT_OP,
-        EVENT_DELIM,
-        EVENT_ITEM,
-        EVENT_DQUOTE,
-        EVENT_SQUOTE,
-};
-
-static struct event *event_list;
-
-static void add_event(struct event *event)
+static int get_common_field(struct scripting_context *context,
+                            int *offset, int *size, const char *type)
 {
-        event->next = event_list;
-        event_list = event;
-}
-
-static int event_item_type(enum event_type type)
-{
-        switch (type) {
-        case EVENT_ITEM ... EVENT_SQUOTE:
-                return 1;
-        case EVENT_ERROR ... EVENT_DELIM:
-        default:
-                return 0;
-        }
-}
-
-static void free_arg(struct print_arg *arg)
-{
-        if (!arg)
-                return;
-
-        switch (arg->type) {
-        case PRINT_ATOM:
-                if (arg->atom.atom)
-                        free(arg->atom.atom);
-                break;
-        case PRINT_NULL:
-        case PRINT_FIELD ... PRINT_OP:
-        default:
-                /* todo */
-                break;
-        }
-
-        free(arg);
-}
-
-static enum event_type get_type(int ch)
-{
-        if (ch == '\n')
-                return EVENT_NEWLINE;
-        if (isspace(ch))
-                return EVENT_SPACE;
-        if (isalnum(ch) || ch == '_')
-                return EVENT_ITEM;
-        if (ch == '\'')
-                return EVENT_SQUOTE;
-        if (ch == '"')
-                return EVENT_DQUOTE;
-        if (!isprint(ch))
-                return EVENT_NONE;
-        if (ch == '(' || ch == ')' || ch == ',')
-                return EVENT_DELIM;
-
-        return EVENT_OP;
-}
-
-static int __read_char(void)
-{
-        if (input_buf_ptr >= input_buf_siz)
-                return -1;
-
-        return input_buf[input_buf_ptr++];
-}
-
-static int __peek_char(void)
-{
-        if (input_buf_ptr >= input_buf_siz)
-                return -1;
-
-        return input_buf[input_buf_ptr];
-}
-
-static enum event_type __read_token(char **tok)
-{
-        char buf[BUFSIZ];
-        int ch, last_ch, quote_ch, next_ch;
-        int i = 0;
-        int tok_size = 0;
-        enum event_type type;
-
-        *tok = NULL;
-
-
-        ch = __read_char();
-        if (ch < 0)
-                return EVENT_NONE;
-
-        type = get_type(ch);
-        if (type == EVENT_NONE)
-                return type;
-
-        buf[i++] = ch;
-
-        switch (type) {
-        case EVENT_NEWLINE:
-        case EVENT_DELIM:
-                *tok = malloc_or_die(2);
-                (*tok)[0] = ch;
-                (*tok)[1] = 0;
-                return type;
-
-        case EVENT_OP:
-                switch (ch) {
-                case '-':
-                        next_ch = __peek_char();
-                        if (next_ch == '>') {
-                                buf[i++] = __read_char();
-                                break;
-                        }
-                        /* fall through */
-                case '+':
-                case '|':
-                case '&':
-                case '>':
-                case '<':
-                        last_ch = ch;
-                        ch = __peek_char();
-                        if (ch != last_ch)
-                                goto test_equal;
-                        buf[i++] = __read_char();
-                        switch (last_ch) {
-                        case '>':
-                        case '<':
-                                goto test_equal;
-                        default:
-                                break;
-                        }
-                        break;
-                case '!':
-                case '=':
-                        goto test_equal;
-                default: /* what should we do instead? */
-                        break;
-                }
-                buf[i] = 0;
-                *tok = strdup(buf);
-                return type;
-
- test_equal:
-                ch = __peek_char();
-                if (ch == '=')
-                        buf[i++] = __read_char();
-                break;
-
-        case EVENT_DQUOTE:
-        case EVENT_SQUOTE:
-                /* don't keep quotes */
-                i--;
-                quote_ch = ch;
-                last_ch = 0;
-                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);
-
-                                if (!*tok)
-                                        return EVENT_NONE;
-                                tok_size += BUFSIZ;
-                                i = 0;
-                        }
-                        last_ch = ch;
-                        ch = __read_char();
-                        buf[i++] = ch;
-                        /* the '\' '\' will cancel itself */
-                        if (ch == '\\' && last_ch == '\\')
-                                last_ch = 0;
-                } while (ch != quote_ch || last_ch == '\\');
-                /* remove the last quote */
-                i--;
-                goto out;
-
-        case EVENT_ERROR ... EVENT_SPACE:
-        case EVENT_ITEM:
-        default:
-                break;
-        }
-
-        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);
-
-                        if (!*tok)
-                                return EVENT_NONE;
-                        tok_size += BUFSIZ;
-                        i = 0;
-                }
-                ch = __read_char();
-                buf[i++] = ch;
-        }
-
- 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)
-                return EVENT_NONE;
-
-        return type;
-}
-
-static void free_token(char *tok)
-{
-        if (tok)
-                free(tok);
-}
-
-static enum event_type read_token(char **tok)
-{
-        enum event_type type;
-
-        for (;;) {
-                type = __read_token(tok);
-                if (type != EVENT_SPACE)
-                        return type;
-
-                free_token(*tok);
-        }
-
-        /* not reached */
-        return EVENT_NONE;
-}
-
-/* no newline */
-static enum event_type read_token_item(char **tok)
-{
-        enum event_type type;
-
-        for (;;) {
-                type = __read_token(tok);
-                if (type != EVENT_SPACE && type != EVENT_NEWLINE)
-                        return type;
-
-                free_token(*tok);
-        }
-
-        /* not reached */
-        return EVENT_NONE;
-}
-
-static int test_type(enum event_type type, enum event_type expect)
-{
-        if (type != expect) {
-                warning("Error: expected type %d but read %d",
-                    expect, type);
-                return -1;
-        }
-        return 0;
-}
+        struct event_format *event;
+        struct format_field *field;
 
-static int __test_type_token(enum event_type type, char *token,
-                             enum event_type expect, const char *expect_tok,
-                             bool warn)
-{
-        if (type != expect) {
-                if (warn)
-                        warning("Error: expected type %d but read %d",
-                                expect, type);
-                return -1;
-        }
+        if (!*size) {
+                if (!pevent->events)
+                        return 0;
 
-        if (strcmp(token, expect_tok) != 0) {
-                if (warn)
-                        warning("Error: expected '%s' but read '%s'",
-                                expect_tok, token);
-                return -1;
+                event = pevent->events[0];
+                field = pevent_find_common_field(event, type);
+                if (!field)
+                        return 0;
+                *offset = field->offset;
+                *size = field->size;
         }
-        return 0;
-}
 
-static int test_type_token(enum event_type type, char *token,
-                           enum event_type expect, const char *expect_tok)
-{
-        return __test_type_token(type, token, expect, expect_tok, true);
+        return pevent_read_number(pevent, context->event_data + *offset, *size);
 }
 
-static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
-{
-        enum event_type type;
-
-        if (newline_ok)
-                type = read_token(tok);
-        else
-                type = read_token_item(tok);
-        return test_type(type, expect);
-}
-
-static int read_expect_type(enum event_type expect, char **tok)
-{
-        return __read_expect_type(expect, tok, 1);
-}
-
-static int __read_expected(enum event_type expect, const char *str,
-                           int newline_ok, bool warn)
+int common_lock_depth(struct scripting_context *context)
 {
-        enum event_type type;
-        char *token;
+        static int offset;
+        static int size;
         int ret;
 
-        if (newline_ok)
-                type = read_token(&token);
-        else
-                type = read_token_item(&token);
-
-        ret = __test_type_token(type, token, expect, str, warn);
-
-        free_token(token);
+        ret = get_common_field(context, &size, &offset,
+                               "common_lock_depth");
+        if (ret < 0)
+                return -1;
 
         return ret;
 }
 
-static int read_expected(enum event_type expect, const char *str)
-{
-        return __read_expected(expect, str, 1, true);
-}
-
-static int read_expected_item(enum event_type expect, const char *str)
-{
-        return __read_expected(expect, str, 0, true);
-}
-
-static char *event_read_name(void)
-{
-        char *token;
-
-        if (read_expected(EVENT_ITEM, "name") < 0)
-                return NULL;
-
-        if (read_expected(EVENT_OP, ":") < 0)
-                return NULL;
-
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-
-        return token;
-
- fail:
-        free_token(token);
-        return NULL;
-}
-
-static int event_read_id(void)
+int common_flags(struct scripting_context *context)
 {
-        char *token;
-        int id = -1;
-
-        if (read_expected_item(EVENT_ITEM, "ID") < 0)
-                return -1;
+        static int offset;
+        static int size;
+        int ret;
 
-        if (read_expected(EVENT_OP, ":") < 0)
+        ret = get_common_field(context, &size, &offset,
+                               "common_flags");
+        if (ret < 0)
                 return -1;
 
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto free;
-
-        id = strtoul(token, NULL, 0);
-
- free:
-        free_token(token);
-        return id;
-}
-
-static int field_is_string(struct format_field *field)
-{
-        if ((field->flags & FIELD_IS_ARRAY) &&
-            (!strstr(field->type, "char") || !strstr(field->type, "u8") ||
-             !strstr(field->type, "s8")))
-                return 1;
-
-        return 0;
-}
-
-static int field_is_dynamic(struct format_field *field)
-{
-        if (!strncmp(field->type, "__data_loc", 10))
-                return 1;
-
-        return 0;
-}
-
-static int event_read_fields(struct event *event, struct format_field **fields)
-{
-        struct format_field *field = NULL;
-        enum event_type type;
-        char *token;
-        char *last_token;
-        int count = 0;
-
-        do {
-                type = read_token(&token);
-                if (type == EVENT_NEWLINE) {
-                        free_token(token);
-                        return count;
-                }
-
-                count++;
-
-                if (test_type_token(type, token, EVENT_ITEM, "field"))
-                        goto fail;
-                free_token(token);
-
-                type = read_token(&token);
-                /*
-                 * The ftrace fields may still use the "special" name.
-                 * Just ignore it.
-                 */
-                if (event->flags & EVENT_FL_ISFTRACE &&
-                    type == EVENT_ITEM && strcmp(token, "special") == 0) {
-                        free_token(token);
-                        type = read_token(&token);
-                }
-
-                if (test_type_token(type, token, EVENT_OP, ":") < 0)
-                        return -1;
-
-                if (read_expect_type(EVENT_ITEM, &token) < 0)
-                        goto fail;
-
-                last_token = token;
-
-                field = malloc_or_die(sizeof(*field));
-                memset(field, 0, sizeof(*field));
-
-                /* read the rest of the type */
-                for (;;) {
-                        type = read_token(&token);
-                        if (type == EVENT_ITEM ||
-                            (type == EVENT_OP && strcmp(token, "*") == 0) ||
-                            /*
-                             * Some of the ftrace fields are broken and have
-                             * an illegal "." in them.
-                             */
-                            (event->flags & EVENT_FL_ISFTRACE &&
-                             type == EVENT_OP && strcmp(token, ".") == 0)) {
-
-                                if (strcmp(token, "*") == 0)
-                                        field->flags |= FIELD_IS_POINTER;
-
-                                if (field->type) {
-                                        field->type = realloc(field->type,
-                                                              strlen(field->type) +
-                                                              strlen(last_token) + 2);
-                                        strcat(field->type, " ");
-                                        strcat(field->type, last_token);
-                                } else
-                                        field->type = last_token;
-                                last_token = token;
-                                continue;
-                        }
-
-                        break;
-                }
-
-                if (!field->type) {
-                        die("no type found");
-                        goto fail;
-                }
-                field->name = last_token;
-
-                if (test_type(type, EVENT_OP))
-                        goto fail;
-
-                if (strcmp(token, "[") == 0) {
-                        enum event_type last_type = type;
-                        char *brackets = token;
-                        int len;
-
-                        field->flags |= FIELD_IS_ARRAY;
-
-                        type = read_token(&token);
-                        while (strcmp(token, "]") != 0) {
-                                if (last_type == EVENT_ITEM &&
-                                    type == EVENT_ITEM)
-                                        len = 2;
-                                else
-                                        len = 1;
-                                last_type = type;
-
-                                brackets = realloc(brackets,
-                                                   strlen(brackets) +
-                                                   strlen(token) + len);
-                                if (len == 2)
-                                        strcat(brackets, " ");
-                                strcat(brackets, token);
-                                free_token(token);
-                                type = read_token(&token);
-                                if (type == EVENT_NONE) {
-                                        die("failed to find token");
-                                        goto fail;
-                                }
-                        }
-
-                        free_token(token);
-
-                        brackets = realloc(brackets, strlen(brackets) + 2);
-                        strcat(brackets, "]");
-
-                        /* add brackets to type */
-
-                        type = read_token(&token);
-                        /*
-                         * If the next token is not an OP, then it is of
-                         * the format: type [] item;
-                         */
-                        if (type == EVENT_ITEM) {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(field->name) +
-                                                      strlen(brackets) + 2);
-                                strcat(field->type, " ");
-                                strcat(field->type, field->name);
-                                free_token(field->name);
-                                strcat(field->type, brackets);
-                                field->name = token;
-                                type = read_token(&token);
-                        } else {
-                                field->type = realloc(field->type,
-                                                      strlen(field->type) +
-                                                      strlen(brackets) + 1);
-                                strcat(field->type, brackets);
-                        }
-                        free(brackets);
-                }
-
-                if (field_is_string(field)) {
-                        field->flags |= FIELD_IS_STRING;
-                        if (field_is_dynamic(field))
-                                field->flags |= FIELD_IS_DYNAMIC;
-                }
-
-                if (test_type_token(type, token,  EVENT_OP, ";"))
-                        goto fail;
-                free_token(token);
-
-                if (read_expected(EVENT_ITEM, "offset") < 0)
-                        goto fail_expect;
-
-                if (read_expected(EVENT_OP, ":") < 0)
-                        goto fail_expect;
-
-                if (read_expect_type(EVENT_ITEM, &token))
-                        goto fail;
-                field->offset = strtoul(token, NULL, 0);
-                free_token(token);
-
-                if (read_expected(EVENT_OP, ";") < 0)
-                        goto fail_expect;
-
-                if (read_expected(EVENT_ITEM, "size") < 0)
-                        goto fail_expect;
-
-                if (read_expected(EVENT_OP, ":") < 0)
-                        goto fail_expect;
-
-                if (read_expect_type(EVENT_ITEM, &token))
-                        goto fail;
-                field->size = strtoul(token, NULL, 0);
-                free_token(token);
-
-                if (read_expected(EVENT_OP, ";") < 0)
-                        goto fail_expect;
-
-                type = read_token(&token);
-                if (type != EVENT_NEWLINE) {
-                        /* newer versions of the kernel have a "signed" type */
-                        if (test_type_token(type, token, EVENT_ITEM, "signed"))
-                                goto fail;
-
-                        free_token(token);
-
-                        if (read_expected(EVENT_OP, ":") < 0)
-                                goto fail_expect;
-
-                        if (read_expect_type(EVENT_ITEM, &token))
-                                goto fail;
-
-                        if (strtoul(token, NULL, 0))
-                                field->flags |= FIELD_IS_SIGNED;
-
-                        free_token(token);
-                        if (read_expected(EVENT_OP, ";") < 0)
-                                goto fail_expect;
-
-                        if (read_expect_type(EVENT_NEWLINE, &token))
-                                goto fail;
-                }
-
-                free_token(token);
-
-                *fields = field;
-                fields = &field->next;
-
-        } while (1);
-
-        return 0;
-
-fail:
-        free_token(token);
-fail_expect:
-        if (field)
-                free(field);
-        return -1;
+        return ret;
 }
 
-static int event_read_format(struct event *event)
+int common_pc(struct scripting_context *context)
 {
-        char *token;
+        static int offset;
+        static int size;
         int ret;
 
-        if (read_expected_item(EVENT_ITEM, "format") < 0)
-                return -1;
-
-        if (read_expected(EVENT_OP, ":") < 0)
-                return -1;
-
-        if (read_expect_type(EVENT_NEWLINE, &token))
-                goto fail;
-        free_token(token);
-
-        ret = event_read_fields(event, &event->format.common_fields);
+        ret = get_common_field(context, &size, &offset,
+                               "common_preempt_count");
         if (ret < 0)
-                return ret;
-        event->format.nr_common = ret;
-
-        ret = event_read_fields(event, &event->format.fields);
-        if (ret < 0)
-                return ret;
-        event->format.nr_fields = ret;
-
-        return 0;
-
- fail:
-        free_token(token);
-        return -1;
-}
-
-enum event_type
-process_arg_token(struct event *event, struct print_arg *arg,
-                  char **tok, enum event_type type);
-
-static enum event_type
-process_arg(struct event *event, struct print_arg *arg, char **tok)
-{
-        enum event_type type;
-        char *token;
-
-        type = read_token(&token);
-        *tok = token;
+                return -1;
 
-        return process_arg_token(event, arg, tok, type);
+        return ret;
 }
 
-static enum event_type
-process_cond(struct event *event, struct print_arg *top, char **tok)
+unsigned long long
+raw_field_value(struct event_format *event, const char *name, void *data)
 {
-        struct print_arg *arg, *left, *right;
-        enum event_type type;
-        char *token = NULL;
-
-        arg = malloc_or_die(sizeof(*arg));
-        memset(arg, 0, sizeof(*arg));
-
-        left = malloc_or_die(sizeof(*left));
-
-        right = malloc_or_die(sizeof(*right));
-
-        arg->type = PRINT_OP;
-        arg->op.left = left;
-        arg->op.right = right;
-
-        *tok = NULL;
-        type = process_arg(event, left, &token);
-        if (test_type_token(type, token, EVENT_OP, ":"))
-                goto out_free;
-
-        arg->op.op = token;
-
-        type = process_arg(event, right, &token);
+        struct format_field *field;
+        unsigned long long val;
 
-        top->op.right = arg;
+        field = pevent_find_any_field(event, name);
+        if (!field)
+                return 0ULL;
 
-        *tok = token;
-        return type;
+        pevent_read_number_field(field, data, &val);
 
-out_free:
-        free_token(*tok);
-        free(right);
-        free(left);
-        free_arg(arg);
-        return EVENT_ERROR;
+        return val;
 }
 
-static enum event_type
-process_array(struct event *event, struct print_arg *top, char **tok)
+void *raw_field_ptr(struct event_format *event, const char *name, void *data)
 {
-        struct print_arg *arg;
-        enum event_type type;
-        char *token = NULL;
-
-        arg = malloc_or_die(sizeof(*arg));
-        memset(arg, 0, sizeof(*arg));
-
-        *tok = NULL;
-        type = process_arg(event, arg, &token);
-        if (test_type_token(type, token, EVENT_OP, "]"))
-                goto out_free;
-
-        top->op.right = arg;
-
-        free_token(token);
-        type = read_token_item(&token);
-        *tok = token;
-
-        return type;
+        struct format_field *field;
 
-out_free:
-        free_token(*tok);
-        free_arg(arg);
-        return EVENT_ERROR;
-}
+        field = pevent_find_any_field(event, name);
+        if (!field)
+                return NULL;
 
-static int get_op_prio(char *op)
-{
-        if (!op[1]) {
-                switch (op[0]) {
-                case '*':
-                case '/':
-                case '%':
-                        return 6;
-                case '+':
-                case '-':
-                        return 7;
-                        /* '>>' and '<<' are 8 */
-                case '<':
-                case '>':
-                        return 9;
-                        /* '==' and '!=' are 10 */
-                case '&':
-                        return 11;
-                case '^':
-                        return 12;
-                case '|':
-                        return 13;
-                case '?':
-                        return 16;
-                default:
-                        die("unknown op '%c'", op[0]);
-                        return -1;
-                }
-        } else {
-                if (strcmp(op, "++") == 0 ||
-                    strcmp(op, "--") == 0) {
-                        return 3;
-                } else if (strcmp(op, ">>") == 0 ||
-                           strcmp(op, "<<") == 0) {
-                        return 8;
-                } else if (strcmp(op, ">=") == 0 ||
-                           strcmp(op, "<=") == 0) {
-                        return 9;
-                } else if (strcmp(op, "==") == 0 ||
-                           strcmp(op, "!=") == 0) {
-                        return 10;
-                } else if (strcmp(op, "&&") == 0) {
-                        return 14;
-                } else if (strcmp(op, "||") == 0) {
-                        return 15;
-                } else {
-                        die("unknown op '%s'", op);
-                        return -1;
-                }
-        }
-}
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                int offset;
 
-static void set_op_prio(struct print_arg *arg)
-{
+                offset = *(int *)(data + field->offset);
+                offset &= 0xffff;
 
-        /* single ops are the greatest */
-        if (!arg->op.left || arg->op.left->type == PRINT_NULL) {
-                arg->op.prio = 0;
-                return;
+                return data + offset;
         }
 
-        arg->op.prio = get_op_prio(arg->op.op);
+        return data + field->offset;
 }
 
-static enum event_type
-process_op(struct event *event, struct print_arg *arg, char **tok)
+int trace_parse_common_type(void *data)
 {
-        struct print_arg *left, *right = NULL;
-        enum event_type type;
-        char *token;
-
-        /* the op is passed in via tok */
-        token = *tok;
-
-        if (arg->type == PRINT_OP && !arg->op.left) {
-                /* handle single op */
-                if (token[1]) {
-                        die("bad op token %s", token);
-                        return EVENT_ERROR;
-                }
-                switch (token[0]) {
-                case '!':
-                case '+':
-                case '-':
-                        break;
-                default:
-                        die("bad op token %s", token);
-                        return EVENT_ERROR;
-                }
-
-                /* make an empty left */
-                left = malloc_or_die(sizeof(*left));
-                left->type = PRINT_NULL;
-                arg->op.left = left;
-
-                right = malloc_or_die(sizeof(*right));
-                arg->op.right = right;
-
-                type = process_arg(event, right, tok);
-
-        } else if (strcmp(token, "?") == 0) {
-
-                left = malloc_or_die(sizeof(*left));
-                /* copy the top arg to the left */
-                *left = *arg;
-
-                arg->type = PRINT_OP;
-                arg->op.op = token;
-                arg->op.left = left;
-                arg->op.prio = 0;
-
-                type = process_cond(event, arg, tok);
-
-        } else if (strcmp(token, ">>") == 0 ||
-                   strcmp(token, "<<") == 0 ||
-                   strcmp(token, "&") == 0 ||
-                   strcmp(token, "|") == 0 ||
-                   strcmp(token, "&&") == 0 ||
-                   strcmp(token, "||") == 0 ||
-                   strcmp(token, "-") == 0 ||
-                   strcmp(token, "+") == 0 ||
-                   strcmp(token, "*") == 0 ||
-                   strcmp(token, "^") == 0 ||
-                   strcmp(token, "/") == 0 ||
-                   strcmp(token, "<") == 0 ||
-                   strcmp(token, ">") == 0 ||
-                   strcmp(token, "==") == 0 ||
-                   strcmp(token, "!=") == 0) {
-
-                left = malloc_or_die(sizeof(*left));
-
-                /* copy the top arg to the left */
-                *left = *arg;
-
-                arg->type = PRINT_OP;
-                arg->op.op = token;
-                arg->op.left = left;
-
-                set_op_prio(arg);
-
-                right = malloc_or_die(sizeof(*right));
-
-                type = read_token_item(&token);
-                *tok = token;
-
-                /* could just be a type pointer */
-                if ((strcmp(arg->op.op, "*") == 0) &&
-                    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
-                        if (left->type != PRINT_ATOM)
-                                die("bad pointer type");
-                        left->atom.atom = realloc(left->atom.atom,
-                                            sizeof(left->atom.atom) + 3);
-                        strcat(left->atom.atom, " *");
-                        *arg = *left;
-                        free(arg);
-
-                        return type;
-                }
-
-                type = process_arg_token(event, right, tok, type);
-
-                arg->op.right = right;
-
-        } else if (strcmp(token, "[") == 0) {
-
-                left = malloc_or_die(sizeof(*left));
-                *left = *arg;
-
-                arg->type = PRINT_OP;
-                arg->op.op = token;
-                arg->op.left = left;
-
-                arg->op.prio = 0;
-                type = process_array(event, arg, tok);
-
-        } else {
-                warning("unknown op '%s'", token);
-                event->flags |= EVENT_FL_FAILED;
-                /* the arg is now the left side */
-                return EVENT_NONE;
-        }
-
-        if (type == EVENT_OP) {
-                int prio;
-
-                /* higher prios need to be closer to the root */
-                prio = get_op_prio(*tok);
-
-                if (prio > arg->op.prio)
-                        return process_op(event, arg, tok);
+        struct pevent_record record;
 
-                return process_op(event, right, tok);
-        }
-
-        return type;
+        record.data = data;
+        return pevent_data_type(pevent, &record);
 }
 
-static enum event_type
-process_entry(struct event *event __unused, struct print_arg *arg,
-              char **tok)
+int trace_parse_common_pid(void *data)
 {
-        enum event_type type;
-        char *field;
-        char *token;
-
-        if (read_expected(EVENT_OP, "->") < 0)
-                return EVENT_ERROR;
-
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-        field = token;
-
-        arg->type = PRINT_FIELD;
-        arg->field.name = field;
-
-        if (is_flag_field) {
-                arg->field.field = find_any_field(event, arg->field.name);
-                arg->field.field->flags |= FIELD_IS_FLAG;
-                is_flag_field = 0;
-        } else if (is_symbolic_field) {
-                arg->field.field = find_any_field(event, arg->field.name);
-                arg->field.field->flags |= FIELD_IS_SYMBOLIC;
-                is_symbolic_field = 0;
-        }
-
-        type = read_token(&token);
-        *tok = token;
+        struct pevent_record record;
 
-        return type;
-
-fail:
-        free_token(token);
-        return EVENT_ERROR;
+        record.data = data;
+        return pevent_data_pid(pevent, &record);
 }
 
-static char *arg_eval (struct print_arg *arg);
-
-static long long arg_num_eval(struct print_arg *arg)
+unsigned long long read_size(void *ptr, int size)
 {
-        long long left, right;
-        long long val = 0;
-
-        switch (arg->type) {
-        case PRINT_ATOM:
-                val = strtoll(arg->atom.atom, NULL, 0);
-                break;
-        case PRINT_TYPE:
-                val = arg_num_eval(arg->typecast.item);
-                break;
-        case PRINT_OP:
-                switch (arg->op.op[0]) {
-                case '|':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-                        if (arg->op.op[1])
-                                val = left || right;
-                        else
-                                val = left | right;
-                        break;
-                case '&':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-                        if (arg->op.op[1])
-                                val = left && right;
-                        else
-                                val = left & right;
-                        break;
-                case '<':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-                        switch (arg->op.op[1]) {
-                        case 0:
-                                val = left < right;
-                                break;
-                        case '<':
-                                val = left << right;
-                                break;
-                        case '=':
-                                val = left <= right;
-                                break;
-                        default:
-                                die("unknown op '%s'", arg->op.op);
-                        }
-                        break;
-                case '>':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-                        switch (arg->op.op[1]) {
-                        case 0:
-                                val = left > right;
-                                break;
-                        case '>':
-                                val = left >> right;
-                                break;
-                        case '=':
-                                val = left >= right;
-                                break;
-                        default:
-                                die("unknown op '%s'", arg->op.op);
-                        }
-                        break;
-                case '=':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-
-                        if (arg->op.op[1] != '=')
-                                die("unknown op '%s'", arg->op.op);
-
-                        val = left == right;
-                        break;
-                case '!':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-
-                        switch (arg->op.op[1]) {
-                        case '=':
-                                val = left != right;
-                                break;
-                        default:
-                                die("unknown op '%s'", arg->op.op);
-                        }
-                        break;
-                case '+':
-                        left = arg_num_eval(arg->op.left);
-                        right = arg_num_eval(arg->op.right);
-                        val = left + right;
-                        break;
-                default:
-                        die("unknown op '%s'", arg->op.op);
-                }
-                break;
-
-        case PRINT_NULL:
-        case PRINT_FIELD ... PRINT_SYMBOL:
-        case PRINT_STRING:
-        default:
-                die("invalid eval type %d", arg->type);
-
-        }
-        return val;
+        return pevent_read_number(pevent, ptr, size);
 }
 
-static char *arg_eval (struct print_arg *arg)
+struct event_format *trace_find_event(int type)
 {
-        long long val;
-        static char buf[20];
-
-        switch (arg->type) {
-        case PRINT_ATOM:
-                return arg->atom.atom;
-        case PRINT_TYPE:
-                return arg_eval(arg->typecast.item);
-        case PRINT_OP:
-                val = arg_num_eval(arg);
-                sprintf(buf, "%lld", val);
-                return buf;
-
-        case PRINT_NULL:
-        case PRINT_FIELD ... PRINT_SYMBOL:
-        case PRINT_STRING:
-        default:
-                die("invalid eval type %d", arg->type);
-                break;
-        }
-
-        return NULL;
+        return pevent_find_event(pevent, type);
 }
 
-static enum event_type
-process_fields(struct event *event, struct print_flag_sym **list, char **tok)
-{
-        enum event_type type;
-        struct print_arg *arg = NULL;
-        struct print_flag_sym *field;
-        char *token = NULL;
-        char *value;
-
-        do {
-                free_token(token);
-                type = read_token_item(&token);
-                if (test_type_token(type, token, EVENT_OP, "{"))
-                        break;
-
-                arg = malloc_or_die(sizeof(*arg));
-
-                free_token(token);
-                type = process_arg(event, arg, &token);
-
-                if (type == EVENT_OP)
-                        type = process_op(event, arg, &token);
-
-                if (type == EVENT_ERROR)
-                        goto out_free;
-
-                if (test_type_token(type, token, EVENT_DELIM, ","))
-                        goto out_free;
-
-                field = malloc_or_die(sizeof(*field));
-                memset(field, 0, sizeof(*field));
-
-                value = arg_eval(arg);
-                field->value = strdup(value);
-
-                free_token(token);
-                type = process_arg(event, arg, &token);
-                if (test_type_token(type, token, EVENT_OP, "}"))
-                        goto out_free;
-
-                value = arg_eval(arg);
-                field->str = strdup(value);
-                free_arg(arg);
-                arg = NULL;
-
-                *list = field;
-                list = &field->next;
 
-                free_token(token);
-                type = read_token_item(&token);
-        } while (type == EVENT_DELIM && strcmp(token, ",") == 0);
-
-        *tok = token;
-        return type;
-
-out_free:
-        free_arg(arg);
-        free_token(token);
-
-        return EVENT_ERROR;
-}
-
-static enum event_type
-process_flags(struct event *event, struct print_arg *arg, char **tok)
+void print_trace_event(int cpu, void *data, int size)
 {
-        struct print_arg *field;
-        enum event_type type;
-        char *token;
-
-        memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_FLAGS;
-
-        if (read_expected_item(EVENT_DELIM, "(") < 0)
-                return EVENT_ERROR;
-
-        field = malloc_or_die(sizeof(*field));
-
-        type = process_arg(event, field, &token);
-        while (type == EVENT_OP)
-                type = process_op(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ","))
-                goto out_free;
+        struct event_format *event;
+        struct pevent_record record;
+        struct trace_seq s;
+        int type;
 
-        arg->flags.field = field;
+        type = trace_parse_common_type(data);
 
-        type = read_token_item(&token);
-        if (event_item_type(type)) {
-                arg->flags.delim = token;
-                type = read_token_item(&token);
+        event = trace_find_event(type);
+        if (!event) {
+                warning("ug! no event found for type %d", type);
+                return;
         }
 
-        if (test_type_token(type, token, EVENT_DELIM, ","))
-                goto out_free;
-
-        type = process_fields(event, &arg->flags.flags, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
-                goto out_free;
+        memset(&record, 0, sizeof(record));
+        record.cpu = cpu;
+        record.size = size;
+        record.data = data;
 
-        free_token(token);
-        type = read_token_item(tok);
-        return type;
-
-out_free:
-        free_token(token);
-        return EVENT_ERROR;
+        trace_seq_init(&s);
+        pevent_print_event(pevent, &s, &record);
+        trace_seq_do_printf(&s);
+        printf("\n");
 }
 
-static enum event_type
-process_symbols(struct event *event, struct print_arg *arg, char **tok)
+void print_event(int cpu, void *data, int size, unsigned long long nsecs,
+                  char *comm)
 {
-        struct print_arg *field;
-        enum event_type type;
-        char *token;
-
-        memset(arg, 0, sizeof(*arg));
-        arg->type = PRINT_SYMBOL;
-
-        if (read_expected_item(EVENT_DELIM, "(") < 0)
-                return EVENT_ERROR;
-
-        field = malloc_or_die(sizeof(*field));
-
-        type = process_arg(event, field, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ","))
-                goto out_free;
+        struct pevent_record record;
+        struct trace_seq s;
+        int pid;
 
-        arg->symbol.field = field;
+        pevent->latency_format = latency_format;
 
-        type = process_fields(event, &arg->symbol.symbols, &token);
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
-                goto out_free;
+        record.ts = nsecs;
+        record.cpu = cpu;
+        record.size = size;
+        record.data = data;
+        pid = pevent_data_pid(pevent, &record);
 
-        free_token(token);
-        type = read_token_item(tok);
-        return type;
+        if (!pevent_pid_is_registered(pevent, pid))
+                pevent_register_comm(pevent, comm, pid);
 
-out_free:
-        free_token(token);
-        return EVENT_ERROR;
+        trace_seq_init(&s);
+        pevent_print_event(pevent, &s, &record);
+        trace_seq_do_printf(&s);
+        printf("\n");
 }
 
-static enum event_type
-process_paren(struct event *event, struct print_arg *arg, char **tok)
+void parse_proc_kallsyms(char *file, unsigned int size __unused)
 {
-        struct print_arg *item_arg;
-        enum event_type type;
-        char *token;
-
-        type = process_arg(event, arg, &token);
-
-        if (type == EVENT_ERROR)
-                return EVENT_ERROR;
-
-        if (type == EVENT_OP)
-                type = process_op(event, arg, &token);
-
-        if (type == EVENT_ERROR)
-                return EVENT_ERROR;
-
-        if (test_type_token(type, token, EVENT_DELIM, ")")) {
-                free_token(token);
-                return EVENT_ERROR;
-        }
-
-        free_token(token);
-        type = read_token_item(&token);
-
-        /*
-         * If the next token is an item or another open paren, then
-         * this was a typecast.
-         */
-        if (event_item_type(type) ||
-            (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
-
-                /* make this a typecast and contine */
+        unsigned long long addr;
+        char *func;
+        char *line;
+        char *next = NULL;
+        char *addr_str;
+        char *mod;
+        char ch;
 
-                /* prevous must be an atom */
-                if (arg->type != PRINT_ATOM)
-                        die("previous needed to be PRINT_ATOM");
+        line = strtok_r(file, "\n", &next);
+        while (line) {
+                mod = NULL;
+                sscanf(line, "%as %c %as\t[%as",
+                       (float *)(void *)&addr_str, /* workaround gcc warning */
+                       &ch, (float *)(void *)&func, (float *)(void *)&mod);
+                addr = strtoull(addr_str, NULL, 16);
+                free(addr_str);
 
-                item_arg = malloc_or_die(sizeof(*item_arg));
+                /* truncate the extra ']' */
+                if (mod)
+                        mod[strlen(mod) - 1] = 0;
 
-                arg->type = PRINT_TYPE;
-                arg->typecast.type = arg->atom.atom;
-                arg->typecast.item = item_arg;
-                type = process_arg_token(event, item_arg, &token, type);
+                pevent_register_function(pevent, func, addr, mod);
+                free(func);
+                free(mod);
 
+                line = strtok_r(NULL, "\n", &next);
         }
-
-        *tok = token;
-        return type;
 }
 
-
-static enum event_type
-process_str(struct event *event __unused, struct print_arg *arg, char **tok)
+void parse_ftrace_printk(char *file, unsigned int size __unused)
 {
-        enum event_type type;
-        char *token;
-
-        if (read_expected(EVENT_DELIM, "(") < 0)
-                return EVENT_ERROR;
-
-        if (read_expect_type(EVENT_ITEM, &token) < 0)
-                goto fail;
-
-        arg->type = PRINT_STRING;
-        arg->string.string = token;
-        arg->string.offset = -1;
-
-        if (read_expected(EVENT_DELIM, ")") < 0)
-                return EVENT_ERROR;
-
-        type = read_token(&token);
-        *tok = token;
-
-        return type;
-fail:
-        free_token(token);
-        return EVENT_ERROR;
-}
+        unsigned long long addr;
+        char *printk;
+        char *line;
+        char *next = NULL;
+        char *addr_str;
+        char *fmt;
 
-enum event_type
-process_arg_token(struct event *event, struct print_arg *arg,
-                  char **tok, enum event_type type)
-{
-        char *token;
-        char *atom;
-
-        token = *tok;
-
-        switch (type) {
-        case EVENT_ITEM:
-                if (strcmp(token, "REC") == 0) {
-                        free_token(token);
-                        type = process_entry(event, arg, &token);
-                } else if (strcmp(token, "__print_flags") == 0) {
-                        free_token(token);
-                        is_flag_field = 1;
-                        type = process_flags(event, arg, &token);
-                } else if (strcmp(token, "__print_symbolic") == 0) {
-                        free_token(token);
-                        is_symbolic_field = 1;
-                        type = process_symbols(event, arg, &token);
-                } else if (strcmp(token, "__get_str") == 0) {
-                        free_token(token);
-                        type = process_str(event, arg, &token);
-                } else {
-                        atom = token;
-                        /* test the next token */
-                        type = read_token_item(&token);
-
-                        /* atoms can be more than one token long */
-                        while (type == EVENT_ITEM) {
-                                atom = realloc(atom, strlen(atom) + strlen(token) + 2);
-                                strcat(atom, " ");
-                                strcat(atom, token);
-                                free_token(token);
-                                type = read_token_item(&token);
-                        }
-
-                        /* todo, test for function */
-
-                        arg->type = PRINT_ATOM;
-                        arg->atom.atom = atom;
-                }
-                break;
-        case EVENT_DQUOTE:
-        case EVENT_SQUOTE:
-                arg->type = PRINT_ATOM;
-                arg->atom.atom = token;
-                type = read_token_item(&token);
-                break;
-        case EVENT_DELIM:
-                if (strcmp(token, "(") == 0) {
-                        free_token(token);
-                        type = process_paren(event, arg, &token);
+        line = strtok_r(file, "\n", &next);
+        while (line) {
+                addr_str = strtok_r(line, ":", &fmt);
+                if (!addr_str) {
+                        warning("printk format with empty entry");
                         break;
                 }
-        case EVENT_OP:
-                /* handle single ops */
-                arg->type = PRINT_OP;
-                arg->op.op = token;
-                arg->op.left = NULL;
-                type = process_op(event, arg, &token);
-
-                break;
-
-        case EVENT_ERROR ... EVENT_NEWLINE:
-        default:
-                die("unexpected type %d", type);
-        }
-        *tok = token;
-
-        return type;
-}
-
-static int event_read_print_args(struct event *event, struct print_arg **list)
-{
-        enum event_type type = EVENT_ERROR;
-        struct print_arg *arg;
-        char *token;
-        int args = 0;
-
-        do {
-                if (type == EVENT_NEWLINE) {
-                        free_token(token);
-                        type = read_token_item(&token);
-                        continue;
-                }
-
-                arg = malloc_or_die(sizeof(*arg));
-                memset(arg, 0, sizeof(*arg));
-
-                type = process_arg(event, arg, &token);
-
-                if (type == EVENT_ERROR) {
-                        free_arg(arg);
-                        return -1;
-                }
-
-                *list = arg;
-                args++;
-
-                if (type == EVENT_OP) {
-                        type = process_op(event, arg, &token);
-                        list = &arg->next;
-                        continue;
-                }
-
-                if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
-                        free_token(token);
-                        *list = arg;
-                        list = &arg->next;
-                        continue;
-                }
-                break;
-        } while (type != EVENT_NONE);
-
-        if (type != EVENT_NONE)
-                free_token(token);
-
-        return args;
-}
-
-static int event_read_print(struct event *event)
-{
-        enum event_type type;
-        char *token;
-        int ret;
-
-        if (read_expected_item(EVENT_ITEM, "print") < 0)
-                return -1;
-
-        if (read_expected(EVENT_ITEM, "fmt") < 0)
-                return -1;
-
-        if (read_expected(EVENT_OP, ":") < 0)
-                return -1;
-
-        if (read_expect_type(EVENT_DQUOTE, &token) < 0)
-                goto fail;
-
- concat:
-        event->print_fmt.format = token;
-        event->print_fmt.args = NULL;
-
-        /* ok to have no arg */
-        type = read_token_item(&token);
-
-        if (type == EVENT_NONE)
-                return 0;
-
-        /* Handle concatination of print lines */
-        if (type == EVENT_DQUOTE) {
-                char *cat;
-
-                cat = malloc_or_die(strlen(event->print_fmt.format) +
-                                    strlen(token) + 1);
-                strcpy(cat, event->print_fmt.format);
-                strcat(cat, token);
-                free_token(token);
-                free_token(event->print_fmt.format);
-                event->print_fmt.format = NULL;
-                token = cat;
-                goto concat;
-        }
-
-        if (test_type_token(type, token, EVENT_DELIM, ","))
-                goto fail;
-
-        free_token(token);
-
-        ret = event_read_print_args(event, &event->print_fmt.args);
-        if (ret < 0)
-                return -1;
-
-        return ret;
-
- fail:
-        free_token(token);
-        return -1;
-}
-
-static struct format_field *
-find_common_field(struct event *event, const char *name)
-{
-        struct format_field *format;
-
-        for (format = event->format.common_fields;
-             format; format = format->next) {
-                if (strcmp(format->name, name) == 0)
-                        break;
-        }
-
-        return format;
-}
-
-static struct format_field *
-find_field(struct event *event, const char *name)
-{
-        struct format_field *format;
-
-        for (format = event->format.fields;
-             format; format = format->next) {
-                if (strcmp(format->name, name) == 0)
-                        break;
+                addr = strtoull(addr_str, NULL, 16);
+                /* fmt still has a space, skip it */
+                printk = strdup(fmt+1);
+                line = strtok_r(NULL, "\n", &next);
+                pevent_register_print_string(pevent, printk, addr);
         }
-
-        return format;
 }
 
-static struct format_field *
-find_any_field(struct event *event, const char *name)
+int parse_ftrace_file(char *buf, unsigned long size)
 {
-        struct format_field *format;
-
-        format = find_common_field(event, name);
-        if (format)
-                return format;
-        return find_field(event, name);
+        return pevent_parse_event(pevent, buf, size, "ftrace");
 }
 
-unsigned long long read_size(void *ptr, int size)
+int parse_event_file(char *buf, unsigned long size, char *sys)
 {
-        switch (size) {
-        case 1:
-                return *(unsigned char *)ptr;
-        case 2:
-                return data2host2(ptr);
-        case 4:
-                return data2host4(ptr);
-        case 8:
-                return data2host8(ptr);
-        default:
-                /* BUG! */
-                return 0;
-        }
+        return pevent_parse_event(pevent, buf, size, sys);
 }
 
-unsigned long long
-raw_field_value(struct event *event, const char *name, void *data)
+struct event_format *trace_find_next_event(struct event_format *event)
 {
-        struct format_field *field;
-
-        field = find_any_field(event, name);
-        if (!field)
-                return 0ULL;
+        static int idx;
 
-        return read_size(data + field->offset, field->size);
-}
-
-void *raw_field_ptr(struct event *event, const char *name, void *data)
-{
-        struct format_field *field;
-
-        field = find_any_field(event, name);
-        if (!field)
+        if (!pevent->events)
                 return NULL;
 
-        if (field->flags & FIELD_IS_DYNAMIC) {
-                int offset;
-
-                offset = *(int *)(data + field->offset);
-                offset &= 0xffff;
-
-                return data + offset;
-        }
-
-        return data + field->offset;
-}
-
-static int get_common_info(const char *type, int *offset, int *size)
-{
-        struct event *event;
-        struct format_field *field;
-
-        /*
-         * All events should have the same common elements.
-         * Pick any event to find where the type is;
-         */
-        if (!event_list)
-                die("no event_list!");
-
-        event = event_list;
-        field = find_common_field(event, type);
-        if (!field)
-                die("field '%s' not found", type);
-
-        *offset = field->offset;
-        *size = field->size;
-
-        return 0;
-}
-
-static int __parse_common(void *data, int *size, int *offset,
-                          const char *name)
-{
-        int ret;
-
-        if (!*size) {
-                ret = get_common_info(name, offset, size);
-                if (ret < 0)
-                        return ret;
+        if (!event) {
+                idx = 0;
+                return pevent->events[0];
         }
-        return read_size(data + *offset, *size);
-}
-
-int trace_parse_common_type(void *data)
-{
-        static int type_offset;
-        static int type_size;
-
-        return __parse_common(data, &type_size, &type_offset,
-                              "common_type");
-}
-
-int trace_parse_common_pid(void *data)
-{
-        static int pid_offset;
-        static int pid_size;
-
-        return __parse_common(data, &pid_size, &pid_offset,
-                              "common_pid");
-}
-
-int parse_common_pc(void *data)
-{
-        static int pc_offset;
-        static int pc_size;
-
-        return __parse_common(data, &pc_size, &pc_offset,
-                              "common_preempt_count");
-}
-
-int parse_common_flags(void *data)
-{
-        static int flags_offset;
-        static int flags_size;
-
-        return __parse_common(data, &flags_size, &flags_offset,
-                              "common_flags");
-}
-
-int parse_common_lock_depth(void *data)
-{
-        static int ld_offset;
-        static int ld_size;
-        int ret;
 
-        ret = __parse_common(data, &ld_size, &ld_offset,
-                             "common_lock_depth");
-        if (ret < 0)
-                return -1;
-
-        return ret;
-}
-
-struct event *trace_find_event(int id)
-{
-        struct event *event;
-
-        for (event = event_list; event; event = event->next) {
-                if (event->id == id)
-                        break;
+        if (idx < pevent->nr_events && event == pevent->events[idx]) {
+                idx++;
+                if (idx == pevent->nr_events)
+                        return NULL;
+                return pevent->events[idx];
         }
-        return event;
-}
-
-struct event *trace_find_next_event(struct event *event)
-{
-        if (!event)
-                return event_list;
-
-        return event->next;
-}
-
-static unsigned long long eval_num_arg(void *data, int size,
-                                   struct event *event, struct print_arg *arg)
-{
-        unsigned long long val = 0;
-        unsigned long long left, right;
-        struct print_arg *larg;
 
-        switch (arg->type) {
-        case PRINT_NULL:
-                /* ?? */
-                return 0;
-        case PRINT_ATOM:
-                return strtoull(arg->atom.atom, NULL, 0);
-        case PRINT_FIELD:
-                if (!arg->field.field) {
-                        arg->field.field = find_any_field(event, arg->field.name);
-                        if (!arg->field.field)
-                                die("field %s not found", arg->field.name);
-                }
-                /* must be a number */
-                val = read_size(data + arg->field.field->offset,
-                                arg->field.field->size);
-                break;
-        case PRINT_FLAGS:
-        case PRINT_SYMBOL:
-                break;
-        case PRINT_TYPE:
-                return eval_num_arg(data, size, event, arg->typecast.item);
-        case PRINT_STRING:
-                return 0;
-                break;
-        case PRINT_OP:
-                if (strcmp(arg->op.op, "[") == 0) {
-                        /*
-                         * Arrays are special, since we don't want
-                         * to read the arg as is.
-                         */
-                        if (arg->op.left->type != PRINT_FIELD)
-                                goto default_op; /* oops, all bets off */
-                        larg = arg->op.left;
-                        if (!larg->field.field) {
-                                larg->field.field =
-                                        find_any_field(event, larg->field.name);
-                                if (!larg->field.field)
-                                        die("field %s not found", larg->field.name);
-                        }
-                        right = eval_num_arg(data, size, event, arg->op.right);
-                        val = read_size(data + larg->field.field->offset +
-                                        right * long_size, long_size);
-                        break;
-                }
- default_op:
-                left = eval_num_arg(data, size, event, arg->op.left);
-                right = eval_num_arg(data, size, event, arg->op.right);
-                switch (arg->op.op[0]) {
-                case '|':
-                        if (arg->op.op[1])
-                                val = left || right;
-                        else
-                                val = left | right;
-                        break;
-                case '&':
-                        if (arg->op.op[1])
-                                val = left && right;
-                        else
-                                val = left & right;
-                        break;
-                case '<':
-                        switch (arg->op.op[1]) {
-                        case 0:
-                                val = left < right;
-                                break;
-                        case '<':
-                                val = left << right;
-                                break;
-                        case '=':
-                                val = left <= right;
-                                break;
-                        default:
-                                die("unknown op '%s'", arg->op.op);
-                        }
-                        break;
-                case '>':
-                        switch (arg->op.op[1]) {
-                        case 0:
-                                val = left > right;
-                                break;
-                        case '>':
-                                val = left >> right;
-                                break;
-                        case '=':
-                                val = left >= right;
-                                break;
-                        default:
-                                die("unknown op '%s'", arg->op.op);
-                        }
-                        break;
-                case '=':
-                        if (arg->op.op[1] != '=')
-                                die("unknown op '%s'", arg->op.op);
-                        val = left == right;
-                        break;
-                case '-':
-                        val = left - right;
-                        break;
-                case '+':
-                        val = left + right;
-                        break;
-                default:
-                        die("unknown op '%s'", arg->op.op);
-                }
-                break;
-        default: /* not sure what to do there */
-                return 0;
+        for (idx = 1; idx < pevent->nr_events; idx++) {
+                if (event == pevent->events[idx - 1])
+                        return pevent->events[idx];
         }
-        return val;
+        return NULL;
 }
 
 struct flag {
@@ -2221,933 +357,3 @@ unsigned long long eval_flag(const char *flag)
 
         return 0;
 }
-
-static void print_str_arg(void *data, int size,
-                          struct event *event, struct print_arg *arg)
-{
-        struct print_flag_sym *flag;
-        unsigned long long val, fval;
-        char *str;
-        int print;
-
-        switch (arg->type) {
-        case PRINT_NULL:
-                /* ?? */
-                return;
-        case PRINT_ATOM:
-                printf("%s", arg->atom.atom);
-                return;
-        case PRINT_FIELD:
-                if (!arg->field.field) {
-                        arg->field.field = find_any_field(event, arg->field.name);
-                        if (!arg->field.field)
-                                die("field %s not found", arg->field.name);
-                }
-                str = malloc_or_die(arg->field.field->size + 1);
-                memcpy(str, data + arg->field.field->offset,
-                       arg->field.field->size);
-                str[arg->field.field->size] = 0;
-                printf("%s", str);
-                free(str);
-                break;
-        case PRINT_FLAGS:
-                val = eval_num_arg(data, size, event, arg->flags.field);
-                print = 0;
-                for (flag = arg->flags.flags; flag; flag = flag->next) {
-                        fval = eval_flag(flag->value);
-                        if (!val && !fval) {
-                                printf("%s", flag->str);
-                                break;
-                        }
-                        if (fval && (val & fval) == fval) {
-                                if (print && arg->flags.delim)
-                                        printf("%s", arg->flags.delim);
-                                printf("%s", flag->str);
-                                print = 1;
-                                val &= ~fval;
-                        }
-                }
-                break;
-        case PRINT_SYMBOL:
-                val = eval_num_arg(data, size, event, arg->symbol.field);
-                for (flag = arg->symbol.symbols; flag; flag = flag->next) {
-                        fval = eval_flag(flag->value);
-                        if (val == fval) {
-                                printf("%s", flag->str);
-                                break;
-                        }
-                }
-                break;
-
-        case PRINT_TYPE:
-                break;
-        case PRINT_STRING: {
-                int str_offset;
-
-                if (arg->string.offset == -1) {
-                        struct format_field *f;
-
-                        f = find_any_field(event, arg->string.string);
-                        arg->string.offset = f->offset;
-                }
-                str_offset = *(int *)(data + arg->string.offset);
-                str_offset &= 0xffff;
-                printf("%s", ((char *)data) + str_offset);
-                break;
-        }
-        case PRINT_OP:
-                /*
-                 * The only op for string should be ? :
-                 */
-                if (arg->op.op[0] != '?')
-                        return;
-                val = eval_num_arg(data, size, event, arg->op.left);
-                if (val)
-                        print_str_arg(data, size, event, arg->op.right->op.left);
-                else
-                        print_str_arg(data, size, event, arg->op.right->op.right);
-                break;
-        default:
-                /* well... */
-                break;
-        }
-}
-
-static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event)
-{
-        static struct format_field *field, *ip_field;
-        struct print_arg *args, *arg, **next;
-        unsigned long long ip, val;
-        char *ptr;
-        void *bptr;
-
-        if (!field) {
-                field = find_field(event, "buf");
-                if (!field)
-                        die("can't find buffer field for binary printk");
-                ip_field = find_field(event, "ip");
-                if (!ip_field)
-                        die("can't find ip field for binary printk");
-        }
-
-        ip = read_size(data + ip_field->offset, ip_field->size);
-
-        /*
-         * The first arg is the IP pointer.
-         */
-        args = malloc_or_die(sizeof(*args));
-        arg = args;
-        arg->next = NULL;
-        next = &arg->next;
-
-        arg->type = PRINT_ATOM;
-        arg->atom.atom = malloc_or_die(32);
-        sprintf(arg->atom.atom, "%lld", ip);
-
-        /* skip the first "%pf : " */
-        for (ptr = fmt + 6, bptr = data + field->offset;
-             bptr < data + size && *ptr; ptr++) {
-                int ls = 0;
-
-                if (*ptr == '%') {
- process_again:
-                        ptr++;
-                        switch (*ptr) {
-                        case '%':
-                                break;
-                        case 'l':
-                                ls++;
-                                goto process_again;
-                        case 'L':
-                                ls = 2;
-                                goto process_again;
-                        case '0' ... '9':
-                                goto process_again;
-                        case 'p':
-                                ls = 1;
-                                /* fall through */
-                        case 'd':
-                        case 'u':
-                        case 'x':
-                        case 'i':
-                                /* the pointers are always 4 bytes aligned */
-                                bptr = (void *)(((unsigned long)bptr + 3) &
-                                                ~3);
-                                switch (ls) {
-                                case 0:
-                                case 1:
-                                        ls = long_size;
-                                        break;
-                                case 2:
-                                        ls = 8;
-                                default:
-                                        break;
-                                }
-                                val = read_size(bptr, ls);
-                                bptr += ls;
-                                arg = malloc_or_die(sizeof(*arg));
-                                arg->next = NULL;
-                                arg->type = PRINT_ATOM;
-                                arg->atom.atom = malloc_or_die(32);
-                                sprintf(arg->atom.atom, "%lld", val);
-                                *next = arg;
-                                next = &arg->next;
-                                break;
-                        case 's':
-                                arg = malloc_or_die(sizeof(*arg));
-                                arg->next = NULL;
-                                arg->type = PRINT_STRING;
-                                arg->string.string = strdup(bptr);
-                                bptr += strlen(bptr) + 1;
-                                *next = arg;
-                                next = &arg->next;
-                        default:
-                                break;
-                        }
-                }
-        }
-
-        return args;
-}
-
-static void free_args(struct print_arg *args)
-{
-        struct print_arg *next;
-
-        while (args) {
-                next = args->next;
-
-                if (args->type == PRINT_ATOM)
-                        free(args->atom.atom);
-                else
-                        free(args->string.string);
-                free(args);
-                args = next;
-        }
-}
-
-static char *get_bprint_format(void *data, int size __unused, struct event *event)
-{
-        unsigned long long addr;
-        static struct format_field *field;
-        struct printk_map *printk;
-        char *format;
-        char *p;
-
-        if (!field) {
-                field = find_field(event, "fmt");
-                if (!field)
-                        die("can't find format field for binary printk");
-                printf("field->offset = %d size=%d\n", field->offset, field->size);
-        }
-
-        addr = read_size(data + field->offset, field->size);
-
-        printk = find_printk(addr);
-        if (!printk) {
-                format = malloc_or_die(45);
-                sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
-                        addr);
-                return format;
-        }
-
-        p = printk->printk;
-        /* Remove any quotes. */
-        if (*p == '"')
-                p++;
-        format = malloc_or_die(strlen(p) + 10);
-        sprintf(format, "%s : %s", "%pf", p);
-        /* remove ending quotes and new line since we will add one too */
-        p = format + strlen(format) - 1;
-        if (*p == '"')
-                *p = 0;
-
-        p -= 2;
-        if (strcmp(p, "\\n") == 0)
-                *p = 0;
-
-        return format;
-}
-
-static void pretty_print(void *data, int size, struct event *event)
-{
-        struct print_fmt *print_fmt = &event->print_fmt;
-        struct print_arg *arg = print_fmt->args;
-        struct print_arg *args = NULL;
-        const char *ptr = print_fmt->format;
-        unsigned long long val;
-        struct func_map *func;
-        const char *saveptr;
-        char *bprint_fmt = NULL;
-        char format[32];
-        int show_func;
-        int len;
-        int ls;
-
-        if (event->flags & EVENT_FL_ISFUNC)
-                ptr = " %pF <-- %pF";
-
-        if (event->flags & EVENT_FL_ISBPRINT) {
-                bprint_fmt = get_bprint_format(data, size, event);
-                args = make_bprint_args(bprint_fmt, data, size, event);
-                arg = args;
-                ptr = bprint_fmt;
-        }
-
-        for (; *ptr; ptr++) {
-                ls = 0;
-                if (*ptr == '\\') {
-                        ptr++;
-                        switch (*ptr) {
-                        case 'n':
-                                printf("\n");
-                                break;
-                        case 't':
-                                printf("\t");
-                                break;
-                        case 'r':
-                                printf("\r");
-                                break;
-                        case '\\':
-                                printf("\\");
-                                break;
-                        default:
-                                printf("%c", *ptr);
-                                break;
-                        }
-
-                } else if (*ptr == '%') {
-                        saveptr = ptr;
-                        show_func = 0;
- cont_process:
-                        ptr++;
-                        switch (*ptr) {
-                        case '%':
-                                printf("%%");
-                                break;
-                        case 'l':
-                                ls++;
-                                goto cont_process;
-                        case 'L':
-                                ls = 2;
-                                goto cont_process;
-                        case 'z':
-                        case 'Z':
-                        case '0' ... '9':
-                                goto cont_process;
-                        case 'p':
-                                if (long_size == 4)
-                                        ls = 1;
-                                else
-                                        ls = 2;
-
-                                if (*(ptr+1) == 'F' ||
-                                    *(ptr+1) == 'f') {
-                                        ptr++;
-                                        show_func = *ptr;
-                                }
-
-                                /* fall through */
-                        case 'd':
-                        case 'i':
-                        case 'x':
-                        case 'X':
-                        case 'u':
-                                if (!arg)
-                                        die("no argument match");
-
-                                len = ((unsigned long)ptr + 1) -
-                                        (unsigned long)saveptr;
-
-                                /* should never happen */
-                                if (len > 32)
-                                        die("bad format!");
-
-                                memcpy(format, saveptr, len);
-                                format[len] = 0;
-
-                                val = eval_num_arg(data, size, event, arg);
-                                arg = arg->next;
-
-                                if (show_func) {
-                                        func = find_func(val);
-                                        if (func) {
-                                                printf("%s", func->func);
-                                                if (show_func == 'F')
-                                                        printf("+0x%llx",
-                                                               val - func->addr);
-                                                break;
-                                        }
-                                }
-                                switch (ls) {
-                                case 0:
-                                        printf(format, (int)val);
-                                        break;
-                                case 1:
-                                        printf(format, (long)val);
-                                        break;
-                                case 2:
-                                        printf(format, (long long)val);
-                                        break;
-                                default:
-                                        die("bad count (%d)", ls);
-                                }
-                                break;
-                        case 's':
-                                if (!arg)
-                                        die("no matching argument");
-
-                                print_str_arg(data, size, event, arg);
-                                arg = arg->next;
-                                break;
-                        default:
-                                printf(">%c<", *ptr);
-
-                        }
-                } else
-                        printf("%c", *ptr);
-        }
-
-        if (args) {
-                free_args(args);
-                free(bprint_fmt);
-        }
-}
-
-static inline int log10_cpu(int nb)
-{
-        if (nb / 100)
-                return 3;
-        if (nb / 10)
-                return 2;
-        return 1;
-}
-
-static void print_lat_fmt(void *data, int size __unused)
-{
-        unsigned int lat_flags;
-        unsigned int pc;
-        int lock_depth;
-        int hardirq;
-        int softirq;
-
-        lat_flags = parse_common_flags(data);
-        pc = parse_common_pc(data);
-        lock_depth = parse_common_lock_depth(data);
-
-        hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
-        softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
-
-        printf("%c%c%c",
-               (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
-               (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
-               'X' : '.',
-               (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
-               'N' : '.',
-               (hardirq && softirq) ? 'H' :
-               hardirq ? 'h' : softirq ? 's' : '.');
-
-        if (pc)
-                printf("%x", pc);
-        else
-                printf(".");
-
-        if (lock_depth < 0)
-                printf(". ");
-        else
-                printf("%d ", lock_depth);
-}
-
-#define TRACE_GRAPH_INDENT      2
-
-static struct record *
-get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
-                    struct record *next)
-{
-        struct format_field *field;
-        struct event *event;
-        unsigned long val;
-        int type;
-        int pid;
-
-        type = trace_parse_common_type(next->data);
-        event = trace_find_event(type);
-        if (!event)
-                return NULL;
-
-        if (!(event->flags & EVENT_FL_ISFUNCRET))
-                return NULL;
-
-        pid = trace_parse_common_pid(next->data);
-        field = find_field(event, "func");
-        if (!field)
-                die("function return does not have field func");
-
-        val = read_size(next->data + field->offset, field->size);
-
-        if (cur_pid != pid || cur_func != val)
-                return NULL;
-
-        /* this is a leaf, now advance the iterator */
-        return trace_read_data(cpu);
-}
-
-/* Signal a overhead of time execution to the output */
-static void print_graph_overhead(unsigned long long duration)
-{
-        /* Non nested entry or return */
-        if (duration == ~0ULL)
-                return (void)printf("  ");
-
-        /* Duration exceeded 100 msecs */
-        if (duration > 100000ULL)
-                return (void)printf("! ");
-
-        /* Duration exceeded 10 msecs */
-        if (duration > 10000ULL)
-                return (void)printf("+ ");
-
-        printf("  ");
-}
-
-static void print_graph_duration(unsigned long long duration)
-{
-        unsigned long usecs = duration / 1000;
-        unsigned long nsecs_rem = duration % 1000;
-        /* log10(ULONG_MAX) + '\0' */
-        char msecs_str[21];
-        char nsecs_str[5];
-        int len;
-        int i;
-
-        sprintf(msecs_str, "%lu", usecs);
-
-        /* Print msecs */
-        len = printf("%lu", usecs);
-
-        /* Print nsecs (we don't want to exceed 7 numbers) */
-        if (len < 7) {
-                snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
-                len += printf(".%s", nsecs_str);
-        }
-
-        printf(" us ");
-
-        /* Print remaining spaces to fit the row's width */
-        for (i = len; i < 7; i++)
-                printf(" ");
-
-        printf("|  ");
-}
-
-static void
-print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec)
-{
-        unsigned long long rettime, calltime;
-        unsigned long long duration, depth;
-        unsigned long long val;
-        struct format_field *field;
-        struct func_map *func;
-        struct event *ret_event;
-        int type;
-        int i;
-
-        type = trace_parse_common_type(ret_rec->data);
-        ret_event = trace_find_event(type);
-
-        field = find_field(ret_event, "rettime");
-        if (!field)
-                die("can't find rettime in return graph");
-        rettime = read_size(ret_rec->data + field->offset, field->size);
-
-        field = find_field(ret_event, "calltime");
-        if (!field)
-                die("can't find rettime in return graph");
-        calltime = read_size(ret_rec->data + field->offset, field->size);
-
-        duration = rettime - calltime;
-
-        /* Overhead */
-        print_graph_overhead(duration);
-
-        /* Duration */
-        print_graph_duration(duration);
-
-        field = find_field(event, "depth");
-        if (!field)
-                die("can't find depth in entry graph");
-        depth = read_size(data + field->offset, field->size);
-
-        /* Function */
-        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
-                printf(" ");
-
-        field = find_field(event, "func");
-        if (!field)
-                die("can't find func in entry graph");
-        val = read_size(data + field->offset, field->size);
-        func = find_func(val);
-
-        if (func)
-                printf("%s();", func->func);
-        else
-                printf("%llx();", val);
-}
-
-static void print_graph_nested(struct event *event, void *data)
-{
-        struct format_field *field;
-        unsigned long long depth;
-        unsigned long long val;
-        struct func_map *func;
-        int i;
-
-        /* No overhead */
-        print_graph_overhead(-1);
-
-        /* No time */
-        printf("           |  ");
-
-        field = find_field(event, "depth");
-        if (!field)
-                die("can't find depth in entry graph");
-        depth = read_size(data + field->offset, field->size);
-
-        /* Function */
-        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
-                printf(" ");
-
-        field = find_field(event, "func");
-        if (!field)
-                die("can't find func in entry graph");
-        val = read_size(data + field->offset, field->size);
-        func = find_func(val);
-
-        if (func)
-                printf("%s() {", func->func);
-        else
-                printf("%llx() {", val);
-}
-
-static void
-pretty_print_func_ent(void *data, int size, struct event *event,
-                      int cpu, int pid)
-{
-        struct format_field *field;
-        struct record *rec;
-        void *copy_data;
-        unsigned long val;
-
-        if (latency_format) {
-                print_lat_fmt(data, size);
-                printf(" | ");
-        }
-
-        field = find_field(event, "func");
-        if (!field)
-                die("function entry does not have func field");
-
-        val = read_size(data + field->offset, field->size);
-
-        /*
-         * peek_data may unmap the data pointer. Copy it first.
-         */
-        copy_data = malloc_or_die(size);
-        memcpy(copy_data, data, size);
-        data = copy_data;
-
-        rec = trace_peek_data(cpu);
-        if (rec) {
-                rec = get_return_for_leaf(cpu, pid, val, rec);
-                if (rec) {
-                        print_graph_entry_leaf(event, data, rec);
-                        goto out_free;
-                }
-        }
-        print_graph_nested(event, data);
-out_free:
-        free(data);
-}
-
-static void
-pretty_print_func_ret(void *data, int size __unused, struct event *event)
-{
-        unsigned long long rettime, calltime;
-        unsigned long long duration, depth;
-        struct format_field *field;
-        int i;
-
-        if (latency_format) {
-                print_lat_fmt(data, size);
-                printf(" | ");
-        }
-
-        field = find_field(event, "rettime");
-        if (!field)
-                die("can't find rettime in return graph");
-        rettime = read_size(data + field->offset, field->size);
-
-        field = find_field(event, "calltime");
-        if (!field)
-                die("can't find calltime in return graph");
-        calltime = read_size(data + field->offset, field->size);
-
-        duration = rettime - calltime;
-
-        /* Overhead */
-        print_graph_overhead(duration);
-
-        /* Duration */
-        print_graph_duration(duration);
-
-        field = find_field(event, "depth");
-        if (!field)
-                die("can't find depth in entry graph");
-        depth = read_size(data + field->offset, field->size);
-
-        /* Function */
-        for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
-                printf(" ");
-
-        printf("}");
-}
-
-static void
-pretty_print_func_graph(void *data, int size, struct event *event,
-                        int cpu, int pid)
-{
-        if (event->flags & EVENT_FL_ISFUNCENT)
-                pretty_print_func_ent(data, size, event, cpu, pid);
-        else if (event->flags & EVENT_FL_ISFUNCRET)
-                pretty_print_func_ret(data, size, event);
-        printf("\n");
-}
-
-void print_trace_event(int cpu, void *data, int size)
-{
-        struct event *event;
-        int type;
-        int pid;
-
-        type = trace_parse_common_type(data);
-
-        event = trace_find_event(type);
-        if (!event) {
-                warning("ug! no event found for type %d", type);
-                return;
-        }
-
-        pid = trace_parse_common_pid(data);
-
-        if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
-                return pretty_print_func_graph(data, size, event, cpu, pid);
-
-        if (latency_format)
-                print_lat_fmt(data, size);
-
-        if (event->flags & EVENT_FL_FAILED) {
-                printf("EVENT '%s' FAILED TO PARSE\n",
-                       event->name);
-                return;
-        }
-
-        pretty_print(data, size, event);
-}
-
-static void print_fields(struct print_flag_sym *field)
-{
-        printf("{ %s, %s }", field->value, field->str);
-        if (field->next) {
-                printf(", ");
-                print_fields(field->next);
-        }
-}
-
-static void print_args(struct print_arg *args)
-{
-        int print_paren = 1;
-
-        switch (args->type) {
-        case PRINT_NULL:
-                printf("null");
-                break;
-        case PRINT_ATOM:
-                printf("%s", args->atom.atom);
-                break;
-        case PRINT_FIELD:
-                printf("REC->%s", args->field.name);
-                break;
-        case PRINT_FLAGS:
-                printf("__print_flags(");
-                print_args(args->flags.field);
-                printf(", %s, ", args->flags.delim);
-                print_fields(args->flags.flags);
-                printf(")");
-                break;
-        case PRINT_SYMBOL:
-                printf("__print_symbolic(");
-                print_args(args->symbol.field);
-                printf(", ");
-                print_fields(args->symbol.symbols);
-                printf(")");
-                break;
-        case PRINT_STRING:
-                printf("__get_str(%s)", args->string.string);
-                break;
-        case PRINT_TYPE:
-                printf("(%s)", args->typecast.type);
-                print_args(args->typecast.item);
-                break;
-        case PRINT_OP:
-                if (strcmp(args->op.op, ":") == 0)
-                        print_paren = 0;
-                if (print_paren)
-                        printf("(");
-                print_args(args->op.left);
-                printf(" %s ", args->op.op);
-                print_args(args->op.right);
-                if (print_paren)
-                        printf(")");
-                break;
-        default:
-                /* we should warn... */
-                return;
-        }
-        if (args->next) {
-                printf("\n");
-                print_args(args->next);
-        }
-}
-
-int parse_ftrace_file(char *buf, unsigned long size)
-{
-        struct format_field *field;
-        struct print_arg *arg, **list;
-        struct event *event;
-        int ret;
-
-        init_input_buf(buf, size);
-
-        event = alloc_event();
-        if (!event)
-                return -ENOMEM;
-
-        event->flags |= EVENT_FL_ISFTRACE;
-
-        event->name = event_read_name();
-        if (!event->name)
-                die("failed to read ftrace event name");
-
-        if (strcmp(event->name, "function") == 0)
-                event->flags |= EVENT_FL_ISFUNC;
-
-        else if (strcmp(event->name, "funcgraph_entry") == 0)
-                event->flags |= EVENT_FL_ISFUNCENT;
-
-        else if (strcmp(event->name, "funcgraph_exit") == 0)
-                event->flags |= EVENT_FL_ISFUNCRET;
-
-        else if (strcmp(event->name, "bprint") == 0)
-                event->flags |= EVENT_FL_ISBPRINT;
-
-        event->id = event_read_id();
-        if (event->id < 0)
-                die("failed to read ftrace event id");
-
-        add_event(event);
-
-        ret = event_read_format(event);
-        if (ret < 0)
-                die("failed to read ftrace event format");
-
-        ret = event_read_print(event);
-        if (ret < 0)
-                die("failed to read ftrace event print fmt");
-
-        /* New ftrace handles args */
-        if (ret > 0)
-                return 0;
-        /*
-         * The arguments for ftrace files are parsed by the fields.
-         * Set up the fields as their arguments.
-         */
-        list = &event->print_fmt.args;
-        for (field = event->format.fields; field; field = field->next) {
-                arg = malloc_or_die(sizeof(*arg));
-                memset(arg, 0, sizeof(*arg));
-                *list = arg;
-                list = &arg->next;
-                arg->type = PRINT_FIELD;
-                arg->field.name = field->name;
-                arg->field.field = field;
-        }
-        return 0;
-}
-
-int parse_event_file(char *buf, unsigned long size, char *sys)
-{
-        struct event *event;
-        int ret;
-
-        init_input_buf(buf, size);
-
-        event = alloc_event();
-        if (!event)
-                return -ENOMEM;
-
-        event->name = event_read_name();
-        if (!event->name)
-                die("failed to read event name");
-
-        event->id = event_read_id();
-        if (event->id < 0)
-                die("failed to read event id");
-
-        ret = event_read_format(event);
-        if (ret < 0) {
-                warning("failed to read event format for %s", event->name);
-                goto event_failed;
-        }
-
-        ret = event_read_print(event);
-        if (ret < 0) {
-                warning("failed to read event print fmt for %s", event->name);
-                goto event_failed;
-        }
-
-        event->system = strdup(sys);
-
-#define PRINT_ARGS 0
-        if (PRINT_ARGS && event->print_fmt.args)
-                print_args(event->print_fmt.args);
-
-        add_event(event);
-        return 0;
-
- event_failed:
-        event->flags |= EVENT_FL_FAILED;
-        /* still add it even if it failed */
-        add_event(event);
-        return -1;
-}
-
-void parse_set_info(int nr_cpus, int long_sz)
-{
-        cpus = nr_cpus;
-        long_size = long_sz;
-}
-
-int common_pc(struct scripting_context *context)
-{
-        return parse_common_pc(context->event_data);
-}
-
-int common_flags(struct scripting_context *context)
-{
-        return parse_common_flags(context->event_data);
-}
-
-int common_lock_depth(struct scripting_context *context)
-{
-        return parse_common_lock_depth(context->event_data);
-}
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index b9592e0de8d7..f097e0dd6c5c 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -52,6 +52,16 @@ static unsigned long	page_size;
 static ssize_t calc_data_size;
 static bool repipe;
 
+static void *malloc_or_die(int size)
+{
+        void *ret;
+
+        ret = malloc(size);
+        if (!ret)
+                die("malloc");
+        return ret;
+}
+
 static int do_read(int fd, void *buf, int size)
 {
         int rsize = size;
@@ -109,7 +119,7 @@ static unsigned int read4(void)
         unsigned int data;
 
         read_or_die(&data, 4);
-        return __data2host4(data);
+        return __data2host4(perf_pevent, data);
 }
 
 static unsigned long long read8(void)
@@ -117,7 +127,7 @@ static unsigned long long read8(void)
         unsigned long long data;
 
         read_or_die(&data, 8);
-        return __data2host8(data);
+        return __data2host8(perf_pevent, data);
 }
 
 static char *read_string(void)
@@ -282,7 +292,7 @@ struct cpu_data {
         unsigned long long      offset;
         unsigned long long      size;
         unsigned long long      timestamp;
-        struct record           *next;
+        struct pevent_record    *next;
         char                    *page;
         int                     cpu;
         int                     index;
@@ -367,9 +377,9 @@ static int calc_index(void *ptr, int cpu)
         return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
 }
 
-struct record *trace_peek_data(int cpu)
+struct pevent_record *trace_peek_data(int cpu)
 {
-        struct record *data;
+        struct pevent_record *data;
         void *page = cpu_data[cpu].page;
         int idx = cpu_data[cpu].index;
         void *ptr = page + idx;
@@ -389,15 +399,15 @@ struct 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(ptr);
+                cpu_data[cpu].timestamp = data2host8(perf_pevent, ptr);
                 ptr += 8;
                 switch (header_page_size_size) {
                 case 4:
-                        cpu_data[cpu].page_size = data2host4(ptr);
+                        cpu_data[cpu].page_size = data2host4(perf_pevent, ptr);
                         ptr += 4;
                         break;
                 case 8:
-                        cpu_data[cpu].page_size = data2host8(ptr);
+                        cpu_data[cpu].page_size = data2host8(perf_pevent, ptr);
                         ptr += 8;
                         break;
                 default:
@@ -414,7 +424,7 @@ read_again:
                 return trace_peek_data(cpu);
         }
 
-        type_len_ts = data2host4(ptr);
+        type_len_ts = data2host4(perf_pevent, ptr);
         ptr += 4;
 
         type_len = type_len4host(type_len_ts);
@@ -424,14 +434,14 @@ read_again:
         case RINGBUF_TYPE_PADDING:
                 if (!delta)
                         die("error, hit unexpected end of page");
-                length = data2host4(ptr);
+                length = data2host4(perf_pevent, ptr);
                 ptr += 4;
                 length *= 4;
                 ptr += length;
                 goto read_again;
 
         case RINGBUF_TYPE_TIME_EXTEND:
-                extend = data2host4(ptr);
+                extend = data2host4(perf_pevent, ptr);
                 ptr += 4;
                 extend <<= TS_SHIFT;
                 extend += delta;
@@ -442,7 +452,7 @@ read_again:
                 ptr += 12;
                 break;
         case 0:
-                length = data2host4(ptr);
+                length = data2host4(perf_pevent, ptr);
                 ptr += 4;
                 die("here! length=%d", length);
                 break;
@@ -467,9 +477,9 @@ read_again:
         return data;
 }
 
-struct record *trace_read_data(int cpu)
+struct pevent_record *trace_read_data(int cpu)
 {
-        struct record *data;
+        struct pevent_record *data;
 
         data = trace_peek_data(cpu);
         cpu_data[cpu].next = NULL;
@@ -509,6 +519,8 @@ ssize_t trace_report(int fd, bool __repipe)
         file_bigendian = buf[0];
         host_bigendian = bigendian();
 
+        read_trace_init(file_bigendian, host_bigendian);
+
         read_or_die(buf, 1);
         long_size = buf[0];
 
@@ -526,11 +538,11 @@ ssize_t trace_report(int fd, bool __repipe)
         repipe = false;
 
         if (show_funcs) {
-                print_funcs();
+                pevent_print_funcs(perf_pevent);
                 return size;
         }
         if (show_printk) {
-                print_printk();
+                pevent_print_printk(perf_pevent);
                 return size;
         }
 
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 58ae14c5baac..639852ac1117 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -1,20 +1,21 @@
-#ifndef __PERF_TRACE_EVENTS_H
-#define __PERF_TRACE_EVENTS_H
+#ifndef _PERF_UTIL_TRACE_EVENT_H
+#define _PERF_UTIL_TRACE_EVENT_H
 
-#include <stdbool.h>
 #include "parse-events.h"
+#include "event-parse.h"
+#include "session.h"
 
 struct machine;
 struct perf_sample;
 union perf_event;
 struct thread;
 
-#define __unused __attribute__((unused))
-
+extern int header_page_size_size;
+extern int header_page_ts_size;
+extern int header_page_data_offset;
 
-#ifndef PAGE_MASK
-#define PAGE_MASK (page_size - 1)
-#endif
+extern bool latency_format;
+extern struct pevent *perf_pevent;
 
 enum {
         RINGBUF_TYPE_PADDING            = 29,
@@ -26,246 +27,37 @@ enum {
 #define TS_SHIFT                27
 #endif
 
-#define NSECS_PER_SEC           1000000000ULL
-#define NSECS_PER_USEC          1000ULL
-
-enum format_flags {
-        FIELD_IS_ARRAY          = 1,
-        FIELD_IS_POINTER        = 2,
-        FIELD_IS_SIGNED         = 4,
-        FIELD_IS_STRING         = 8,
-        FIELD_IS_DYNAMIC        = 16,
-        FIELD_IS_FLAG           = 32,
-        FIELD_IS_SYMBOLIC       = 64,
-};
-
-struct format_field {
-        struct format_field     *next;
-        char                    *type;
-        char                    *name;
-        int                     offset;
-        int                     size;
-        unsigned long           flags;
-};
-
-struct format {
-        int                     nr_common;
-        int                     nr_fields;
-        struct format_field     *common_fields;
-        struct format_field     *fields;
-};
-
-struct print_arg_atom {
-        char                    *atom;
-};
-
-struct print_arg_string {
-        char                    *string;
-        int                     offset;
-};
-
-struct print_arg_field {
-        char                    *name;
-        struct format_field     *field;
-};
-
-struct print_flag_sym {
-        struct print_flag_sym   *next;
-        char                    *value;
-        char                    *str;
-};
-
-struct print_arg_typecast {
-        char                    *type;
-        struct print_arg        *item;
-};
-
-struct print_arg_flags {
-        struct print_arg        *field;
-        char                    *delim;
-        struct print_flag_sym   *flags;
-};
-
-struct print_arg_symbol {
-        struct print_arg        *field;
-        struct print_flag_sym   *symbols;
-};
-
-struct print_arg;
-
-struct print_arg_op {
-        char                    *op;
-        int                     prio;
-        struct print_arg        *left;
-        struct print_arg        *right;
-};
-
-struct print_arg_func {
-        char                    *name;
-        struct print_arg        *args;
-};
-
-enum print_arg_type {
-        PRINT_NULL,
-        PRINT_ATOM,
-        PRINT_FIELD,
-        PRINT_FLAGS,
-        PRINT_SYMBOL,
-        PRINT_TYPE,
-        PRINT_STRING,
-        PRINT_OP,
-};
-
-struct print_arg {
-        struct print_arg                *next;
-        enum print_arg_type             type;
-        union {
-                struct print_arg_atom           atom;
-                struct print_arg_field          field;
-                struct print_arg_typecast       typecast;
-                struct print_arg_flags          flags;
-                struct print_arg_symbol         symbol;
-                struct print_arg_func           func;
-                struct print_arg_string         string;
-                struct print_arg_op             op;
-        };
-};
-
-struct print_fmt {
-        char                    *format;
-        struct print_arg        *args;
-};
-
-struct event {
-        struct event            *next;
-        char                    *name;
-        int                     id;
-        int                     flags;
-        struct format           format;
-        struct print_fmt        print_fmt;
-        char                    *system;
-};
-
-enum {
-        EVENT_FL_ISFTRACE       = 0x01,
-        EVENT_FL_ISPRINT        = 0x02,
-        EVENT_FL_ISBPRINT       = 0x04,
-        EVENT_FL_ISFUNC         = 0x08,
-        EVENT_FL_ISFUNCENT      = 0x10,
-        EVENT_FL_ISFUNCRET      = 0x20,
-
-        EVENT_FL_FAILED         = 0x80000000
-};
-
-struct record {
-        unsigned long long ts;
-        int size;
-        void *data;
-};
-
-struct record *trace_peek_data(int cpu);
-struct record *trace_read_data(int cpu);
-
-void parse_set_info(int nr_cpus, int long_sz);
-
-ssize_t trace_report(int fd, bool repipe);
-
-void *malloc_or_die(unsigned int size);
+int bigendian(void);
 
-void parse_cmdlines(char *file, int size);
-void parse_proc_kallsyms(char *file, unsigned int size);
-void parse_ftrace_printk(char *file, unsigned int size);
+int read_trace_init(int file_bigendian, int host_bigendian);
+void print_trace_event(int cpu, void *data, int size);
 
-void print_funcs(void);
-void print_printk(void);
+void print_event(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);
-void print_trace_event(int cpu, void *data, int size);
-
-extern int file_bigendian;
-extern int host_bigendian;
-
-int bigendian(void);
-
-static inline unsigned short __data2host2(unsigned short data)
-{
-        unsigned short swap;
-
-        if (host_bigendian == file_bigendian)
-                return data;
 
-        swap = ((data & 0xffULL) << 8) |
-                ((data & (0xffULL << 8)) >> 8);
+struct pevent_record *trace_peek_data(int cpu);
+struct event_format *trace_find_event(int type);
 
-        return swap;
-}
-
-static inline unsigned int __data2host4(unsigned int data)
-{
-        unsigned int swap;
-
-        if (host_bigendian == file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 24) |
-                ((data & (0xffULL << 8)) << 8) |
-                ((data & (0xffULL << 16)) >> 8) |
-                ((data & (0xffULL << 24)) >> 24);
-
-        return swap;
-}
-
-static inline unsigned long long __data2host8(unsigned long long data)
-{
-        unsigned long long swap;
-
-        if (host_bigendian == file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 56) |
-                ((data & (0xffULL << 8)) << 40) |
-                ((data & (0xffULL << 16)) << 24) |
-                ((data & (0xffULL << 24)) << 8) |
-                ((data & (0xffULL << 32)) >> 8) |
-                ((data & (0xffULL << 40)) >> 24) |
-                ((data & (0xffULL << 48)) >> 40) |
-                ((data & (0xffULL << 56)) >> 56);
-
-        return swap;
-}
+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);
 
-#define data2host2(ptr)         __data2host2(*(unsigned short *)ptr)
-#define data2host4(ptr)         __data2host4(*(unsigned int *)ptr)
-#define data2host8(ptr)         ({                              \
-        unsigned long long __val;                               \
-                                                                \
-        memcpy(&__val, (ptr), sizeof(unsigned long long));      \
-        __data2host8(__val);                                    \
-})
+void parse_proc_kallsyms(char *file, unsigned int size __unused);
+void parse_ftrace_printk(char *file, unsigned int size __unused);
 
-extern int header_page_ts_offset;
-extern int header_page_ts_size;
-extern int header_page_size_offset;
-extern int header_page_size_size;
-extern int header_page_data_offset;
-extern int header_page_data_size;
-
-extern bool latency_format;
+ssize_t trace_report(int fd, bool repipe);
 
 int trace_parse_common_type(void *data);
 int trace_parse_common_pid(void *data);
-int parse_common_pc(void *data);
-int parse_common_flags(void *data);
-int parse_common_lock_depth(void *data);
-struct event *trace_find_event(int id);
-struct event *trace_find_next_event(struct event *event);
+
+struct event_format *trace_find_next_event(struct event_format *event);
 unsigned long long read_size(void *ptr, int size);
-unsigned long long
-raw_field_value(struct event *event, const char *name, void *data);
-void *raw_field_ptr(struct event *event, const char *name, void *data);
 unsigned long long eval_flag(const char *flag);
 
+struct pevent_record *trace_read_data(int cpu);
 int read_tracing_data(int fd, struct list_head *pattrs);
 
 struct tracing_data {
@@ -280,15 +72,6 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 void tracing_data_put(struct tracing_data *tdata);
 
 
-/* taken from kernel/trace/trace.h */
-enum trace_flag_type {
-        TRACE_FLAG_IRQS_OFF             = 0x01,
-        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
-        TRACE_FLAG_NEED_RESCHED         = 0x04,
-        TRACE_FLAG_HARDIRQ              = 0x08,
-        TRACE_FLAG_SOFTIRQ              = 0x10,
-};
-
 struct scripting_ops {
         const char *name;
         int (*start_script) (const char *script, int argc, const char **argv);
@@ -314,4 +97,4 @@ int common_pc(struct scripting_context *context);
 int common_flags(struct scripting_context *context);
 int common_lock_depth(struct scripting_context *context);
 
-#endif /* __PERF_TRACE_EVENTS_H */
+#endif /* _PERF_UTIL_TRACE_EVENT_H */
diff --git a/tools/perf/util/types.h b/tools/perf/util/types.h
index 5f3689a3d085..c51fa6b70a28 100644
--- a/tools/perf/util/types.h
+++ b/tools/perf/util/types.h
@@ -16,4 +16,9 @@ typedef signed short	   s16;
 typedef unsigned char      u8;
 typedef signed char        s8;
 
+union u64_swap {
+        u64 val64;
+        u32 val32[2];
+};
+
 #endif /* __PERF_TYPES_H */
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
deleted file mode 100644
index 57a4c6ef3fd2..000000000000
--- a/tools/perf/util/ui/browsers/annotate.c
+++ /dev/null
@@ -1,433 +0,0 @@
-#include "../../util.h"
-#include "../browser.h"
-#include "../helpline.h"
-#include "../libslang.h"
-#include "../ui.h"
-#include "../util.h"
-#include "../../annotate.h"
-#include "../../hist.h"
-#include "../../sort.h"
-#include "../../symbol.h"
-#include <pthread.h>
-#include <newt.h>
-
-struct annotate_browser {
-        struct ui_browser b;
-        struct rb_root    entries;
-        struct rb_node    *curr_hot;
-        struct objdump_line *selection;
-        int                 nr_asm_entries;
-        int                 nr_entries;
-        bool                hide_src_code;
-};
-
-struct objdump_line_rb_node {
-        struct rb_node  rb_node;
-        double          percent;
-        u32             idx;
-        int             idx_asm;
-};
-
-static inline
-struct objdump_line_rb_node *objdump_line__rb(struct objdump_line *self)
-{
-        return (struct objdump_line_rb_node *)(self + 1);
-}
-
-static bool objdump_line__filter(struct ui_browser *browser, void *entry)
-{
-        struct annotate_browser *ab = container_of(browser, struct annotate_browser, b);
-
-        if (ab->hide_src_code) {
-                struct objdump_line *ol = list_entry(entry, struct objdump_line, node);
-                return ol->offset == -1;
-        }
-
-        return false;
-}
-
-static void annotate_browser__write(struct ui_browser *self, void *entry, int row)
-{
-        struct annotate_browser *ab = container_of(self, struct annotate_browser, b);
-        struct objdump_line *ol = list_entry(entry, struct objdump_line, node);
-        bool current_entry = ui_browser__is_current_entry(self, row);
-        int width = self->width;
-
-        if (ol->offset != -1) {
-                struct objdump_line_rb_node *olrb = objdump_line__rb(ol);
-                ui_browser__set_percent_color(self, olrb->percent, current_entry);
-                slsmg_printf(" %7.2f ", olrb->percent);
-        } else {
-                ui_browser__set_percent_color(self, 0, current_entry);
-                slsmg_write_nstring(" ", 9);
-        }
-
-        SLsmg_write_char(':');
-        slsmg_write_nstring(" ", 8);
-
-        /* The scroll bar isn't being used */
-        if (!self->navkeypressed)
-                width += 1;
-
-        if (!ab->hide_src_code && ol->offset != -1)
-                if (!current_entry || (self->use_navkeypressed &&
-                                       !self->navkeypressed))
-                        ui_browser__set_color(self, HE_COLORSET_CODE);
-
-        if (!*ol->line)
-                slsmg_write_nstring(" ", width - 18);
-        else
-                slsmg_write_nstring(ol->line, width - 18);
-
-        if (current_entry)
-                ab->selection = ol;
-}
-
-static double objdump_line__calc_percent(struct objdump_line *self,
-                                         struct symbol *sym, int evidx)
-{
-        double percent = 0.0;
-
-        if (self->offset != -1) {
-                int len = sym->end - sym->start;
-                unsigned int hits = 0;
-                struct annotation *notes = symbol__annotation(sym);
-                struct source_line *src_line = notes->src->lines;
-                struct sym_hist *h = annotation__histogram(notes, evidx);
-                s64 offset = self->offset;
-                struct objdump_line *next;
-
-                next = objdump__get_next_ip_line(&notes->src->source, self);
-                while (offset < (s64)len &&
-                       (next == NULL || offset < next->offset)) {
-                        if (src_line) {
-                                percent += src_line[offset].percent;
-                        } else
-                                hits += h->addr[offset];
-
-                        ++offset;
-                }
-                /*
-                 * If the percentage wasn't already calculated in
-                 * symbol__get_source_line, do it now:
-                 */
-                if (src_line == NULL && h->sum)
-                        percent = 100.0 * hits / h->sum;
-        }
-
-        return percent;
-}
-
-static void objdump__insert_line(struct rb_root *self,
-                                 struct objdump_line_rb_node *line)
-{
-        struct rb_node **p = &self->rb_node;
-        struct rb_node *parent = NULL;
-        struct objdump_line_rb_node *l;
-
-        while (*p != NULL) {
-                parent = *p;
-                l = rb_entry(parent, struct objdump_line_rb_node, rb_node);
-                if (line->percent < l->percent)
-                        p = &(*p)->rb_left;
-                else
-                        p = &(*p)->rb_right;
-        }
-        rb_link_node(&line->rb_node, parent, p);
-        rb_insert_color(&line->rb_node, self);
-}
-
-static void annotate_browser__set_top(struct annotate_browser *self,
-                                      struct rb_node *nd)
-{
-        struct objdump_line_rb_node *rbpos;
-        struct objdump_line *pos;
-        unsigned back;
-
-        ui_browser__refresh_dimensions(&self->b);
-        back = self->b.height / 2;
-        rbpos = rb_entry(nd, struct objdump_line_rb_node, rb_node);
-        pos = ((struct objdump_line *)rbpos) - 1;
-        self->b.top_idx = self->b.index = rbpos->idx;
-
-        while (self->b.top_idx != 0 && back != 0) {
-                pos = list_entry(pos->node.prev, struct objdump_line, node);
-
-                --self->b.top_idx;
-                --back;
-        }
-
-        self->b.top = pos;
-        self->curr_hot = nd;
-}
-
-static void annotate_browser__calc_percent(struct annotate_browser *browser,
-                                           int evidx)
-{
-        struct map_symbol *ms = browser->b.priv;
-        struct symbol *sym = ms->sym;
-        struct annotation *notes = symbol__annotation(sym);
-        struct objdump_line *pos;
-
-        browser->entries = RB_ROOT;
-
-        pthread_mutex_lock(&notes->lock);
-
-        list_for_each_entry(pos, &notes->src->source, node) {
-                struct objdump_line_rb_node *rbpos = objdump_line__rb(pos);
-                rbpos->percent = objdump_line__calc_percent(pos, sym, evidx);
-                if (rbpos->percent < 0.01) {
-                        RB_CLEAR_NODE(&rbpos->rb_node);
-                        continue;
-                }
-                objdump__insert_line(&browser->entries, rbpos);
-        }
-        pthread_mutex_unlock(&notes->lock);
-
-        browser->curr_hot = rb_last(&browser->entries);
-}
-
-static bool annotate_browser__toggle_source(struct annotate_browser *browser)
-{
-        struct objdump_line *ol;
-        struct objdump_line_rb_node *olrb;
-        off_t offset = browser->b.index - browser->b.top_idx;
-
-        browser->b.seek(&browser->b, offset, SEEK_CUR);
-        ol = list_entry(browser->b.top, struct objdump_line, node);
-        olrb = objdump_line__rb(ol);
-
-        if (browser->hide_src_code) {
-                if (olrb->idx_asm < offset)
-                        offset = olrb->idx;
-
-                browser->b.nr_entries = browser->nr_entries;
-                browser->hide_src_code = false;
-                browser->b.seek(&browser->b, -offset, SEEK_CUR);
-                browser->b.top_idx = olrb->idx - offset;
-                browser->b.index = olrb->idx;
-        } else {
-                if (olrb->idx_asm < 0) {
-                        ui_helpline__puts("Only available for assembly lines.");
-                        browser->b.seek(&browser->b, -offset, SEEK_CUR);
-                        return false;
-                }
-
-                if (olrb->idx_asm < offset)
-                        offset = olrb->idx_asm;
-
-                browser->b.nr_entries = browser->nr_asm_entries;
-                browser->hide_src_code = true;
-                browser->b.seek(&browser->b, -offset, SEEK_CUR);
-                browser->b.top_idx = olrb->idx_asm - offset;
-                browser->b.index = olrb->idx_asm;
-        }
-
-        return true;
-}
-
-static int annotate_browser__run(struct annotate_browser *self, int evidx,
-                                 void(*timer)(void *arg),
-                                 void *arg, int delay_secs)
-{
-        struct rb_node *nd = NULL;
-        struct map_symbol *ms = self->b.priv;
-        struct symbol *sym = ms->sym;
-        const char *help = "<-/ESC: Exit, TAB/shift+TAB: Cycle hot lines, "
-                           "H: Go to hottest line, ->/ENTER: Line action, "
-                           "S: Toggle source code view";
-        int key;
-
-        if (ui_browser__show(&self->b, sym->name, help) < 0)
-                return -1;
-
-        annotate_browser__calc_percent(self, evidx);
-
-        if (self->curr_hot)
-                annotate_browser__set_top(self, self->curr_hot);
-
-        nd = self->curr_hot;
-
-        while (1) {
-                key = ui_browser__run(&self->b, delay_secs);
-
-                if (delay_secs != 0) {
-                        annotate_browser__calc_percent(self, evidx);
-                        /*
-                         * Current line focus got out of the list of most active
-                         * lines, NULL it so that if TAB|UNTAB is pressed, we
-                         * move to curr_hot (current hottest line).
-                         */
-                        if (nd != NULL && RB_EMPTY_NODE(nd))
-                                nd = NULL;
-                }
-
-                switch (key) {
-                case K_TIMER:
-                        if (timer != NULL)
-                                timer(arg);
-
-                        if (delay_secs != 0)
-                                symbol__annotate_decay_histogram(sym, evidx);
-                        continue;
-                case K_TAB:
-                        if (nd != NULL) {
-                                nd = rb_prev(nd);
-                                if (nd == NULL)
-                                        nd = rb_last(&self->entries);
-                        } else
-                                nd = self->curr_hot;
-                        break;
-                case K_UNTAB:
-                        if (nd != NULL)
-                                nd = rb_next(nd);
-                                if (nd == NULL)
-                                        nd = rb_first(&self->entries);
-                        else
-                                nd = self->curr_hot;
-                        break;
-                case 'H':
-                case 'h':
-                        nd = self->curr_hot;
-                        break;
-                case 'S':
-                case 's':
-                        if (annotate_browser__toggle_source(self))
-                                ui_helpline__puts(help);
-                        continue;
-                case K_ENTER:
-                case K_RIGHT:
-                        if (self->selection == NULL) {
-                                ui_helpline__puts("Huh? No selection. Report to linux-kernel@vger.kernel.org");
-                                continue;
-                        }
-
-                        if (self->selection->offset == -1) {
-                                ui_helpline__puts("Actions are only available for assembly lines.");
-                                continue;
-                        } else {
-                                char *s = strstr(self->selection->line, "callq ");
-                                struct annotation *notes;
-                                struct symbol *target;
-                                u64 ip;
-
-                                if (s == NULL) {
-                                        ui_helpline__puts("Actions are only available for the 'callq' instruction.");
-                                        continue;
-                                }
-
-                                s = strchr(s, ' ');
-                                if (s++ == NULL) {
-                                        ui_helpline__puts("Invallid callq instruction.");
-                                        continue;
-                                }
-
-                                ip = strtoull(s, NULL, 16);
-                                ip = ms->map->map_ip(ms->map, ip);
-                                target = map__find_symbol(ms->map, ip, NULL);
-                                if (target == NULL) {
-                                        ui_helpline__puts("The called function was not found.");
-                                        continue;
-                                }
-
-                                notes = symbol__annotation(target);
-                                pthread_mutex_lock(&notes->lock);
-
-                                if (notes->src == NULL && symbol__alloc_hist(target) < 0) {
-                                        pthread_mutex_unlock(&notes->lock);
-                                        ui__warning("Not enough memory for annotating '%s' symbol!\n",
-                                                    target->name);
-                                        continue;
-                                }
-
-                                pthread_mutex_unlock(&notes->lock);
-                                symbol__tui_annotate(target, ms->map, evidx,
-                                                     timer, arg, delay_secs);
-                                ui_browser__show_title(&self->b, sym->name);
-                        }
-                        continue;
-                case K_LEFT:
-                case K_ESC:
-                case 'q':
-                case CTRL('c'):
-                        goto out;
-                default:
-                        continue;
-                }
-
-                if (nd != NULL)
-                        annotate_browser__set_top(self, nd);
-        }
-out:
-        ui_browser__hide(&self->b);
-        return key;
-}
-
-int hist_entry__tui_annotate(struct hist_entry *he, int evidx,
-                             void(*timer)(void *arg), void *arg, int delay_secs)
-{
-        return symbol__tui_annotate(he->ms.sym, he->ms.map, evidx,
-                                    timer, arg, delay_secs);
-}
-
-int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
-                         void(*timer)(void *arg), void *arg,
-                         int delay_secs)
-{
-        struct objdump_line *pos, *n;
-        struct annotation *notes;
-        struct map_symbol ms = {
-                .map = map,
-                .sym = sym,
-        };
-        struct annotate_browser browser = {
-                .b = {
-                        .refresh = ui_browser__list_head_refresh,
-                        .seek    = ui_browser__list_head_seek,
-                        .write   = annotate_browser__write,
-                        .filter  = objdump_line__filter,
-                        .priv    = &ms,
-                        .use_navkeypressed = true,
-                },
-        };
-        int ret;
-
-        if (sym == NULL)
-                return -1;
-
-        if (map->dso->annotate_warned)
-                return -1;
-
-        if (symbol__annotate(sym, map, sizeof(struct objdump_line_rb_node)) < 0) {
-                ui__error("%s", ui_helpline__last_msg);
-                return -1;
-        }
-
-        ui_helpline__push("Press <- or ESC to exit");
-
-        notes = symbol__annotation(sym);
-
-        list_for_each_entry(pos, &notes->src->source, node) {
-                struct objdump_line_rb_node *rbpos;
-                size_t line_len = strlen(pos->line);
-
-                if (browser.b.width < line_len)
-                        browser.b.width = line_len;
-                rbpos = objdump_line__rb(pos);
-                rbpos->idx = browser.nr_entries++;
-                if (pos->offset != -1)
-                        rbpos->idx_asm = browser.nr_asm_entries++;
-                else
-                        rbpos->idx_asm = -1;
-        }
-
-        browser.b.nr_entries = browser.nr_entries;
-        browser.b.entries = &notes->src->source,
-        browser.b.width += 18; /* Percentage */
-        ret = annotate_browser__run(&browser, evidx, timer, arg, delay_secs);
-        list_for_each_entry_safe(pos, n, &notes->src->source, node) {
-                list_del(&pos->node);
-                objdump_line__free(pos);
-        }
-        return ret;
-}
diff --git a/tools/perf/util/usage.c b/tools/perf/util/usage.c
index 52bb07c6442a..4007aca8e0ca 100644
--- a/tools/perf/util/usage.c
+++ b/tools/perf/util/usage.c
@@ -82,41 +82,3 @@ void warning(const char *warn, ...)
         warn_routine(warn, params);
         va_end(params);
 }
-
-uid_t parse_target_uid(const char *str, const char *tid, const char *pid)
-{
-        struct passwd pwd, *result;
-        char buf[1024];
-
-        if (str == NULL)
-                return UINT_MAX;
-
-        /* UID and PID are mutually exclusive */
-        if (tid || pid) {
-                ui__warning("PID/TID switch overriding UID\n");
-                sleep(1);
-                return UINT_MAX;
-        }
-
-        getpwnam_r(str, &pwd, buf, sizeof(buf), &result);
-
-        if (result == NULL) {
-                char *endptr;
-                int uid = strtol(str, &endptr, 10);
-
-                if (*endptr != '\0') {
-                        ui__error("Invalid user %s\n", str);
-                        return UINT_MAX - 1;
-                }
-
-                getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
-
-                if (result == NULL) {
-                        ui__error("Problems obtaining information for user %s\n",
-                                  str);
-                        return UINT_MAX - 1;
-                }
-        }
-
-        return result->pw_uid;
-}
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 8109a907841e..d03599fbe78b 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -148,3 +148,13 @@ int readn(int fd, void *buf, size_t n)
 
         return buf - buf_start;
 }
+
+size_t hex_width(u64 v)
+{
+        size_t n = 1;
+
+        while ((v >>= 4))
+                ++n;
+
+        return n;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 0f99f394d8e0..2daaedb83d84 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -74,7 +74,6 @@
 #include <netinet/tcp.h>
 #include <arpa/inet.h>
 #include <netdb.h>
-#include <pwd.h>
 #include <inttypes.h>
 #include "../../../include/linux/magic.h"
 #include "types.h"
@@ -249,8 +248,6 @@ struct perf_event_attr;
 
 void event_attr_init(struct perf_event_attr *attr);
 
-uid_t parse_target_uid(const char *str, const char *tid, const char *pid);
-
 #define _STR(x) #x
 #define STR(x) _STR(x)
 
@@ -265,4 +262,6 @@ bool is_power_of_2(unsigned long n)
         return (n != 0 && ((n & (n - 1)) == 0));
 }
 
+size_t hex_width(u64 v);
+
 #endif
diff --git a/tools/power/cpupower/man/cpupower-set.1 b/tools/power/cpupower/man/cpupower-set.1
index c4954a9fe4e7..9dbd536518ab 100644
--- a/tools/power/cpupower/man/cpupower-set.1
+++ b/tools/power/cpupower/man/cpupower-set.1
@@ -85,15 +85,6 @@ Possible values are:
 savings
 .RE
 
-sched_mc_power_savings is dependent upon SCHED_MC, which is
-itself architecture dependent.
-
-sched_smt_power_savings is dependent upon SCHED_SMT, which
-is itself architecture dependent.
-
-The two files are independent of each other. It is possible
-that one file may be present without the other.
-
 .SH "SEE ALSO"
 cpupower-info(1), cpupower-monitor(1), powertop(1)
 .PP
diff --git a/tools/power/cpupower/utils/helpers/sysfs.c b/tools/power/cpupower/utils/helpers/sysfs.c
index c6343024a611..96e28c124b5c 100644
--- a/tools/power/cpupower/utils/helpers/sysfs.c
+++ b/tools/power/cpupower/utils/helpers/sysfs.c
@@ -362,22 +362,7 @@ char *sysfs_get_cpuidle_driver(void)
  */
 int sysfs_get_sched(const char *smt_mc)
 {
-        unsigned long value;
-        char linebuf[MAX_LINE_LEN];
-        char *endp;
-        char path[SYSFS_PATH_MAX];
-
-        if (strcmp("mc", smt_mc) && strcmp("smt", smt_mc))
-                return -EINVAL;
-
-        snprintf(path, sizeof(path),
-                PATH_TO_CPU "sched_%s_power_savings", smt_mc);
-        if (sysfs_read_file(path, linebuf, MAX_LINE_LEN) == 0)
-                return -1;
-        value = strtoul(linebuf, &endp, 0);
-        if (endp == linebuf || errno == ERANGE)
-                return -1;
-        return value;
+        return -ENODEV;
 }
 
 /*
@@ -388,21 +373,5 @@ int sysfs_get_sched(const char *smt_mc)
  */
 int sysfs_set_sched(const char *smt_mc, int val)
 {
-        char linebuf[MAX_LINE_LEN];
-        char path[SYSFS_PATH_MAX];
-        struct stat statbuf;
-
-        if (strcmp("mc", smt_mc) && strcmp("smt", smt_mc))
-                return -EINVAL;
-
-        snprintf(path, sizeof(path),
-                PATH_TO_CPU "sched_%s_power_savings", smt_mc);
-        sprintf(linebuf, "%d", val);
-
-        if (stat(path, &statbuf) != 0)
-                return -ENODEV;
-
-        if (sysfs_write_file(path, linebuf, MAX_LINE_LEN) == 0)
-                return -1;
-        return 0;
+        return -ENODEV;
 }
diff --git a/tools/scripts/Makefile.include b/tools/scripts/Makefile.include
new file mode 100644
index 000000000000..bde8521d56bb
--- /dev/null
+++ b/tools/scripts/Makefile.include
@@ -0,0 +1,58 @@
+ifeq ("$(origin O)", "command line")
+        OUTPUT := $(O)/
+        COMMAND_O := O=$(O)
+endif
+
+ifneq ($(OUTPUT),)
+# check that the output directory actually exists
+OUTDIR := $(shell cd $(OUTPUT) && /bin/pwd)
+$(if $(OUTDIR),, $(error output directory "$(OUTPUT)" does not exist))
+endif
+
+#
+# Include saner warnings here, which can catch bugs:
+#
+EXTRA_WARNINGS := -Wbad-function-cast
+EXTRA_WARNINGS += -Wdeclaration-after-statement
+EXTRA_WARNINGS += -Wformat-security
+EXTRA_WARNINGS += -Wformat-y2k
+EXTRA_WARNINGS += -Winit-self
+EXTRA_WARNINGS += -Wmissing-declarations
+EXTRA_WARNINGS += -Wmissing-prototypes
+EXTRA_WARNINGS += -Wnested-externs
+EXTRA_WARNINGS += -Wno-system-headers
+EXTRA_WARNINGS += -Wold-style-definition
+EXTRA_WARNINGS += -Wpacked
+EXTRA_WARNINGS += -Wredundant-decls
+EXTRA_WARNINGS += -Wshadow
+EXTRA_WARNINGS += -Wstrict-aliasing=3
+EXTRA_WARNINGS += -Wstrict-prototypes
+EXTRA_WARNINGS += -Wswitch-default
+EXTRA_WARNINGS += -Wswitch-enum
+EXTRA_WARNINGS += -Wundef
+EXTRA_WARNINGS += -Wwrite-strings
+EXTRA_WARNINGS += -Wformat
+
+ifneq ($(findstring $(MAKEFLAGS), w),w)
+PRINT_DIR = --no-print-directory
+else
+NO_SUBDIR = :
+endif
+
+QUIET_SUBDIR0  = +$(MAKE) -C # space to separate -C and subdir
+QUIET_SUBDIR1  =
+
+ifneq ($(findstring $(MAKEFLAGS),s),s)
+ifndef V
+        QUIET_CC       = @echo '   ' CC $@;
+        QUIET_AR       = @echo '   ' AR $@;
+        QUIET_LINK     = @echo '   ' LINK $@;
+        QUIET_MKDIR    = @echo '   ' MKDIR $@;
+        QUIET_GEN      = @echo '   ' GEN $@;
+        QUIET_SUBDIR0  = +@subdir=
+        QUIET_SUBDIR1  = ;$(NO_SUBDIR) echo '   ' SUBDIR $$subdir; \
+                         $(MAKE) $(PRINT_DIR) -C $$subdir
+        QUIET_FLEX     = @echo '   ' FLEX $@;
+        QUIET_BISON    = @echo '   ' BISON $@;
+endif
+endif
diff --git a/tools/testing/ktest/examples/README b/tools/testing/ktest/examples/README
new file mode 100644
index 000000000000..a12d295a09d8
--- /dev/null
+++ b/tools/testing/ktest/examples/README
@@ -0,0 +1,32 @@
+This directory contains example configs to use ktest for various tasks.
+The configs still need to be customized for your environment, but it
+is broken up by task which makes it easier to understand how to set up
+ktest.
+
+The configs are based off of real working configs but have been modified
+and commented to show more generic use cases that are more helpful for
+developers.
+
+crosstests.conf - this config shows an example of testing a git repo against
+    lots of different architectures. It only does build tests, but makes
+    it easy to compile test different archs. You can download the arch
+    cross compilers from:
+  http://kernel.org/pub/tools/crosstool/files/bin/x86_64/
+
+test.conf - A generic example of a config. This is based on an actual config
+     used to perform real testing.
+
+kvm.conf - A example of a config that is used to test a virtual guest running
+     on a host.
+
+snowball.conf - An example config that was used to demo ktest.pl against
+     a snowball ARM board.
+
+include/  -  The include directory holds default configs that can be
+    included into other configs. This is a real use example that shows how
+    to reuse configs for various machines or set ups. The files here
+    are included by other config files, where the other config files define
+    options and variables that will make the included config work for the
+    given environment.
+
+
diff --git a/tools/testing/ktest/examples/crosstests.conf b/tools/testing/ktest/examples/crosstests.conf
new file mode 100644
index 000000000000..46736604c26c
--- /dev/null
+++ b/tools/testing/ktest/examples/crosstests.conf
@@ -0,0 +1,260 @@
+#
+# Example config for cross compiling
+#
+# In this config, it is expected that the tool chains from:
+#
+#   http://kernel.org/pub/tools/crosstool/files/bin/x86_64/
+#
+# running on a x86_64 system have been downloaded and installed into:
+#
+#   /usr/local/
+#
+# such that the compiler binaries are something like:
+#
+#   /usr/local/gcc-4.5.2-nolibc/mips-linux/bin/mips-linux-gcc
+#
+# Some of the archs will use gcc-4.5.1 instead of gcc-4.5.2
+# this config uses variables to differentiate them.
+# 
+# Comments describe some of the options, but full descriptions of
+# options are described in the samples.conf file.
+
+# ${PWD} is defined by ktest.pl to be the directory that the user
+# was in when they executed ktest.pl. It may be better to hardcode the
+# path name here. THIS_DIR is the variable used through out the config file
+# in case you want to change it.
+
+THIS_DIR := ${PWD}
+
+# Update the BUILD_DIR option to the location of your git repo you want to test.
+BUILD_DIR = ${THIS_DIR}/linux.git
+
+# The build will go into this directory. It will be created when you run the test.
+OUTPUT_DIR = ${THIS_DIR}/cross-compile
+
+# The build will be compiled with -j8
+BUILD_OPTIONS = -j8
+
+# The test will not stop when it hits a failure.
+DIE_ON_FAILURE = 0
+
+# If you want to have ktest.pl store the failure somewhere, uncomment this option
+# and change the directory where ktest should store the failures.
+#STORE_FAILURES = ${THIS_DIR}/failures
+
+# The log file is stored in the OUTPUT_DIR called cross.log
+# If you enable this, you need to create the OUTPUT_DIR. It wont be created for you.
+LOG_FILE = ${OUTPUT_DIR}/cross.log
+
+# The log file will be cleared each time you run ktest.
+CLEAR_LOG = 1
+
+# As some archs do not build with the defconfig, they have been marked
+# to be ignored. If you want to test them anyway, change DO_FAILED to 1.
+# If a test that has been marked as DO_FAILED passes, then you should change
+# that test to be DO_DEFAULT
+
+DO_FAILED := 0
+DO_DEFAULT := 1
+
+# By setting both DO_FAILED and DO_DEFAULT to zero, you can pick a single
+# arch that you want to test. (uncomment RUN and chose your arch)
+#RUN := m32r
+
+# At the bottom of the config file exists a bisect test. You can update that
+# test and set DO_FAILED and DO_DEFAULT to zero, and uncomment this variable
+# to run the bisect on the arch.
+#RUN := bisect
+
+# By default all tests will be running gcc 4.5.2. Some tests are using 4.5.1
+# and they select that in the test.
+# Note: GCC_VER is declared as on option and not a variable ('=' instead of ':=')
+# This is important. A variable is used only in the config file and if it is set
+# it stays that way for the rest of the config file until it is change again.
+# Here we want GCC_VER to remain persistent and change for each test, as it is used in
+# the MAKE_CMD. By using '=' instead of ':=' we achieve our goal.
+
+GCC_VER = 4.5.2
+MAKE_CMD = PATH=/usr/local/gcc-${GCC_VER}-nolibc/${CROSS}/bin:$PATH CROSS_COMPILE=${CROSS}- make ARCH=${ARCH}
+
+# all tests are only doing builds.
+TEST_TYPE = build
+
+# If you want to add configs on top of the defconfig, you can add those configs into
+# the add-config file and uncomment this option. This is useful if you want to test
+# all cross compiles with PREEMPT set, or TRACING on, etc.
+#ADD_CONFIG = ${THIS_DIR}/add-config
+
+# All tests are using defconfig
+BUILD_TYPE = defconfig
+
+# The test names will have the arch and cross compiler used. This will be shown in
+# the results.
+TEST_NAME = ${ARCH} ${CROSS}
+
+# alpha
+TEST_START IF ${RUN} == alpha || ${DO_DEFAULT}
+# Notice that CROSS and ARCH are also options and not variables (again '=' instead
+# of ':='). This is because TEST_NAME and MAKE_CMD wil use them for each test.
+# Only options are available during runs. Variables are only present in parsing the
+# config file.
+CROSS = alpha-linux
+ARCH = alpha
+
+# arm
+TEST_START IF ${RUN} == arm || ${DO_DEFAULT}
+CROSS = arm-unknown-linux-gnueabi
+ARCH = arm
+
+# black fin
+TEST_START IF ${RUN} == bfin || ${DO_DEFAULT}
+CROSS = bfin-uclinux
+ARCH = blackfin
+BUILD_OPTIONS = -j8 vmlinux
+
+# cris - FAILS?
+TEST_START IF ${RUN} == cris || ${RUN} == cris64 || ${DO_FAILED}
+CROSS = cris-linux
+ARCH = cris
+
+# cris32 - not right arch?
+TEST_START IF ${RUN} == cris || ${RUN} == cris32 || ${DO_FAILED}
+CROSS = crisv32-linux
+ARCH = cris
+
+# ia64
+TEST_START IF ${RUN} == ia64 || ${DO_DEFAULT}
+CROSS = ia64-linux
+ARCH = ia64
+
+# frv
+TEST_START IF ${RUN} == frv || ${DO_FAILED}
+CROSS = frv-linux
+ARCH = frv
+GCC_VER = 4.5.1
+
+# h8300 - failed make defconfig??
+TEST_START IF ${RUN} == h8300 || ${DO_FAILED}
+CROSS = h8300-elf
+ARCH = h8300
+GCC_VER = 4.5.1
+
+# m68k fails with error?
+TEST_START IF ${RUN} == m68k || ${DO_DEFAULT}
+CROSS = m68k-linux
+ARCH = m68k
+
+# mips64
+TEST_START IF ${RUN} == mips || ${RUN} == mips64 || ${DO_DEFAULT}
+CROSS = mips64-linux
+ARCH = mips
+
+# mips32
+TEST_START IF ${RUN} == mips || ${RUN} == mips32 || ${DO_DEFAULT}
+CROSS = mips-linux
+ARCH = mips
+
+# m32r
+TEST_START IF ${RUN} == m32r || ${DO_FAILED}
+CROSS = m32r-linux
+ARCH = m32r
+GCC_VER = 4.5.1
+BUILD_OPTIONS = -j8 vmlinux
+
+# parisc64 failed?
+TEST_START IF ${RUN} == hppa || ${RUN} == hppa64 || ${DO_FAILED}
+CROSS = hppa64-linux
+ARCH = parisc
+
+# parisc
+TEST_START IF ${RUN} == hppa || ${RUN} == hppa32 || ${DO_FAILED}
+CROSS = hppa-linux
+ARCH = parisc
+
+# ppc
+TEST_START IF ${RUN} == ppc || ${RUN} == ppc32 || ${DO_DEFAULT}
+CROSS = powerpc-linux
+ARCH = powerpc
+
+# ppc64
+TEST_START IF ${RUN} == ppc || ${RUN} == ppc64 || ${DO_DEFAULT}
+CROSS = powerpc64-linux
+ARCH = powerpc
+
+# s390
+TEST_START IF ${RUN} == s390 || ${DO_DEFAULT}
+CROSS = s390x-linux
+ARCH = s390
+
+# sh
+TEST_START IF ${RUN} == sh || ${DO_DEFAULT}
+CROSS = sh4-linux
+ARCH = sh
+
+# sparc64
+TEST_START IF ${RUN} == sparc || ${RUN} == sparc64 || ${DO_DEFAULT}
+CROSS = sparc64-linux
+ARCH = sparc64
+
+# sparc
+TEST_START IF ${RUN} == sparc || ${RUN} == sparc32 || ${DO_DEFAULT}
+CROSS = sparc-linux
+ARCH = sparc
+
+# xtensa failed
+TEST_START IF ${RUN} == xtensa || ${DO_FAILED}
+CROSS = xtensa-linux
+ARCH = xtensa
+
+# UML
+TEST_START IF ${RUN} == uml || ${DO_DEFAULT}
+MAKE_CMD = make ARCH=um SUBARCH=x86_64
+ARCH = uml
+CROSS =
+
+TEST_START IF ${RUN} == x86 || ${RUN} == i386 || ${DO_DEFAULT}
+MAKE_CMD = make ARCH=i386
+ARCH = i386
+CROSS = 
+
+TEST_START IF ${RUN} == x86 || ${RUN} == x86_64 || ${DO_DEFAULT}
+MAKE_CMD = make ARCH=x86_64
+ARCH = x86_64
+CROSS = 
+
+#################################
+
+# This is a bisect if needed. You need to give it a MIN_CONFIG that
+# will be the config file it uses. Basically, just copy the created defconfig
+# for the arch someplace and point MIN_CONFIG to it.
+TEST_START IF ${RUN} == bisect
+MIN_CONFIG = ${THIS_DIR}/min-config
+CROSS = s390x-linux
+ARCH = s390
+TEST_TYPE = bisect
+BISECT_TYPE = build
+BISECT_GOOD = v3.1
+BISECT_BAD = v3.2
+CHECKOUT = v3.2
+
+#################################
+
+# These defaults are needed to keep ktest.pl from complaining. They are
+# ignored because the test does not go pass the build. No install or
+# booting of the target images.
+
+DEFAULTS
+MACHINE = crosstest
+SSH_USER = root
+BUILD_TARGET = cross
+TARGET_IMAGE = image
+POWER_CYCLE = cycle
+CONSOLE = console
+LOCALVERSION = version
+GRUB_MENU = grub
+
+REBOOT_ON_ERROR = 0
+POWEROFF_ON_ERROR = 0
+POWEROFF_ON_SUCCESS = 0
+REBOOT_ON_SUCCESS = 0
+
diff --git a/tools/testing/ktest/examples/include/bisect.conf b/tools/testing/ktest/examples/include/bisect.conf
new file mode 100644
index 000000000000..009bea65bfb6
--- /dev/null
+++ b/tools/testing/ktest/examples/include/bisect.conf
@@ -0,0 +1,90 @@
+#
+# This example shows the bisect tests (git bisect and config bisect)
+#
+
+
+# The config that includes this file may define a RUN_TEST
+# variable that will tell this config what test to run.
+# (what to set the TEST option to).
+#
+DEFAULTS IF NOT DEFINED RUN_TEST
+# Requires that hackbench is in the PATH
+RUN_TEST := ${SSH} hackbench 50
+
+
+# Set TEST to 'bisect' to do a normal git bisect. You need
+# to modify the options below to make it bisect the exact
+# commits you are interested in.
+#
+TEST_START IF ${TEST} == bisect
+TEST_TYPE = bisect
+# You must set the commit that was considered good (git bisect good)
+BISECT_GOOD = v3.3
+# You must set the commit that was considered bad (git bisect bad)
+BISECT_BAD = HEAD
+# It's best to specify the branch to checkout before starting the bisect.
+CHECKOUT = origin/master
+# This can be build, boot, or test. Here we are doing a bisect
+# that requires to run a test to know if the bisect was good or bad.
+# The test should exit with 0 on good, non-zero for bad. But see
+# the BISECT_RET_* options in samples.conf to override this.
+BISECT_TYPE = test
+TEST = ${RUN_TEST}
+# It is usually a good idea to confirm that the GOOD and the BAD
+# commits are truly good and bad respectively. Having BISECT_CHECK
+# set to 1 will check both that the good commit works and the bad
+# commit fails. If you only want to check one or the other,
+# set BISECT_CHECK to 'good' or to 'bad'.
+BISECT_CHECK = 1
+#BISECT_CHECK = good
+#BISECT_CHECK = bad
+
+# Usually it's a good idea to specify the exact config you
+# want to use throughout the entire bisect. Here we placed
+# it in the directory we called ktest.pl from and named it
+# 'config-bisect'.
+MIN_CONFIG = ${THIS_DIR}/config-bisect
+# By default, if we are doing a BISECT_TYPE = test run but the
+# build or boot fails, ktest.pl will do a 'git bisect skip'.
+# Uncomment the below option to make ktest stop testing on such
+# an error.
+#BISECT_SKIP = 0
+# Now if you had BISECT_SKIP = 0 and the test fails, you can
+# examine what happened and then do 'git bisect log > /tmp/replay'
+# Set BISECT_REPLAY to /tmp/replay and ktest.pl will run the
+# 'git bisect replay /tmp/replay' before continuing the bisect test.
+#BISECT_REPLAY = /tmp/replay
+# If you used BISECT_REPLAY after the bisect test failed, you may
+# not want to continue the bisect on that commit that failed.
+# By setting BISECT_START to a new commit. ktest.pl will checkout
+# that commit after it has performed the 'git bisect replay' but
+# before it continues running the bisect test.
+#BISECT_START = 2545eb6198e7e1ec50daa0cfc64a4cdfecf24ec9
+
+# Now if you don't trust ktest.pl to make the decisions for you, then
+# set BISECT_MANUAL to 1. This will cause ktest.pl not to decide
+# if the commit was good or bad. Instead, it will ask you to tell
+# it if the current commit was good. In the mean time, you could
+# take the result, load it on any machine you want. Run several tests,
+# or whatever you feel like. Then, when you are happy, you can tell
+# ktest if you think it was good or not and ktest.pl will continue
+# the git bisect. You can even change what commit it is currently at.
+#BISECT_MANUAL = 1
+
+
+# One of the unique tests that ktest does is the config bisect.
+# Currently (which hopefully will be fixed soon), the bad config
+# must be a superset of the good config. This is because it only
+# searches for a config that causes the target to fail. If the
+# good config is not a subset of the bad config, or if the target
+# fails because of a lack of a config, then it will not find
+# the config for you.
+TEST_START IF ${TEST} == config-bisect
+TEST_TYPE = config_bisect
+# set to build, boot, test
+CONFIG_BISECT_TYPE = boot
+# Set the config that is considered bad.
+CONFIG_BISECT = ${THIS_DIR}/config-bad
+# This config is optional. By default it uses the
+# MIN_CONFIG as the good config.
+CONFIG_BISECT_GOOD = ${THIS_DIR}/config-good
diff --git a/tools/testing/ktest/examples/include/defaults.conf b/tools/testing/ktest/examples/include/defaults.conf
new file mode 100644
index 000000000000..323a552ce642
--- /dev/null
+++ b/tools/testing/ktest/examples/include/defaults.conf
@@ -0,0 +1,157 @@
+# This file holds defaults for most the tests. It defines the options that
+# are most common to tests that are likely to be shared.
+#
+# Note, after including this file, a config file may override any option
+# with a DEFAULTS OVERRIDE section.
+#
+
+# For those cases that use the same machine to boot a 64 bit
+# and a 32 bit version. The MACHINE is the DNS name to get to the
+# box (usually different if it was 64 bit or 32 bit) but the
+# BOX here is defined as a variable that will be the name of the box
+# itself. It is useful for calling scripts that will power cycle
+# the box, as only one script needs to be created to power cycle
+# even though the box itself has multiple operating systems on it.
+# By default, BOX and MACHINE are the same.
+
+DEFAULTS IF NOT DEFINED BOX
+BOX := ${MACHINE}
+
+
+# Consider each box as 64 bit box, unless the config including this file
+# has defined BITS = 32
+
+DEFAULTS IF NOT DEFINED BITS
+BITS := 64
+
+
+DEFAULTS
+
+# THIS_DIR is used through out the configs and defaults to ${PWD} which
+# is the directory that ktest.pl was called from.
+
+THIS_DIR := ${PWD}
+
+
+# to orginize your configs, having each machine save their configs
+# into a separate directly is useful.
+CONFIG_DIR := ${THIS_DIR}/configs/${MACHINE}
+
+# Reset the log before running each test.
+CLEAR_LOG = 1
+
+# As installing kernels usually requires root privilege, default the
+# user on the target as root. It is also required that the target
+# allows ssh to root from the host without asking for a password.
+
+SSH_USER = root
+
+# For accesing the machine, we will ssh to root@machine.
+SSH := ssh ${SSH_USER}@${MACHINE}
+
+# Update this. The default here is ktest will ssh to the target box
+# and run a script called 'run-test' located on that box.
+TEST = ${SSH} run-test
+
+# Point build dir to the git repo you use
+BUILD_DIR = ${THIS_DIR}/linux.git
+
+# Each machine will have its own output build directory.
+OUTPUT_DIR = ${THIS_DIR}/build/${MACHINE}
+
+# Yes this config is focused on x86 (but ktest works for other archs too)
+BUILD_TARGET = arch/x86/boot/bzImage
+TARGET_IMAGE = /boot/vmlinuz-test
+
+# have directory for the scripts to reboot and power cycle the boxes
+SCRIPTS_DIR := ${THIS_DIR}/scripts
+
+# You can have each box/machine have a script to power cycle it.
+# Name your script <box>-cycle.
+POWER_CYCLE = ${SCRIPTS_DIR}/${BOX}-cycle
+
+# This script is used to power off the box.
+POWER_OFF = ${SCRIPTS_DIR}/${BOX}-poweroff
+
+# Keep your test kernels separate from your other kernels.
+LOCALVERSION = -test
+
+# The /boot/grub/menu.lst is searched for the line:
+#  title Test Kernel
+# and ktest will use that kernel to reboot into.
+# For grub2 or other boot loaders, you need to set BOOT_TYPE
+# to 'script' and define other ways to load the kernel.
+# See snowball.conf example.
+#
+GRUB_MENU = Test Kernel
+
+# The kernel build will use this option.
+BUILD_OPTIONS = -j8
+
+# Keeping the log file with the output dir is convenient.
+LOG_FILE = ${OUTPUT_DIR}/${MACHINE}.log
+
+# Each box should have their own minum configuration
+# See min-config.conf
+MIN_CONFIG = ${CONFIG_DIR}/config-min
+
+# For things like randconfigs, there may be configs you find that
+# are already broken, or there may be some configs that you always
+# want set. Uncomment ADD_CONFIG and point it to the make config files
+# that set the configs you want to keep on (or off) in your build.
+# ADD_CONFIG is usually something to add configs to all machines,
+# where as, MIN_CONFIG is specific per machine.
+#ADD_CONFIG = ${THIS_DIR}/config-broken ${THIS_DIR}/config-general
+
+# To speed up reboots for bisects and patchcheck, instead of
+# waiting 60 seconds for the console to be idle, if this line is
+# seen in the console output, ktest will know the good kernel has
+# finished rebooting and it will be able to continue the tests.
+REBOOT_SUCCESS_LINE = ${MACHINE} login:
+
+# The following is different ways to end the test.
+# by setting the variable REBOOT to: none, error, fail or
+# something else, ktest will power cycle or reboot the target box
+# at the end of the tests.
+#
+# REBOOT := none
+#   Don't do anything at the end of the test.
+#
+# REBOOT := error
+#   Reboot the box if ktest detects an error
+#
+# REBOOT := fail
+#   Do not stop on failure, and after all tests are complete
+#   power off the box (for both success and error)
+#   This is good to run over a weekend and you don't want to waste
+#   electricity.
+#
+
+DEFAULTS IF ${REBOOT} == none
+REBOOT_ON_SUCCESS = 0
+REBOOT_ON_ERROR = 0
+POWEROFF_ON_ERROR = 0
+POWEROFF_ON_SUCCESS = 0
+
+DEFAULTS ELSE IF ${REBOOT} == error
+REBOOT_ON_SUCCESS = 0
+REBOOT_ON_ERROR = 1
+POWEROFF_ON_ERROR = 0
+POWEROFF_ON_SUCCESS = 0
+
+DEFAULTS ELSE IF ${REBOOT} == fail
+REBOOT_ON_SUCCESS = 0
+POWEROFF_ON_ERROR = 1
+POWEROFF_ON_SUCCESS = 1
+POWEROFF_AFTER_HALT = 120
+DIE_ON_FAILURE = 0
+
+# Store the failure information into this directory
+# such as the .config, dmesg, and build log.
+STORE_FAILURES = ${THIS_DIR}/failures
+
+DEFAULTS ELSE
+REBOOT_ON_SUCCESS = 1
+REBOOT_ON_ERROR = 1
+POWEROFF_ON_ERROR = 0
+POWEROFF_ON_SUCCESS = 0
diff --git a/tools/testing/ktest/examples/include/min-config.conf b/tools/testing/ktest/examples/include/min-config.conf
new file mode 100644
index 000000000000..c703cc46d151
--- /dev/null
+++ b/tools/testing/ktest/examples/include/min-config.conf
@@ -0,0 +1,60 @@
+#
+# This file has some examples for creating a MIN_CONFIG.
+# (A .config file that is the minimum for a machine to boot, or
+#  to boot and make a network connection.)
+#
+# A MIN_CONFIG is very useful as it is the minimum configuration
+# needed to boot a given machine. You can debug someone else's
+# .config by only setting the configs in your MIN_CONFIG. The closer
+# your MIN_CONFIG is to the true minimum set of configs needed to
+# boot your machine, the closer the config you test with will be
+# to the users config that had the failure.
+#
+# The make_min_config test allows you to create a MIN_CONFIG that
+# is truly the minimum set of configs needed to boot a box.
+#
+# In this example, the final config will reside in
+# ${CONFIG_DIR}/config-new-min and ${CONFIG_DIR}/config-new-min-net.
+# Just move one to the location you have set for MIN_CONFIG.
+#
+# The first test creates a MIN_CONFIG that will be the minimum
+# configuration to boot ${MACHINE} and be able to ssh to it.
+#
+# The second test creates a MIN_CONFIG that will only boot
+# the target and most likely will not let you ssh to it. (Notice
+# how the second test uses the first test's result to continue with.
+# This is because the second test config is a subset of the first).
+#
+# The ${CONFIG_DIR}/config-skip (and -net) will hold the configs
+# that ktest.pl found would not boot the target without them set.
+# The config-new-min holds configs that ktest.pl could not test
+# directly because another config that was needed to boot the box
+# selected them. Sometimes it is possible that this file will hold
+# the true minimum configuration. You can test to see if this is
+# the case by running the boot test with BOOT_TYPE = allnoconfig and
+# setting setting the MIN_CONFIG to ${CONFIG_DIR}/config-skip. If the
+# machine still boots, then you can use the config-skip as your MIN_CONFIG.
+#
+# These tests can run for several hours (and perhaps days).
+# It's OK to kill the test with a Ctrl^C. By restarting without
+# modifying this config, ktest.pl will notice that the config-new-min(-net)
+# exists, and will use that instead as the starting point.
+# The USE_OUTPUT_MIN_CONFIG is set to 1 to keep ktest.pl from asking
+# you if you want to use the OUTPUT_MIN_CONFIG as the starting point.
+# By using the OUTPUT_MIN_CONFIG as the starting point will allow ktest.pl to
+# start almost where it left off.
+#
+TEST_START IF ${TEST} == min-config
+TEST_TYPE = make_min_config
+OUTPUT_MIN_CONFIG = ${CONFIG_DIR}/config-new-min-net
+IGNORE_CONFIG = ${CONFIG_DIR}/config-skip-net
+MIN_CONFIG_TYPE = test
+TEST = ${SSH} echo hi
+USE_OUTPUT_MIN_CONFIG = 1
+
+TEST_START IF ${TEST} == min-config && ${MULTI}
+TEST_TYPE = make_min_config
+OUTPUT_MIN_CONFIG = ${CONFIG_DIR}/config-new-min
+IGNORE_CONFIG = ${CONFIG_DIR}/config-skip
+MIN_CONFIG = ${CONFIG_DIR}/config-new-min-net
+USE_OUTPUT_MIN_CONFIG = 1
diff --git a/tools/testing/ktest/examples/include/patchcheck.conf b/tools/testing/ktest/examples/include/patchcheck.conf
new file mode 100644
index 000000000000..339d3e1700ff
--- /dev/null
+++ b/tools/testing/ktest/examples/include/patchcheck.conf
@@ -0,0 +1,74 @@
+# patchcheck.conf
+#
+# This contains a test that takes two git commits and will test each
+# commit between the two. The build test will look at what files the
+# commit has touched, and if any of those files produce a warning, then
+# the build will fail.
+
+
+# PATCH_START is the commit to begin with and PATCH_END is the commit
+# to end with (inclusive). This is similar to doing a git rebase -i PATCH_START~1
+# and then testing each commit and doing a git rebase --continue.
+# You can use a SHA1, a git tag, or anything that git will accept for a checkout
+
+PATCH_START := HEAD~3
+PATCH_END := HEAD
+
+# Change PATCH_CHECKOUT to be the branch you want to test. The test will
+# do a git checkout of this branch before starting. Obviously both
+# PATCH_START and PATCH_END must be in this branch (and PATCH_START must
+# be contained by PATCH_END).
+
+PATCH_CHECKOUT := test/branch
+
+# Usually it's a good idea to have a set config to use for testing individual
+# patches.
+PATCH_CONFIG := ${CONFIG_DIR}/config-patchcheck
+
+# Change PATCH_TEST to run some test for each patch. Each commit that is
+# tested, after it is built and installed on the test machine, this command
+# will be executed. Usually what is done is to ssh to the target box and
+# run some test scripts. If you just want to boot test your patches
+# comment PATCH_TEST out.
+PATCH_TEST := ${SSH} "/usr/local/bin/ktest-test-script"
+
+DEFAULTS IF DEFINED PATCH_TEST
+PATCH_TEST_TYPE := test
+
+DEFAULTS ELSE
+PATCH_TEST_TYPE := boot
+
+# If for some reason a file has a warning that one of your patches touch
+# but you do not care about it, set IGNORE_WARNINGS to that commit(s)
+# (space delimited)
+#IGNORE_WARNINGS = 39eaf7ef884dcc44f7ff1bac803ca2a1dcf43544 6edb2a8a385f0cdef51dae37ff23e74d76d8a6ce
+
+# If you are running a multi test, and the test failed on the first
+# test but on, say the 5th patch. If you want to restart on the
+# fifth patch, set PATCH_START1. This will make the first test start
+# from this commit instead of the PATCH_START commit.
+# Note, do not change this option. Just define PATCH_START1 in the
+# top config (the one you pass to ktest.pl), and this will use it,
+# otherwise it will just use PATCH_START if PATCH_START1 is not defined.
+DEFAULTS IF NOT DEFINED PATCH_START1
+PATCH_START1 := ${PATCH_START}
+
+TEST_START IF ${TEST} == patchcheck
+TEST_TYPE = patchcheck
+MIN_CONFIG = ${PATCH_CONFIG}
+TEST = ${PATCH_TEST}
+PATCHCHECK_TYPE = ${PATCH_TEST_TYPE}
+PATCHCHECK_START = ${PATCH_START1}
+PATCHCHECK_END = ${PATCH_END}
+CHECKOUT = ${PATCH_CHECKOUT}
+
+TEST_START IF ${TEST} == patchcheck && ${MULTI}
+TEST_TYPE = patchcheck
+MIN_CONFIG = ${PATCH_CONFIG}
+TEST = ${PATCH_TEST}
+PATCHCHECK_TYPE = ${PATCH_TEST_TYPE}
+PATCHCHECK_START = ${PATCH_START}
+PATCHCHECK_END = ${PATCH_END}
+CHECKOUT = ${PATCH_CHECKOUT}
+# Use multi to test different compilers?
+MAKE_CMD = CC=gcc-4.5.1 make
diff --git a/tools/testing/ktest/examples/include/tests.conf b/tools/testing/ktest/examples/include/tests.conf
new file mode 100644
index 000000000000..4fdb811bd810
--- /dev/null
+++ b/tools/testing/ktest/examples/include/tests.conf
@@ -0,0 +1,74 @@
+#
+# This is an example of various tests that you can run
+#
+# The variable TEST can be of boot, build, randconfig, or test.
+#
+# Note that TEST is a variable created with ':=' and only exists
+# throughout the config processing (not during the tests itself).
+#
+# The TEST option (defined with '=') is used to tell ktest.pl
+# what test to run after a successful boot. The TEST option is
+# persistent into the test runs.
+#
+
+# The config that includes this file may define a BOOT_TYPE
+# variable that tells this config what type of boot test to run.
+# If it's not defined, the below DEFAULTS will set the default
+# to 'oldconfig'.
+#
+DEFAULTS IF NOT DEFINED BOOT_TYPE
+BOOT_TYPE := oldconfig
+
+# The config that includes this file may define a RUN_TEST
+# variable that will tell this config what test to run.
+# (what to set the TEST option to).
+#
+DEFAULTS IF NOT DEFINED RUN_TEST
+# Requires that hackbench is in the PATH
+RUN_TEST := ${SSH} hackbench 50
+
+
+# If TEST is set to 'boot' then just build a kernel and boot
+# the target.
+TEST_START IF ${TEST} == boot
+TEST_TYPE = boot
+# Notice how we set the BUILD_TYPE option to the BOOT_TYPE variable.
+BUILD_TYPE = ${BOOT_TYPE}
+# Do not do a make mrproper.
+BUILD_NOCLEAN = 1
+
+# If you only want to build the kernel, and perhaps install
+# and test it yourself, then just set TEST to build.
+TEST_START IF ${TEST} == build
+TEST_TYPE = build
+BUILD_TYPE = ${BOOT_TYPE}
+BUILD_NOCLEAN = 1
+
+# Build, install, boot and test with a randconfg 10 times.
+# It is important that you have set MIN_CONFIG in the config
+# that includes this file otherwise it is likely that the
+# randconfig will not have the neccessary configs needed to
+# boot your box. This version of the test requires a min
+# config that has enough to make sure the target has network
+# working.
+TEST_START ITERATE 10 IF ${TEST} == randconfig
+MIN_CONFIG = ${CONFIG_DIR}/config-min-net
+TEST_TYPE = test
+BUILD_TYPE = randconfig
+TEST = ${RUN_TEST}
+
+# This is the same as above, but only tests to a boot prompt.
+# The MIN_CONFIG used here does not need to have networking
+# working.
+TEST_START ITERATE 10 IF ${TEST} == randconfig && ${MULTI}
+TEST_TYPE = boot
+BUILD_TYPE = randconfig
+MIN_CONFIG = ${CONFIG_DIR}/config-min
+MAKE_CMD = make
+
+# This builds, installs, boots and tests the target.
+TEST_START IF ${TEST} == test
+TEST_TYPE = test
+BUILD_TYPE = ${BOOT_TYPE}
+TEST = ${RUN_TEST}
+BUILD_NOCLEAN = 1
diff --git a/tools/testing/ktest/examples/kvm.conf b/tools/testing/ktest/examples/kvm.conf
new file mode 100644
index 000000000000..831c7c5395f1
--- /dev/null
+++ b/tools/testing/ktest/examples/kvm.conf
@@ -0,0 +1,88 @@
+#
+# This config is an example usage of ktest.pl with a kvm guest
+#
+# The guest is called 'Guest' and this would be something that
+# could be run on the host to test a virtual machine target.
+
+MACHINE = Guest
+
+
+# Use virsh to read the serial console of the guest
+CONSOLE =  virsh console ${MACHINE}
+
+#*************************************#
+# This part is the same as test.conf  #
+#*************************************#
+
+# The include files will set up the type of test to run. Just set TEST to
+# which test you want to run.
+#
+# TESTS = patchcheck, randconfig, boot, test, config-bisect, bisect, min-config
+#
+# See the include/*.conf files that define these tests
+#
+TEST := patchcheck
+
+# Some tests may have more than one test to run. Define MULTI := 1 to run
+# the extra tests.
+MULTI := 0
+
+# In case you want to differentiate which type of system you are testing
+BITS := 64
+
+# REBOOT = none, error, fail, empty
+#  See include/defaults.conf
+REBOOT := empty
+
+
+# The defaults file will set up various settings that can be used by all
+# machine configs.
+INCLUDE include/defaults.conf
+
+
+#*************************************#
+# Now we are different from test.conf #
+#*************************************#
+
+
+# The example here assumes that Guest is running a Fedora release
+# that uses dracut for its initfs. The POST_INSTALL will be executed
+# after the install of the kernel and modules are complete.
+#
+POST_INSTALL = ${SSH} /sbin/dracut -f /boot/initramfs-test.img $KERNEL_VERSION
+
+# Guests sometimes get stuck on reboot. We wait 3 seconds after running
+# the reboot command and then  do a full power-cycle of the guest.
+# This forces the guest to restart.
+#
+POWERCYCLE_AFTER_REBOOT = 3
+
+# We do the same after the halt command, but this time we wait 20 seconds.
+POWEROFF_AFTER_HALT = 20
+
+
+# As the defaults.conf file has a POWER_CYCLE option already defined,
+# and options can not be defined in the same section more than once
+# (all DEFAULTS sections are considered the same). We use the
+# DEFAULTS OVERRIDE to tell ktest.pl to ignore the previous defined
+# options, for the options set in the OVERRIDE section.
+#
+DEFAULTS OVERRIDE
+
+# Instead of using the default POWER_CYCLE option defined in
+# defaults.conf, we use virsh to cycle it. To do so, we destroy
+# the guest, wait 5 seconds, and then start it up again.
+# Crude, but effective.
+#
+POWER_CYCLE = virsh destroy ${MACHINE}; sleep 5; virsh start ${MACHINE}
+
+
+DEFAULTS
+
+# The following files each handle a different test case.
+# Having them included allows you to set up more than one machine and share
+# the same tests.
+INCLUDE include/patchcheck.conf
+INCLUDE include/tests.conf
+INCLUDE include/bisect.conf
+INCLUDE include/min-config.conf
diff --git a/tools/testing/ktest/examples/snowball.conf b/tools/testing/ktest/examples/snowball.conf
new file mode 100644
index 000000000000..a82a3c5bc2b7
--- /dev/null
+++ b/tools/testing/ktest/examples/snowball.conf
@@ -0,0 +1,53 @@
+# This example was used to boot the snowball ARM board.
+# See http://people.redhat.com/srostedt/ktest-embedded-2012/
+
+# PWD is a ktest.pl variable that will result in the process working
+# directory that ktest.pl is executed in.
+
+# THIS_DIR is automatically assigned the PWD of the path that generated
+# the config file. It is best to use this variable when assigning other
+# directory paths within this directory. This allows you to easily
+# move the test cases to other locations or to other machines.
+#
+THIS_DIR := /home/rostedt/work/demo/ktest-embed
+LOG_FILE = ${OUTPUT_DIR}/snowball.log
+CLEAR_LOG = 1
+MAKE_CMD = PATH=/usr/local/gcc-4.5.2-nolibc/arm-unknown-linux-gnueabi/bin:$PATH CROSS_COMPILE=arm-unknown-linux-gnueabi- make ARCH=arm
+ADD_CONFIG = ${THIS_DIR}/addconfig
+
+SCP_TO_TARGET = echo "don't do scp"
+
+TFTPBOOT := /var/lib/tftpboot
+TFTPDEF := ${TFTPBOOT}/snowball-default
+TFTPTEST := ${OUTPUT_DIR}/${BUILD_TARGET}
+
+SWITCH_TO_GOOD = cp ${TFTPDEF} ${TARGET_IMAGE}
+SWITCH_TO_TEST = cp ${TFTPTEST} ${TARGET_IMAGE}
+
+# Define each test with TEST_START
+# The config options below it will override the defaults
+TEST_START SKIP
+TEST_TYPE = boot
+BUILD_TYPE = u8500_defconfig
+BUILD_NOCLEAN = 1
+
+TEST_START
+TEST_TYPE = make_min_config
+OUTPUT_MIN_CONFIG = ${THIS_DIR}/config.newmin
+START_MIN_CONFIG = ${THIS_DIR}/config.orig
+IGNORE_CONFIG = ${THIS_DIR}/config.ignore
+BUILD_NOCLEAN = 1
+
+
+DEFAULTS
+LOCALVERSION = -test
+POWER_CYCLE = echo use the thumb luke; read a
+CONSOLE = cat ${THIS_DIR}/snowball-cat
+REBOOT_TYPE = script
+SSH_USER = root
+BUILD_OPTIONS = -j8 uImage
+BUILD_DIR = ${THIS_DIR}/linux.git
+OUTPUT_DIR = ${THIS_DIR}/snowball-build
+MACHINE = snowball
+TARGET_IMAGE = /var/lib/tftpboot/snowball-image
+BUILD_TARGET = arch/arm/boot/uImage
diff --git a/tools/testing/ktest/examples/test.conf b/tools/testing/ktest/examples/test.conf
new file mode 100644
index 000000000000..b725210efb7f
--- /dev/null
+++ b/tools/testing/ktest/examples/test.conf
@@ -0,0 +1,62 @@
+#
+# Generic config for a machine
+#
+
+# Name your machine (the DNS name, what you ssh to)
+MACHINE = foo
+
+# BOX can be different than foo, if the machine BOX has
+# multiple partitions with different systems installed. For example,
+# you may have a i386 and x86_64 installation on a test box.
+# If this is the case, MACHINE defines the way to connect to the
+# machine, which may be different between which system the machine
+# is booting into. BOX is used for the scripts to reboot and power cycle
+# the machine, where it does not matter which system the machine boots into.
+#
+#BOX := bar
+
+# Define a way to read the console
+CONSOLE = stty -F /dev/ttyS0 115200 parodd; cat /dev/ttyS0
+
+# The include files will set up the type of test to run. Just set TEST to
+# which test you want to run.
+#
+# TESTS = patchcheck, randconfig, boot, test, config-bisect, bisect, min-config
+#
+# See the include/*.conf files that define these tests
+#
+TEST := patchcheck
+
+# Some tests may have more than one test to run. Define MULTI := 1 to run
+# the extra tests.
+MULTI := 0
+
+# In case you want to differentiate which type of system you are testing
+BITS := 64
+
+# REBOOT = none, error, fail, empty
+#  See include/defaults.conf
+REBOOT := empty
+
+# The defaults file will set up various settings that can be used by all
+# machine configs.
+INCLUDE include/defaults.conf
+
+# In case you need to add a patch for a bisect or something
+#PRE_BUILD = patch -p1 < ${THIS_DIR}/fix.patch
+
+# Reset the repo after the build and remove all 'test' modules from the target
+# Notice that DO_POST_BUILD is a variable (defined by ':=') and POST_BUILD
+# is the option (defined by '=')
+
+DO_POST_BUILD := git reset --hard
+POST_BUILD = ${SSH} 'rm -rf /lib/modules/*-test*'; ${DO_POST_BUILD}
+
+# The following files each handle a different test case.
+# Having them included allows you to set up more than one machine and share
+# the same tests.
+INCLUDE include/patchcheck.conf
+INCLUDE include/tests.conf
+INCLUDE include/bisect.conf
+INCLUDE include/min-config.conf
+
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 4915408f6a98..292b13ad03f5 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -39,6 +39,7 @@ my %default = (
     "CLEAR_LOG"                 => 0,
     "BISECT_MANUAL"             => 0,
     "BISECT_SKIP"               => 1,
+    "MIN_CONFIG_TYPE"           => "boot",
     "SUCCESS_LINE"              => "login:",
     "DETECT_TRIPLE_FAULT"       => 1,
     "NO_INSTALL"                => 0,
@@ -66,6 +67,7 @@ my %default = (
 
 my $ktest_config;
 my $version;
+my $have_version = 0;
 my $machine;
 my $ssh_user;
 my $tmpdir;
@@ -106,6 +108,8 @@ my $minconfig;
 my $start_minconfig;
 my $start_minconfig_defined;
 my $output_minconfig;
+my $minconfig_type;
+my $use_output_minconfig;
 my $ignore_config;
 my $ignore_errors;
 my $addconfig;
@@ -205,6 +209,8 @@ my %option_map = (
     "MIN_CONFIG"                => \$minconfig,
     "OUTPUT_MIN_CONFIG"         => \$output_minconfig,
     "START_MIN_CONFIG"          => \$start_minconfig,
+    "MIN_CONFIG_TYPE"           => \$minconfig_type,
+    "USE_OUTPUT_MIN_CONFIG"     => \$use_output_minconfig,
     "IGNORE_CONFIG"             => \$ignore_config,
     "TEST"                      => \$run_test,
     "ADD_CONFIG"                => \$addconfig,
@@ -1702,10 +1708,12 @@ sub install {
 
 sub get_version {
     # get the release name
+    return if ($have_version);
     doprint "$make kernelrelease ... ";
     $version = `$make kernelrelease | tail -1`;
     chomp($version);
     doprint "$version\n";
+    $have_version = 1;
 }
 
 sub start_monitor_and_boot {
@@ -1828,6 +1836,9 @@ sub build {
     my $save_no_reboot = $no_reboot;
     $no_reboot = 1;
 
+    # Calculate a new version from here.
+    $have_version = 0;
+
     if (defined($pre_build)) {
         my $ret = run_command $pre_build;
         if (!$ret && defined($pre_build_die) &&
@@ -1887,6 +1898,9 @@ sub build {
     undef $redirect;
 
     if (defined($post_build)) {
+        # Because a post build may change the kernel version
+        # do it now.
+        get_version;
         my $ret = run_command $post_build;
         if (!$ret && defined($post_build_die) &&
             $post_build_die) {
@@ -3119,6 +3133,12 @@ sub test_this_config {
 sub make_min_config {
     my ($i) = @_;
 
+    my $type = $minconfig_type;
+    if ($type ne "boot" && $type ne "test") {
+        fail "Invalid MIN_CONFIG_TYPE '$minconfig_type'\n" .
+            " make_min_config works only with 'boot' and 'test'\n" and return;
+    }
+
     if (!defined($output_minconfig)) {
         fail "OUTPUT_MIN_CONFIG not defined" and return;
     }
@@ -3128,8 +3148,15 @@ sub make_min_config {
     # that instead.
     if (-f $output_minconfig && !$start_minconfig_defined) {
         print "$output_minconfig exists\n";
-        if (read_yn " Use it as minconfig?") {
+        if (!defined($use_output_minconfig)) {
+            if (read_yn " Use it as minconfig?") {
+                $start_minconfig = $output_minconfig;
+            }
+        } elsif ($use_output_minconfig > 0) {
+            doprint "Using $output_minconfig as MIN_CONFIG\n";
             $start_minconfig = $output_minconfig;
+        } else {
+            doprint "Set to still use MIN_CONFIG as starting point\n";
         }
     }
 
@@ -3278,6 +3305,11 @@ sub make_min_config {
         build "oldconfig" or $failed = 1;
         if (!$failed) {
                 start_monitor_and_boot or $failed = 1;
+
+                if ($type eq "test" && !$failed) {
+                    do_run_test or $failed = 1;
+                }
+
                 end_monitor;
         }
 
@@ -3474,6 +3506,8 @@ for (my $i = 1; $i <= $opt{"NUM_TESTS"}; $i++) {
     $no_reboot = 1;
     $reboot_success = 0;
 
+    $have_version = 0;
+
     $iteration = $i;
 
     my $makecmd = set_test_option("MAKE_CMD", $i);
diff --git a/tools/testing/ktest/sample.conf b/tools/testing/ktest/sample.conf
index b682456afda8..cf362b3d1ec9 100644
--- a/tools/testing/ktest/sample.conf
+++ b/tools/testing/ktest/sample.conf
@@ -158,7 +158,7 @@
 #
 # TEST_START IF (DEFINED ALL_TESTS || ${MYTEST} == boottest) && ${MACHINE} == gandalf
 #
-# Notice the use of paranthesis. Without any paranthesis the above would be
+# Notice the use of parentheses. Without any parentheses the above would be
 # processed the same as:
 #
 # TEST_START IF DEFINED ALL_TESTS || (${MYTEST} == boottest && ${MACHINE} == gandalf)
@@ -1105,10 +1105,26 @@
 #   and will not be tested again in later runs.
 #   (optional)
 #
+#  MIN_CONFIG_TYPE can be either 'boot' or 'test'. With 'boot' it will
+#   test if the created config can just boot the machine. If this is
+#   set to 'test', then the TEST option must be defined and the created
+#   config will not only boot the target, but also make sure that the
+#   config lets the test succeed. This is useful to make sure the final
+#   config that is generated allows network activity (ssh).
+#   (optional)
+#
+#  USE_OUTPUT_MIN_CONFIG set this to 1 if you do not want to be prompted
+#   about using the OUTPUT_MIN_CONFIG as the MIN_CONFIG as the starting
+#   point. Set it to 0 if you want to always just use the given MIN_CONFIG.
+#   If it is not defined, it will prompt you to pick which config
+#   to start with (MIN_CONFIG or OUTPUT_MIN_CONFIG).
+#
 # Example:
 #
 #  TEST_TYPE = make_min_config
 #  OUTPUT_MIN_CONFIG = /path/to/config-new-min
 #  START_MIN_CONFIG = /path/to/config-min
 #  IGNORE_CONFIG = /path/to/config-tested
+#  MIN_CONFIG_TYPE = test
+#  TEST = ssh ${USER}@${MACHINE} echo hi
 #
diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index 28bc57ee757c..a4162e15c25f 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -1,4 +1,4 @@
-TARGETS = breakpoints vm
+TARGETS = breakpoints kcmp mqueue vm
 
 all:
         for TARGET in $(TARGETS); do \
diff --git a/tools/testing/selftests/kcmp/Makefile b/tools/testing/selftests/kcmp/Makefile
new file mode 100644
index 000000000000..dc79b86ea65c
--- /dev/null
+++ b/tools/testing/selftests/kcmp/Makefile
@@ -0,0 +1,29 @@
+uname_M := $(shell uname -m 2>/dev/null || echo not)
+ARCH ?= $(shell echo $(uname_M) | sed -e s/i.86/i386/)
+ifeq ($(ARCH),i386)
+        ARCH := X86
+        CFLAGS := -DCONFIG_X86_32 -D__i386__
+endif
+ifeq ($(ARCH),x86_64)
+        ARCH := X86
+        CFLAGS := -DCONFIG_X86_64 -D__x86_64__
+endif
+
+CFLAGS += -I../../../../arch/x86/include/generated/
+CFLAGS += -I../../../../include/
+CFLAGS += -I../../../../usr/include/
+CFLAGS += -I../../../../arch/x86/include/
+
+all:
+ifeq ($(ARCH),X86)
+        gcc $(CFLAGS) kcmp_test.c -o run_test
+else
+        echo "Not an x86 target, can't build kcmp selftest"
+endif
+
+run-tests: all
+        ./kcmp_test
+
+clean:
+        rm -fr ./run_test
+        rm -fr ./test-file
diff --git a/tools/testing/selftests/kcmp/kcmp_test.c b/tools/testing/selftests/kcmp/kcmp_test.c
new file mode 100644
index 000000000000..358cc6bfa35d
--- /dev/null
+++ b/tools/testing/selftests/kcmp/kcmp_test.c
@@ -0,0 +1,94 @@
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <limits.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include <linux/unistd.h>
+#include <linux/kcmp.h>
+
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
+static long sys_kcmp(int pid1, int pid2, int type, int fd1, int fd2)
+{
+        return syscall(__NR_kcmp, pid1, pid2, type, fd1, fd2);
+}
+
+int main(int argc, char **argv)
+{
+        const char kpath[] = "kcmp-test-file";
+        int pid1, pid2;
+        int fd1, fd2;
+        int status;
+
+        fd1 = open(kpath, O_RDWR | O_CREAT | O_TRUNC, 0644);
+        pid1 = getpid();
+
+        if (fd1 < 0) {
+                perror("Can't create file");
+                exit(1);
+        }
+
+        pid2 = fork();
+        if (pid2 < 0) {
+                perror("fork failed");
+                exit(1);
+        }
+
+        if (!pid2) {
+                int pid2 = getpid();
+                int ret;
+
+                fd2 = open(kpath, O_RDWR, 0644);
+                if (fd2 < 0) {
+                        perror("Can't open file");
+                        exit(1);
+                }
+
+                /* An example of output and arguments */
+                printf("pid1: %6d pid2: %6d FD: %2ld FILES: %2ld VM: %2ld "
+                       "FS: %2ld SIGHAND: %2ld IO: %2ld SYSVSEM: %2ld "
+                       "INV: %2ld\n",
+                       pid1, pid2,
+                       sys_kcmp(pid1, pid2, KCMP_FILE,          fd1, fd2),
+                       sys_kcmp(pid1, pid2, KCMP_FILES,         0, 0),
+                       sys_kcmp(pid1, pid2, KCMP_VM,            0, 0),
+                       sys_kcmp(pid1, pid2, KCMP_FS,            0, 0),
+                       sys_kcmp(pid1, pid2, KCMP_SIGHAND,       0, 0),
+                       sys_kcmp(pid1, pid2, KCMP_IO,            0, 0),
+                       sys_kcmp(pid1, pid2, KCMP_SYSVSEM,       0, 0),
+
+                        /* This one should fail */
+                       sys_kcmp(pid1, pid2, KCMP_TYPES + 1,     0, 0));
+
+                /* This one should return same fd */
+                ret = sys_kcmp(pid1, pid2, KCMP_FILE, fd1, fd1);
+                if (ret) {
+                        printf("FAIL: 0 expected but %d returned\n", ret);
+                        ret = -1;
+                } else
+                        printf("PASS: 0 returned as expected\n");
+
+                /* Compare with self */
+                ret = sys_kcmp(pid1, pid1, KCMP_VM, 0, 0);
+                if (ret) {
+                        printf("FAIL: 0 expected but %li returned\n", ret);
+                        ret = -1;
+                } else
+                        printf("PASS: 0 returned as expected\n");
+
+                exit(ret);
+        }
+
+        waitpid(pid2, &status, P_ALL);
+
+        return 0;
+}
diff --git a/tools/testing/selftests/mqueue/.gitignore b/tools/testing/selftests/mqueue/.gitignore
new file mode 100644
index 000000000000..d8d42377205a
--- /dev/null
+++ b/tools/testing/selftests/mqueue/.gitignore
@@ -0,0 +1,2 @@
+mq_open_tests
+mq_perf_tests
diff --git a/tools/testing/selftests/mqueue/Makefile b/tools/testing/selftests/mqueue/Makefile
new file mode 100644
index 000000000000..54c0aad2b47c
--- /dev/null
+++ b/tools/testing/selftests/mqueue/Makefile
@@ -0,0 +1,10 @@
+all:
+        gcc -O2 -lrt mq_open_tests.c -o mq_open_tests
+        gcc -O2 -lrt -lpthread -lpopt -o mq_perf_tests mq_perf_tests.c
+
+run_tests:
+        ./mq_open_tests /test1
+        ./mq_perf_tests
+
+clean:
+        rm -f mq_open_tests mq_perf_tests
diff --git a/tools/testing/selftests/mqueue/mq_open_tests.c b/tools/testing/selftests/mqueue/mq_open_tests.c
new file mode 100644
index 000000000000..711cc2923047
--- /dev/null
+++ b/tools/testing/selftests/mqueue/mq_open_tests.c
@@ -0,0 +1,492 @@
+/*
+ * This application is Copyright 2012 Red Hat, Inc.
+ *      Doug Ledford <dledford@redhat.com>
+ *
+ * mq_open_tests is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * mq_open_tests is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * For the full text of the license, see <http://www.gnu.org/licenses/>.
+ *
+ * mq_open_tests.c
+ *   Tests the various situations that should either succeed or fail to
+ *   open a posix message queue and then reports whether or not they
+ *   did as they were supposed to.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <mqueue.h>
+
+static char *usage =
+"Usage:\n"
+"  %s path\n"
+"\n"
+"       path    Path name of the message queue to create\n"
+"\n"
+"       Note: this program must be run as root in order to enable all tests\n"
+"\n";
+
+char *DEF_MSGS = "/proc/sys/fs/mqueue/msg_default";
+char *DEF_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_default";
+char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
+char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
+
+int default_settings;
+struct rlimit saved_limits, cur_limits;
+int saved_def_msgs, saved_def_msgsize, saved_max_msgs, saved_max_msgsize;
+int cur_def_msgs, cur_def_msgsize, cur_max_msgs, cur_max_msgsize;
+FILE *def_msgs, *def_msgsize, *max_msgs, *max_msgsize;
+char *queue_path;
+mqd_t queue = -1;
+
+static inline void __set(FILE *stream, int value, char *err_msg);
+void shutdown(int exit_val, char *err_cause, int line_no);
+static inline int get(FILE *stream);
+static inline void set(FILE *stream, int value);
+static inline void getr(int type, struct rlimit *rlim);
+static inline void setr(int type, struct rlimit *rlim);
+void validate_current_settings();
+static inline void test_queue(struct mq_attr *attr, struct mq_attr *result);
+static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result);
+
+static inline void __set(FILE *stream, int value, char *err_msg)
+{
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                perror(err_msg);
+}
+
+
+void shutdown(int exit_val, char *err_cause, int line_no)
+{
+        static int in_shutdown = 0;
+
+        /* In case we get called recursively by a set() call below */
+        if (in_shutdown++)
+                return;
+
+        seteuid(0);
+
+        if (queue != -1)
+                if (mq_close(queue))
+                        perror("mq_close() during shutdown");
+        if (queue_path)
+                /*
+                 * Be silent if this fails, if we cleaned up already it's
+                 * expected to fail
+                 */
+                mq_unlink(queue_path);
+        if (default_settings) {
+                if (saved_def_msgs)
+                        __set(def_msgs, saved_def_msgs,
+                              "failed to restore saved_def_msgs");
+                if (saved_def_msgsize)
+                        __set(def_msgsize, saved_def_msgsize,
+                              "failed to restore saved_def_msgsize");
+        }
+        if (saved_max_msgs)
+                __set(max_msgs, saved_max_msgs,
+                      "failed to restore saved_max_msgs");
+        if (saved_max_msgsize)
+                __set(max_msgsize, saved_max_msgsize,
+                      "failed to restore saved_max_msgsize");
+        if (exit_val)
+                error(exit_val, errno, "%s at %d", err_cause, line_no);
+        exit(0);
+}
+
+static inline int get(FILE *stream)
+{
+        int value;
+        rewind(stream);
+        if (fscanf(stream, "%d", &value) != 1)
+                shutdown(4, "Error reading /proc entry", __LINE__ - 1);
+        return value;
+}
+
+static inline void set(FILE *stream, int value)
+{
+        int new_value;
+
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                return shutdown(5, "Failed writing to /proc file",
+                                __LINE__ - 1);
+        new_value = get(stream);
+        if (new_value != value)
+                return shutdown(5, "We didn't get what we wrote to /proc back",
+                                __LINE__ - 1);
+}
+
+static inline void getr(int type, struct rlimit *rlim)
+{
+        if (getrlimit(type, rlim))
+                shutdown(6, "getrlimit()", __LINE__ - 1);
+}
+
+static inline void setr(int type, struct rlimit *rlim)
+{
+        if (setrlimit(type, rlim))
+                shutdown(7, "setrlimit()", __LINE__ - 1);
+}
+
+void validate_current_settings()
+{
+        int rlim_needed;
+
+        if (cur_limits.rlim_cur < 4096) {
+                printf("Current rlimit value for POSIX message queue bytes is "
+                       "unreasonably low,\nincreasing.\n\n");
+                cur_limits.rlim_cur = 8192;
+                cur_limits.rlim_max = 16384;
+                setr(RLIMIT_MSGQUEUE, &cur_limits);
+        }
+
+        if (default_settings) {
+                rlim_needed = (cur_def_msgs + 1) * (cur_def_msgsize + 1 +
+                                                    2 * sizeof(void *));
+                if (rlim_needed > cur_limits.rlim_cur) {
+                        printf("Temporarily lowering default queue parameters "
+                               "to something that will work\n"
+                               "with the current rlimit values.\n\n");
+                        set(def_msgs, 10);
+                        cur_def_msgs = 10;
+                        set(def_msgsize, 128);
+                        cur_def_msgsize = 128;
+                }
+        } else {
+                rlim_needed = (cur_max_msgs + 1) * (cur_max_msgsize + 1 +
+                                                    2 * sizeof(void *));
+                if (rlim_needed > cur_limits.rlim_cur) {
+                        printf("Temporarily lowering maximum queue parameters "
+                               "to something that will work\n"
+                               "with the current rlimit values in case this is "
+                               "a kernel that ties the default\n"
+                               "queue parameters to the maximum queue "
+                               "parameters.\n\n");
+                        set(max_msgs, 10);
+                        cur_max_msgs = 10;
+                        set(max_msgsize, 128);
+                        cur_max_msgsize = 128;
+                }
+        }
+}
+
+/*
+ * test_queue - Test opening a queue, shutdown if we fail.  This should
+ * only be called in situations that should never fail.  We clean up
+ * after ourselves and return the queue attributes in *result.
+ */
+static inline void test_queue(struct mq_attr *attr, struct mq_attr *result)
+{
+        int flags = O_RDWR | O_EXCL | O_CREAT;
+        int perms = DEFFILEMODE;
+
+        if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
+                shutdown(1, "mq_open()", __LINE__);
+        if (mq_getattr(queue, result))
+                shutdown(1, "mq_getattr()", __LINE__);
+        if (mq_close(queue))
+                shutdown(1, "mq_close()", __LINE__);
+        queue = -1;
+        if (mq_unlink(queue_path))
+                shutdown(1, "mq_unlink()", __LINE__);
+}
+
+/*
+ * Same as test_queue above, but failure is not fatal.
+ * Returns:
+ * 0 - Failed to create a queue
+ * 1 - Created a queue, attributes in *result
+ */
+static inline int test_queue_fail(struct mq_attr *attr, struct mq_attr *result)
+{
+        int flags = O_RDWR | O_EXCL | O_CREAT;
+        int perms = DEFFILEMODE;
+
+        if ((queue = mq_open(queue_path, flags, perms, attr)) == -1)
+                return 0;
+        if (mq_getattr(queue, result))
+                shutdown(1, "mq_getattr()", __LINE__);
+        if (mq_close(queue))
+                shutdown(1, "mq_close()", __LINE__);
+        queue = -1;
+        if (mq_unlink(queue_path))
+                shutdown(1, "mq_unlink()", __LINE__);
+        return 1;
+}
+
+int main(int argc, char *argv[])
+{
+        struct mq_attr attr, result;
+
+        if (argc != 2) {
+                fprintf(stderr, "Must pass a valid queue name\n\n");
+                fprintf(stderr, usage, argv[0]);
+                exit(1);
+        }
+
+        /*
+         * Although we can create a msg queue with a non-absolute path name,
+         * unlink will fail.  So, if the name doesn't start with a /, add one
+         * when we save it.
+         */
+        if (*argv[1] == '/')
+                queue_path = strdup(argv[1]);
+        else {
+                queue_path = malloc(strlen(argv[1]) + 2);
+                if (!queue_path) {
+                        perror("malloc()");
+                        exit(1);
+                }
+                queue_path[0] = '/';
+                queue_path[1] = 0;
+                strcat(queue_path, argv[1]);
+        }
+
+        if (getuid() != 0) {
+                fprintf(stderr, "Not running as root, but almost all tests "
+                        "require root in order to modify\nsystem settings.  "
+                        "Exiting.\n");
+                exit(1);
+        }
+
+        /* Find out what files there are for us to make tweaks in */
+        def_msgs = fopen(DEF_MSGS, "r+");
+        def_msgsize = fopen(DEF_MSGSIZE, "r+");
+        max_msgs = fopen(MAX_MSGS, "r+");
+        max_msgsize = fopen(MAX_MSGSIZE, "r+");
+
+        if (!max_msgs)
+                shutdown(2, "Failed to open msg_max", __LINE__);
+        if (!max_msgsize)
+                shutdown(2, "Failed to open msgsize_max", __LINE__);
+        if (def_msgs || def_msgsize)
+                default_settings = 1;
+
+        /* Load up the current system values for everything we can */
+        getr(RLIMIT_MSGQUEUE, &saved_limits);
+        cur_limits = saved_limits;
+        if (default_settings) {
+                saved_def_msgs = cur_def_msgs = get(def_msgs);
+                saved_def_msgsize = cur_def_msgsize = get(def_msgsize);
+        }
+        saved_max_msgs = cur_max_msgs = get(max_msgs);
+        saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
+
+        /* Tell the user our initial state */
+        printf("\nInitial system state:\n");
+        printf("\tUsing queue path:\t\t%s\n", queue_path);
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", saved_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", saved_limits.rlim_max);
+        printf("\tMaximum Message Size:\t\t%d\n", saved_max_msgsize);
+        printf("\tMaximum Queue Size:\t\t%d\n", saved_max_msgs);
+        if (default_settings) {
+                printf("\tDefault Message Size:\t\t%d\n", saved_def_msgsize);
+                printf("\tDefault Queue Size:\t\t%d\n", saved_def_msgs);
+        } else {
+                printf("\tDefault Message Size:\t\tNot Supported\n");
+                printf("\tDefault Queue Size:\t\tNot Supported\n");
+        }
+        printf("\n");
+
+        validate_current_settings();
+
+        printf("Adjusted system state for testing:\n");
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t%d\n", cur_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t%d\n", cur_limits.rlim_max);
+        printf("\tMaximum Message Size:\t\t%d\n", cur_max_msgsize);
+        printf("\tMaximum Queue Size:\t\t%d\n", cur_max_msgs);
+        if (default_settings) {
+                printf("\tDefault Message Size:\t\t%d\n", cur_def_msgsize);
+                printf("\tDefault Queue Size:\t\t%d\n", cur_def_msgs);
+        }
+
+        printf("\n\nTest series 1, behavior when no attr struct "
+               "passed to mq_open:\n");
+        if (!default_settings) {
+                test_queue(NULL, &result);
+                printf("Given sane system settings, mq_open without an attr "
+                       "struct succeeds:\tPASS\n");
+                if (result.mq_maxmsg != cur_max_msgs ||
+                    result.mq_msgsize != cur_max_msgsize) {
+                        printf("Kernel does not support setting the default "
+                               "mq attributes,\nbut also doesn't tie the "
+                               "defaults to the maximums:\t\t\tPASS\n");
+                } else {
+                        set(max_msgs, ++cur_max_msgs);
+                        set(max_msgsize, ++cur_max_msgsize);
+                        test_queue(NULL, &result);
+                        if (result.mq_maxmsg == cur_max_msgs &&
+                            result.mq_msgsize == cur_max_msgsize)
+                                printf("Kernel does not support setting the "
+                                       "default mq attributes and\n"
+                                       "also ties system wide defaults to "
+                                       "the system wide maximums:\t\t"
+                                       "FAIL\n");
+                        else
+                                printf("Kernel does not support setting the "
+                                       "default mq attributes,\n"
+                                       "but also doesn't tie the defaults to "
+                                       "the maximums:\t\t\tPASS\n");
+                }
+        } else {
+                printf("Kernel supports setting defaults separately from "
+                       "maximums:\t\tPASS\n");
+                /*
+                 * While we are here, go ahead and test that the kernel
+                 * properly follows the default settings
+                 */
+                test_queue(NULL, &result);
+                printf("Given sane values, mq_open without an attr struct "
+                       "succeeds:\t\tPASS\n");
+                if (result.mq_maxmsg != cur_def_msgs ||
+                    result.mq_msgsize != cur_def_msgsize)
+                        printf("Kernel supports setting defaults, but does "
+                               "not actually honor them:\tFAIL\n\n");
+                else {
+                        set(def_msgs, ++cur_def_msgs);
+                        set(def_msgsize, ++cur_def_msgsize);
+                        /* In case max was the same as the default */
+                        set(max_msgs, ++cur_max_msgs);
+                        set(max_msgsize, ++cur_max_msgsize);
+                        test_queue(NULL, &result);
+                        if (result.mq_maxmsg != cur_def_msgs ||
+                            result.mq_msgsize != cur_def_msgsize)
+                                printf("Kernel supports setting defaults, but "
+                                       "does not actually honor them:\t"
+                                       "FAIL\n");
+                        else
+                                printf("Kernel properly honors default setting "
+                                       "knobs:\t\t\t\tPASS\n");
+                }
+                set(def_msgs, cur_max_msgs + 1);
+                cur_def_msgs = cur_max_msgs + 1;
+                set(def_msgsize, cur_max_msgsize + 1);
+                cur_def_msgsize = cur_max_msgsize + 1;
+                if (cur_def_msgs * (cur_def_msgsize + 2 * sizeof(void *)) >=
+                    cur_limits.rlim_cur) {
+                        cur_limits.rlim_cur = (cur_def_msgs + 2) *
+                                (cur_def_msgsize + 2 * sizeof(void *));
+                        cur_limits.rlim_max = 2 * cur_limits.rlim_cur;
+                        setr(RLIMIT_MSGQUEUE, &cur_limits);
+                }
+                if (test_queue_fail(NULL, &result)) {
+                        if (result.mq_maxmsg == cur_max_msgs &&
+                            result.mq_msgsize == cur_max_msgsize)
+                                printf("Kernel properly limits default values "
+                                       "to lesser of default/max:\t\tPASS\n");
+                        else
+                                printf("Kernel does not properly set default "
+                                       "queue parameters when\ndefaults > "
+                                       "max:\t\t\t\t\t\t\t\tFAIL\n");
+                } else
+                        printf("Kernel fails to open mq because defaults are "
+                               "greater than maximums:\tFAIL\n");
+                set(def_msgs, --cur_def_msgs);
+                set(def_msgsize, --cur_def_msgsize);
+                cur_limits.rlim_cur = cur_limits.rlim_max = cur_def_msgs *
+                        cur_def_msgsize;
+                setr(RLIMIT_MSGQUEUE, &cur_limits);
+                if (test_queue_fail(NULL, &result))
+                        printf("Kernel creates queue even though defaults "
+                               "would exceed\nrlimit setting:"
+                               "\t\t\t\t\t\t\t\tFAIL\n");
+                else
+                        printf("Kernel properly fails to create queue when "
+                               "defaults would\nexceed rlimit:"
+                               "\t\t\t\t\t\t\t\tPASS\n");
+        }
+
+        /*
+         * Test #2 - open with an attr struct that exceeds rlimit
+         */
+        printf("\n\nTest series 2, behavior when attr struct is "
+               "passed to mq_open:\n");
+        cur_max_msgs = 32;
+        cur_max_msgsize = cur_limits.rlim_max >> 4;
+        set(max_msgs, cur_max_msgs);
+        set(max_msgsize, cur_max_msgsize);
+        attr.mq_maxmsg = cur_max_msgs;
+        attr.mq_msgsize = cur_max_msgsize;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open in excess of rlimit max when euid = 0 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open in excess of rlimit max when euid = 0 "
+                       "failed:\t\tPASS\n");
+        attr.mq_maxmsg = cur_max_msgs + 1;
+        attr.mq_msgsize = 10;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with mq_maxmsg > limit when euid = 0 "
+                       "succeeded:\t\tPASS\n");
+        else
+                printf("Queue open with mq_maxmsg > limit when euid = 0 "
+                       "failed:\t\tFAIL\n");
+        attr.mq_maxmsg = 1;
+        attr.mq_msgsize = cur_max_msgsize + 1;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with mq_msgsize > limit when euid = 0 "
+                       "succeeded:\t\tPASS\n");
+        else
+                printf("Queue open with mq_msgsize > limit when euid = 0 "
+                       "failed:\t\tFAIL\n");
+        attr.mq_maxmsg = 65536;
+        attr.mq_msgsize = 65536;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with total size > 2GB when euid = 0 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open with total size > 2GB when euid = 0 "
+                       "failed:\t\t\tPASS\n");
+        seteuid(99);
+        attr.mq_maxmsg = cur_max_msgs;
+        attr.mq_msgsize = cur_max_msgsize;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open in excess of rlimit max when euid = 99 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open in excess of rlimit max when euid = 99 "
+                       "failed:\t\tPASS\n");
+        attr.mq_maxmsg = cur_max_msgs + 1;
+        attr.mq_msgsize = 10;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with mq_maxmsg > limit when euid = 99 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open with mq_maxmsg > limit when euid = 99 "
+                       "failed:\t\tPASS\n");
+        attr.mq_maxmsg = 1;
+        attr.mq_msgsize = cur_max_msgsize + 1;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with mq_msgsize > limit when euid = 99 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open with mq_msgsize > limit when euid = 99 "
+                       "failed:\t\tPASS\n");
+        attr.mq_maxmsg = 65536;
+        attr.mq_msgsize = 65536;
+        if (test_queue_fail(&attr, &result))
+                printf("Queue open with total size > 2GB when euid = 99 "
+                       "succeeded:\t\tFAIL\n");
+        else
+                printf("Queue open with total size > 2GB when euid = 99 "
+                       "failed:\t\t\tPASS\n");
+
+        shutdown(0,"",0);
+}
diff --git a/tools/testing/selftests/mqueue/mq_perf_tests.c b/tools/testing/selftests/mqueue/mq_perf_tests.c
new file mode 100644
index 000000000000..2fadd4b97045
--- /dev/null
+++ b/tools/testing/selftests/mqueue/mq_perf_tests.c
@@ -0,0 +1,741 @@
+/*
+ * This application is Copyright 2012 Red Hat, Inc.
+ *      Doug Ledford <dledford@redhat.com>
+ *
+ * mq_perf_tests is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3.
+ *
+ * mq_perf_tests is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * For the full text of the license, see <http://www.gnu.org/licenses/>.
+ *
+ * mq_perf_tests.c
+ *   Tests various types of message queue workloads, concentrating on those
+ *   situations that invole large message sizes, large message queue depths,
+ *   or both, and reports back useful metrics about kernel message queue
+ *   performance.
+ *
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <signal.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <mqueue.h>
+#include <popt.h>
+
+static char *usage =
+"Usage:\n"
+"  %s [-c #[,#..] -f] path\n"
+"\n"
+"       -c #    Skip most tests and go straight to a high queue depth test\n"
+"               and then run that test continuously (useful for running at\n"
+"               the same time as some other workload to see how much the\n"
+"               cache thrashing caused by adding messages to a very deep\n"
+"               queue impacts the performance of other programs).  The number\n"
+"               indicates which CPU core we should bind the process to during\n"
+"               the run.  If you have more than one physical CPU, then you\n"
+"               will need one copy per physical CPU package, and you should\n"
+"               specify the CPU cores to pin ourself to via a comma separated\n"
+"               list of CPU values.\n"
+"       -f      Only usable with continuous mode.  Pin ourself to the CPUs\n"
+"               as requested, then instead of looping doing a high mq\n"
+"               workload, just busy loop.  This will allow us to lock up a\n"
+"               single CPU just like we normally would, but without actually\n"
+"               thrashing the CPU cache.  This is to make it easier to get\n"
+"               comparable numbers from some other workload running on the\n"
+"               other CPUs.  One set of numbers with # CPUs locked up running\n"
+"               an mq workload, and another set of numbers with those same\n"
+"               CPUs locked away from the test workload, but not doing\n"
+"               anything to trash the cache like the mq workload might.\n"
+"       path    Path name of the message queue to create\n"
+"\n"
+"       Note: this program must be run as root in order to enable all tests\n"
+"\n";
+
+char *MAX_MSGS = "/proc/sys/fs/mqueue/msg_max";
+char *MAX_MSGSIZE = "/proc/sys/fs/mqueue/msgsize_max";
+
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define MAX_CPUS 64
+char *cpu_option_string;
+int cpus_to_pin[MAX_CPUS];
+int num_cpus_to_pin;
+pthread_t cpu_threads[MAX_CPUS];
+pthread_t main_thread;
+cpu_set_t *cpu_set;
+int cpu_set_size;
+int cpus_online;
+
+#define MSG_SIZE 16
+#define TEST1_LOOPS 10000000
+#define TEST2_LOOPS 100000
+int continuous_mode;
+int continuous_mode_fake;
+
+struct rlimit saved_limits, cur_limits;
+int saved_max_msgs, saved_max_msgsize;
+int cur_max_msgs, cur_max_msgsize;
+FILE *max_msgs, *max_msgsize;
+int cur_nice;
+char *queue_path = "/mq_perf_tests";
+mqd_t queue = -1;
+struct mq_attr result;
+int mq_prio_max;
+
+const struct poptOption options[] = {
+        {
+                .longName = "continuous",
+                .shortName = 'c',
+                .argInfo = POPT_ARG_STRING,
+                .arg = &cpu_option_string,
+                .val = 'c',
+                .descrip = "Run continuous tests at a high queue depth in "
+                        "order to test the effects of cache thrashing on "
+                        "other tasks on the system.  This test is intended "
+                        "to be run on one core of each physical CPU while "
+                        "some other CPU intensive task is run on all the other "
+                        "cores of that same physical CPU and the other task "
+                        "is timed.  It is assumed that the process of adding "
+                        "messages to the message queue in a tight loop will "
+                        "impact that other task to some degree.  Once the "
+                        "tests are performed in this way, you should then "
+                        "re-run the tests using fake mode in order to check "
+                        "the difference in time required to perform the CPU "
+                        "intensive task",
+                .argDescrip = "cpu[,cpu]",
+        },
+        {
+                .longName = "fake",
+                .shortName = 'f',
+                .argInfo = POPT_ARG_NONE,
+                .arg = &continuous_mode_fake,
+                .val = 0,
+                .descrip = "Tie up the CPUs that we would normally tie up in"
+                        "continuous mode, but don't actually do any mq stuff, "
+                        "just keep the CPU busy so it can't be used to process "
+                        "system level tasks as this would free up resources on "
+                        "the other CPU cores and skew the comparison between "
+                        "the no-mqueue work and mqueue work tests",
+                .argDescrip = NULL,
+        },
+        {
+                .longName = "path",
+                .shortName = 'p',
+                .argInfo = POPT_ARG_STRING | POPT_ARGFLAG_SHOW_DEFAULT,
+                .arg = &queue_path,
+                .val = 'p',
+                .descrip = "The name of the path to use in the mqueue "
+                        "filesystem for our tests",
+                .argDescrip = "pathname",
+        },
+        POPT_AUTOHELP
+        POPT_TABLEEND
+};
+
+static inline void __set(FILE *stream, int value, char *err_msg);
+void shutdown(int exit_val, char *err_cause, int line_no);
+void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context);
+void sig_action(int signum, siginfo_t *info, void *context);
+static inline int get(FILE *stream);
+static inline void set(FILE *stream, int value);
+static inline int try_set(FILE *stream, int value);
+static inline void getr(int type, struct rlimit *rlim);
+static inline void setr(int type, struct rlimit *rlim);
+static inline void open_queue(struct mq_attr *attr);
+void increase_limits(void);
+
+static inline void __set(FILE *stream, int value, char *err_msg)
+{
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                perror(err_msg);
+}
+
+
+void shutdown(int exit_val, char *err_cause, int line_no)
+{
+        static int in_shutdown = 0;
+        int errno_at_shutdown = errno;
+        int i;
+
+        /* In case we get called by multiple threads or from an sighandler */
+        if (in_shutdown++)
+                return;
+
+        for (i = 0; i < num_cpus_to_pin; i++)
+                if (cpu_threads[i]) {
+                        pthread_kill(cpu_threads[i], SIGUSR1);
+                        pthread_join(cpu_threads[i], NULL);
+                }
+
+        if (queue != -1)
+                if (mq_close(queue))
+                        perror("mq_close() during shutdown");
+        if (queue_path)
+                /*
+                 * Be silent if this fails, if we cleaned up already it's
+                 * expected to fail
+                 */
+                mq_unlink(queue_path);
+        if (saved_max_msgs)
+                __set(max_msgs, saved_max_msgs,
+                      "failed to restore saved_max_msgs");
+        if (saved_max_msgsize)
+                __set(max_msgsize, saved_max_msgsize,
+                      "failed to restore saved_max_msgsize");
+        if (exit_val)
+                error(exit_val, errno_at_shutdown, "%s at %d",
+                      err_cause, line_no);
+        exit(0);
+}
+
+void sig_action_SIGUSR1(int signum, siginfo_t *info, void *context)
+{
+        if (pthread_self() != main_thread)
+                pthread_exit(0);
+        else {
+                fprintf(stderr, "Caught signal %d in SIGUSR1 handler, "
+                                "exiting\n", signum);
+                shutdown(0, "", 0);
+                fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
+                exit(0);
+        }
+}
+
+void sig_action(int signum, siginfo_t *info, void *context)
+{
+        if (pthread_self() != main_thread)
+                pthread_kill(main_thread, signum);
+        else {
+                fprintf(stderr, "Caught signal %d, exiting\n", signum);
+                shutdown(0, "", 0);
+                fprintf(stderr, "\n\nReturned from shutdown?!?!\n\n");
+                exit(0);
+        }
+}
+
+static inline int get(FILE *stream)
+{
+        int value;
+        rewind(stream);
+        if (fscanf(stream, "%d", &value) != 1)
+                shutdown(4, "Error reading /proc entry", __LINE__);
+        return value;
+}
+
+static inline void set(FILE *stream, int value)
+{
+        int new_value;
+
+        rewind(stream);
+        if (fprintf(stream, "%d", value) < 0)
+                return shutdown(5, "Failed writing to /proc file", __LINE__);
+        new_value = get(stream);
+        if (new_value != value)
+                return shutdown(5, "We didn't get what we wrote to /proc back",
+                                __LINE__);
+}
+
+static inline int try_set(FILE *stream, int value)
+{
+        int new_value;
+
+        rewind(stream);
+        fprintf(stream, "%d", value);
+        new_value = get(stream);
+        return new_value == value;
+}
+
+static inline void getr(int type, struct rlimit *rlim)
+{
+        if (getrlimit(type, rlim))
+                shutdown(6, "getrlimit()", __LINE__);
+}
+
+static inline void setr(int type, struct rlimit *rlim)
+{
+        if (setrlimit(type, rlim))
+                shutdown(7, "setrlimit()", __LINE__);
+}
+
+/**
+ * open_queue - open the global queue for testing
+ * @attr - An attr struct specifying the desired queue traits
+ * @result - An attr struct that lists the actual traits the queue has
+ *
+ * This open is not allowed to fail, failure will result in an orderly
+ * shutdown of the program.  The global queue_path is used to set what
+ * queue to open, the queue descriptor is saved in the global queue
+ * variable.
+ */
+static inline void open_queue(struct mq_attr *attr)
+{
+        int flags = O_RDWR | O_EXCL | O_CREAT | O_NONBLOCK;
+        int perms = DEFFILEMODE;
+
+        queue = mq_open(queue_path, flags, perms, attr);
+        if (queue == -1)
+                shutdown(1, "mq_open()", __LINE__);
+        if (mq_getattr(queue, &result))
+                shutdown(1, "mq_getattr()", __LINE__);
+        printf("\n\tQueue %s created:\n", queue_path);
+        printf("\t\tmq_flags:\t\t\t%s\n", result.mq_flags & O_NONBLOCK ?
+               "O_NONBLOCK" : "(null)");
+        printf("\t\tmq_maxmsg:\t\t\t%d\n", result.mq_maxmsg);
+        printf("\t\tmq_msgsize:\t\t\t%d\n", result.mq_msgsize);
+        printf("\t\tmq_curmsgs:\t\t\t%d\n", result.mq_curmsgs);
+}
+
+void *fake_cont_thread(void *arg)
+{
+        int i;
+
+        for (i = 0; i < num_cpus_to_pin; i++)
+                if (cpu_threads[i] == pthread_self())
+                        break;
+        printf("\tStarted fake continuous mode thread %d on CPU %d\n", i,
+               cpus_to_pin[i]);
+        while (1)
+                ;
+}
+
+void *cont_thread(void *arg)
+{
+        char buff[MSG_SIZE];
+        int i, priority;
+
+        for (i = 0; i < num_cpus_to_pin; i++)
+                if (cpu_threads[i] == pthread_self())
+                        break;
+        printf("\tStarted continuous mode thread %d on CPU %d\n", i,
+               cpus_to_pin[i]);
+        while (1) {
+                while (mq_send(queue, buff, sizeof(buff), 0) == 0)
+                        ;
+                mq_receive(queue, buff, sizeof(buff), &priority);
+        }
+}
+
+#define drain_queue() \
+        while (mq_receive(queue, buff, MSG_SIZE, &prio_in) == MSG_SIZE)
+
+#define do_untimed_send() \
+        do { \
+                if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
+                        shutdown(3, "Test send failure", __LINE__); \
+        } while (0)
+
+#define do_send_recv() \
+        do { \
+                clock_gettime(clock, &start); \
+                if (mq_send(queue, buff, MSG_SIZE, prio_out)) \
+                        shutdown(3, "Test send failure", __LINE__); \
+                clock_gettime(clock, &middle); \
+                if (mq_receive(queue, buff, MSG_SIZE, &prio_in) != MSG_SIZE) \
+                        shutdown(3, "Test receive failure", __LINE__); \
+                clock_gettime(clock, &end); \
+                nsec = ((middle.tv_sec - start.tv_sec) * 1000000000) + \
+                        (middle.tv_nsec - start.tv_nsec); \
+                send_total.tv_nsec += nsec; \
+                if (send_total.tv_nsec >= 1000000000) { \
+                        send_total.tv_sec++; \
+                        send_total.tv_nsec -= 1000000000; \
+                } \
+                nsec = ((end.tv_sec - middle.tv_sec) * 1000000000) + \
+                        (end.tv_nsec - middle.tv_nsec); \
+                recv_total.tv_nsec += nsec; \
+                if (recv_total.tv_nsec >= 1000000000) { \
+                        recv_total.tv_sec++; \
+                        recv_total.tv_nsec -= 1000000000; \
+                } \
+        } while (0)
+
+struct test {
+        char *desc;
+        void (*func)(int *);
+};
+
+void const_prio(int *prio)
+{
+        return;
+}
+
+void inc_prio(int *prio)
+{
+        if (++*prio == mq_prio_max)
+                *prio = 0;
+}
+
+void dec_prio(int *prio)
+{
+        if (--*prio < 0)
+                *prio = mq_prio_max - 1;
+}
+
+void random_prio(int *prio)
+{
+        *prio = random() % mq_prio_max;
+}
+
+struct test test2[] = {
+        {"\n\tTest #2a: Time send/recv message, queue full, constant prio\n",
+                const_prio},
+        {"\n\tTest #2b: Time send/recv message, queue full, increasing prio\n",
+                inc_prio},
+        {"\n\tTest #2c: Time send/recv message, queue full, decreasing prio\n",
+                dec_prio},
+        {"\n\tTest #2d: Time send/recv message, queue full, random prio\n",
+                random_prio},
+        {NULL, NULL}
+};
+
+/**
+ * Tests to perform (all done with MSG_SIZE messages):
+ *
+ * 1) Time to add/remove message with 0 messages on queue
+ * 1a) with constant prio
+ * 2) Time to add/remove message when queue close to capacity:
+ * 2a) with constant prio
+ * 2b) with increasing prio
+ * 2c) with decreasing prio
+ * 2d) with random prio
+ * 3) Test limits of priorities honored (double check _SC_MQ_PRIO_MAX)
+ */
+void *perf_test_thread(void *arg)
+{
+        char buff[MSG_SIZE];
+        int prio_out, prio_in;
+        int i;
+        clockid_t clock;
+        pthread_t *t;
+        struct timespec res, start, middle, end, send_total, recv_total;
+        unsigned long long nsec;
+        struct test *cur_test;
+
+        t = &cpu_threads[0];
+        printf("\n\tStarted mqueue performance test thread on CPU %d\n",
+               cpus_to_pin[0]);
+        mq_prio_max = sysconf(_SC_MQ_PRIO_MAX);
+        if (mq_prio_max == -1)
+                shutdown(2, "sysconf(_SC_MQ_PRIO_MAX)", __LINE__);
+        if (pthread_getcpuclockid(cpu_threads[0], &clock) != 0)
+                shutdown(2, "pthread_getcpuclockid", __LINE__);
+
+        if (clock_getres(clock, &res))
+                shutdown(2, "clock_getres()", __LINE__);
+
+        printf("\t\tMax priorities:\t\t\t%d\n", mq_prio_max);
+        printf("\t\tClock resolution:\t\t%d nsec%s\n", res.tv_nsec,
+               res.tv_nsec > 1 ? "s" : "");
+
+
+
+        printf("\n\tTest #1: Time send/recv message, queue empty\n");
+        printf("\t\t(%d iterations)\n", TEST1_LOOPS);
+        prio_out = 0;
+        send_total.tv_sec = 0;
+        send_total.tv_nsec = 0;
+        recv_total.tv_sec = 0;
+        recv_total.tv_nsec = 0;
+        for (i = 0; i < TEST1_LOOPS; i++)
+                do_send_recv();
+        printf("\t\tSend msg:\t\t\t%d.%ds total time\n",
+               send_total.tv_sec, send_total.tv_nsec);
+        nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
+                 send_total.tv_nsec) / TEST1_LOOPS;
+        printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+        printf("\t\tRecv msg:\t\t\t%d.%ds total time\n",
+               recv_total.tv_sec, recv_total.tv_nsec);
+        nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
+                recv_total.tv_nsec) / TEST1_LOOPS;
+        printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+
+
+        for (cur_test = test2; cur_test->desc != NULL; cur_test++) {
+                printf(cur_test->desc);
+                printf("\t\t(%d iterations)\n", TEST2_LOOPS);
+                prio_out = 0;
+                send_total.tv_sec = 0;
+                send_total.tv_nsec = 0;
+                recv_total.tv_sec = 0;
+                recv_total.tv_nsec = 0;
+                printf("\t\tFilling queue...");
+                fflush(stdout);
+                clock_gettime(clock, &start);
+                for (i = 0; i < result.mq_maxmsg - 1; i++) {
+                        do_untimed_send();
+                        cur_test->func(&prio_out);
+                }
+                clock_gettime(clock, &end);
+                nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
+                        1000000000) + (end.tv_nsec - start.tv_nsec);
+                printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
+                       nsec % 1000000000);
+                printf("\t\tTesting...");
+                fflush(stdout);
+                for (i = 0; i < TEST2_LOOPS; i++) {
+                        do_send_recv();
+                        cur_test->func(&prio_out);
+                }
+                printf("done.\n");
+                printf("\t\tSend msg:\t\t\t%d.%ds total time\n",
+                       send_total.tv_sec, send_total.tv_nsec);
+                nsec = ((unsigned long long)send_total.tv_sec * 1000000000 +
+                         send_total.tv_nsec) / TEST2_LOOPS;
+                printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+                printf("\t\tRecv msg:\t\t\t%d.%ds total time\n",
+                       recv_total.tv_sec, recv_total.tv_nsec);
+                nsec = ((unsigned long long)recv_total.tv_sec * 1000000000 +
+                        recv_total.tv_nsec) / TEST2_LOOPS;
+                printf("\t\t\t\t\t\t%d nsec/msg\n", nsec);
+                printf("\t\tDraining queue...");
+                fflush(stdout);
+                clock_gettime(clock, &start);
+                drain_queue();
+                clock_gettime(clock, &end);
+                nsec = ((unsigned long long)(end.tv_sec - start.tv_sec) *
+                        1000000000) + (end.tv_nsec - start.tv_nsec);
+                printf("done.\t\t%lld.%llds\n", nsec / 1000000000,
+                       nsec % 1000000000);
+        }
+        return 0;
+}
+
+void increase_limits(void)
+{
+        cur_limits.rlim_cur = RLIM_INFINITY;
+        cur_limits.rlim_max = RLIM_INFINITY;
+        setr(RLIMIT_MSGQUEUE, &cur_limits);
+        while (try_set(max_msgs, cur_max_msgs += 10))
+                ;
+        cur_max_msgs = get(max_msgs);
+        while (try_set(max_msgsize, cur_max_msgsize += 1024))
+                ;
+        cur_max_msgsize = get(max_msgsize);
+        if (setpriority(PRIO_PROCESS, 0, -20) != 0)
+                shutdown(2, "setpriority()", __LINE__);
+        cur_nice = -20;
+}
+
+int main(int argc, char *argv[])
+{
+        struct mq_attr attr;
+        char *option, *next_option;
+        int i, cpu;
+        struct sigaction sa;
+        poptContext popt_context;
+        char rc;
+        void *retval;
+
+        main_thread = pthread_self();
+        num_cpus_to_pin = 0;
+
+        if (sysconf(_SC_NPROCESSORS_ONLN) == -1) {
+                perror("sysconf(_SC_NPROCESSORS_ONLN)");
+                exit(1);
+        }
+        cpus_online = min(MAX_CPUS, sysconf(_SC_NPROCESSORS_ONLN));
+        cpu_set = CPU_ALLOC(cpus_online);
+        if (cpu_set == NULL) {
+                perror("CPU_ALLOC()");
+                exit(1);
+        }
+        cpu_set_size = CPU_ALLOC_SIZE(cpus_online);
+        CPU_ZERO_S(cpu_set_size, cpu_set);
+
+        popt_context = poptGetContext(NULL, argc, (const char **)argv,
+                                      options, 0);
+
+        while ((rc = poptGetNextOpt(popt_context)) > 0) {
+                switch (rc) {
+                case 'c':
+                        continuous_mode = 1;
+                        option = cpu_option_string;
+                        do {
+                                next_option = strchr(option, ',');
+                                if (next_option)
+                                        *next_option = '\0';
+                                cpu = atoi(option);
+                                if (cpu >= cpus_online)
+                                        fprintf(stderr, "CPU %d exceeds "
+                                                "cpus online, ignoring.\n",
+                                                cpu);
+                                else
+                                        cpus_to_pin[num_cpus_to_pin++] = cpu;
+                                if (next_option)
+                                        option = ++next_option;
+                        } while (next_option && num_cpus_to_pin < MAX_CPUS);
+                        /* Double check that they didn't give us the same CPU
+                         * more than once */
+                        for (cpu = 0; cpu < num_cpus_to_pin; cpu++) {
+                                if (CPU_ISSET_S(cpus_to_pin[cpu], cpu_set_size,
+                                                cpu_set)) {
+                                        fprintf(stderr, "Any given CPU may "
+                                                "only be given once.\n");
+                                        exit(1);
+                                } else
+                                        CPU_SET_S(cpus_to_pin[cpu],
+                                                  cpu_set_size, cpu_set);
+                        }
+                        break;
+                case 'p':
+                        /*
+                         * Although we can create a msg queue with a
+                         * non-absolute path name, unlink will fail.  So,
+                         * if the name doesn't start with a /, add one
+                         * when we save it.
+                         */
+                        option = queue_path;
+                        if (*option != '/') {
+                                queue_path = malloc(strlen(option) + 2);
+                                if (!queue_path) {
+                                        perror("malloc()");
+                                        exit(1);
+                                }
+                                queue_path[0] = '/';
+                                queue_path[1] = 0;
+                                strcat(queue_path, option);
+                                free(option);
+                        }
+                        break;
+                }
+        }
+
+        if (continuous_mode && num_cpus_to_pin == 0) {
+                fprintf(stderr, "Must pass at least one CPU to continuous "
+                        "mode.\n");
+                poptPrintUsage(popt_context, stderr, 0);
+                exit(1);
+        } else if (!continuous_mode) {
+                num_cpus_to_pin = 1;
+                cpus_to_pin[0] = cpus_online - 1;
+        }
+
+        if (getuid() != 0) {
+                fprintf(stderr, "Not running as root, but almost all tests "
+                        "require root in order to modify\nsystem settings.  "
+                        "Exiting.\n");
+                exit(1);
+        }
+
+        max_msgs = fopen(MAX_MSGS, "r+");
+        max_msgsize = fopen(MAX_MSGSIZE, "r+");
+        if (!max_msgs)
+                shutdown(2, "Failed to open msg_max", __LINE__);
+        if (!max_msgsize)
+                shutdown(2, "Failed to open msgsize_max", __LINE__);
+
+        /* Load up the current system values for everything we can */
+        getr(RLIMIT_MSGQUEUE, &saved_limits);
+        cur_limits = saved_limits;
+        saved_max_msgs = cur_max_msgs = get(max_msgs);
+        saved_max_msgsize = cur_max_msgsize = get(max_msgsize);
+        errno = 0;
+        cur_nice = getpriority(PRIO_PROCESS, 0);
+        if (errno)
+                shutdown(2, "getpriority()", __LINE__);
+
+        /* Tell the user our initial state */
+        printf("\nInitial system state:\n");
+        printf("\tUsing queue path:\t\t\t%s\n", queue_path);
+        printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%d\n", saved_limits.rlim_cur);
+        printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%d\n", saved_limits.rlim_max);
+        printf("\tMaximum Message Size:\t\t\t%d\n", saved_max_msgsize);
+        printf("\tMaximum Queue Size:\t\t\t%d\n", saved_max_msgs);
+        printf("\tNice value:\t\t\t\t%d\n", cur_nice);
+        printf("\n");
+
+        increase_limits();
+
+        printf("Adjusted system state for testing:\n");
+        if (cur_limits.rlim_cur == RLIM_INFINITY) {
+                printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t(unlimited)\n");
+                printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t(unlimited)\n");
+        } else {
+                printf("\tRLIMIT_MSGQUEUE(soft):\t\t\t%d\n",
+                       cur_limits.rlim_cur);
+                printf("\tRLIMIT_MSGQUEUE(hard):\t\t\t%d\n",
+                       cur_limits.rlim_max);
+        }
+        printf("\tMaximum Message Size:\t\t\t%d\n", cur_max_msgsize);
+        printf("\tMaximum Queue Size:\t\t\t%d\n", cur_max_msgs);
+        printf("\tNice value:\t\t\t\t%d\n", cur_nice);
+        printf("\tContinuous mode:\t\t\t(%s)\n", continuous_mode ?
+               (continuous_mode_fake ? "fake mode" : "enabled") :
+               "disabled");
+        printf("\tCPUs to pin:\t\t\t\t%d", cpus_to_pin[0]);
+        for (cpu = 1; cpu < num_cpus_to_pin; cpu++)
+                        printf(",%d", cpus_to_pin[cpu]);
+        printf("\n");
+
+        sa.sa_sigaction = sig_action_SIGUSR1;
+        sigemptyset(&sa.sa_mask);
+        sigaddset(&sa.sa_mask, SIGHUP);
+        sigaddset(&sa.sa_mask, SIGINT);
+        sigaddset(&sa.sa_mask, SIGQUIT);
+        sigaddset(&sa.sa_mask, SIGTERM);
+        sa.sa_flags = SA_SIGINFO;
+        if (sigaction(SIGUSR1, &sa, NULL) == -1)
+                shutdown(1, "sigaction(SIGUSR1)", __LINE__);
+        sa.sa_sigaction = sig_action;
+        if (sigaction(SIGHUP, &sa, NULL) == -1)
+                shutdown(1, "sigaction(SIGHUP)", __LINE__);
+        if (sigaction(SIGINT, &sa, NULL) == -1)
+                shutdown(1, "sigaction(SIGINT)", __LINE__);
+        if (sigaction(SIGQUIT, &sa, NULL) == -1)
+                shutdown(1, "sigaction(SIGQUIT)", __LINE__);
+        if (sigaction(SIGTERM, &sa, NULL) == -1)
+                shutdown(1, "sigaction(SIGTERM)", __LINE__);
+
+        if (!continuous_mode_fake) {
+                attr.mq_flags = O_NONBLOCK;
+                attr.mq_maxmsg = cur_max_msgs;
+                attr.mq_msgsize = MSG_SIZE;
+                open_queue(&attr);
+        }
+        for (i = 0; i < num_cpus_to_pin; i++) {
+                pthread_attr_t thread_attr;
+                void *thread_func;
+
+                if (continuous_mode_fake)
+                        thread_func = &fake_cont_thread;
+                else if (continuous_mode)
+                        thread_func = &cont_thread;
+                else
+                        thread_func = &perf_test_thread;
+
+                CPU_ZERO_S(cpu_set_size, cpu_set);
+                CPU_SET_S(cpus_to_pin[i], cpu_set_size, cpu_set);
+                pthread_attr_init(&thread_attr);
+                pthread_attr_setaffinity_np(&thread_attr, cpu_set_size,
+                                            cpu_set);
+                if (pthread_create(&cpu_threads[i], &thread_attr, thread_func,
+                                   NULL))
+                        shutdown(1, "pthread_create()", __LINE__);
+                pthread_attr_destroy(&thread_attr);
+        }
+
+        if (!continuous_mode) {
+                pthread_join(cpu_threads[0], &retval);
+                shutdown((long)retval, "perf_test_thread()", __LINE__);
+        } else {
+                while (1)
+                        sleep(1);
+        }
+        shutdown(0, "", 0);
+}
diff --git a/tools/usb/ffs-test.c b/tools/usb/ffs-test.c
index 4b107b5e623f..8674b9ec14f6 100644
--- a/tools/usb/ffs-test.c
+++ b/tools/usb/ffs-test.c
@@ -297,7 +297,7 @@ static void *start_thread_helper(void *arg)
 
                 ret = t->in(t, t->buf, t->buf_size);
                 if (ret > 0) {
-                        ret = t->out(t, t->buf, t->buf_size);
+                        ret = t->out(t, t->buf, ret);
                         name = out_name;
                         op = "write";
                 } else {
diff --git a/tools/usb/testusb.c b/tools/usb/testusb.c
index 6e0f56701e44..82d7c590c026 100644
--- a/tools/usb/testusb.c
+++ b/tools/usb/testusb.c
@@ -358,6 +358,7 @@ static const char *usbfs_dir_find(void)
 {
         static char usbfs_path_0[] = "/dev/usb/devices";
         static char usbfs_path_1[] = "/proc/bus/usb/devices";
+        static char udev_usb_path[] = "/dev/bus/usb";
 
         static char *const usbfs_paths[] = {
                 usbfs_path_0, usbfs_path_1
@@ -376,6 +377,10 @@ static const char *usbfs_dir_find(void)
                 }
         } while (++it != end);
 
+        /* real device-nodes managed by udev */
+        if (access(udev_usb_path, F_OK) == 0)
+                return udev_usb_path;
+
         return NULL;
 }
 
diff --git a/tools/virtio/linux/virtio.h b/tools/virtio/linux/virtio.h
index 7579f19e61e0..81847dd08bd0 100644
--- a/tools/virtio/linux/virtio.h
+++ b/tools/virtio/linux/virtio.h
@@ -203,6 +203,7 @@ void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
 void virtqueue_disable_cb(struct virtqueue *vq);
 
 bool virtqueue_enable_cb(struct virtqueue *vq);
+bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
 
 void *virtqueue_detach_unused_buf(struct virtqueue *vq);
 struct virtqueue *vring_new_virtqueue(unsigned int num,
diff --git a/tools/virtio/virtio_test.c b/tools/virtio/virtio_test.c
index 6bf95f995364..e626fa553c5a 100644
--- a/tools/virtio/virtio_test.c
+++ b/tools/virtio/virtio_test.c
@@ -144,7 +144,8 @@ static void wait_for_interrupt(struct vdev_info *dev)
                 }
 }
 
-static void run_test(struct vdev_info *dev, struct vq_info *vq, int bufs)
+static void run_test(struct vdev_info *dev, struct vq_info *vq,
+                     bool delayed, int bufs)
 {
         struct scatterlist sl;
         long started = 0, completed = 0;
@@ -183,8 +184,12 @@ static void run_test(struct vdev_info *dev, struct vq_info *vq, int bufs)
                 assert(started <= bufs);
                 if (completed == bufs)
                         break;
-                if (virtqueue_enable_cb(vq->vq)) {
-                        wait_for_interrupt(dev);
+                if (delayed) {
+                        if (virtqueue_enable_cb_delayed(vq->vq))
+                                wait_for_interrupt(dev);
+                } else {
+                        if (virtqueue_enable_cb(vq->vq))
+                                wait_for_interrupt(dev);
                 }
         }
         test = 0;
@@ -216,6 +221,14 @@ const struct option longopts[] = {
                 .val = 'i',
         },
         {
+                .name = "delayed-interrupt",
+                .val = 'D',
+        },
+        {
+                .name = "no-delayed-interrupt",
+                .val = 'd',
+        },
+        {
         }
 };
 
@@ -224,6 +237,7 @@ static void help()
         fprintf(stderr, "Usage: virtio_test [--help]"
                 " [--no-indirect]"
                 " [--no-event-idx]"
+                " [--delayed-interrupt]"
                 "\n");
 }
 
@@ -233,6 +247,7 @@ int main(int argc, char **argv)
         unsigned long long features = (1ULL << VIRTIO_RING_F_INDIRECT_DESC) |
                 (1ULL << VIRTIO_RING_F_EVENT_IDX);
         int o;
+        bool delayed = false;
 
         for (;;) {
                 o = getopt_long(argc, argv, optstring, longopts, NULL);
@@ -251,6 +266,9 @@ int main(int argc, char **argv)
                 case 'i':
                         features &= ~(1ULL << VIRTIO_RING_F_INDIRECT_DESC);
                         break;
+                case 'D':
+                        delayed = true;
+                        break;
                 default:
                         assert(0);
                         break;
@@ -260,6 +278,6 @@ int main(int argc, char **argv)
 done:
         vdev_info_init(&dev, features);
         vq_info_add(&dev, 256);
-        run_test(&dev, &dev.vqs[0], 0x100000);
+        run_test(&dev, &dev.vqs[0], delayed, 0x100000);
         return 0;
 }
diff --git a/tools/vm/page-types.c b/tools/vm/page-types.c
index 7dab7b25b5c6..f576971f6556 100644
--- a/tools/vm/page-types.c
+++ b/tools/vm/page-types.c
@@ -35,6 +35,7 @@
 #include <sys/mount.h>
 #include <sys/statfs.h>
 #include "../../include/linux/magic.h"
+#include "../../include/linux/kernel-page-flags.h"
 
 
 #ifndef MAX_PATH
@@ -73,33 +74,6 @@
 #define KPF_BYTES               8
 #define PROC_KPAGEFLAGS         "/proc/kpageflags"
 
-/* copied from kpageflags_read() */
-#define KPF_LOCKED              0
-#define KPF_ERROR               1
-#define KPF_REFERENCED          2
-#define KPF_UPTODATE            3
-#define KPF_DIRTY               4
-#define KPF_LRU                 5
-#define KPF_ACTIVE              6
-#define KPF_SLAB                7
-#define KPF_WRITEBACK           8
-#define KPF_RECLAIM             9
-#define KPF_BUDDY               10
-
-/* [11-20] new additions in 2.6.31 */
-#define KPF_MMAP                11
-#define KPF_ANON                12
-#define KPF_SWAPCACHE           13
-#define KPF_SWAPBACKED          14
-#define KPF_COMPOUND_HEAD       15
-#define KPF_COMPOUND_TAIL       16
-#define KPF_HUGE                17
-#define KPF_UNEVICTABLE         18
-#define KPF_HWPOISON            19
-#define KPF_NOPAGE              20
-#define KPF_KSM                 21
-#define KPF_THP                 22
-
 /* [32-] kernel hacking assistances */
 #define KPF_RESERVED            32
 #define KPF_MLOCKED             33
@@ -326,7 +300,7 @@ static char *page_flag_name(uint64_t flags)
 {
         static char buf[65];
         int present;
-        int i, j;
+        size_t i, j;
 
         for (i = 0, j = 0; i < ARRAY_SIZE(page_flag_names); i++) {
                 present = (flags >> i) & 1;
@@ -344,7 +318,7 @@ static char *page_flag_name(uint64_t flags)
 static char *page_flag_longname(uint64_t flags)
 {
         static char buf[1024];
-        int i, n;
+        size_t i, n;
 
         for (i = 0, n = 0; i < ARRAY_SIZE(page_flag_names); i++) {
                 if (!page_flag_names[i])
@@ -402,7 +376,7 @@ static void show_page(unsigned long voffset,
 
 static void show_summary(void)
 {
-        int i;
+        size_t i;
 
         printf("             flags\tpage-count       MB"
                 "  symbolic-flags\t\t\tlong-symbolic-flags\n");
@@ -500,7 +474,7 @@ static int debugfs_valid_mountpoint(const char *debugfs)
 /* find the path to the mounted debugfs */
 static const char *debugfs_find_mountpoint(void)
 {
-        const char **ptr;
+        const char *const *ptr;
         char type[100];
         FILE *fp;
 
@@ -537,7 +511,7 @@ static const char *debugfs_find_mountpoint(void)
 
 static void debugfs_mount(void)
 {
-        const char **ptr;
+        const char *const *ptr;
 
         /* see if it's already mounted */
         if (debugfs_find_mountpoint())
@@ -614,10 +588,10 @@ static int unpoison_page(unsigned long offset)
  * page frame walker
  */
 
-static int hash_slot(uint64_t flags)
+static size_t hash_slot(uint64_t flags)
 {
-        int k = HASH_KEY(flags);
-        int i;
+        size_t k = HASH_KEY(flags);
+        size_t i;
 
         /* Explicitly reserve slot 0 for flags 0: the following logic
          * cannot distinguish an unoccupied slot from slot (flags==0).
@@ -670,7 +644,7 @@ static void walk_pfn(unsigned long voffset,
 {
         uint64_t buf[KPAGEFLAGS_BATCH];
         unsigned long batch;
-        long pages;
+        unsigned long pages;
         unsigned long i;
 
         while (count) {
@@ -779,7 +753,7 @@ static const char *page_flag_type(uint64_t flag)
 
 static void usage(void)
 {
-        int i, j;
+        size_t i, j;
 
         printf(
 "page-types [options]\n"
@@ -938,7 +912,7 @@ static void add_bits_filter(uint64_t mask, uint64_t bits)
 
 static uint64_t parse_flag_name(const char *str, int len)
 {
-        int i;
+        size_t i;
 
         if (!*str || !len)
                 return 0;