Merge branch 'perf/core' into perf/timer, before applying new changes

Signed-off-by: Ingo Molnar <mingo@kernel.org>

21 files changed, 673 insertions, 378 deletions

diff --git a/tools/lib/api/Build b/tools/lib/api/Build
new file mode 100644
index 000000000000..3653965cf481
--- /dev/null
+++ b/tools/lib/api/Build
@@ -0,0 +1,2 @@
+libapi-y += fd/
+libapi-y += fs/
diff --git a/tools/lib/api/Makefile b/tools/lib/api/Makefile
index 36c08b1f4afb..d8fe29fc19a4 100644
--- a/tools/lib/api/Makefile
+++ b/tools/lib/api/Makefile
@@ -1,49 +1,43 @@
 include ../../scripts/Makefile.include
 include ../../perf/config/utilities.mak         # QUIET_CLEAN
 
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
+endif
+
 CC = $(CROSS_COMPILE)gcc
 AR = $(CROSS_COMPILE)ar
 
-# guard against environment variables
-LIB_H=
-LIB_OBJS=
-
-LIB_H += fs/debugfs.h
-LIB_H += fs/fs.h
-# See comment below about piggybacking...
-LIB_H += fd/array.h
-
-LIB_OBJS += $(OUTPUT)fs/debugfs.o
-LIB_OBJS += $(OUTPUT)fs/fs.o
-# XXX piggybacking here, need to introduce libapikfd, or rename this
-# to plain libapik.a and make it have it all api goodies
-LIB_OBJS += $(OUTPUT)fd/array.o
+MAKEFLAGS += --no-print-directory
 
-LIBFILE = libapikfs.a
+LIBFILE = $(OUTPUT)libapi.a
 
-CFLAGS = -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -D_FORTIFY_SOURCE=2 $(EXTRA_WARNINGS) $(EXTRA_CFLAGS) -fPIC
-EXTLIBS = -lelf -lpthread -lrt -lm
-ALL_CFLAGS = $(CFLAGS) $(BASIC_CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
-ALL_LDFLAGS = $(LDFLAGS)
+CFLAGS := $(EXTRA_WARNINGS) $(EXTRA_CFLAGS)
+CFLAGS += -ggdb3 -Wall -Wextra -std=gnu99 -Werror -O6 -D_FORTIFY_SOURCE=2 -fPIC
+CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 
 RM = rm -f
 
-$(LIBFILE): $(LIB_OBJS)
-        $(QUIET_AR)$(RM) $@ && $(AR) rcs $(OUTPUT)$@ $(LIB_OBJS)
+build  := -f $(srctree)/tools/build/Makefile.build dir=. obj
+API_IN := $(OUTPUT)libapi-in.o
 
-$(LIB_OBJS): $(LIB_H)
+export srctree OUTPUT CC LD CFLAGS V
 
-libapi_dirs:
-        $(QUIET_MKDIR)mkdir -p $(OUTPUT)fd $(OUTPUT)fs
+all: $(LIBFILE)
 
-$(OUTPUT)%.o: %.c libapi_dirs
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
-$(OUTPUT)%.s: %.c libapi_dirs
-        $(QUIET_CC)$(CC) -S $(ALL_CFLAGS) $<
-$(OUTPUT)%.o: %.S libapi_dirs
-        $(QUIET_CC)$(CC) -o $@ -c $(ALL_CFLAGS) $<
+$(API_IN): FORCE
+        @$(MAKE) $(build)=libapi
+
+$(LIBFILE): $(API_IN)
+        $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(API_IN)
 
 clean:
-        $(call QUIET_CLEAN, libapi) $(RM) $(LIB_OBJS) $(LIBFILE)
+        $(call QUIET_CLEAN, libapi) $(RM) $(LIBFILE); \
+        find $(if $(OUTPUT),$(OUTPUT),.) -name \*.o | xargs $(RM)
+
+FORCE:
 
-.PHONY: clean
+.PHONY: clean FORCE
diff --git a/tools/lib/api/fd/Build b/tools/lib/api/fd/Build
new file mode 100644
index 000000000000..605d99f6d71a
--- /dev/null
+++ b/tools/lib/api/fd/Build
@@ -0,0 +1 @@
+libapi-y += array.o
diff --git a/tools/lib/api/fs/Build b/tools/lib/api/fs/Build
new file mode 100644
index 000000000000..6de5a4f0b501
--- /dev/null
+++ b/tools/lib/api/fs/Build
@@ -0,0 +1,4 @@
+libapi-y += fs.o
+libapi-y += debugfs.o
+libapi-y += findfs.o
+libapi-y += tracefs.o
diff --git a/tools/lib/api/fs/debugfs.c b/tools/lib/api/fs/debugfs.c
index d2b18e887071..8305b3e9d48e 100644
--- a/tools/lib/api/fs/debugfs.c
+++ b/tools/lib/api/fs/debugfs.c
@@ -3,75 +3,50 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 #include <stdbool.h>
 #include <sys/vfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
 #include <sys/mount.h>
 #include <linux/kernel.h>
 
 #include "debugfs.h"
 
-char debugfs_mountpoint[PATH_MAX + 1] = "/sys/kernel/debug";
+#ifndef DEBUGFS_DEFAULT_PATH
+#define DEBUGFS_DEFAULT_PATH            "/sys/kernel/debug"
+#endif
+
+char debugfs_mountpoint[PATH_MAX + 1] = DEBUGFS_DEFAULT_PATH;
 
 static const char * const debugfs_known_mountpoints[] = {
-        "/sys/kernel/debug",
+        DEBUGFS_DEFAULT_PATH,
         "/debug",
         0,
 };
 
 static bool debugfs_found;
 
+bool debugfs_configured(void)
+{
+        return debugfs_find_mountpoint() != NULL;
+}
+
 /* find the path to the mounted debugfs */
 const char *debugfs_find_mountpoint(void)
 {
-        const char * const *ptr;
-        char type[100];
-        FILE *fp;
+        const char *ret;
 
         if (debugfs_found)
                 return (const char *)debugfs_mountpoint;
 
-        ptr = debugfs_known_mountpoints;
-        while (*ptr) {
-                if (debugfs_valid_mountpoint(*ptr) == 0) {
-                        debugfs_found = true;
-                        strcpy(debugfs_mountpoint, *ptr);
-                        return debugfs_mountpoint;
-                }
-                ptr++;
-        }
-
-        /* give up and parse /proc/mounts */
-        fp = fopen("/proc/mounts", "r");
-        if (fp == NULL)
-                return NULL;
-
-        while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
-                      debugfs_mountpoint, type) == 2) {
-                if (strcmp(type, "debugfs") == 0)
-                        break;
-        }
-        fclose(fp);
+        ret = find_mountpoint("debugfs", (long) DEBUGFS_MAGIC,
+                              debugfs_mountpoint, PATH_MAX + 1,
+                              debugfs_known_mountpoints);
+        if (ret)
+                debugfs_found = true;
 
