[deliverable/linux.git] / tools / perf / util / trace-event-read.c

/*
 * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * 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
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
#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 <errno.h>

#include "../perf.h"
#include "util.h"
#include "trace-event.h"

static int input_fd;

int file_bigendian;
int host_bigendian;
static int long_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) {
				pr_debug("repiping input file");
				return -1;
			}
		}

		size -= ret;
		buf += ret;
	}

	return rsize;
}

static int do_read(void *data, int size)
{
	int r;

	r = __do_read(input_fd, data, size);
	if (r <= 0) {
		pr_debug("reading input file (size expected=%d received=%d)",
			 size, r);
		return -1;
	}

	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;
		do_read(buf, r);
		size -= r;
	};
}

static unsigned int read4(struct pevent *pevent)
{
	unsigned int data;

	if (do_read(&data, 4) < 0)
		return 0;
	return __data2host4(pevent, data);
}

static unsigned long long read8(struct pevent *pevent)
{
	unsigned long long data;

	if (do_read(&data, 8) < 0)
		return 0;
	return __data2host8(pevent, 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) {
			pr_debug("reading input file");
			goto out;
		}

		if (!r) {
			pr_debug("no data");
			goto out;
		}

		if (repipe) {
			int retw = write(STDOUT_FILENO, &c, 1);

			if (retw <= 0 || retw != r) {
				pr_debug("repiping input file string");
				goto out;
			}
		}

		buf[size++] = c;

		if (!c)
			break;
	}

	if (calc_data_size)
		calc_data_size += size;

	str = malloc(size);
	if (str)
		memcpy(str, buf, size);
out:
	return str;
}

static int read_proc_kallsyms(struct pevent *pevent)
{
	unsigned int size;
	char *buf;

	size = read4(pevent);
	if (!size)
		return 0;

	buf = malloc(size + 1);
	if (buf == NULL)
		return -1;

	if (do_read(buf, size) < 0) {
		free(buf);
		return -1;
	}
	buf[size] = '\0';

	parse_proc_kallsyms(pevent, buf, size);

	free(buf);
	return 0;
}

static int read_ftrace_printk(struct pevent *pevent)
{
	unsigned int size;
	char *buf;

	/* it can have 0 size */
	size = read4(pevent);
	if (!size)
		return 0;

	buf = malloc(size);
	if (buf == NULL)
		return -1;

	if (do_read(buf, size) < 0) {
		free(buf);
		return -1;
	}

	parse_ftrace_printk(pevent, buf, size);

	free(buf);
	return 0;
}

static int read_header_files(struct pevent *pevent)
{
	unsigned long long size;
	char *header_event;
	char buf[BUFSIZ];
	int ret = 0;

	if (do_read(buf, 12) < 0)
		return -1;

	if (memcmp(buf, "header_page", 12) != 0) {
		pr_debug("did not read header page");
		return -1;
	}

	size = read8(pevent);
	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;

	if (do_read(buf, 13) < 0)
		return -1;

	if (memcmp(buf, "header_event", 13) != 0) {
		pr_debug("did not read header event");
		return -1;
	}

	size = read8(pevent);
	header_event = malloc(size);
	if (header_event == NULL)
		return -1;

	if (do_read(header_event, size) < 0)
		ret = -1;

	free(header_event);
	return ret;
}

static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
{
	char *buf;

	buf = malloc(size);
	if (buf == NULL)
		return -1;

	if (do_read(buf, size) < 0) {
		free(buf);
		return -1;
	}

	parse_ftrace_file(pevent, buf, size);
	free(buf);
	return 0;
}

static int read_event_file(struct pevent *pevent, char *sys,
			    unsigned long long size)
{
	char *buf;

	buf = malloc(size);
	if (buf == NULL)
		return -1;

	if (do_read(buf, size) < 0) {
		free(buf);
		return -1;
	}

	parse_event_file(pevent, buf, size, sys);
	free(buf);
	return 0;
}

static int read_ftrace_files(struct pevent *pevent)
{
	unsigned long long size;
	int count;
	int i;
	int ret;

	count = read4(pevent);

	for (i = 0; i < count; i++) {
		size = read8(pevent);
		ret = read_ftrace_file(pevent, size);
		if (ret)
			return ret;
	}
	return 0;
}

