Re: [PATCH 15/21] perf: Export trace event utils

[Steven Rostedt]

Hi Borislav,

I'm actually working on making a libparsevent.a that does some of what
you are doing.

The idea is, if I can separate out this code from perf, I can then bring
it up to speed with what I have in trace-cmd.

-- Steve


On Thu, 2010-07-01 at 17:55 +0200, Borislav Petkov wrote:
> From: Borislav Petkov <borislav.petkov@xxxxxxx>
> 
> Those are indirectly needed by parse-events.c too.
> 
> Signed-off-by: Borislav Petkov <borislav.petkov@xxxxxxx>
> ---
>  tools/lib/Makefile                  |    3 +
>  tools/lib/trace/trace-event-info.c  |  563 ++++++
>  tools/lib/trace/trace-event-parse.c | 3233 +++++++++++++++++++++++++++++++++++
>  tools/lib/trace/trace-event-read.c  |  539 ++++++
>  tools/perf/Makefile                 |    3 -
>  tools/perf/util/trace-event-info.c  |  563 ------
>  tools/perf/util/trace-event-parse.c | 3233 -----------------------------------
>  tools/perf/util/trace-event-read.c  |  539 ------
>  8 files changed, 4338 insertions(+), 4338 deletions(-)
>  create mode 100644 tools/lib/trace/trace-event-info.c
>  create mode 100644 tools/lib/trace/trace-event-parse.c
>  create mode 100644 tools/lib/trace/trace-event-read.c
>  delete mode 100644 tools/perf/util/trace-event-info.c
>  delete mode 100644 tools/perf/util/trace-event-parse.c
>  delete mode 100644 tools/perf/util/trace-event-read.c
> 
> diff --git a/tools/lib/Makefile b/tools/lib/Makefile
> index cabef46..795fa3a 100644
> --- a/tools/lib/Makefile
> +++ b/tools/lib/Makefile
> @@ -49,6 +49,9 @@ LIB_OBJS += $(OUTPUT)perf/hist.o
>  LIB_OBJS += $(OUTPUT)perf/thread.o
>  LIB_OBJS += $(OUTPUT)perf/sort.o
>  LIB_OBJS += $(OUTPUT)perf/event.o
> +LIB_OBJS += $(OUTPUT)trace/trace-event-read.o
> +LIB_OBJS += $(OUTPUT)trace/trace-event-info.o
> +LIB_OBJS += $(OUTPUT)trace/trace-event-parse.o
>  
>  LIBFILE = lklib.a
>  
> diff --git a/tools/lib/trace/trace-event-info.c b/tools/lib/trace/trace-event-info.c
> new file mode 100644
> index 0000000..e1ad23f
> --- /dev/null
> +++ b/tools/lib/trace/trace-event-info.c
> @@ -0,0 +1,563 @@
> +/*
> + * Copyright (C) 2008,2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; version 2 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 General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + */
> +#define _GNU_SOURCE
> +#include <dirent.h>
> +#include <mntent.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <stdarg.h>
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/wait.h>
> +#include <pthread.h>
> +#include <fcntl.h>
> +#include <unistd.h>
> +#include <ctype.h>
> +#include <errno.h>
> +#include <stdbool.h>
> +#include <linux/kernel.h>
> +
> +#include <perf.h>
> +#include <util/trace-event.h>
> +#include <lk/debugfs.h>
> +
> +#define VERSION "0.5"
> +
> +#define _STR(x) #x
> +#define STR(x) _STR(x)
> +#define MAX_PATH 256
> +
> +#define TRACE_CTRL	"tracing_on"
> +#define TRACE		"trace"
> +#define AVAILABLE	"available_tracers"
> +#define CURRENT		"current_tracer"
> +#define ITER_CTRL	"trace_options"
> +#define MAX_LATENCY	"tracing_max_latency"
> +
> +unsigned int page_size;
> +
> +static const char *output_file = "trace.info";
> +static int output_fd;
> +
> +struct event_list {
> +	struct event_list *next;
> +	const char *event;
> +};
> +
> +struct events {
> +	struct events *sibling;
> +	struct events *children;
> +	struct events *next;
> +	char *name;
> +};
> +
> +
> +
> +static void die(const char *fmt, ...)
> +{
> +	va_list ap;
> +	int ret = errno;
> +
> +	if (errno)
> +		perror("trace-cmd");
> +	else
> +		ret = -1;
> +
> +	va_start(ap, fmt);
> +	fprintf(stderr, "  ");
> +	vfprintf(stderr, fmt, ap);
> +	va_end(ap);
> +
> +	fprintf(stderr, "\n");
> +	exit(ret);
> +}
> +
> +void *malloc_or_die(unsigned int size)
> +{
> +	void *data;
> +
> +	data = malloc(size);
> +	if (!data)
> +		die("malloc");
> +	return data;
> +}
> +
> +static const char *find_debugfs(void)
> +{
> +	const char *path = debugfs_mount(NULL);
> +
> +	if (!path)
> +		die("Your kernel not support debugfs filesystem");
> +
> +	return path;
> +}
> +
> +/*
> + * Finds the path to the debugfs/tracing
> + * Allocates the string and stores it.
> + */
> +static const char *find_tracing_dir(void)
> +{
> +	static char *tracing;
> +	static int tracing_found;
> +	const char *debugfs;
> +
> +	if (tracing_found)
> +		return tracing;
> +
> +	debugfs = find_debugfs();
> +
> +	tracing = malloc_or_die(strlen(debugfs) + 9);
> +
> +	sprintf(tracing, "%s/tracing", debugfs);
> +
> +	tracing_found = 1;
> +	return tracing;
> +}
> +
> +static char *get_tracing_file(const char *name)
> +{
> +	const char *tracing;
> +	char *file;
> +
> +	tracing = find_tracing_dir();
> +	if (!tracing)
> +		return NULL;
> +
> +	file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
> +
> +	sprintf(file, "%s/%s", tracing, name);
> +	return file;
> +}
> +
> +static void put_tracing_file(char *file)
> +{
> +	free(file);
> +}
> +
> +static ssize_t calc_data_size;
> +
> +static ssize_t write_or_die(const void *buf, size_t len)
> +{
> +	int ret;
> +
> +	if (calc_data_size) {
> +		calc_data_size += len;
> +		return len;
> +	}
> +
> +	ret = write(output_fd, buf, len);
> +	if (ret < 0)
> +		die("writing to '%s'", output_file);
> +
> +	return ret;
> +}
> +
> +int bigendian(void)
> +{
> +	unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
> +	unsigned int *ptr;
> +
> +	ptr = (unsigned int *)(void *)str;
> +	return *ptr == 0x01020304;
> +}
> +
> +static unsigned long long copy_file_fd(int fd)
> +{
> +	unsigned long long size = 0;
> +	char buf[BUFSIZ];
> +	int r;
> +
> +	do {
> +		r = read(fd, buf, BUFSIZ);
> +		if (r > 0) {
> +			size += r;
> +			write_or_die(buf, r);
> +		}
> +	} while (r > 0);
> +
> +	return size;
> +}
> +
> +static unsigned long long copy_file(const char *file)
> +{
> +	unsigned long long size = 0;
> +	int fd;
> +
> +	fd = open(file, O_RDONLY);
> +	if (fd < 0)
> +		die("Can't read '%s'", file);
> +	size = copy_file_fd(fd);
> +	close(fd);
> +
> +	return size;
> +}
> +
> +static unsigned long get_size_fd(int fd)
> +{
> +	unsigned long long size = 0;
> +	char buf[BUFSIZ];
> +	int r;
> +
> +	do {
> +		r = read(fd, buf, BUFSIZ);
> +		if (r > 0)
> +			size += r;
> +	} while (r > 0);
> +
> +	lseek(fd, 0, SEEK_SET);
> +
> +	return size;
> +}
> +
> +static unsigned long get_size(const char *file)
> +{
> +	unsigned long long size = 0;
> +	int fd;
> +
> +	fd = open(file, O_RDONLY);
> +	if (fd < 0)
> +		die("Can't read '%s'", file);
> +	size = get_size_fd(fd);
> +	close(fd);
> +
> +	return size;
> +}
> +
> +static void read_header_files(void)
> +{
> +	unsigned long long size, check_size;
> +	char *path;
> +	int fd;
> +
> +	path = get_tracing_file("events/header_page");
> +	fd = open(path, O_RDONLY);
> +	if (fd < 0)
> +		die("can't read '%s'", path);
> +
> +	/* unfortunately, you can not stat debugfs files for size */
> +	size = get_size_fd(fd);
> +
> +	write_or_die("header_page", 12);
> +	write_or_die(&size, 8);
> +	check_size = copy_file_fd(fd);
> +	close(fd);
> +
> +	if (size != check_size)
> +		die("wrong size for '%s' size=%lld read=%lld",
> +		    path, size, check_size);
> +	put_tracing_file(path);
> +
> +	path = get_tracing_file("events/header_event");
> +	fd = open(path, O_RDONLY);
> +	if (fd < 0)
> +		die("can't read '%s'", path);
> +
> +	size = get_size_fd(fd);
> +
> +	write_or_die("header_event", 13);
> +	write_or_die(&size, 8);
> +	check_size = copy_file_fd(fd);
> +	if (size != check_size)
> +		die("wrong size for '%s'", path);
> +	put_tracing_file(path);
> +	close(fd);
> +}
> +
> +static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
> +{
> +	while (tps) {
> +		if (!strcmp(sys, tps->name))
> +			return true;
> +		tps = tps->next;
> +	}
> +
> +	return false;
> +}
> +
> +static void copy_event_system(const char *sys, struct tracepoint_path *tps)
> +{
> +	unsigned long long size, check_size;
> +	struct dirent *dent;
> +	struct stat st;
> +	char *format;
> +	DIR *dir;
> +	int count = 0;
> +	int ret;
> +
> +	dir = opendir(sys);
> +	if (!dir)
> +		die("can't read directory '%s'", sys);
> +
> +	while ((dent = readdir(dir))) {
> +		if (dent->d_type != DT_DIR ||
> +		    strcmp(dent->d_name, ".") == 0 ||
> +		    strcmp(dent->d_name, "..") == 0 ||
> +		    !name_in_tp_list(dent->d_name, tps))
> +			continue;
> +		format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
> +		sprintf(format, "%s/%s/format", sys, dent->d_name);
> +		ret = stat(format, &st);
> +		free(format);
> +		if (ret < 0)
> +			continue;
> +		count++;
> +	}
> +
> +	write_or_die(&count, 4);
> +
> +	rewinddir(dir);
> +	while ((dent = readdir(dir))) {
> +		if (dent->d_type != DT_DIR ||
> +		    strcmp(dent->d_name, ".") == 0 ||
> +		    strcmp(dent->d_name, "..") == 0 ||
> +		    !name_in_tp_list(dent->d_name, tps))
> +			continue;
> +		format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
> +		sprintf(format, "%s/%s/format", sys, dent->d_name);
> +		ret = stat(format, &st);
> +
> +		if (ret >= 0) {
> +			/* unfortunately, you can not stat debugfs files for size */
> +			size = get_size(format);
> +			write_or_die(&size, 8);
> +			check_size = copy_file(format);
> +			if (size != check_size)
> +				die("error in size of file '%s'", format);
> +		}
> +
> +		free(format);
> +	}
> +	closedir(dir);
> +}
> +
> +static void read_ftrace_files(struct tracepoint_path *tps)
> +{
> +	char *path;
> +
> +	path = get_tracing_file("events/ftrace");
> +
> +	copy_event_system(path, tps);
> +
> +	put_tracing_file(path);
> +}
> +
> +static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
> +{
> +	while (tps) {
> +		if (!strcmp(sys, tps->system))
> +			return true;
> +		tps = tps->next;
> +	}
> +
> +	return false;
> +}
> +
> +static void read_event_files(struct tracepoint_path *tps)
> +{
> +	struct dirent *dent;
> +	struct stat st;
> +	char *path;
> +	char *sys;
> +	DIR *dir;
> +	int count = 0;
> +	int ret;
> +
> +	path = get_tracing_file("events");
> +
> +	dir = opendir(path);
> +	if (!dir)
> +		die("can't read directory '%s'", path);
> +
> +	while ((dent = readdir(dir))) {
> +		if (dent->d_type != DT_DIR ||
> +		    strcmp(dent->d_name, ".") == 0 ||
> +		    strcmp(dent->d_name, "..") == 0 ||
> +		    strcmp(dent->d_name, "ftrace") == 0 ||
> +		    !system_in_tp_list(dent->d_name, tps))
> +			continue;
> +		count++;
> +	}
> +
> +	write_or_die(&count, 4);
> +
> +	rewinddir(dir);
> +	while ((dent = readdir(dir))) {
> +		if (dent->d_type != DT_DIR ||
> +		    strcmp(dent->d_name, ".") == 0 ||
> +		    strcmp(dent->d_name, "..") == 0 ||
> +		    strcmp(dent->d_name, "ftrace") == 0 ||
> +		    !system_in_tp_list(dent->d_name, tps))
> +			continue;
> +		sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
> +		sprintf(sys, "%s/%s", path, dent->d_name);
> +		ret = stat(sys, &st);
> +		if (ret >= 0) {
> +			write_or_die(dent->d_name, strlen(dent->d_name) + 1);
> +			copy_event_system(sys, tps);
> +		}
> +		free(sys);
> +	}
> +
> +	closedir(dir);
> +	put_tracing_file(path);
> +}
> +
> +static void read_proc_kallsyms(void)
> +{
> +	unsigned int size, check_size;
> +	const char *path = "/proc/kallsyms";
> +	struct stat st;
> +	int ret;
> +
> +	ret = stat(path, &st);
> +	if (ret < 0) {
> +		/* not found */
> +		size = 0;
> +		write_or_die(&size, 4);
> +		return;
> +	}
> +	size = get_size(path);
> +	write_or_die(&size, 4);
> +	check_size = copy_file(path);
> +	if (size != check_size)
> +		die("error in size of file '%s'", path);
> +
> +}
> +
> +static void read_ftrace_printk(void)
> +{
> +	unsigned int size, check_size;
> +	char *path;
> +	struct stat st;
> +	int ret;
> +
> +	path = get_tracing_file("printk_formats");
> +	ret = stat(path, &st);
> +	if (ret < 0) {
> +		/* not found */
> +		size = 0;
> +		write_or_die(&size, 4);
> +		goto out;
> +	}
> +	size = get_size(path);
> +	write_or_die(&size, 4);
> +	check_size = copy_file(path);
> +	if (size != check_size)
> +		die("error in size of file '%s'", path);
> +out:
> +	put_tracing_file(path);
> +}
> +
> +static struct tracepoint_path *
> +get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
> +{
> +	struct tracepoint_path path, *ppath = &path;
> +	int i, nr_tracepoints = 0;
> +
> +	for (i = 0; i < nb_events; i++) {
> +		if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
> +			continue;
> +		++nr_tracepoints;
> +		ppath->next = tracepoint_id_to_path(pattrs[i].config);
> +		if (!ppath->next)
> +			die("%s\n", "No memory to alloc tracepoints list");
> +		ppath = ppath->next;
> +	}
> +
> +	return nr_tracepoints > 0 ? path.next : NULL;
> +}
> +
> +bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
> +{
> +	int i;
> +
> +	for (i = 0; i < nb_events; i++)
> +		if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
> +			return true;
> +
> +	return false;
> +}
> +
> +int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
> +{
> +	char buf[BUFSIZ];
> +	struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
> +
> +	/*
> +	 * What? No tracepoints? No sense writing anything here, bail out.
> +	 */
> +	if (tps == NULL)
> +		return -1;
> +
> +	output_fd = fd;
> +
> +	buf[0] = 23;
> +	buf[1] = 8;
> +	buf[2] = 68;
> +	memcpy(buf + 3, "tracing", 7);
> +
> +	write_or_die(buf, 10);
> +
> +	write_or_die(VERSION, strlen(VERSION) + 1);
> +
> +	/* save endian */
> +	if (bigendian())
> +		buf[0] = 1;
> +	else
> +		buf[0] = 0;
> +
> +	write_or_die(buf, 1);
> +
> +	/* save size of long */
> +	buf[0] = sizeof(long);
> +	write_or_die(buf, 1);
> +
> +	/* save page_size */
> +	page_size = sysconf(_SC_PAGESIZE);
> +	write_or_die(&page_size, 4);
> +
> +	read_header_files();
> +	read_ftrace_files(tps);
> +	read_event_files(tps);
> +	read_proc_kallsyms();
> +	read_ftrace_printk();
> +
> +	return 0;
> +}
> +
> +ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
> +			       int nb_events)
> +{
> +	ssize_t size;
> +	int err = 0;
> +
> +	calc_data_size = 1;
> +	err = read_tracing_data(fd, pattrs, nb_events);
> +	size = calc_data_size - 1;
> +	calc_data_size = 0;
> +
> +	if (err < 0)
> +		return err;
> +
> +	return size;
> +}
> diff --git a/tools/lib/trace/trace-event-parse.c b/tools/lib/trace/trace-event-parse.c
> new file mode 100644
> index 0000000..d76c350
> --- /dev/null
> +++ b/tools/lib/trace/trace-event-parse.c
> @@ -0,0 +1,3233 @@
> +/*
> + * Copyright (C) 2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; version 2 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 General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + *
> + *  The parts for function graph printing was taken and modified from the
> + *  Linux Kernel that were written by Frederic Weisbecker.
> + */
> +#define _GNU_SOURCE
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <ctype.h>
> +#include <errno.h>
> +
> +#undef _GNU_SOURCE
> +#include <perf.h>
> +#include <lk/util.h>
> +#include <util/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_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;
> +
> +	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;
> +	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;
> +}
> +
> +/*
> + * 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 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");
> +	}
> +}
> +
> +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;
> +
> +	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)
> +{
> +	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;
> +}
> +
> +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 (strcmp(token, expect_tok) != 0) {
> +		if (warn)
> +			warning("Error: expected '%s' but read '%s'",
> +				expect_tok, token);
> +		return -1;
> +	}
> +	return 0;
> +}
> +
> +static int test_type_token(enum event_type type, char *token,
> +			   enum event_type expect, const char *expect_tok)
> +{
> +	return __test_type_token(type, token, expect, expect_tok, true);
> +}
> +
> +static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
> +{
> +	enum event_type type;
> +
> +	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)
> +{
> +	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, warn);
> +
> +	free_token(token);
> +
> +	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)
> +{
> +	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))
> +		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;
> +}
> +
> +static int event_read_format(struct event *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;
> +}
> +
> +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 process_arg_token(event, arg, tok, type);
> +}
> +
> +static enum event_type
> +process_cond(struct event *event, struct print_arg *top, char **tok)
> +{
> +	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);
> +
> +	top->op.right = arg;
> +
> +	*tok = token;
> +	return type;
> +
> +out_free:
> +	free_token(*tok);
> +	free(right);
> +	free(left);
> +	free_arg(arg);
> +	return EVENT_ERROR;
> +}
> +
> +static enum event_type
> +process_array(struct event *event, struct print_arg *top, char **tok)
> +{
> +	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;
> +
> +out_free:
> +	free_token(*tok);
> +	free_arg(arg);
> +	return EVENT_ERROR;
> +}
> +
> +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;
> +		}
> +	}
> +}
> +
> +static void 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;
> +		return;
> +	}
> +
> +	arg->op.prio = get_op_prio(arg->op.op);
> +}
> +
> +static enum event_type
> +process_op(struct event *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);
> +			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);
> +
> +		return process_op(event, right, tok);
> +	}
> +
> +	return type;
> +}
> +
> +static enum event_type
> +process_entry(struct event *event __unused, struct print_arg *arg,
> +	      char **tok)
> +{
> +	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;
> +
> +	return type;
> +
> +fail:
> +	free_token(token);
> +	return EVENT_ERROR;
> +}
> +
> +static char *arg_eval (struct print_arg *arg);
> +
> +static long long arg_num_eval(struct print_arg *arg)
> +{
> +	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;
> +		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;
> +}
> +
> +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:
> +		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;
> +}
> +
> +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 (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)
> +{
> +	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);
> +	if (test_type_token(type, token, EVENT_DELIM, ","))
> +		goto out_free;
> +
> +	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);
> +	return EVENT_ERROR;
> +}
> +
> +static enum event_type
> +process_symbols(struct event *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;
> +
> +	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;
> +
> +	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);
> +	return EVENT_ERROR;
> +}
> +
> +static enum event_type
> +process_paren(struct event *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)
> +		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 */
> +
> +		/* prevous must be an atom */
> +		if (arg->type != PRINT_ATOM)
> +			die("previous needed to be PRINT_ATOM");
> +
> +		item_arg = malloc_or_die(sizeof(*item_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;
> +}
> +
> +
> +static enum event_type
> +process_str(struct event *event __unused, struct print_arg *arg, char **tok)
> +{
> +	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;
> +}
> +
> +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);
> +			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;
> +	}
> +
> +	return format;
> +}
> +
> +static struct format_field *
> +find_any_field(struct event *event, const char *name)
> +{
> +	struct format_field *format;
> +
> +	format = find_common_field(event, name);
> +	if (format)
> +		return format;
> +	return find_field(event, name);
> +}
> +
> +unsigned long long read_size(void *ptr, int size)
> +{
> +	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;
> +	}
> +}
> +
> +unsigned long long
> +raw_field_value(struct event *event, const char *name, void *data)
> +{
> +	struct format_field *field;
> +
> +	field = find_any_field(event, name);
> +	if (!field)
> +		return 0ULL;
> +
> +	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)
> +		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;
> +	}
> +	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;
> +	}
> +	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;
> +	}
> +	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 },
> +};
> +
> +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_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);
> +}
> +
> +/* taken from Linux, written by Frederic Weisbecker */
> +static void print_graph_cpu(int cpu)
> +{
> +	int i;
> +	int log10_this = log10_cpu(cpu);
> +	int log10_all = log10_cpu(cpus);
> +
> +
> +	/*
> +	 * Start with a space character - to make it stand out
> +	 * to the right a bit when trace output is pasted into
> +	 * email:
> +	 */
> +	printf(" ");
> +
> +	/*
> +	 * Tricky - we space the CPU field according to the max
> +	 * number of online CPUs. On a 2-cpu system it would take
> +	 * a maximum of 1 digit - on a 128 cpu system it would
> +	 * take up to 3 digits:
> +	 */
> +	for (i = 0; i < log10_all - log10_this; i++)
> +		printf(" ");
> +
> +	printf("%d) ", cpu);
> +}
> +
> +#define TRACE_GRAPH_PROCINFO_LENGTH	14
> +#define TRACE_GRAPH_INDENT	2
> +
> +static void print_graph_proc(int pid, const char *comm)
> +{
> +	/* sign + log10(MAX_INT) + '\0' */
> +	char pid_str[11];
> +	int spaces = 0;
> +	int len;
> +	int i;
> +
> +	sprintf(pid_str, "%d", pid);
> +
> +	/* 1 stands for the "-" character */
> +	len = strlen(comm) + strlen(pid_str) + 1;
> +
> +	if (len < TRACE_GRAPH_PROCINFO_LENGTH)
> +		spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
> +
> +	/* First spaces to align center */
> +	for (i = 0; i < spaces / 2; i++)
> +		printf(" ");
> +
> +	printf("%s-%s", comm, pid_str);
> +
> +	/* Last spaces to align center */
> +	for (i = 0; i < spaces - (spaces / 2); i++)
> +		printf(" ");
> +}
> +
> +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, const char *comm,
> +		      unsigned long secs, unsigned long usecs)
> +{
> +	struct format_field *field;
> +	struct record *rec;
> +	void *copy_data;
> +	unsigned long val;
> +
> +	printf("%5lu.%06lu |  ", secs, usecs);
> +
> +	print_graph_cpu(cpu);
> +	print_graph_proc(pid, comm);
> +
> +	printf(" | ");
> +
> +	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,
> +		      int cpu, int pid, const char *comm,
> +		      unsigned long secs, unsigned long usecs)
> +{
> +	unsigned long long rettime, calltime;
> +	unsigned long long duration, depth;
> +	struct format_field *field;
> +	int i;
> +
> +	printf("%5lu.%06lu |  ", secs, usecs);
> +
> +	print_graph_cpu(cpu);
> +	print_graph_proc(pid, comm);
> +
> +	printf(" | ");
> +
> +	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, const char *comm,
> +			unsigned long secs, unsigned long usecs)
> +{
> +	if (event->flags & EVENT_FL_ISFUNCENT)
> +		pretty_print_func_ent(data, size, event,
> +				      cpu, pid, comm, secs, usecs);
> +	else if (event->flags & EVENT_FL_ISFUNCRET)
> +		pretty_print_func_ret(data, size, event,
> +				      cpu, pid, comm, secs, usecs);
> +	printf("\n");
> +}
> +
> +void print_event(int cpu, void *data, int size, unsigned long long nsecs,
> +		  char *comm)
> +{
> +	struct event *event;
> +	unsigned long secs;
> +	unsigned long usecs;
> +	int type;
> +	int pid;
> +
> +	secs = nsecs / NSECS_PER_SEC;
> +	nsecs -= secs * NSECS_PER_SEC;
> +	usecs = nsecs / NSECS_PER_USEC;
> +
> +	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, comm, secs, usecs);
> +
> +	if (latency_format) {
> +		printf("%8.8s-%-5d %3d",
> +		       comm, pid, cpu);
> +		print_lat_fmt(data, size);
> +	} else
> +		printf("%16s-%-5d [%03d]", comm, pid,  cpu);
> +
> +	printf(" %5lu.%06lu: %s: ", secs, usecs, event->name);
> +
> +	if (event->flags & EVENT_FL_FAILED) {
> +		printf("EVENT '%s' FAILED TO PARSE\n",
> +		       event->name);
> +		return;
> +	}
> +
> +	pretty_print(data, size, event);
> +	printf("\n");
> +}
> +
> +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/lib/trace/trace-event-read.c b/tools/lib/trace/trace-event-read.c
> new file mode 100644
> index 0000000..d7d8ceb
> --- /dev/null
> +++ b/tools/lib/trace/trace-event-read.c
> @@ -0,0 +1,539 @@
> +/*
> + * Copyright (C) 2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; version 2 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 General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> + *
> + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> + */
> +#define _FILE_OFFSET_BITS 64
> +
> +#include <dirent.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <getopt.h>
> +#include <stdarg.h>
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <sys/wait.h>
> +#include <sys/mman.h>
> +#include <pthread.h>
> +#include <fcntl.h>
> +#include <unistd.h>
> +#include <ctype.h>
> +#include <errno.h>
> +
> +#include <perf.h>
> +#include <lk/util.h>
> +#include <util/trace-event.h>
> +
> +static int input_fd;
> +
> +static int read_page;
> +
> +int file_bigendian;
> +int host_bigendian;
> +static int long_size;
> +
> +static unsigned long	page_size;
> +
> +static ssize_t calc_data_size;
> +static bool repipe;
> +
> +static int do_read(int fd, void *buf, int size)
> +{
> +	int rsize = size;
> +
> +	while (size) {
> +		int ret = read(fd, buf, size);
> +
> +		if (ret <= 0)
> +			return -1;
> +
> +		if (repipe) {
> +			int retw = write(STDOUT_FILENO, buf, ret);
> +
> +			if (retw <= 0 || retw != ret)
> +				die("repiping input file");
> +		}
> +
> +		size -= ret;
> +		buf += ret;
> +	}
> +
> +	return rsize;
> +}
> +
> +static int read_or_die(void *data, int size)
> +{
> +	int r;
> +
> +	r = do_read(input_fd, data, size);
> +	if (r <= 0)
> +		die("reading input file (size expected=%d received=%d)",
> +		    size, r);
> +
> +	if (calc_data_size)
> +		calc_data_size += r;
> +
> +	return r;
> +}
> +
> +/* If it fails, the next read will report it */
> +static void skip(int size)
> +{
> +	char buf[BUFSIZ];
> +	int r;
> +
> +	while (size) {
> +		r = size > BUFSIZ ? BUFSIZ : size;
> +		read_or_die(buf, r);
> +		size -= r;
> +	};
> +}
> +
> +static unsigned int read4(void)
> +{
> +	unsigned int data;
> +
> +	read_or_die(&data, 4);
> +	return __data2host4(data);
> +}
> +
> +static unsigned long long read8(void)
> +{
> +	unsigned long long data;
> +
> +	read_or_die(&data, 8);
> +	return __data2host8(data);
> +}
> +
> +static char *read_string(void)
> +{
> +	char buf[BUFSIZ];
> +	char *str = NULL;
> +	int size = 0;
> +	off_t r;
> +	char c;
> +
> +	for (;;) {
> +		r = read(input_fd, &c, 1);
> +		if (r < 0)
> +			die("reading input file");
> +
> +		if (!r)
> +			die("no data");
> +
> +		if (repipe) {
> +			int retw = write(STDOUT_FILENO, &c, 1);
> +
> +			if (retw <= 0 || retw != r)
> +				die("repiping input file string");
> +		}
> +
> +		buf[size++] = c;
> +
> +		if (!c)
> +			break;
> +	}
> +
> +	if (calc_data_size)
> +		calc_data_size += size;
> +
> +	str = malloc_or_die(size);
> +	memcpy(str, buf, size);
> +
> +	return str;
> +}
> +
> +static void read_proc_kallsyms(void)
> +{
> +	unsigned int size;
> +	char *buf;
> +
> +	size = read4();
> +	if (!size)
> +		return;
> +
> +	buf = malloc_or_die(size + 1);
> +	read_or_die(buf, size);
> +	buf[size] = '\0';
> +
> +	parse_proc_kallsyms(buf, size);
> +
> +	free(buf);
> +}
> +
> +static void read_ftrace_printk(void)
> +{
> +	unsigned int size;
> +	char *buf;
> +
> +	size = read4();
> +	if (!size)
> +		return;
> +
> +	buf = malloc_or_die(size);
> +	read_or_die(buf, size);
> +
> +	parse_ftrace_printk(buf, size);
> +
> +	free(buf);
> +}
> +
> +static void read_header_files(void)
> +{
> +	unsigned long long size;
> +	char *header_event;
> +	char buf[BUFSIZ];
> +
> +	read_or_die(buf, 12);
> +
> +	if (memcmp(buf, "header_page", 12) != 0)
> +		die("did not read header page");
> +
> +	size = read8();
> +	skip(size);
> +
> +	/*
> +	 * The size field in the page is of type long,
> +	 * use that instead, since it represents the kernel.
> +	 */
> +	long_size = header_page_size_size;
> +
> +	read_or_die(buf, 13);
> +	if (memcmp(buf, "header_event", 13) != 0)
> +		die("did not read header event");
> +
> +	size = read8();
> +	header_event = malloc_or_die(size);
> +	read_or_die(header_event, size);
> +	free(header_event);
> +}
> +
> +static void read_ftrace_file(unsigned long long size)
> +{
> +	char *buf;
> +
> +	buf = malloc_or_die(size);
> +	read_or_die(buf, size);
> +	parse_ftrace_file(buf, size);
> +	free(buf);
> +}
> +
> +static void read_event_file(char *sys, unsigned long long size)
> +{
> +	char *buf;
> +
> +	buf = malloc_or_die(size);
> +	read_or_die(buf, size);
> +	parse_event_file(buf, size, sys);
> +	free(buf);
> +}
> +
> +static void read_ftrace_files(void)
> +{
> +	unsigned long long size;
> +	int count;
> +	int i;
> +
> +	count = read4();
> +
> +	for (i = 0; i < count; i++) {
> +		size = read8();
> +		read_ftrace_file(size);
> +	}
> +}
> +
> +static void read_event_files(void)
> +{
> +	unsigned long long size;
> +	char *sys;
> +	int systems;
> +	int count;
> +	int i,x;
> +
> +	systems = read4();
> +
> +	for (i = 0; i < systems; i++) {
> +		sys = read_string();
> +
> +		count = read4();
> +		for (x=0; x < count; x++) {
> +			size = read8();
> +			read_event_file(sys, size);
> +		}
> +	}
> +}
> +
> +struct cpu_data {
> +	unsigned long long	offset;
> +	unsigned long long	size;
> +	unsigned long long	timestamp;
> +	struct record		*next;
> +	char			*page;
> +	int			cpu;
> +	int			index;
> +	int			page_size;
> +};
> +
> +static struct cpu_data *cpu_data;
> +
> +static void update_cpu_data_index(int cpu)
> +{
> +	cpu_data[cpu].offset += page_size;
> +	cpu_data[cpu].size -= page_size;
> +	cpu_data[cpu].index = 0;
> +}
> +
> +static void get_next_page(int cpu)
> +{
> +	off_t save_seek;
> +	off_t ret;
> +
> +	if (!cpu_data[cpu].page)
> +		return;
> +
> +	if (read_page) {
> +		if (cpu_data[cpu].size <= page_size) {
> +			free(cpu_data[cpu].page);
> +			cpu_data[cpu].page = NULL;
> +			return;
> +		}
> +
> +		update_cpu_data_index(cpu);
> +
> +		/* other parts of the code may expect the pointer to not move */
> +		save_seek = lseek(input_fd, 0, SEEK_CUR);
> +
> +		ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
> +		if (ret == (off_t)-1)
> +			die("failed to lseek");
> +		ret = read(input_fd, cpu_data[cpu].page, page_size);
> +		if (ret < 0)
> +			die("failed to read page");
> +
> +		/* reset the file pointer back */
> +		lseek(input_fd, save_seek, SEEK_SET);
> +
> +		return;
> +	}
> +
> +	munmap(cpu_data[cpu].page, page_size);
> +	cpu_data[cpu].page = NULL;
> +
> +	if (cpu_data[cpu].size <= page_size)
> +		return;
> +
> +	update_cpu_data_index(cpu);
> +
> +	cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE,
> +				  input_fd, cpu_data[cpu].offset);
> +	if (cpu_data[cpu].page == MAP_FAILED)
> +		die("failed to mmap cpu %d at offset 0x%llx",
> +		    cpu, cpu_data[cpu].offset);
> +}
> +
> +static unsigned int type_len4host(unsigned int type_len_ts)
> +{
> +	if (file_bigendian)
> +		return (type_len_ts >> 27) & ((1 << 5) - 1);
> +	else
> +		return type_len_ts & ((1 << 5) - 1);
> +}
> +
> +static unsigned int ts4host(unsigned int type_len_ts)
> +{
> +	if (file_bigendian)
> +		return type_len_ts & ((1 << 27) - 1);
> +	else
> +		return type_len_ts >> 5;
> +}
> +
> +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 record *data;
> +	void *page = cpu_data[cpu].page;
> +	int idx = cpu_data[cpu].index;
> +	void *ptr = page + idx;
> +	unsigned long long extend;
> +	unsigned int type_len_ts;
> +	unsigned int type_len;
> +	unsigned int delta;
> +	unsigned int length = 0;
> +
> +	if (cpu_data[cpu].next)
> +		return cpu_data[cpu].next;
> +
> +	if (!page)
> +		return NULL;
> +
> +	if (!idx) {
> +		/* FIXME: handle header page */
> +		if (header_page_ts_size != 8)
> +			die("expected a long long type for timestamp");
> +		cpu_data[cpu].timestamp = data2host8(ptr);
> +		ptr += 8;
> +		switch (header_page_size_size) {
> +		case 4:
> +			cpu_data[cpu].page_size = data2host4(ptr);
> +			ptr += 4;
> +			break;
> +		case 8:
> +			cpu_data[cpu].page_size = data2host8(ptr);
> +			ptr += 8;
> +			break;
> +		default:
> +			die("bad long size");
> +		}
> +		ptr = cpu_data[cpu].page + header_page_data_offset;
> +	}
> +
> +read_again:
> +	idx = calc_index(ptr, cpu);
> +
> +	if (idx >= cpu_data[cpu].page_size) {
> +		get_next_page(cpu);
> +		return trace_peek_data(cpu);
> +	}
> +
> +	type_len_ts = data2host4(ptr);
> +	ptr += 4;
> +
> +	type_len = type_len4host(type_len_ts);
> +	delta = ts4host(type_len_ts);
> +
> +	switch (type_len) {
> +	case RINGBUF_TYPE_PADDING:
> +		if (!delta)
> +			die("error, hit unexpected end of page");
> +		length = data2host4(ptr);
> +		ptr += 4;
> +		length *= 4;
> +		ptr += length;
> +		goto read_again;
> +
> +	case RINGBUF_TYPE_TIME_EXTEND:
> +		extend = data2host4(ptr);
> +		ptr += 4;
> +		extend <<= TS_SHIFT;
> +		extend += delta;
> +		cpu_data[cpu].timestamp += extend;
> +		goto read_again;
> +
> +	case RINGBUF_TYPE_TIME_STAMP:
> +		ptr += 12;
> +		break;
> +	case 0:
> +		length = data2host4(ptr);
> +		ptr += 4;
> +		die("here! length=%d", length);
> +		break;
> +	default:
> +		length = type_len * 4;
> +		break;
> +	}
> +
> +	cpu_data[cpu].timestamp += delta;
> +
> +	data = malloc_or_die(sizeof(*data));
> +	memset(data, 0, sizeof(*data));
> +
> +	data->ts = cpu_data[cpu].timestamp;
> +	data->size = length;
> +	data->data = ptr;
> +	ptr += length;
> +
> +	cpu_data[cpu].index = calc_index(ptr, cpu);
> +	cpu_data[cpu].next = data;
> +
> +	return data;
> +}
> +
> +struct record *trace_read_data(int cpu)
> +{
> +	struct record *data;
> +
> +	data = trace_peek_data(cpu);
> +	cpu_data[cpu].next = NULL;
> +
> +	return data;
> +}
> +
> +ssize_t trace_report(int fd, bool __repipe)
> +{
> +	char buf[BUFSIZ];
> +	char test[] = { 23, 8, 68 };
> +	char *version;
> +	int show_version = 0;
> +	int show_funcs = 0;
> +	int show_printk = 0;
> +	ssize_t size;
> +
> +	calc_data_size = 1;
> +	repipe = __repipe;
> +
> +	input_fd = fd;
> +
> +	read_or_die(buf, 3);
> +	if (memcmp(buf, test, 3) != 0)
> +		die("no trace data in the file");
> +
> +	read_or_die(buf, 7);
> +	if (memcmp(buf, "tracing", 7) != 0)
> +		die("not a trace file (missing 'tracing' tag)");
> +
> +	version = read_string();
> +	if (show_version)
> +		printf("version = %s\n", version);
> +	free(version);
> +
> +	read_or_die(buf, 1);
> +	file_bigendian = buf[0];
> +	host_bigendian = bigendian();
> +
> +	read_or_die(buf, 1);
> +	long_size = buf[0];
> +
> +	page_size = read4();
> +
> +	read_header_files();
> +
> +	read_ftrace_files();
> +	read_event_files();
> +	read_proc_kallsyms();
> +	read_ftrace_printk();
> +
> +	size = calc_data_size - 1;
> +	calc_data_size = 0;
> +	repipe = false;
> +
> +	if (show_funcs) {
> +		print_funcs();
> +		return size;
> +	}
> +	if (show_printk) {
> +		print_printk();
> +		return size;
> +	}
> +
> +	return size;
> +}
> diff --git a/tools/perf/Makefile b/tools/perf/Makefile
> index 001831e..590c8f6 100644
> --- a/tools/perf/Makefile
> +++ b/tools/perf/Makefile
> @@ -383,9 +383,6 @@ LIB_OBJS += $(OUTPUT)util/sigchain.o
>  LIB_OBJS += $(OUTPUT)util/pager.o
>  LIB_OBJS += $(OUTPUT)util/callchain.o
>  LIB_OBJS += $(OUTPUT)util/values.o
> -LIB_OBJS += $(OUTPUT)util/trace-event-parse.o
> -LIB_OBJS += $(OUTPUT)util/trace-event-read.o
> -LIB_OBJS += $(OUTPUT)util/trace-event-info.o
>  LIB_OBJS += $(OUTPUT)util/trace-event-scripting.o
>  LIB_OBJS += $(OUTPUT)util/svghelper.o
>  LIB_OBJS += $(OUTPUT)util/probe-event.o
> diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
> deleted file mode 100644
> index 0918a63..0000000
> --- a/tools/perf/util/trace-event-info.c
> +++ /dev/null
> @@ -1,563 +0,0 @@
> -/*
> - * Copyright (C) 2008,2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - *
> - * This program is free software; you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; version 2 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 General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - */
> -#define _GNU_SOURCE
> -#include <dirent.h>
> -#include <mntent.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <stdarg.h>
> -#include <sys/types.h>
> -#include <sys/stat.h>
> -#include <sys/wait.h>
> -#include <pthread.h>
> -#include <fcntl.h>
> -#include <unistd.h>
> -#include <ctype.h>
> -#include <errno.h>
> -#include <stdbool.h>
> -#include <linux/kernel.h>
> -
> -#include "../perf.h"
> -#include "trace-event.h"
> -#include <lk/debugfs.h>
> -
> -#define VERSION "0.5"
> -
> -#define _STR(x) #x
> -#define STR(x) _STR(x)
> -#define MAX_PATH 256
> -
> -#define TRACE_CTRL	"tracing_on"
> -#define TRACE		"trace"
> -#define AVAILABLE	"available_tracers"
> -#define CURRENT		"current_tracer"
> -#define ITER_CTRL	"trace_options"
> -#define MAX_LATENCY	"tracing_max_latency"
> -
> -unsigned int page_size;
> -
> -static const char *output_file = "trace.info";
> -static int output_fd;
> -
> -struct event_list {
> -	struct event_list *next;
> -	const char *event;
> -};
> -
> -struct events {
> -	struct events *sibling;
> -	struct events *children;
> -	struct events *next;
> -	char *name;
> -};
> -
> -
> -
> -static void die(const char *fmt, ...)
> -{
> -	va_list ap;
> -	int ret = errno;
> -
> -	if (errno)
> -		perror("trace-cmd");
> -	else
> -		ret = -1;
> -
> -	va_start(ap, fmt);
> -	fprintf(stderr, "  ");
> -	vfprintf(stderr, fmt, ap);
> -	va_end(ap);
> -
> -	fprintf(stderr, "\n");
> -	exit(ret);
> -}
> -
> -void *malloc_or_die(unsigned int size)
> -{
> -	void *data;
> -
> -	data = malloc(size);
> -	if (!data)
> -		die("malloc");
> -	return data;
> -}
> -
> -static const char *find_debugfs(void)
> -{
> -	const char *path = debugfs_mount(NULL);
> -
> -	if (!path)
> -		die("Your kernel not support debugfs filesystem");
> -
> -	return path;
> -}
> -
> -/*
> - * Finds the path to the debugfs/tracing
> - * Allocates the string and stores it.
> - */
> -static const char *find_tracing_dir(void)
> -{
> -	static char *tracing;
> -	static int tracing_found;
> -	const char *debugfs;
> -
> -	if (tracing_found)
> -		return tracing;
> -
> -	debugfs = find_debugfs();
> -
> -	tracing = malloc_or_die(strlen(debugfs) + 9);
> -
> -	sprintf(tracing, "%s/tracing", debugfs);
> -
> -	tracing_found = 1;
> -	return tracing;
> -}
> -
> -static char *get_tracing_file(const char *name)
> -{
> -	const char *tracing;
> -	char *file;
> -
> -	tracing = find_tracing_dir();
> -	if (!tracing)
> -		return NULL;
> -
> -	file = malloc_or_die(strlen(tracing) + strlen(name) + 2);
> -
> -	sprintf(file, "%s/%s", tracing, name);
> -	return file;
> -}
> -
> -static void put_tracing_file(char *file)
> -{
> -	free(file);
> -}
> -
> -static ssize_t calc_data_size;
> -
> -static ssize_t write_or_die(const void *buf, size_t len)
> -{
> -	int ret;
> -
> -	if (calc_data_size) {
> -		calc_data_size += len;
> -		return len;
> -	}
> -
> -	ret = write(output_fd, buf, len);
> -	if (ret < 0)
> -		die("writing to '%s'", output_file);
> -
> -	return ret;
> -}
> -
> -int bigendian(void)
> -{
> -	unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
> -	unsigned int *ptr;
> -
> -	ptr = (unsigned int *)(void *)str;
> -	return *ptr == 0x01020304;
> -}
> -
> -static unsigned long long copy_file_fd(int fd)
> -{
> -	unsigned long long size = 0;
> -	char buf[BUFSIZ];
> -	int r;
> -
> -	do {
> -		r = read(fd, buf, BUFSIZ);
> -		if (r > 0) {
> -			size += r;
> -			write_or_die(buf, r);
> -		}
> -	} while (r > 0);
> -
> -	return size;
> -}
> -
> -static unsigned long long copy_file(const char *file)
> -{
> -	unsigned long long size = 0;
> -	int fd;
> -
> -	fd = open(file, O_RDONLY);
> -	if (fd < 0)
> -		die("Can't read '%s'", file);
> -	size = copy_file_fd(fd);
> -	close(fd);
> -
> -	return size;
> -}
> -
> -static unsigned long get_size_fd(int fd)
> -{
> -	unsigned long long size = 0;
> -	char buf[BUFSIZ];
> -	int r;
> -
> -	do {
> -		r = read(fd, buf, BUFSIZ);
> -		if (r > 0)
> -			size += r;
> -	} while (r > 0);
> -
> -	lseek(fd, 0, SEEK_SET);
> -
> -	return size;
> -}
> -
> -static unsigned long get_size(const char *file)
> -{
> -	unsigned long long size = 0;
> -	int fd;
> -
> -	fd = open(file, O_RDONLY);
> -	if (fd < 0)
> -		die("Can't read '%s'", file);
> -	size = get_size_fd(fd);
> -	close(fd);
> -
> -	return size;
> -}
> -
> -static void read_header_files(void)
> -{
> -	unsigned long long size, check_size;
> -	char *path;
> -	int fd;
> -
> -	path = get_tracing_file("events/header_page");
> -	fd = open(path, O_RDONLY);
> -	if (fd < 0)
> -		die("can't read '%s'", path);
> -
> -	/* unfortunately, you can not stat debugfs files for size */
> -	size = get_size_fd(fd);
> -
> -	write_or_die("header_page", 12);
> -	write_or_die(&size, 8);
> -	check_size = copy_file_fd(fd);
> -	close(fd);
> -
> -	if (size != check_size)
> -		die("wrong size for '%s' size=%lld read=%lld",
> -		    path, size, check_size);
> -	put_tracing_file(path);
> -
> -	path = get_tracing_file("events/header_event");
> -	fd = open(path, O_RDONLY);
> -	if (fd < 0)
> -		die("can't read '%s'", path);
> -
> -	size = get_size_fd(fd);
> -
> -	write_or_die("header_event", 13);
> -	write_or_die(&size, 8);
> -	check_size = copy_file_fd(fd);
> -	if (size != check_size)
> -		die("wrong size for '%s'", path);
> -	put_tracing_file(path);
> -	close(fd);
> -}
> -
> -static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
> -{
> -	while (tps) {
> -		if (!strcmp(sys, tps->name))
> -			return true;
> -		tps = tps->next;
> -	}
> -
> -	return false;
> -}
> -
> -static void copy_event_system(const char *sys, struct tracepoint_path *tps)
> -{
> -	unsigned long long size, check_size;
> -	struct dirent *dent;
> -	struct stat st;
> -	char *format;
> -	DIR *dir;
> -	int count = 0;
> -	int ret;
> -
> -	dir = opendir(sys);
> -	if (!dir)
> -		die("can't read directory '%s'", sys);
> -
> -	while ((dent = readdir(dir))) {
> -		if (dent->d_type != DT_DIR ||
> -		    strcmp(dent->d_name, ".") == 0 ||
> -		    strcmp(dent->d_name, "..") == 0 ||
> -		    !name_in_tp_list(dent->d_name, tps))
> -			continue;
> -		format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
> -		sprintf(format, "%s/%s/format", sys, dent->d_name);
> -		ret = stat(format, &st);
> -		free(format);
> -		if (ret < 0)
> -			continue;
> -		count++;
> -	}
> -
> -	write_or_die(&count, 4);
> -
> -	rewinddir(dir);
> -	while ((dent = readdir(dir))) {
> -		if (dent->d_type != DT_DIR ||
> -		    strcmp(dent->d_name, ".") == 0 ||
> -		    strcmp(dent->d_name, "..") == 0 ||
> -		    !name_in_tp_list(dent->d_name, tps))
> -			continue;
> -		format = malloc_or_die(strlen(sys) + strlen(dent->d_name) + 10);
> -		sprintf(format, "%s/%s/format", sys, dent->d_name);
> -		ret = stat(format, &st);
> -
> -		if (ret >= 0) {
> -			/* unfortunately, you can not stat debugfs files for size */
> -			size = get_size(format);
> -			write_or_die(&size, 8);
> -			check_size = copy_file(format);
> -			if (size != check_size)
> -				die("error in size of file '%s'", format);
> -		}
> -
> -		free(format);
> -	}
> -	closedir(dir);
> -}
> -
> -static void read_ftrace_files(struct tracepoint_path *tps)
> -{
> -	char *path;
> -
> -	path = get_tracing_file("events/ftrace");
> -
> -	copy_event_system(path, tps);
> -
> -	put_tracing_file(path);
> -}
> -
> -static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
> -{
> -	while (tps) {
> -		if (!strcmp(sys, tps->system))
> -			return true;
> -		tps = tps->next;
> -	}
> -
> -	return false;
> -}
> -
> -static void read_event_files(struct tracepoint_path *tps)
> -{
> -	struct dirent *dent;
> -	struct stat st;
> -	char *path;
> -	char *sys;
> -	DIR *dir;
> -	int count = 0;
> -	int ret;
> -
> -	path = get_tracing_file("events");
> -
> -	dir = opendir(path);
> -	if (!dir)
> -		die("can't read directory '%s'", path);
> -
> -	while ((dent = readdir(dir))) {
> -		if (dent->d_type != DT_DIR ||
> -		    strcmp(dent->d_name, ".") == 0 ||
> -		    strcmp(dent->d_name, "..") == 0 ||
> -		    strcmp(dent->d_name, "ftrace") == 0 ||
> -		    !system_in_tp_list(dent->d_name, tps))
> -			continue;
> -		count++;
> -	}
> -
> -	write_or_die(&count, 4);
> -
> -	rewinddir(dir);
> -	while ((dent = readdir(dir))) {
> -		if (dent->d_type != DT_DIR ||
> -		    strcmp(dent->d_name, ".") == 0 ||
> -		    strcmp(dent->d_name, "..") == 0 ||
> -		    strcmp(dent->d_name, "ftrace") == 0 ||
> -		    !system_in_tp_list(dent->d_name, tps))
> -			continue;
> -		sys = malloc_or_die(strlen(path) + strlen(dent->d_name) + 2);
> -		sprintf(sys, "%s/%s", path, dent->d_name);
> -		ret = stat(sys, &st);
> -		if (ret >= 0) {
> -			write_or_die(dent->d_name, strlen(dent->d_name) + 1);
> -			copy_event_system(sys, tps);
> -		}
> -		free(sys);
> -	}
> -
> -	closedir(dir);
> -	put_tracing_file(path);
> -}
> -
> -static void read_proc_kallsyms(void)
> -{
> -	unsigned int size, check_size;
> -	const char *path = "/proc/kallsyms";
> -	struct stat st;
> -	int ret;
> -
> -	ret = stat(path, &st);
> -	if (ret < 0) {
> -		/* not found */
> -		size = 0;
> -		write_or_die(&size, 4);
> -		return;
> -	}
> -	size = get_size(path);
> -	write_or_die(&size, 4);
> -	check_size = copy_file(path);
> -	if (size != check_size)
> -		die("error in size of file '%s'", path);
> -
> -}
> -
> -static void read_ftrace_printk(void)
> -{
> -	unsigned int size, check_size;
> -	char *path;
> -	struct stat st;
> -	int ret;
> -
> -	path = get_tracing_file("printk_formats");
> -	ret = stat(path, &st);
> -	if (ret < 0) {
> -		/* not found */
> -		size = 0;
> -		write_or_die(&size, 4);
> -		goto out;
> -	}
> -	size = get_size(path);
> -	write_or_die(&size, 4);
> -	check_size = copy_file(path);
> -	if (size != check_size)
> -		die("error in size of file '%s'", path);
> -out:
> -	put_tracing_file(path);
> -}
> -
> -static struct tracepoint_path *
> -get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
> -{
> -	struct tracepoint_path path, *ppath = &path;
> -	int i, nr_tracepoints = 0;
> -
> -	for (i = 0; i < nb_events; i++) {
> -		if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
> -			continue;
> -		++nr_tracepoints;
> -		ppath->next = tracepoint_id_to_path(pattrs[i].config);
> -		if (!ppath->next)
> -			die("%s\n", "No memory to alloc tracepoints list");
> -		ppath = ppath->next;
> -	}
> -
> -	return nr_tracepoints > 0 ? path.next : NULL;
> -}
> -
> -bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
> -{
> -	int i;
> -
> -	for (i = 0; i < nb_events; i++)
> -		if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
> -			return true;
> -
> -	return false;
> -}
> -
> -int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
> -{
> -	char buf[BUFSIZ];
> -	struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
> -
> -	/*
> -	 * What? No tracepoints? No sense writing anything here, bail out.
> -	 */
> -	if (tps == NULL)
> -		return -1;
> -
> -	output_fd = fd;
> -
> -	buf[0] = 23;
> -	buf[1] = 8;
> -	buf[2] = 68;
> -	memcpy(buf + 3, "tracing", 7);
> -
> -	write_or_die(buf, 10);
> -
> -	write_or_die(VERSION, strlen(VERSION) + 1);
> -
> -	/* save endian */
> -	if (bigendian())
> -		buf[0] = 1;
> -	else
> -		buf[0] = 0;
> -
> -	write_or_die(buf, 1);
> -
> -	/* save size of long */
> -	buf[0] = sizeof(long);
> -	write_or_die(buf, 1);
> -
> -	/* save page_size */
> -	page_size = sysconf(_SC_PAGESIZE);
> -	write_or_die(&page_size, 4);
> -
> -	read_header_files();
> -	read_ftrace_files(tps);
> -	read_event_files(tps);
> -	read_proc_kallsyms();
> -	read_ftrace_printk();
> -
> -	return 0;
> -}
> -
> -ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
> -			       int nb_events)
> -{
> -	ssize_t size;
> -	int err = 0;
> -
> -	calc_data_size = 1;
> -	err = read_tracing_data(fd, pattrs, nb_events);
> -	size = calc_data_size - 1;
> -	calc_data_size = 0;
> -
> -	if (err < 0)
> -		return err;
> -
> -	return size;
> -}
> diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
> deleted file mode 100644
> index 9a46fa1..0000000
> --- a/tools/perf/util/trace-event-parse.c
> +++ /dev/null
> @@ -1,3233 +0,0 @@
> -/*
> - * Copyright (C) 2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - *
> - * This program is free software; you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; version 2 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 General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - *
> - *  The parts for function graph printing was taken and modified from the
> - *  Linux Kernel that were written by Frederic Weisbecker.
> - */
> -#define _GNU_SOURCE
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <ctype.h>
> -#include <errno.h>
> -
> -#undef _GNU_SOURCE
> -#include "../perf.h"
> -#include <lk/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_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;
> -
> -	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;
> -	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;
> -}
> -
> -/*
> - * 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 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");
> -	}
> -}
> -
> -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;
> -
> -	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)
> -{
> -	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;
> -}
> -
> -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 (strcmp(token, expect_tok) != 0) {
> -		if (warn)
> -			warning("Error: expected '%s' but read '%s'",
> -				expect_tok, token);
> -		return -1;
> -	}
> -	return 0;
> -}
> -
> -static int test_type_token(enum event_type type, char *token,
> -			   enum event_type expect, const char *expect_tok)
> -{
> -	return __test_type_token(type, token, expect, expect_tok, true);
> -}
> -
> -static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
> -{
> -	enum event_type type;
> -
> -	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)
> -{
> -	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, warn);
> -
> -	free_token(token);
> -
> -	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)
> -{
> -	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))
> -		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;
> -}
> -
> -static int event_read_format(struct event *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;
> -}
> -
> -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 process_arg_token(event, arg, tok, type);
> -}
> -
> -static enum event_type
> -process_cond(struct event *event, struct print_arg *top, char **tok)
> -{
> -	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);
> -
> -	top->op.right = arg;
> -
> -	*tok = token;
> -	return type;
> -
> -out_free:
> -	free_token(*tok);
> -	free(right);
> -	free(left);
> -	free_arg(arg);
> -	return EVENT_ERROR;
> -}
> -
> -static enum event_type
> -process_array(struct event *event, struct print_arg *top, char **tok)
> -{
> -	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;
> -
> -out_free:
> -	free_token(*tok);
> -	free_arg(arg);
> -	return EVENT_ERROR;
> -}
> -
> -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;
> -		}
> -	}
> -}
> -
> -static void 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;
> -		return;
> -	}
> -
> -	arg->op.prio = get_op_prio(arg->op.op);
> -}
> -
> -static enum event_type
> -process_op(struct event *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);
> -			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);
> -
> -		return process_op(event, right, tok);
> -	}
> -
> -	return type;
> -}
> -
> -static enum event_type
> -process_entry(struct event *event __unused, struct print_arg *arg,
> -	      char **tok)
> -{
> -	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;
> -
> -	return type;
> -
> -fail:
> -	free_token(token);
> -	return EVENT_ERROR;
> -}
> -
> -static char *arg_eval (struct print_arg *arg);
> -
> -static long long arg_num_eval(struct print_arg *arg)
> -{
> -	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;
> -		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;
> -}
> -
> -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:
> -		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;
> -}
> -
> -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 (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)
> -{
> -	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);
> -	if (test_type_token(type, token, EVENT_DELIM, ","))
> -		goto out_free;
> -
> -	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);
> -	return EVENT_ERROR;
> -}
> -
> -static enum event_type
> -process_symbols(struct event *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;
> -
> -	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;
> -
> -	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);
> -	return EVENT_ERROR;
> -}
> -
> -static enum event_type
> -process_paren(struct event *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)
> -		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 */
> -
> -		/* prevous must be an atom */
> -		if (arg->type != PRINT_ATOM)
> -			die("previous needed to be PRINT_ATOM");
> -
> -		item_arg = malloc_or_die(sizeof(*item_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;
> -}
> -
> -
> -static enum event_type
> -process_str(struct event *event __unused, struct print_arg *arg, char **tok)
> -{
> -	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;
> -}
> -
> -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);
> -			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;
> -	}
> -
> -	return format;
> -}
> -
> -static struct format_field *
> -find_any_field(struct event *event, const char *name)
> -{
> -	struct format_field *format;
> -
> -	format = find_common_field(event, name);
> -	if (format)
> -		return format;
> -	return find_field(event, name);
> -}
> -
> -unsigned long long read_size(void *ptr, int size)
> -{
> -	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;
> -	}
> -}
> -
> -unsigned long long
> -raw_field_value(struct event *event, const char *name, void *data)
> -{
> -	struct format_field *field;
> -
> -	field = find_any_field(event, name);
> -	if (!field)
> -		return 0ULL;
> -
> -	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)
> -		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;
> -	}
> -	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;
> -	}
> -	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;
> -	}
> -	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 },
> -};
> -
> -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_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);
> -}
> -
> -/* taken from Linux, written by Frederic Weisbecker */
> -static void print_graph_cpu(int cpu)
> -{
> -	int i;
> -	int log10_this = log10_cpu(cpu);
> -	int log10_all = log10_cpu(cpus);
> -
> -
> -	/*
> -	 * Start with a space character - to make it stand out
> -	 * to the right a bit when trace output is pasted into
> -	 * email:
> -	 */
> -	printf(" ");
> -
> -	/*
> -	 * Tricky - we space the CPU field according to the max
> -	 * number of online CPUs. On a 2-cpu system it would take
> -	 * a maximum of 1 digit - on a 128 cpu system it would
> -	 * take up to 3 digits:
> -	 */
> -	for (i = 0; i < log10_all - log10_this; i++)
> -		printf(" ");
> -
> -	printf("%d) ", cpu);
> -}
> -
> -#define TRACE_GRAPH_PROCINFO_LENGTH	14
> -#define TRACE_GRAPH_INDENT	2
> -
> -static void print_graph_proc(int pid, const char *comm)
> -{
> -	/* sign + log10(MAX_INT) + '\0' */
> -	char pid_str[11];
> -	int spaces = 0;
> -	int len;
> -	int i;
> -
> -	sprintf(pid_str, "%d", pid);
> -
> -	/* 1 stands for the "-" character */
> -	len = strlen(comm) + strlen(pid_str) + 1;
> -
> -	if (len < TRACE_GRAPH_PROCINFO_LENGTH)
> -		spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;
> -
> -	/* First spaces to align center */
> -	for (i = 0; i < spaces / 2; i++)
> -		printf(" ");
> -
> -	printf("%s-%s", comm, pid_str);
> -
> -	/* Last spaces to align center */
> -	for (i = 0; i < spaces - (spaces / 2); i++)
> -		printf(" ");
> -}
> -
> -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, const char *comm,
> -		      unsigned long secs, unsigned long usecs)
> -{
> -	struct format_field *field;
> -	struct record *rec;
> -	void *copy_data;
> -	unsigned long val;
> -
> -	printf("%5lu.%06lu |  ", secs, usecs);
> -
> -	print_graph_cpu(cpu);
> -	print_graph_proc(pid, comm);
> -
> -	printf(" | ");
> -
> -	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,
> -		      int cpu, int pid, const char *comm,
> -		      unsigned long secs, unsigned long usecs)
> -{
> -	unsigned long long rettime, calltime;
> -	unsigned long long duration, depth;
> -	struct format_field *field;
> -	int i;
> -
> -	printf("%5lu.%06lu |  ", secs, usecs);
> -
> -	print_graph_cpu(cpu);
> -	print_graph_proc(pid, comm);
> -
> -	printf(" | ");
> -
> -	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, const char *comm,
> -			unsigned long secs, unsigned long usecs)
> -{
> -	if (event->flags & EVENT_FL_ISFUNCENT)
> -		pretty_print_func_ent(data, size, event,
> -				      cpu, pid, comm, secs, usecs);
> -	else if (event->flags & EVENT_FL_ISFUNCRET)
> -		pretty_print_func_ret(data, size, event,
> -				      cpu, pid, comm, secs, usecs);
> -	printf("\n");
> -}
> -
> -void print_event(int cpu, void *data, int size, unsigned long long nsecs,
> -		  char *comm)
> -{
> -	struct event *event;
> -	unsigned long secs;
> -	unsigned long usecs;
> -	int type;
> -	int pid;
> -
> -	secs = nsecs / NSECS_PER_SEC;
> -	nsecs -= secs * NSECS_PER_SEC;
> -	usecs = nsecs / NSECS_PER_USEC;
> -
> -	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, comm, secs, usecs);
> -
> -	if (latency_format) {
> -		printf("%8.8s-%-5d %3d",
> -		       comm, pid, cpu);
> -		print_lat_fmt(data, size);
> -	} else
> -		printf("%16s-%-5d [%03d]", comm, pid,  cpu);
> -
> -	printf(" %5lu.%06lu: %s: ", secs, usecs, event->name);
> -
> -	if (event->flags & EVENT_FL_FAILED) {
> -		printf("EVENT '%s' FAILED TO PARSE\n",
> -		       event->name);
> -		return;
> -	}
> -
> -	pretty_print(data, size, event);
> -	printf("\n");
> -}
> -
> -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
> deleted file mode 100644
> index 2583227..0000000
> --- a/tools/perf/util/trace-event-read.c
> +++ /dev/null
> @@ -1,539 +0,0 @@
> -/*
> - * Copyright (C) 2009, Steven Rostedt <srostedt@xxxxxxxxxx>
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - *
> - * This program is free software; you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; version 2 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 General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program; if not, write to the Free Software
> - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
> - *
> - * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
> - */
> -#define _FILE_OFFSET_BITS 64
> -
> -#include <dirent.h>
> -#include <stdio.h>
> -#include <stdlib.h>
> -#include <string.h>
> -#include <getopt.h>
> -#include <stdarg.h>
> -#include <sys/types.h>
> -#include <sys/stat.h>
> -#include <sys/wait.h>
> -#include <sys/mman.h>
> -#include <pthread.h>
> -#include <fcntl.h>
> -#include <unistd.h>
> -#include <ctype.h>
> -#include <errno.h>
> -
> -#include "../perf.h"
> -#include <lk/util.h>
> -#include "trace-event.h"
> -
> -static int input_fd;
> -
> -static int read_page;
> -
> -int file_bigendian;
> -int host_bigendian;
> -static int long_size;
> -
> -static unsigned long	page_size;
> -
> -static ssize_t calc_data_size;
> -static bool repipe;
> -
> -static int do_read(int fd, void *buf, int size)
> -{
> -	int rsize = size;
> -
> -	while (size) {
> -		int ret = read(fd, buf, size);
> -
> -		if (ret <= 0)
> -			return -1;
> -
> -		if (repipe) {
> -			int retw = write(STDOUT_FILENO, buf, ret);
> -
> -			if (retw <= 0 || retw != ret)
> -				die("repiping input file");
> -		}
> -
> -		size -= ret;
> -		buf += ret;
> -	}
> -
> -	return rsize;
> -}
> -
> -static int read_or_die(void *data, int size)
> -{
> -	int r;
> -
> -	r = do_read(input_fd, data, size);
> -	if (r <= 0)
> -		die("reading input file (size expected=%d received=%d)",
> -		    size, r);
> -
> -	if (calc_data_size)
> -		calc_data_size += r;
> -
> -	return r;
> -}
> -
> -/* If it fails, the next read will report it */
> -static void skip(int size)
> -{
> -	char buf[BUFSIZ];
> -	int r;
> -
> -	while (size) {
> -		r = size > BUFSIZ ? BUFSIZ : size;
> -		read_or_die(buf, r);
> -		size -= r;
> -	};
> -}
> -
> -static unsigned int read4(void)
> -{
> -	unsigned int data;
> -
> -	read_or_die(&data, 4);
> -	return __data2host4(data);
> -}
> -
> -static unsigned long long read8(void)
> -{
> -	unsigned long long data;
> -
> -	read_or_die(&data, 8);
> -	return __data2host8(data);
> -}
> -
> -static char *read_string(void)
> -{
> -	char buf[BUFSIZ];
> -	char *str = NULL;
> -	int size = 0;
> -	off_t r;
> -	char c;
> -
> -	for (;;) {
> -		r = read(input_fd, &c, 1);
> -		if (r < 0)
> -			die("reading input file");
> -
> -		if (!r)
> -			die("no data");
> -
> -		if (repipe) {
> -			int retw = write(STDOUT_FILENO, &c, 1);
> -
> -			if (retw <= 0 || retw != r)
> -				die("repiping input file string");
> -		}
> -
> -		buf[size++] = c;
> -
> -		if (!c)
> -			break;
> -	}
> -
> -	if (calc_data_size)
> -		calc_data_size += size;
> -
> -	str = malloc_or_die(size);
> -	memcpy(str, buf, size);
> -
> -	return str;
> -}
> -
> -static void read_proc_kallsyms(void)
> -{
> -	unsigned int size;
> -	char *buf;
> -
> -	size = read4();
> -	if (!size)
> -		return;
> -
> -	buf = malloc_or_die(size + 1);
> -	read_or_die(buf, size);
> -	buf[size] = '\0';
> -
> -	parse_proc_kallsyms(buf, size);
> -
> -	free(buf);
> -}
> -
> -static void read_ftrace_printk(void)
> -{
> -	unsigned int size;
> -	char *buf;
> -
> -	size = read4();
> -	if (!size)
> -		return;
> -
> -	buf = malloc_or_die(size);
> -	read_or_die(buf, size);
> -
> -	parse_ftrace_printk(buf, size);
> -
> -	free(buf);
> -}
> -
> -static void read_header_files(void)
> -{
> -	unsigned long long size;
> -	char *header_event;
> -	char buf[BUFSIZ];
> -
> -	read_or_die(buf, 12);
> -
> -	if (memcmp(buf, "header_page", 12) != 0)
> -		die("did not read header page");
> -
> -	size = read8();
> -	skip(size);
> -
> -	/*
> -	 * The size field in the page is of type long,
> -	 * use that instead, since it represents the kernel.
> -	 */
> -	long_size = header_page_size_size;
> -
> -	read_or_die(buf, 13);
> -	if (memcmp(buf, "header_event", 13) != 0)
> -		die("did not read header event");
> -
> -	size = read8();
> -	header_event = malloc_or_die(size);
> -	read_or_die(header_event, size);
> -	free(header_event);
> -}
> -
> -static void read_ftrace_file(unsigned long long size)
> -{
> -	char *buf;
> -
> -	buf = malloc_or_die(size);
> -	read_or_die(buf, size);
> -	parse_ftrace_file(buf, size);
> -	free(buf);
> -}
> -
> -static void read_event_file(char *sys, unsigned long long size)
> -{
> -	char *buf;
> -
> -	buf = malloc_or_die(size);
> -	read_or_die(buf, size);
> -	parse_event_file(buf, size, sys);
> -	free(buf);
> -}
> -
> -static void read_ftrace_files(void)
> -{
> -	unsigned long long size;
> -	int count;
> -	int i;
> -
> -	count = read4();
> -
> -	for (i = 0; i < count; i++) {
> -		size = read8();
> -		read_ftrace_file(size);
> -	}
> -}
> -
> -static void read_event_files(void)
> -{
> -	unsigned long long size;
> -	char *sys;
> -	int systems;
> -	int count;
> -	int i,x;
> -
> -	systems = read4();
> -
> -	for (i = 0; i < systems; i++) {
> -		sys = read_string();
> -
> -		count = read4();
> -		for (x=0; x < count; x++) {
> -			size = read8();
> -			read_event_file(sys, size);
> -		}
> -	}
> -}
> -
> -struct cpu_data {
> -	unsigned long long	offset;
> -	unsigned long long	size;
> -	unsigned long long	timestamp;
> -	struct record		*next;
> -	char			*page;
> -	int			cpu;
> -	int			index;
> -	int			page_size;
> -};
> -
> -static struct cpu_data *cpu_data;
> -
> -static void update_cpu_data_index(int cpu)
> -{
> -	cpu_data[cpu].offset += page_size;
> -	cpu_data[cpu].size -= page_size;
> -	cpu_data[cpu].index = 0;
> -}
> -
> -static void get_next_page(int cpu)
> -{
> -	off_t save_seek;
> -	off_t ret;
> -
> -	if (!cpu_data[cpu].page)
> -		return;
> -
> -	if (read_page) {
> -		if (cpu_data[cpu].size <= page_size) {
> -			free(cpu_data[cpu].page);
> -			cpu_data[cpu].page = NULL;
> -			return;
> -		}
> -
> -		update_cpu_data_index(cpu);
> -
> -		/* other parts of the code may expect the pointer to not move */
> -		save_seek = lseek(input_fd, 0, SEEK_CUR);
> -
> -		ret = lseek(input_fd, cpu_data[cpu].offset, SEEK_SET);
> -		if (ret == (off_t)-1)
> -			die("failed to lseek");
> -		ret = read(input_fd, cpu_data[cpu].page, page_size);
> -		if (ret < 0)
> -			die("failed to read page");
> -
> -		/* reset the file pointer back */
> -		lseek(input_fd, save_seek, SEEK_SET);
> -
> -		return;
> -	}
> -
> -	munmap(cpu_data[cpu].page, page_size);
> -	cpu_data[cpu].page = NULL;
> -
> -	if (cpu_data[cpu].size <= page_size)
> -		return;
> -
> -	update_cpu_data_index(cpu);
> -
> -	cpu_data[cpu].page = mmap(NULL, page_size, PROT_READ, MAP_PRIVATE,
> -				  input_fd, cpu_data[cpu].offset);
> -	if (cpu_data[cpu].page == MAP_FAILED)
> -		die("failed to mmap cpu %d at offset 0x%llx",
> -		    cpu, cpu_data[cpu].offset);
> -}
> -
> -static unsigned int type_len4host(unsigned int type_len_ts)
> -{
> -	if (file_bigendian)
> -		return (type_len_ts >> 27) & ((1 << 5) - 1);
> -	else
> -		return type_len_ts & ((1 << 5) - 1);
> -}
> -
> -static unsigned int ts4host(unsigned int type_len_ts)
> -{
> -	if (file_bigendian)
> -		return type_len_ts & ((1 << 27) - 1);
> -	else
> -		return type_len_ts >> 5;
> -}
> -
> -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 record *data;
> -	void *page = cpu_data[cpu].page;
> -	int idx = cpu_data[cpu].index;
> -	void *ptr = page + idx;
> -	unsigned long long extend;
> -	unsigned int type_len_ts;
> -	unsigned int type_len;
> -	unsigned int delta;
> -	unsigned int length = 0;
> -
> -	if (cpu_data[cpu].next)
> -		return cpu_data[cpu].next;
> -
> -	if (!page)
> -		return NULL;
> -
> -	if (!idx) {
> -		/* FIXME: handle header page */
> -		if (header_page_ts_size != 8)
> -			die("expected a long long type for timestamp");
> -		cpu_data[cpu].timestamp = data2host8(ptr);
> -		ptr += 8;
> -		switch (header_page_size_size) {
> -		case 4:
> -			cpu_data[cpu].page_size = data2host4(ptr);
> -			ptr += 4;
> -			break;
> -		case 8:
> -			cpu_data[cpu].page_size = data2host8(ptr);
> -			ptr += 8;
> -			break;
> -		default:
> -			die("bad long size");
> -		}
> -		ptr = cpu_data[cpu].page + header_page_data_offset;
> -	}
> -
> -read_again:
> -	idx = calc_index(ptr, cpu);
> -
> -	if (idx >= cpu_data[cpu].page_size) {
> -		get_next_page(cpu);
> -		return trace_peek_data(cpu);
> -	}
> -
> -	type_len_ts = data2host4(ptr);
> -	ptr += 4;
> -
> -	type_len = type_len4host(type_len_ts);
> -	delta = ts4host(type_len_ts);
> -
> -	switch (type_len) {
> -	case RINGBUF_TYPE_PADDING:
> -		if (!delta)
> -			die("error, hit unexpected end of page");
> -		length = data2host4(ptr);
> -		ptr += 4;
> -		length *= 4;
> -		ptr += length;
> -		goto read_again;
> -
> -	case RINGBUF_TYPE_TIME_EXTEND:
> -		extend = data2host4(ptr);
> -		ptr += 4;
> -		extend <<= TS_SHIFT;
> -		extend += delta;
> -		cpu_data[cpu].timestamp += extend;
> -		goto read_again;
> -
> -	case RINGBUF_TYPE_TIME_STAMP:
> -		ptr += 12;
> -		break;
> -	case 0:
> -		length = data2host4(ptr);
> -		ptr += 4;
> -		die("here! length=%d", length);
> -		break;
> -	default:
> -		length = type_len * 4;
> -		break;
> -	}
> -
> -	cpu_data[cpu].timestamp += delta;
> -
> -	data = malloc_or_die(sizeof(*data));
> -	memset(data, 0, sizeof(*data));
> -
> -	data->ts = cpu_data[cpu].timestamp;
> -	data->size = length;
> -	data->data = ptr;
> -	ptr += length;
> -
> -	cpu_data[cpu].index = calc_index(ptr, cpu);
> -	cpu_data[cpu].next = data;
> -
> -	return data;
> -}
> -
> -struct record *trace_read_data(int cpu)
> -{
> -	struct record *data;
> -
> -	data = trace_peek_data(cpu);
> -	cpu_data[cpu].next = NULL;
> -
> -	return data;
> -}
> -
> -ssize_t trace_report(int fd, bool __repipe)
> -{
> -	char buf[BUFSIZ];
> -	char test[] = { 23, 8, 68 };
> -	char *version;
> -	int show_version = 0;
> -	int show_funcs = 0;
> -	int show_printk = 0;
> -	ssize_t size;
> -
> -	calc_data_size = 1;
> -	repipe = __repipe;
> -
> -	input_fd = fd;
> -
> -	read_or_die(buf, 3);
> -	if (memcmp(buf, test, 3) != 0)
> -		die("no trace data in the file");
> -
> -	read_or_die(buf, 7);
> -	if (memcmp(buf, "tracing", 7) != 0)
> -		die("not a trace file (missing 'tracing' tag)");
> -
> -	version = read_string();
> -	if (show_version)
> -		printf("version = %s\n", version);
> -	free(version);
> -
> -	read_or_die(buf, 1);
> -	file_bigendian = buf[0];
> -	host_bigendian = bigendian();
> -
> -	read_or_die(buf, 1);
> -	long_size = buf[0];
> -
> -	page_size = read4();
> -
> -	read_header_files();
> -
> -	read_ftrace_files();
> -	read_event_files();
> -	read_proc_kallsyms();
> -	read_ftrace_printk();
> -
> -	size = calc_data_size - 1;
> -	calc_data_size = 0;
> -	repipe = false;
> -
> -	if (show_funcs) {
> -		print_funcs();
> -		return size;
> -	}
> -	if (show_printk) {
> -		print_printk();
> -		return size;
> -	}
> -
> -	return size;
> -}
> -- 
> 1.7.1
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/


--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/