-        if (strcmp(type, "debugfs") != 0)
-                return NULL;
-
-        debugfs_found = true;
-
-        return debugfs_mountpoint;
-}
-
-/* verify that a mountpoint is actually a debugfs instance */
-
-int debugfs_valid_mountpoint(const char *debugfs)
-{
-        struct statfs st_fs;
-
-        if (statfs(debugfs, &st_fs) < 0)
-                return -ENOENT;
-        else if ((long)st_fs.f_type != (long)DEBUGFS_MAGIC)
-                return -ENOENT;
-
-        return 0;
+        return ret;
 }
 
 /* mount the debugfs somewhere if it's not mounted */
@@ -87,7 +62,7 @@ char *debugfs_mount(const char *mountpoint)
                 mountpoint = getenv(PERF_DEBUGFS_ENVIRONMENT);
                 /* if no environment variable, use default */
                 if (mountpoint == NULL)
-                        mountpoint = "/sys/kernel/debug";
+                        mountpoint = DEBUGFS_DEFAULT_PATH;
         }
 
         if (mount(NULL, mountpoint, "debugfs", 0, NULL) < 0)
diff --git a/tools/lib/api/fs/debugfs.h b/tools/lib/api/fs/debugfs.h
index 0739881a9897..455023698d2b 100644
--- a/tools/lib/api/fs/debugfs.h
+++ b/tools/lib/api/fs/debugfs.h
@@ -1,16 +1,7 @@
 #ifndef __API_DEBUGFS_H__
 #define __API_DEBUGFS_H__
 
-#define _STR(x) #x
-#define STR(x) _STR(x)
-
-/*
- * On most systems <limits.h> would have given us this, but  not on some systems
- * (e.g. GNU/Hurd).
- */
-#ifndef PATH_MAX
-#define PATH_MAX 4096
-#endif
+#include "findfs.h"
 
 #ifndef DEBUGFS_MAGIC
 #define DEBUGFS_MAGIC          0x64626720
@@ -20,8 +11,8 @@
 #define PERF_DEBUGFS_ENVIRONMENT "PERF_DEBUGFS_DIR"
 #endif
 
+bool debugfs_configured(void);
 const char *debugfs_find_mountpoint(void);
-int debugfs_valid_mountpoint(const char *debugfs);
 char *debugfs_mount(const char *mountpoint);
 
 extern char debugfs_mountpoint[];
diff --git a/tools/lib/api/fs/findfs.c b/tools/lib/api/fs/findfs.c
new file mode 100644
index 000000000000..49946cb6d7af
--- /dev/null
+++ b/tools/lib/api/fs/findfs.c
@@ -0,0 +1,63 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/vfs.h>
+
+#include "findfs.h"
+
+/* verify that a mountpoint is actually the type we want */
+
+int valid_mountpoint(const char *mount, long magic)
+{
+        struct statfs st_fs;
+
+        if (statfs(mount, &st_fs) < 0)
+                return -ENOENT;
+        else if ((long)st_fs.f_type != magic)
+                return -ENOENT;
+
+        return 0;
+}
+
+/* find the path to a mounted file system */
+const char *find_mountpoint(const char *fstype, long magic,
+                            char *mountpoint, int len,
+                            const char * const *known_mountpoints)
+{
+        const char * const *ptr;
+        char format[128];
+        char type[100];
+        FILE *fp;
+
+        if (known_mountpoints) {
+                ptr = known_mountpoints;
+                while (*ptr) {
+                        if (valid_mountpoint(*ptr, magic) == 0) {
+                                strncpy(mountpoint, *ptr, len - 1);
+                                mountpoint[len-1] = 0;
+                                return mountpoint;
+                        }
+                        ptr++;
+                }
+        }
+
+        /* give up and parse /proc/mounts */
+        fp = fopen("/proc/mounts", "r");
+        if (fp == NULL)
+                return NULL;
+
+        snprintf(format, 128, "%%*s %%%ds %%99s %%*s %%*d %%*d\n", len);
+
+        while (fscanf(fp, format, mountpoint, type) == 2) {
+                if (strcmp(type, fstype) == 0)
+                        break;
+        }
+        fclose(fp);
+
+        if (strcmp(type, fstype) != 0)
+                return NULL;
+
+        return mountpoint;
+}
diff --git a/tools/lib/api/fs/findfs.h b/tools/lib/api/fs/findfs.h
new file mode 100644
index 000000000000..b6f5d05acc42
--- /dev/null
+++ b/tools/lib/api/fs/findfs.h
@@ -0,0 +1,23 @@
+#ifndef __API_FINDFS_H__
+#define __API_FINDFS_H__
+
+#include <stdbool.h>
+
+#define _STR(x) #x
+#define STR(x) _STR(x)
+
+/*
+ * On most systems <limits.h> would have given us this, but  not on some systems
+ * (e.g. GNU/Hurd).
+ */
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+const char *find_mountpoint(const char *fstype, long magic,
+                            char *mountpoint, int len,
+                            const char * const *known_mountpoints);
+
+int valid_mountpoint(const char *mount, long magic);
+
+#endif /* __API_FINDFS_H__ */
diff --git a/tools/lib/api/fs/tracefs.c b/tools/lib/api/fs/tracefs.c
new file mode 100644
index 000000000000..e4aa9688b71e
--- /dev/null
+++ b/tools/lib/api/fs/tracefs.c
@@ -0,0 +1,78 @@
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdbool.h>
+#include <sys/vfs.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <linux/kernel.h>
+
+#include "tracefs.h"
+
+#ifndef TRACEFS_DEFAULT_PATH
+#define TRACEFS_DEFAULT_PATH            "/sys/kernel/tracing"
+#endif
+
+char tracefs_mountpoint[PATH_MAX + 1] = TRACEFS_DEFAULT_PATH;
+
+static const char * const tracefs_known_mountpoints[] = {
+        TRACEFS_DEFAULT_PATH,
+        "/sys/kernel/debug/tracing",
+        "/tracing",
+        "/trace",
+        0,
+};
+
+static bool tracefs_found;
+
+bool tracefs_configured(void)
+{
+        return tracefs_find_mountpoint() != NULL;
+}
+
+/* find the path to the mounted tracefs */
+const char *tracefs_find_mountpoint(void)
+{
+        const char *ret;
+
+        if (tracefs_found)
+                return (const char *)tracefs_mountpoint;
+
+        ret = find_mountpoint("tracefs", (long) TRACEFS_MAGIC,
+                              tracefs_mountpoint, PATH_MAX + 1,
+                              tracefs_known_mountpoints);
+
+        if (ret)
+                tracefs_found = true;
+
+        return ret;
+}
+
+/* mount the tracefs somewhere if it's not mounted */
+char *tracefs_mount(const char *mountpoint)
+{
+        /* see if it's already mounted */
+        if (tracefs_find_mountpoint())
+                goto out;
+
+        /* if not mounted and no argument */
+        if (mountpoint == NULL) {
+                /* see if environment variable set */
+                mountpoint = getenv(PERF_TRACEFS_ENVIRONMENT);
+                /* if no environment variable, use default */
+                if (mountpoint == NULL)
+                        mountpoint = TRACEFS_DEFAULT_PATH;
+        }
+
+        if (mount(NULL, mountpoint, "tracefs", 0, NULL) < 0)
+                return NULL;
+
+        /* save the mountpoint */
+        tracefs_found = true;
+        strncpy(tracefs_mountpoint, mountpoint, sizeof(tracefs_mountpoint));
+out:
+        return tracefs_mountpoint;
+}
diff --git a/tools/lib/api/fs/tracefs.h b/tools/lib/api/fs/tracefs.h
new file mode 100644
index 000000000000..da780ac49acb
--- /dev/null
+++ b/tools/lib/api/fs/tracefs.h
@@ -0,0 +1,21 @@
+#ifndef __API_TRACEFS_H__
+#define __API_TRACEFS_H__
+
+#include "findfs.h"
+
+#ifndef TRACEFS_MAGIC
+#define TRACEFS_MAGIC          0x74726163
+#endif
+
+#ifndef PERF_TRACEFS_ENVIRONMENT
+#define PERF_TRACEFS_ENVIRONMENT "PERF_TRACEFS_DIR"
+#endif
+
+bool tracefs_configured(void);
+const char *tracefs_find_mountpoint(void);
+int tracefs_valid_mountpoint(const char *debugfs);
+char *tracefs_mount(const char *mountpoint);
+
+extern char tracefs_mountpoint[];
+
+#endif /* __API_DEBUGFS_H__ */
diff --git a/tools/lib/lockdep/Build b/tools/lib/lockdep/Build
new file mode 100644
index 000000000000..6f667355b068
--- /dev/null
+++ b/tools/lib/lockdep/Build
@@ -0,0 +1 @@
+liblockdep-y += common.o lockdep.o preload.o rbtree.o
diff --git a/tools/lib/lockdep/Makefile b/tools/lib/lockdep/Makefile
index 4b866c54f624..0c356fb65022 100644
--- a/tools/lib/lockdep/Makefile
+++ b/tools/lib/lockdep/Makefile
@@ -35,6 +35,10 @@ bindir = $(prefix)/$(bindir_relative)
 
 export DESTDIR DESTDIR_SQ INSTALL
 