static int read_event_files(struct pevent *pevent)
{
	unsigned long long size;
	char *sys;
	int systems;
	int count;
	int i,x;
	int ret;

	systems = read4(pevent);

	for (i = 0; i < systems; i++) {
		sys = read_string();
		if (sys == NULL)
			return -1;

		count = read4(pevent);

		for (x=0; x < count; x++) {
			size = read8(pevent);
			ret = read_event_file(pevent, sys, size);
			if (ret)
				return ret;
		}
	}
	return 0;
}

ssize_t trace_report(int fd, struct pevent **ppevent, 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 = -1;
	struct pevent *pevent;
	int err;

	*ppevent = NULL;

	calc_data_size = 1;
	repipe = __repipe;

	input_fd = fd;

	if (do_read(buf, 3) < 0)
		return -1;
	if (memcmp(buf, test, 3) != 0) {
		pr_debug("no trace data in the file");
		return -1;
	}

	if (do_read(buf, 7) < 0)
		return -1;
	if (memcmp(buf, "tracing", 7) != 0) {
		pr_debug("not a trace file (missing 'tracing' tag)");
		return -1;
	}

	version = read_string();
	if (version == NULL)
		return -1;
	if (show_version)
		printf("version = %s\n", version);
	free(version);

	if (do_read(buf, 1) < 0)
		return -1;
	file_bigendian = buf[0];
	host_bigendian = bigendian();

	pevent = read_trace_init(file_bigendian, host_bigendian);
	if (pevent == NULL) {
		pr_debug("read_trace_init failed");
		goto out;
	}

	if (do_read(buf, 1) < 0)
		goto out;
	long_size = buf[0];

	page_size = read4(pevent);
	if (!page_size)
		goto out;

	err = read_header_files(pevent);
	if (err)
		goto out;
	err = read_ftrace_files(pevent);
	if (err)
		goto out;
	err = read_event_files(pevent);
	if (err)
		goto out;
	err = read_proc_kallsyms(pevent);
	if (err)
		goto out;
	err = read_ftrace_printk(pevent);
	if (err)
		goto out;

	size = calc_data_size - 1;
	calc_data_size = 0;
	repipe = false;

	if (show_funcs) {
		pevent_print_funcs(pevent);
	} else if (show_printk) {
		pevent_print_printk(pevent);
	}

	*ppevent = pevent;
	pevent = NULL;

out:
	if (pevent)
		pevent_free(pevent);
	return size;
}
Commit	Line	Data
538bafb5 SR	1	/*
	2	* Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
	3	*
	4	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; version 2 of the License (not later!)
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*
	19	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	20	*/
538bafb5 SR	21	#include <dirent.h>
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <string.h>
	25	#include <getopt.h>
	26	#include <stdarg.h>
	27	#include <sys/types.h>
	28	#include <sys/stat.h>
	29	#include <sys/wait.h>
	30	#include <sys/mman.h>
	31	#include <pthread.h>
	32	#include <fcntl.h>
	33	#include <unistd.h>
538bafb5 SR	34	#include <errno.h>
538bafb5 SR	35
1ef2ed10	36	#include "../perf.h"
538bafb5 SR	37	#include "util.h"
	38	#include "trace-event.h"
	39
	40	static int input_fd;
	41
538bafb5 SR	42	int file_bigendian;
	43	int host_bigendian;
	44	static int long_size;
	45
9215545e	46	static ssize_t calc_data_size;
454c407e	47	static bool repipe;
9215545e	48
4a31e565	49	static int __do_read(int fd, void *buf, int size)
9215545e TZ	50	{
	51	int rsize = size;
	52
	53	while (size) {
	54	int ret = read(fd, buf, size);
	55
	56	if (ret <= 0)
	57	return -1;
	58
454c407e TZ	59	if (repipe) {
	60	int retw = write(STDOUT_FILENO, buf, ret);
	61
4a31e565 NK	62	if (retw <= 0 \|\| retw != ret) {
	63	pr_debug("repiping input file");
	64	return -1;
	65	}
454c407e TZ	66	}
454c407e TZ	67
9215545e TZ	68	size -= ret;
	69	buf += ret;
	70	}
	71
	72	return rsize;
	73	}
	74