+MAKEFLAGS += --no-print-directory
+
+include ../../scripts/Makefile.include
+
 # copy a bit from Linux kbuild
 
 ifeq ("$(origin V)", "command line")
@@ -44,56 +48,21 @@ ifndef VERBOSE
   VERBOSE = 0
 endif
 
-ifeq ("$(origin O)", "command line")
-  BUILD_OUTPUT := $(O)
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 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         := $(realpath $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR)))
-objtree         := $(realpath $(CURDIR))
-src             := $(srctree)
-obj             := $(objtree)
-
-export prefix libdir bindir src obj
-
 # Shell quotes
 libdir_SQ = $(subst ','\'',$(libdir))
 bindir_SQ = $(subst ','\'',$(bindir))
 
-LIB_FILE = liblockdep.a liblockdep.so.$(LIBLOCKDEP_VERSION)
+LIB_IN := $(OUTPUT)liblockdep-in.o
+
 BIN_FILE = lockdep
+LIB_FILE = $(OUTPUT)liblockdep.a $(OUTPUT)liblockdep.so.$(LIBLOCKDEP_VERSION)
 
 CONFIG_INCLUDES =
 CONFIG_LIBS     =
@@ -108,33 +77,23 @@ INCLUDES = -I. -I./uinclude -I./include -I../../include $(CONFIG_INCLUDES)
 
 # Set compile option CFLAGS if not set elsewhere
 CFLAGS ?= -g -DCONFIG_LOCKDEP -DCONFIG_STACKTRACE -DCONFIG_PROVE_LOCKING -DBITS_PER_LONG=__WORDSIZE -DLIBLOCKDEP_VERSION='"$(LIBLOCKDEP_VERSION)"' -rdynamic -O0 -g
+CFLAGS += -fPIC
 
 override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
 
 ifeq ($(VERBOSE),1)
   Q =
-  print_compile =
-  print_app_build =
-  print_fpic_compile =
   print_shared_lib_compile =
   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_static_lib_build =      echo '  BUILD STATIC LIB   '$(OBJ);