4a31e565	75	static int do_read(void *data, int size)
538bafb5 SR	76	{
	77	int r;
	78
4a31e565 NK	79	r = __do_read(input_fd, data, size);
	80	if (r <= 0) {
	81	pr_debug("reading input file (size expected=%d received=%d)",
	82	size, r);
	83	return -1;
	84	}
9215545e TZ	85
	86	if (calc_data_size)
	87	calc_data_size += r;
	88
538bafb5 SR	89	return r;
	90	}
	91
cbb5cf7f TZ	92	/* If it fails, the next read will report it */
	93	static void skip(int size)
	94	{
	95	char buf[BUFSIZ];
	96	int r;
	97
	98	while (size) {
	99	r = size > BUFSIZ ? BUFSIZ : size;
4a31e565	100	do_read(buf, r);
cbb5cf7f TZ	101	size -= r;
	102	};
	103	}
	104
da378962	105	static unsigned int read4(struct pevent *pevent)
538bafb5 SR	106	{
	107	unsigned int data;
	108
4a31e565 NK	109	if (do_read(&data, 4) < 0)
4a31e565 NK	110	return 0;
da378962	111	return __data2host4(pevent, data);
538bafb5 SR	112	}
538bafb5 SR	113
da378962	114	static unsigned long long read8(struct pevent *pevent)
538bafb5 SR	115	{
	116	unsigned long long data;
	117
4a31e565 NK	118	if (do_read(&data, 8) < 0)
4a31e565 NK	119	return 0;
da378962	120	return __data2host8(pevent, data);
538bafb5 SR	121	}
	122
	123	static char *read_string(void)
	124	{
	125	char buf[BUFSIZ];
	126	char *str = NULL;
	127	int size = 0;
f887f301	128	off_t r;
9215545e	129	char c;
538bafb5 SR	130
538bafb5 SR	131	for (;;) {
9215545e	132	r = read(input_fd, &c, 1);
452958fd NK	133	if (r < 0) {
	134	pr_debug("reading input file");
	135	goto out;
	136	}
538bafb5	137
452958fd NK	138	if (!r) {
	139	pr_debug("no data");
	140	goto out;
	141	}
538bafb5	142
454c407e TZ	143	if (repipe) {
	144	int retw = write(STDOUT_FILENO, &c, 1);
	145
452958fd NK	146	if (retw <= 0 \|\| retw != r) {
	147	pr_debug("repiping input file string");
	148	goto out;
	149	}
454c407e TZ	150	}
454c407e TZ	151
9215545e	152	buf[size++] = c;
538bafb5	153
9215545e TZ	154	if (!c)
9215545e TZ	155	break;
538bafb5 SR	156	}
538bafb5 SR	157
9215545e TZ	158	if (calc_data_size)
	159	calc_data_size += size;
	160
a4c98367 NK	161	str = malloc(size);
	162	if (str)
	163	memcpy(str, buf, size);
452958fd	164	out:
538bafb5 SR	165	return str;
	166	}
	167