-  print_install =               echo '  INSTALL     '$1'        to      $(DESTDIR_SQ)$2';
+  print_shared_lib_compile =    echo '  LD       '$(OBJ);
+  print_static_lib_build =      echo '  LD       '$(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))
+export srctree OUTPUT CC LD CFLAGS V
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
 
 do_compile_shared_library =                     \
         ($(print_shared_lib_compile)            \
@@ -144,22 +103,6 @@ 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 = common.o lockdep.o preload.o rbtree.o
-
-ALL_OBJS = $(PEVENT_LIB_OBJS)
-
 CMD_TARGETS = $(LIB_FILE)
 
 TARGETS = $(CMD_TARGETS)
@@ -169,42 +112,15 @@ all: all_cmd
 
 all_cmd: $(CMD_TARGETS)
 
-liblockdep.so.$(LIBLOCKDEP_VERSION): $(PEVENT_LIB_OBJS)
+$(LIB_IN): force
+        $(Q)$(MAKE) $(build)=liblockdep
+
+liblockdep.so.$(LIBLOCKDEP_VERSION): $(LIB_IN)
         $(Q)$(do_compile_shared_library)
 
-liblockdep.a: $(PEVENT_LIB_OBJS)
+liblockdep.a: $(LIB_IN)
         $(Q)$(do_build_static_lib)
 
-$(PEVENT_LIB_OBJS): %.o: $(src)/%.c
-        $(Q)$(do_fpic_compile)
-
-## make deps
-
-all_objs := $(sort $(ALL_OBJS))
-all_deps := $(all_objs:%.o=.%.d)
-
-# let .d file also depends on the source and header files
-define check_deps
-                @set -e; $(RM) $@; \
-                $(CC) -MM $(CFLAGS) $< > $@.$$$$; \
-                sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
-                $(RM) $@.$$$$
-endef
-
-$(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
-
-### Detect environment changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):$(ARCH):$(CROSS_COMPILE)
-
 tags:   force
         $(RM) tags
         find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px \
@@ -233,8 +149,6 @@ clean:
         $(RM) *.o *~ $(TARGETS) *.a *liblockdep*.so* $(VERSION_FILES) .*.d
         $(RM) tags TAGS
 
-endif # skip-makefile
-
 PHONY += force
 force:
 
diff --git a/tools/lib/traceevent/Build b/tools/lib/traceevent/Build
new file mode 100644
index 000000000000..c681d0575d16
--- /dev/null
+++ b/tools/lib/traceevent/Build
@@ -0,0 +1,17 @@
+libtraceevent-y += event-parse.o
+libtraceevent-y += event-plugin.o
+libtraceevent-y += trace-seq.o
+libtraceevent-y += parse-filter.o
+libtraceevent-y += parse-utils.o
+libtraceevent-y += kbuffer-parse.o
+
+plugin_jbd2-y         += plugin_jbd2.o
+plugin_hrtimer-y      += plugin_hrtimer.o
+plugin_kmem-y         += plugin_kmem.o
+plugin_kvm-y          += plugin_kvm.o
+plugin_mac80211-y     += plugin_mac80211.o
+plugin_sched_switch-y += plugin_sched_switch.o
+plugin_function-y     += plugin_function.o
+plugin_xen-y          += plugin_xen.o
+plugin_scsi-y         += plugin_scsi.o
+plugin_cfg80211-y     += plugin_cfg80211.o
diff --git a/tools/lib/traceevent/Makefile b/tools/lib/traceevent/Makefile
index 005c9cc06935..d410da335e3d 100644
--- a/tools/lib/traceevent/Makefile
+++ b/tools/lib/traceevent/Makefile
@@ -67,7 +67,7 @@ PLUGIN_DIR = -DPLUGIN_DIR="$(plugin_dir)"
 PLUGIN_DIR_SQ = '$(subst ','\'',$(PLUGIN_DIR))'
 endif
 
-include $(if $(BUILD_SRC),$(BUILD_SRC)/)../../scripts/Makefile.include
+include ../../scripts/Makefile.include
 
 # copy a bit from Linux kbuild
 
@@ -78,40 +78,13 @@ ifndef VERBOSE
   VERBOSE = 0
 endif
 
-ifeq ("$(origin O)", "command line")
-  BUILD_OUTPUT := $(O)
+ifeq ($(srctree),)
+srctree := $(patsubst %/,%,$(dir $(shell pwd)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+srctree := $(patsubst %/,%,$(dir $(srctree)))
+#$(info Determined 'srctree' to be $(srctree))
 endif
 
-ifeq ($(BUILD_SRC),)
-ifneq ($(OUTPUT),)
-
-define build_output
-  $(if $(VERBOSE:1=),@)+$(MAKE) -C $(OUTPUT) \
-  BUILD_SRC=$(CURDIR)/ -f $(CURDIR)/Makefile $1
-endef
-
-all: sub-make
-
-$(MAKECMDGOALS): sub-make
-
-sub-make: force
-        $(call build_output, $(MAKECMDGOALS))
-
-
-# Leave processing to above invocation of make
-skip-makefile := 1
-
-endif # 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
@@ -132,16 +105,19 @@ EXTRAVERSION	= $(EP_EXTRAVERSION)
 OBJ             = $@
 N               =
 
-export Q VERBOSE
-
 EVENT_PARSE_VERSION = $(EP_VERSION).$(EP_PATCHLEVEL).$(EP_EXTRAVERSION)
 
-INCLUDES = -I. -I $(srctree)/../../include $(CONFIG_INCLUDES)
+INCLUDES = -I. -I $(srctree)/tools/include $(CONFIG_INCLUDES)
 
-# Set compile option CFLAGS if not set elsewhere
-CFLAGS ?= -g -Wall
+# Set compile option CFLAGS
+ifdef EXTRA_CFLAGS
+  CFLAGS := $(EXTRA_CFLAGS)
+else
+  CFLAGS := -g -Wall
+endif
 
 # Append required CFLAGS
+override CFLAGS += -fPIC
 override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
 override CFLAGS += $(udis86-flags) -D_GNU_SOURCE
 
@@ -151,74 +127,58 @@ else
   Q = @
 endif
 
-do_compile_shared_library =                     \
-        ($(print_shared_lib_compile)            \
-        $(CC) --shared $^ -o $@)
-
-do_plugin_build =                               \
-        ($(print_plugin_build)                  \
-        $(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<)
-
-do_build_static_lib =                           \
-        ($(print_static_lib_build)              \
-        $(RM) $@;  $(AR) rcs $@ $^)
-
-
-do_compile = $(QUIET_CC)$(CC) -c $(CFLAGS) $(EXT) $< -o $(obj)/$@;
+# Disable command line variables (CFLAGS) overide from top
+# level Makefile (perf), otherwise build Makefile will get
+# the same command line setup.
+MAKEOVERRIDES=
 
-$(obj)/%.o: $(src)/%.c
-        $(call do_compile)
+export srctree OUTPUT CC LD CFLAGS V
+build := -f $(srctree)/tools/build/Makefile.build dir=. obj
 
-%.o: $(src)/%.c
-        $(call do_compile)
+PLUGINS  = plugin_jbd2.so
+PLUGINS += plugin_hrtimer.so
+PLUGINS += plugin_kmem.so
+PLUGINS += plugin_kvm.so
+PLUGINS += plugin_mac80211.so
+PLUGINS += plugin_sched_switch.so
+PLUGINS += plugin_function.so
+PLUGINS += plugin_xen.so
+PLUGINS += plugin_scsi.so
+PLUGINS += plugin_cfg80211.so
 
-PEVENT_LIB_OBJS  = event-parse.o
-PEVENT_LIB_OBJS += event-plugin.o
-PEVENT_LIB_OBJS += trace-seq.o
-PEVENT_LIB_OBJS += parse-filter.o
-PEVENT_LIB_OBJS += parse-utils.o
-PEVENT_LIB_OBJS += kbuffer-parse.o
+PLUGINS    := $(addprefix $(OUTPUT),$(PLUGINS))
+PLUGINS_IN := $(PLUGINS:.so=-in.o)
 
-PLUGIN_OBJS  = plugin_jbd2.o
-PLUGIN_OBJS += plugin_hrtimer.o
-PLUGIN_OBJS += plugin_kmem.o
-PLUGIN_OBJS += plugin_kvm.o
-PLUGIN_OBJS += plugin_mac80211.o
-PLUGIN_OBJS += plugin_sched_switch.o
-PLUGIN_OBJS += plugin_function.o
-PLUGIN_OBJS += plugin_xen.o
-PLUGIN_OBJS += plugin_scsi.o
-PLUGIN_OBJS += plugin_cfg80211.o
-
-PLUGINS := $(PLUGIN_OBJS:.o=.so)
-
-ALL_OBJS = $(PEVENT_LIB_OBJS) $(PLUGIN_OBJS)
+TE_IN    := $(OUTPUT)libtraceevent-in.o
+LIB_FILE := $(addprefix $(OUTPUT),$(LIB_FILE))
 
 CMD_TARGETS = $(LIB_FILE) $(PLUGINS)
 
 TARGETS = $(CMD_TARGETS)
 
-
 all: all_cmd
 
 all_cmd: $(CMD_TARGETS)
 
-libtraceevent.so: $(PEVENT_LIB_OBJS)
+$(TE_IN): force
+        $(Q)$(MAKE) $(build)=libtraceevent
+
+$(OUTPUT)libtraceevent.so: $(TE_IN)
         $(QUIET_LINK)$(CC) --shared $^ -o $@
 
-libtraceevent.a: $(PEVENT_LIB_OBJS)
+$(OUTPUT)libtraceevent.a: $(TE_IN)
         $(QUIET_LINK)$(RM) $@; $(AR) rcs $@ $^
 
 plugins: $(PLUGINS)
 
-$(PEVENT_LIB_OBJS): %.o: $(src)/%.c TRACEEVENT-CFLAGS
-        $(QUIET_CC_FPIC)$(CC) -c $(CFLAGS) $(EXT) -fPIC $< -o $@
+__plugin_obj = $(notdir $@)
+  plugin_obj = $(__plugin_obj:-in.o=)
 
-$(PLUGIN_OBJS): %.o : $(src)/%.c
-        $(QUIET_CC_FPIC)$(CC) -c $(CFLAGS) -fPIC -o $@ $<
+$(PLUGINS_IN): force
+        $(Q)$(MAKE) $(build)=$(plugin_obj)
 
-$(PLUGINS): %.so: %.o
-        $(QUIET_LINK)$(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<
+$(OUTPUT)%.so: $(OUTPUT)%-in.o
+        $(QUIET_LINK)$(CC) $(CFLAGS) -shared -nostartfiles -o $@ $^
 
 define make_version.h
   (echo '/* This file is automatically generated. Do not modify. */';           \
@@ -255,40 +215,6 @@ define update_dir
    fi);
 endef
 
-## make deps
-
-all_objs := $(sort $(ALL_OBJS))
-all_deps := $(all_objs:%.o=.%.d)
-
-# let .d file also depends on the source and header files
-define check_deps
-  @set -e; $(RM) $@; \
-  $(CC) -MM $(CFLAGS) $< > $@.$$$$; \
-  sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
-  $(RM) $@.$$$$
-endef
-
-$(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
-
-### Detect environment changes
-TRACK_CFLAGS = $(subst ','\'',$(CFLAGS)):$(ARCH):$(CROSS_COMPILE)
-
-TRACEEVENT-CFLAGS: force
-        @FLAGS='$(TRACK_CFLAGS)'; \
-            if test x"$$FLAGS" != x"`cat TRACEEVENT-CFLAGS 2>/dev/null`" ; then \
-                echo 1>&2 "  FLAGS:   * new build flags or cross compiler"; \
-                echo "$$FLAGS" >TRACEEVENT-CFLAGS; \
-            fi
-
 tags:   force
         $(RM) tags
         find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px \
@@ -327,14 +253,9 @@ clean:
                 $(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES) .*.d \
                 $(RM) TRACEEVENT-CFLAGS tags TAGS
 
-endif # skip-makefile
-
 PHONY += force plugins
 force:
 
-plugins:
-        @echo > /dev/null
-
 # 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
index afe20ed9fac8..6d31b6419d37 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -304,7 +304,10 @@ int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
         if (!item)
                 return -1;
 
-        item->comm = strdup(comm);
+        if (comm)
+                item->comm = strdup(comm);
+        else
+                item->comm = strdup("<...>");
         if (!item->comm) {
                 free(item);
                 return -1;
@@ -318,9 +321,14 @@ int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
         return 0;
 }
 
-void pevent_register_trace_clock(struct pevent *pevent, char *trace_clock)
+int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock)
 {
-        pevent->trace_clock = trace_clock;
+        pevent->trace_clock = strdup(trace_clock);
+        if (!pevent->trace_clock) {
+                errno = ENOMEM;
+                return -1;
+        }
+        return 0;
 }
 
 struct func_map {
@@ -758,6 +766,11 @@ static void free_arg(struct print_arg *arg)
                 free_arg(arg->hex.field);
                 free_arg(arg->hex.size);
                 break;
+        case PRINT_INT_ARRAY:
+                free_arg(arg->int_array.field);
+                free_arg(arg->int_array.count);
+                free_arg(arg->int_array.el_size);
+                break;
         case PRINT_TYPE:
                 free(arg->typecast.type);
                 free_arg(arg->typecast.item);
@@ -2014,6 +2027,38 @@ process_entry(struct event_format *event __maybe_unused, struct print_arg *arg,
         return EVENT_ERROR;
 }
 
+static int alloc_and_process_delim(struct event_format *event, char *next_token,
+                                   struct print_arg **print_arg)
+{
+        struct print_arg *field;
+        enum event_type type;
+        char *token;
+        int ret = 0;
+
+        field = alloc_arg();
+        if (!field) {
+                do_warning_event(event, "%s: not enough memory!", __func__);
+                errno = ENOMEM;
+                return -1;
+        }
+
+        type = process_arg(event, field, &token);
+
+        if (test_type_token(type, token, EVENT_DELIM, next_token)) {
+                errno = EINVAL;
+                ret = -1;
+                free_arg(field);
+                goto out_free_token;
+        }
+
+        *print_arg = field;
+
+out_free_token:
+        free_token(token);
+
+        return ret;
+}
+
 static char *arg_eval (struct print_arg *arg);
 
 static unsigned long long
@@ -2486,49 +2531,46 @@ out_free:
 static enum event_type
 process_hex(struct event_format *event, struct print_arg *arg, char **tok)
 {
-        struct print_arg *field;
-        enum event_type type;
-        char *token = NULL;
-
         memset(arg, 0, sizeof(*arg));
         arg->type = PRINT_HEX;
 
-        field = alloc_arg();
-        if (!field) {
-                do_warning_event(event, "%s: not enough memory!", __func__);
-                goto out_free;
-        }
-
-        type = process_arg(event, field, &token);
+        if (alloc_and_process_delim(event, ",", &arg->hex.field))
+                goto out;
 
-        if (test_type_token(type, token, EVENT_DELIM, ","))
-                goto out_free;
+        if (alloc_and_process_delim(event, ")", &arg->hex.size))
+                goto free_field;
 
-        arg->hex.field = field;
+        return read_token_item(tok);
 
-        free_token(token);
+free_field:
+        free_arg(arg->hex.field);
+out:
+        *tok = NULL;
+        return EVENT_ERROR;
+}
 
-        field = alloc_arg();
-        if (!field) {
-                do_warning_event(event, "%s: not enough memory!", __func__);
-                *tok = NULL;
-                return EVENT_ERROR;
-        }
+static enum event_type
+process_int_array(struct event_format *event, struct print_arg *arg, char **tok)
+{
+        memset(arg, 0, sizeof(*arg));
+        arg->type = PRINT_INT_ARRAY;
 
-        type = process_arg(event, field, &token);
+        if (alloc_and_process_delim(event, ",", &arg->int_array.field))
+                goto out;
 
-        if (test_type_token(type, token, EVENT_DELIM, ")"))
-                goto out_free;
+        if (alloc_and_process_delim(event, ",", &arg->int_array.count))
+                goto free_field;
 
-        arg->hex.size = field;
+        if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
+                goto free_size;
 
-        free_token(token);
-        type = read_token_item(tok);
-        return type;
+        return read_token_item(tok);
 
- out_free:
-        free_arg(field);
-        free_token(token);
+free_size:
+        free_arg(arg->int_array.count);
+free_field:
+        free_arg(arg->int_array.field);
+out:
         *tok = NULL;
         return EVENT_ERROR;
 }
@@ -2828,6 +2870,10 @@ process_function(struct event_format *event, struct print_arg *arg,
                 free_token(token);
                 return process_hex(event, arg, tok);
         }
+        if (strcmp(token, "__print_array") == 0) {
+                free_token(token);
+                return process_int_array(event, arg, tok);
+        }
         if (strcmp(token, "__get_str") == 0) {
                 free_token(token);
                 return process_str(event, arg, tok);
@@ -3356,6 +3402,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                 break;
         case PRINT_FLAGS:
         case PRINT_SYMBOL:
+        case PRINT_INT_ARRAY:
         case PRINT_HEX:
                 break;
         case PRINT_TYPE:
@@ -3568,7 +3615,7 @@ static const struct flag flags[] = {
         { "HRTIMER_RESTART", 1 },
 };
 
-static unsigned long long eval_flag(const char *flag)
+static long long eval_flag(const char *flag)
 {
         int i;
 
@@ -3584,7 +3631,7 @@ static unsigned long long eval_flag(const char *flag)
                 if (strcmp(flags[i].name, flag) == 0)
                         return flags[i].value;
 
-        return 0;
+        return -1LL;
 }
 
 static void print_str_to_seq(struct trace_seq *s, const char *format,
@@ -3658,7 +3705,7 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
         struct print_flag_sym *flag;
         struct format_field *field;
         struct printk_map *printk;
-        unsigned long long val, fval;
+        long long val, fval;
         unsigned long addr;
         char *str;
         unsigned char *hex;
@@ -3717,11 +3764,11 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 print = 0;
                 for (flag = arg->flags.flags; flag; flag = flag->next) {
                         fval = eval_flag(flag->value);
-                        if (!val && !fval) {
+                        if (!val && fval < 0) {
                                 print_str_to_seq(s, format, len_arg, flag->str);
                                 break;
                         }
-                        if (fval && (val & fval) == fval) {
+                        if (fval > 0 && (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);
@@ -3766,6 +3813,54 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
                 }
                 break;
 
+        case PRINT_INT_ARRAY: {
+                void *num;
+                int el_size;
+
+                if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
+                        unsigned long offset;
+                        struct format_field *field =
+                                arg->int_array.field->dynarray.field;
+                        offset = pevent_read_number(pevent,
+                                                    data + field->offset,
+                                                    field->size);
+                        num = data + (offset & 0xffff);
+                } else {
+                        field = arg->int_array.field->field.field;
+                        if (!field) {
+                                str = arg->int_array.field->field.name;
+                                field = pevent_find_any_field(event, str);
+                                if (!field)
+                                        goto out_warning_field;
+                                arg->int_array.field->field.field = field;
+                        }
+                        num = data + field->offset;
+                }
+                len = eval_num_arg(data, size, event, arg->int_array.count);
+                el_size = eval_num_arg(data, size, event,
+                                       arg->int_array.el_size);
+                for (i = 0; i < len; i++) {
+                        if (i)
+                                trace_seq_putc(s, ' ');
+
+                        if (el_size == 1) {
+                                trace_seq_printf(s, "%u", *(uint8_t *)num);
+                        } else if (el_size == 2) {
+                                trace_seq_printf(s, "%u", *(uint16_t *)num);
+                        } else if (el_size == 4) {
+                                trace_seq_printf(s, "%u", *(uint32_t *)num);
+                        } else if (el_size == 8) {
+                                trace_seq_printf(s, "%lu", *(uint64_t *)num);
+                        } else {
+                                trace_seq_printf(s, "BAD SIZE:%d 0x%x",
+                                                 el_size, *(uint8_t *)num);
+                                el_size = 1;
+                        }
+
+                        num += el_size;
+                }
+                break;
+        }
         case PRINT_TYPE:
                 break;
         case PRINT_STRING: {
@@ -3997,6 +4092,10 @@ static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struc
                                 goto process_again;
                         case '.':
                                 goto process_again;
+                        case 'z':
+                        case 'Z':
+                                ls = 1;
+                                goto process_again;
                         case 'p':
                                 ls = 1;
                                 /* fall through */
@@ -4939,6 +5038,96 @@ const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
         return comm;
 }
 
+static struct cmdline *
+pid_from_cmdlist(struct pevent *pevent, const char *comm, struct cmdline *next)
+{
+        struct cmdline_list *cmdlist = (struct cmdline_list *)next;
+
+        if (cmdlist)
+                cmdlist = cmdlist->next;
+        else
+                cmdlist = pevent->cmdlist;
+
+        while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
+                cmdlist = cmdlist->next;
+
+        return (struct cmdline *)cmdlist;
+}
+
+/**
+ * pevent_data_pid_from_comm - return the pid from a given comm
+ * @pevent: a handle to the pevent
+ * @comm: the cmdline to find the pid from
+ * @next: the cmdline structure to find the next comm
+ *
+ * This returns the cmdline structure that holds a pid for a given
+ * comm, or NULL if none found. As there may be more than one pid for
+ * a given comm, the result of this call can be passed back into
+ * a recurring call in the @next paramater, and then it will find the
+ * next pid.
+ * Also, it does a linear seach, so it may be slow.
+ */
+struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,
+                                          struct cmdline *next)
+{
+        struct cmdline *cmdline;
+
+        /*
+         * If the cmdlines have not been converted yet, then use
+         * the list.
+         */
+        if (!pevent->cmdlines)
+                return pid_from_cmdlist(pevent, comm, next);
+
+        if (next) {
+                /*
+                 * The next pointer could have been still from
+                 * a previous call before cmdlines were created
+                 */
+                if (next < pevent->cmdlines ||
+                    next >= pevent->cmdlines + pevent->cmdline_count)
+                        next = NULL;
+                else
+                        cmdline  = next++;
+        }
+
+        if (!next)
+                cmdline = pevent->cmdlines;
+
+        while (cmdline < pevent->cmdlines + pevent->cmdline_count) {
+                if (strcmp(cmdline->comm, comm) == 0)
+                        return cmdline;
+                cmdline++;
+        }
+        return NULL;
+}
+
+/**
+ * pevent_cmdline_pid - return the pid associated to a given cmdline
+ * @cmdline: The cmdline structure to get the pid from
+ *
+ * Returns the pid for a give cmdline. If @cmdline is NULL, then
+ * -1 is returned.
+ */
+int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline)
+{
+        struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
+
+        if (!cmdline)
+                return -1;
+
+        /*
+         * If cmdlines have not been created yet, or cmdline is
+         * not part of the array, then treat it as a cmdlist instead.
+         */
+        if (!pevent->cmdlines ||
+            cmdline < pevent->cmdlines ||
+            cmdline >= pevent->cmdlines + pevent->cmdline_count)
+                return cmdlist->pid;
+
+        return cmdline->pid;
+}
+
 /**
  * pevent_data_comm_from_pid - parse the data into the print format
  * @s: the trace_seq to write to
@@ -5256,6 +5445,15 @@ static void print_args(struct print_arg *args)
                 print_args(args->hex.size);
                 printf(")");
                 break;
+        case PRINT_INT_ARRAY:
+                printf("__print_array(");
+                print_args(args->int_array.field);
+                printf(", ");
+                print_args(args->int_array.count);
+                printf(", ");
+                print_args(args->int_array.el_size);
+                printf(")");
+                break;
         case PRINT_STRING:
         case PRINT_BSTRING:
                 printf("__get_str(%s)", args->string.string);
@@ -6228,15 +6426,20 @@ void pevent_ref(struct pevent *pevent)
         pevent->ref_count++;
 }
 
+void pevent_free_format_field(struct format_field *field)
+{
+        free(field->type);
+        free(field->name);
+        free(field);
+}
+
 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);
+                pevent_free_format_field(field);
                 field = next;
         }
 }
@@ -6341,6 +6544,7 @@ void pevent_free(struct pevent *pevent)
                 free_handler(handle);
         }
 
+        free(pevent->trace_clock);
         free(pevent->events);
         free(pevent->sort_events);
 
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 7a3873ff9a4f..86a5839fb048 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -22,6 +22,7 @@
 
 #include <stdbool.h>
 #include <stdarg.h>
+#include <stdio.h>
 #include <regex.h>
 #include <string.h>
 
@@ -91,6 +92,7 @@ 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_fprintf(struct trace_seq *s, FILE *fp);
 extern int trace_seq_do_printf(struct trace_seq *s);
 
 
@@ -114,7 +116,7 @@ struct pevent_plugin_option {
         char                            *name;
         char                            *plugin_alias;
         char                            *description;
-        char                            *value;
+        const char                      *value;
         void                            *priv;
         int                             set;
 };
@@ -152,6 +154,10 @@ struct pevent_plugin_option {
  *   .plugin_alias is used to give a shorter name to access
  *   the vairable. Useful if a plugin handles more than one event.
  *
+ *   If .value is not set, then it is considered a boolean and only
+ *   .set will be processed. If .value is defined, then it is considered
+ *   a string option and .set will be ignored.
+ *
  * PEVENT_PLUGIN_ALIAS: (optional)
  *   The name to use for finding options (uses filename if not defined)
  */
@@ -245,6 +251,12 @@ struct print_arg_hex {
         struct print_arg        *size;
 };
 
+struct print_arg_int_array {
+        struct print_arg        *field;
+        struct print_arg        *count;
+        struct print_arg        *el_size;
+};
+
 struct print_arg_dynarray {
         struct format_field     *field;
         struct print_arg        *index;
@@ -273,6 +285,7 @@ enum print_arg_type {
         PRINT_FLAGS,
         PRINT_SYMBOL,
         PRINT_HEX,
+        PRINT_INT_ARRAY,
         PRINT_TYPE,
         PRINT_STRING,
         PRINT_BSTRING,
@@ -292,6 +305,7 @@ struct print_arg {
                 struct print_arg_flags          flags;
                 struct print_arg_symbol         symbol;
                 struct print_arg_hex            hex;
+                struct print_arg_int_array      int_array;
                 struct print_arg_func           func;
                 struct print_arg_string         string;
                 struct print_arg_bitmask        bitmask;
@@ -597,7 +611,7 @@ enum trace_flag_type {
 };
 
 int pevent_register_comm(struct pevent *pevent, const char *comm, int pid);
-void pevent_register_trace_clock(struct pevent *pevent, char *trace_clock);
+int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock);
 int pevent_register_function(struct pevent *pevent, char *name,
                              unsigned long long addr, char *mod);
 int pevent_register_print_string(struct pevent *pevent, const char *fmt,
@@ -617,6 +631,7 @@ enum pevent_errno pevent_parse_format(struct pevent *pevent,
                                       const char *buf,
                                       unsigned long size, const char *sys);
 void pevent_free_format(struct event_format *event);
+void pevent_free_format_field(struct format_field *field);
 
 void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
                            const char *name, struct pevent_record *record,
@@ -675,6 +690,11 @@ 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);
+struct cmdline;
+struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,
+                                          struct cmdline *next);
+int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline);
+
 void pevent_event_info(struct trace_seq *s, struct event_format *event,
                        struct pevent_record *record);
 int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum,
diff --git a/tools/lib/traceevent/event-plugin.c b/tools/lib/traceevent/event-plugin.c
index 136162c03af1..a16756ae3526 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -18,6 +18,7 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#include <ctype.h>
 #include <stdio.h>
 #include <string.h>
 #include <dlfcn.h>
@@ -49,6 +50,52 @@ struct plugin_list {
         void                    *handle;
 };
 
+static void lower_case(char *str)
+{
+        if (!str)
+                return;
+        for (; *str; str++)
+                *str = tolower(*str);
+}
+
+static int update_option_value(struct pevent_plugin_option *op, const char *val)
+{
+        char *op_val;
+
+        if (!val) {
+                /* toggle, only if option is boolean */
+                if (op->value)
+                        /* Warn? */
+                        return 0;
+                op->set ^= 1;
+                return 0;
+        }
+
+        /*
+         * If the option has a value then it takes a string
+         * otherwise the option is a boolean.
+         */
+        if (op->value) {
+                op->value = val;
+                return 0;
+        }
+
+        /* Option is boolean, must be either "1", "0", "true" or "false" */
+
+        op_val = strdup(val);
+        if (!op_val)
+                return -1;
+        lower_case(op_val);
+
+        if (strcmp(val, "1") == 0 || strcmp(val, "true") == 0)
+                op->set = 1;
+        else if (strcmp(val, "0") == 0 || strcmp(val, "false") == 0)
+                op->set = 0;
+        free(op_val);
+
+        return 0;
+}
+
 /**
  * traceevent_plugin_list_options - get list of plugin options
  *
@@ -120,6 +167,7 @@ update_option(const char *file, struct pevent_plugin_option *option)
 {
         struct trace_plugin_options *op;
         char *plugin;
+        int ret = 0;
 
         if (option->plugin_alias) {
                 plugin = strdup(option->plugin_alias);
@@ -144,9 +192,10 @@ update_option(const char *file, struct pevent_plugin_option *option)
                 if (strcmp(op->option, option->name) != 0)
                         continue;
 
-                option->value = op->value;
-                option->set ^= 1;
-                goto out;
+                ret = update_option_value(option, op->value);
+                if (ret)
+                        goto out;
+                break;
         }
 
         /* first look for unnamed options */
@@ -156,14 +205,13 @@ update_option(const char *file, struct pevent_plugin_option *option)
                 if (strcmp(op->option, option->name) != 0)
                         continue;
 
-                option->value = op->value;
-                option->set ^= 1;
+                ret = update_option_value(option, op->value);
                 break;
         }
 
  out:
         free(plugin);
-        return 0;
+        return ret;
 }
 
 /**
diff --git a/tools/lib/traceevent/kbuffer-parse.c b/tools/lib/traceevent/kbuffer-parse.c
index dcc665228c71..3bcada3ae05a 100644
--- a/tools/lib/traceevent/kbuffer-parse.c
+++ b/tools/lib/traceevent/kbuffer-parse.c
@@ -372,7 +372,6 @@ translate_data(struct kbuffer *kbuf, void *data, void **rptr,
         switch (type_len) {
         case KBUFFER_TYPE_PADDING:
                 *length = read_4(kbuf, data);
-                data += *length;
                 break;
 
         case KBUFFER_TYPE_TIME_EXTEND:
@@ -730,3 +729,14 @@ void kbuffer_set_old_format(struct kbuffer *kbuf)
 
         kbuf->next_event = __old_next_event;
 }
+
+/**
+ * kbuffer_start_of_data - return offset of where data starts on subbuffer
+ * @kbuf:       The kbuffer
+ *
+ * Returns the location on the subbuffer where the data starts.
+ */
+int kbuffer_start_of_data(struct kbuffer *kbuf)
+{
+        return kbuf->start;
+}
diff --git a/tools/lib/traceevent/kbuffer.h b/tools/lib/traceevent/kbuffer.h
index c831f64b17a0..03dce757553f 100644
--- a/tools/lib/traceevent/kbuffer.h
+++ b/tools/lib/traceevent/kbuffer.h
@@ -63,5 +63,6 @@ int kbuffer_missed_events(struct kbuffer *kbuf);
 int kbuffer_subbuffer_size(struct kbuffer *kbuf);
 
 void kbuffer_set_old_format(struct kbuffer *kbuf);
+int kbuffer_start_of_data(struct kbuffer *kbuf);
 
 #endif /* _K_BUFFER_H */
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index b50234402fc2..0144b3d1bb77 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -1058,6 +1058,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
                                         *parg = current_op;
                                 else
                                         *parg = current_exp;
+                                free(token);
                                 return PEVENT_ERRNO__UNBALANCED_PAREN;
                         }
                         break;
@@ -1168,6 +1169,7 @@ process_filter(struct event_format *event, struct filter_arg **parg,
 
         *parg = current_op;
 
+        free(token);
         return 0;
 
  fail_alloc:
diff --git a/tools/lib/traceevent/trace-seq.c b/tools/lib/traceevent/trace-seq.c
index ec3bd16a5488..292dc9f1d233 100644
--- a/tools/lib/traceevent/trace-seq.c
+++ b/tools/lib/traceevent/trace-seq.c
@@ -231,19 +231,24 @@ void trace_seq_terminate(struct trace_seq *s)
         s->buffer[s->len] = 0;
 }
 
-int trace_seq_do_printf(struct trace_seq *s)
+int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp)
 {
         TRACE_SEQ_CHECK(s);
 
         switch (s->state) {
         case TRACE_SEQ__GOOD:
-                return printf("%.*s", s->len, s->buffer);
+                return fprintf(fp, "%.*s", s->len, s->buffer);
         case TRACE_SEQ__BUFFER_POISONED:
-                puts("Usage of trace_seq after it was destroyed");
+                fprintf(fp, "%s\n", "Usage of trace_seq after it was destroyed");
                 break;
         case TRACE_SEQ__MEM_ALLOC_FAILED:
-                puts("Can't allocate trace_seq buffer memory");
+                fprintf(fp, "%s\n", "Can't allocate trace_seq buffer memory");
                 break;
         }
         return -1;
 }
+
+int trace_seq_do_printf(struct trace_seq *s)
+{
+        return trace_seq_do_fprintf(s, stdout);
+}