a4c98367	168	static int read_proc_kallsyms(struct pevent *pevent)
538bafb5 SR	169	{
	170	unsigned int size;
	171	char *buf;
	172
da378962	173	size = read4(pevent);
538bafb5	174	if (!size)
a4c98367 NK	175	return 0;
	176
	177	buf = malloc(size + 1);
	178	if (buf == NULL)
	179	return -1;
538bafb5	180
4a31e565 NK	181	if (do_read(buf, size) < 0) {
	182	free(buf);
	183	return -1;
	184	}
7691b1ec	185	buf[size] = '\0';
538bafb5	186
da378962	187	parse_proc_kallsyms(pevent, buf, size);
538bafb5 SR	188
538bafb5 SR	189	free(buf);
a4c98367	190	return 0;
538bafb5 SR	191	}
538bafb5 SR	192
a4c98367	193	static int read_ftrace_printk(struct pevent *pevent)
538bafb5 SR	194	{
	195	unsigned int size;
	196	char *buf;
	197
4a31e565	198	/* it can have 0 size */
da378962	199	size = read4(pevent);
538bafb5	200	if (!size)
a4c98367 NK	201	return 0;
	202
	203	buf = malloc(size);
	204	if (buf == NULL)
	205	return -1;
538bafb5	206
4a31e565 NK	207	if (do_read(buf, size) < 0) {
	208	free(buf);
	209	return -1;
	210	}
538bafb5	211
da378962	212	parse_ftrace_printk(pevent, buf, size);
538bafb5 SR	213
538bafb5 SR	214	free(buf);
a4c98367	215	return 0;
538bafb5 SR	216	}
538bafb5 SR	217
a4c98367	218	static int read_header_files(struct pevent *pevent)
538bafb5 SR	219	{
538bafb5 SR	220	unsigned long long size;
538bafb5 SR	221	char *header_event;
538bafb5 SR	222	char buf[BUFSIZ];
4a31e565	223	int ret = 0;
538bafb5	224
4a31e565 NK	225	if (do_read(buf, 12) < 0)
4a31e565 NK	226	return -1;
538bafb5	227
452958fd NK	228	if (memcmp(buf, "header_page", 12) != 0) {
	229	pr_debug("did not read header page");
	230	return -1;
	231	}
538bafb5	232
da378962	233	size = read8(pevent);
d00a47cc	234	skip(size);
538bafb5 SR	235
	236	/*
	237	* The size field in the page is of type long,
	238	* use that instead, since it represents the kernel.
	239	*/
	240	long_size = header_page_size_size;
	241
4a31e565 NK	242	if (do_read(buf, 13) < 0)
	243	return -1;
	244
452958fd NK	245	if (memcmp(buf, "header_event", 13) != 0) {
	246	pr_debug("did not read header event");
	247	return -1;
	248	}
538bafb5	249
da378962	250	size = read8(pevent);
a4c98367 NK	251	header_event = malloc(size);
	252	if (header_event == NULL)
	253	return -1;
	254
4a31e565 NK	255	if (do_read(header_event, size) < 0)
	256	ret = -1;
	257
538bafb5	258	free(header_event);
4a31e565	259	return ret;
538bafb5 SR	260	}
538bafb5 SR	261
a4c98367	262	static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
538bafb5 SR	263	{
	264	char *buf;
	265
a4c98367 NK	266	buf = malloc(size);
	267	if (buf == NULL)
	268	return -1;
	269
4a31e565 NK	270	if (do_read(buf, size) < 0) {
	271	free(buf);
	272	return -1;
	273	}
	274
da378962	275	parse_ftrace_file(pevent, buf, size);
538bafb5	276	free(buf);
a4c98367	277	return 0;
538bafb5 SR	278	}
538bafb5 SR	279
a4c98367	280	static int read_event_file(struct pevent pevent, char sys,
da378962	281	unsigned long long size)
538bafb5 SR	282	{
	283	char *buf;
	284
a4c98367 NK	285	buf = malloc(size);
	286	if (buf == NULL)
	287	return -1;
	288
4a31e565 NK	289	if (do_read(buf, size) < 0) {
	290	free(buf);
	291	return -1;
	292	}
	293
da378962	294	parse_event_file(pevent, buf, size, sys);
538bafb5	295	free(buf);
a4c98367	296	return 0;
538bafb5 SR	297	}
538bafb5 SR	298
a4c98367	299	static int read_ftrace_files(struct pevent *pevent)
538bafb5 SR	300	{
	301	unsigned long long size;
	302	int count;
	303	int i;
a4c98367	304	int ret;
538bafb5	305
da378962	306	count = read4(pevent);
538bafb5 SR	307
538bafb5 SR	308	for (i = 0; i < count; i++) {
da378962	309	size = read8(pevent);
a4c98367 NK	310	ret = read_ftrace_file(pevent, size);
	311	if (ret)
	312	return ret;
538bafb5	313	}
a4c98367	314	return 0;
538bafb5 SR	315	}
538bafb5 SR	316
a4c98367	317	static int read_event_files(struct pevent *pevent)
538bafb5 SR	318	{
	319	unsigned long long size;
	320	char *sys;
	321	int systems;
	322	int count;
	323	int i,x;
a4c98367	324	int ret;
538bafb5	325
da378962	326	systems = read4(pevent);
538bafb5 SR	327
	328	for (i = 0; i < systems; i++) {
	329	sys = read_string();
a4c98367 NK	330	if (sys == NULL)
a4c98367 NK	331	return -1;
538bafb5	332
da378962	333	count = read4(pevent);
4a31e565	334
538bafb5	335	for (x=0; x < count; x++) {
da378962	336	size = read8(pevent);
a4c98367 NK	337	ret = read_event_file(pevent, sys, size);
	338	if (ret)
	339	return ret;
538bafb5 SR	340	}
538bafb5 SR	341	}
a4c98367	342	return 0;
538bafb5 SR	343	}
538bafb5 SR	344
da378962	345	ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
538bafb5	346	{
538bafb5 SR	347	char buf[BUFSIZ];
	348	char test[] = { 23, 8, 68 };
	349	char *version;
d9340c1d	350	int show_version = 0;
538bafb5 SR	351	int show_funcs = 0;
538bafb5 SR	352	int show_printk = 0;
3dce2ce3 NK	353	ssize_t size = -1;
3dce2ce3 NK	354	struct pevent *pevent;
a4c98367	355	int err;
3dce2ce3 NK	356
3dce2ce3 NK	357	*ppevent = NULL;
9215545e TZ	358
9215545e TZ	359	calc_data_size = 1;
454c407e	360	repipe = __repipe;
538bafb5	361
03456a15	362	input_fd = fd;
538bafb5	363
4a31e565 NK	364	if (do_read(buf, 3) < 0)
4a31e565 NK	365	return -1;
452958fd NK	366	if (memcmp(buf, test, 3) != 0) {
	367	pr_debug("no trace data in the file");
	368	return -1;
	369	}
538bafb5	370
4a31e565 NK	371	if (do_read(buf, 7) < 0)
4a31e565 NK	372	return -1;
452958fd NK	373	if (memcmp(buf, "tracing", 7) != 0) {
	374	pr_debug("not a trace file (missing 'tracing' tag)");
	375	return -1;
	376	}
538bafb5 SR	377
538bafb5 SR	378	version = read_string();
a4c98367 NK	379	if (version == NULL)
a4c98367 NK	380	return -1;
d9340c1d IM	381	if (show_version)
d9340c1d IM	382	printf("version = %s\n", version);
538bafb5 SR	383	free(version);
538bafb5 SR	384
4a31e565 NK	385	if (do_read(buf, 1) < 0)
4a31e565 NK	386	return -1;
538bafb5 SR	387	file_bigendian = buf[0];
	388	host_bigendian = bigendian();
	389
3dce2ce3 NK	390	pevent = read_trace_init(file_bigendian, host_bigendian);
	391	if (pevent == NULL) {
	392	pr_debug("read_trace_init failed");
	393	goto out;
	394	}
aaf045f7	395
4a31e565 NK	396	if (do_read(buf, 1) < 0)
4a31e565 NK	397	goto out;
538bafb5 SR	398	long_size = buf[0];
538bafb5 SR	399
3dce2ce3	400	page_size = read4(pevent);
4a31e565 NK	401	if (!page_size)
4a31e565 NK	402	goto out;
538bafb5	403
a4c98367 NK	404	err = read_header_files(pevent);
	405	if (err)
	406	goto out;
	407	err = read_ftrace_files(pevent);
	408	if (err)
	409	goto out;
	410	err = read_event_files(pevent);
	411	if (err)
	412	goto out;
	413	err = read_proc_kallsyms(pevent);
	414	if (err)
	415	goto out;
	416	err = read_ftrace_printk(pevent);
	417	if (err)
	418	goto out;
538bafb5	419
9215545e TZ	420	size = calc_data_size - 1;
9215545e TZ	421	calc_data_size = 0;
454c407e	422	repipe = false;
9215545e	423
538bafb5	424	if (show_funcs) {
3dce2ce3 NK	425	pevent_print_funcs(pevent);
	426	} else if (show_printk) {
	427	pevent_print_printk(pevent);
538bafb5 SR	428	}
538bafb5 SR	429
3dce2ce3 NK	430	*ppevent = pevent;
	431	pevent = NULL;
	432
	433	out:
	434	if (pevent)
	435	pevent_free(pevent);
9215545e	436	return size;
538bafb5	437	}