[deliverable/linux.git] / tools / perf / util / trace-event-parse.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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

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

int header_page_size_size;
int header_page_ts_size;
int header_page_data_offset;

bool latency_format;

struct pevent *read_trace_init(int file_bigendian, int host_bigendian)
{
	struct pevent *pevent = pevent_alloc();

	if (pevent != NULL) {
		pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
		pevent_set_file_bigendian(pevent, file_bigendian);
		pevent_set_host_bigendian(pevent, host_bigendian);
	}

	return pevent;
}

static int get_common_field(struct scripting_context *context,
			    int *offset, int *size, const char *type)
{
	struct pevent *pevent = context->pevent;
	struct event_format *event;
	struct format_field *field;

	if (!*size) {
		if (!pevent->events)
			return 0;

		event = pevent->events[0];
		field = pevent_find_common_field(event, type);
		if (!field)
			return 0;
		*offset = field->offset;
		*size = field->size;
	}

	return pevent_read_number(pevent, context->event_data + *offset, *size);
}

int common_lock_depth(struct scripting_context *context)
{
	static int offset;
	static int size;
	int ret;

	ret = get_common_field(context, &size, &offset,
			       "common_lock_depth");
	if (ret < 0)
		return -1;

	return ret;
}

int common_flags(struct scripting_context *context)
{
	static int offset;
	static int size;
	int ret;

	ret = get_common_field(context, &size, &offset,
			       "common_flags");
	if (ret < 0)
		return -1;

	return ret;
}

int common_pc(struct scripting_context *context)
{
	static int offset;
	static int size;
	int ret;

	ret = get_common_field(context, &size, &offset,
			       "common_preempt_count");
	if (ret < 0)
		return -1;

	return ret;
}

unsigned long long
raw_field_value(struct event_format *event, const char *name, void *data)
{
	struct format_field *field;
	unsigned long long val;

	field = pevent_find_any_field(event, name);
	if (!field)
		return 0ULL;

	pevent_read_number_field(field, data, &val);

	return val;
}

void *raw_field_ptr(struct event_format *event, const char *name, void *data)
{
	struct format_field *field;

	field = pevent_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;
}

int trace_parse_common_type(struct pevent *pevent, void *data)
{
	struct pevent_record record;

	record.data = data;
	return pevent_data_type(pevent, &record);
}

int trace_parse_common_pid(struct pevent *pevent, void *data)
{
	struct pevent_record record;

	record.data = data;
	return pevent_data_pid(pevent, &record);
}

unsigned long long read_size(struct pevent *pevent, void *ptr, int size)
{
	return pevent_read_number(pevent, ptr, size);
}

void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
{
	struct event_format *event;
	struct pevent_record record;
	struct trace_seq s;
	int type;

	type = trace_parse_common_type(pevent, data);

	event = pevent_find_event(pevent, type);
	if (!event) {
		warning("ug! no event found for type %d", type);
		return;
	}

	memset(&record, 0, sizeof(record));
	record.cpu = cpu;
	record.size = size;
	record.data = data;

	trace_seq_init(&s);
	pevent_event_info(&s, event, &record);
	trace_seq_do_printf(&s);
}

void print_event(struct pevent *pevent, int cpu, void *data, int size,
		 unsigned long long nsecs, char *comm)
{
	struct pevent_record record;
	struct trace_seq s;
	int pid;

	pevent->latency_format = latency_format;

	record.ts = nsecs;
	record.cpu = cpu;
	record.size = size;
	record.data = data;
	pid = pevent_data_pid(pevent, &record);

	if (!pevent_pid_is_registered(pevent, pid))
		pevent_register_comm(pevent, comm, pid);

	trace_seq_init(&s);
	pevent_print_event(pevent, &s, &record);
	trace_seq_do_printf(&s);
	printf("\n");
}

void parse_proc_kallsyms(struct pevent *pevent,
			 char *file, unsigned int size __unused)
{
	unsigned long long addr;
	char *func;
	char *line;
	char *next = NULL;
	char *addr_str;
	char *mod;
	char ch;

	line = strtok_r(file, "\n", &next);
	while (line) {
		mod = NULL;
		sscanf(line, "%as %c %as\t[%as",
		       (float *)(void *)&addr_str, /* workaround gcc warning */
		       &ch, (float *)(void *)&func, (float *)(void *)&mod);
		addr = strtoull(addr_str, NULL, 16);
		free(addr_str);

		/* truncate the extra ']' */
		if (mod)
			mod[strlen(mod) - 1] = 0;

		pevent_register_function(pevent, func, addr, mod);
		free(func);
		free(mod);

		line = strtok_r(NULL, "\n", &next);
	}
}

void parse_ftrace_printk(struct pevent *pevent,
			 char *file, unsigned int size __unused)
{
	unsigned long long addr;
	char *printk;
	char *line;
	char *next = NULL;
	char *addr_str;
	char *fmt;

	line = strtok_r(file, "\n", &next);
	while (line) {
		addr_str = strtok_r(line, ":", &fmt);
		if (!addr_str) {
			warning("printk format with empty entry");
			break;
		}
		addr = strtoull(addr_str, NULL, 16);
		/* fmt still has a space, skip it */
		printk = strdup(fmt+1);
		line = strtok_r(NULL, "\n", &next);
		pevent_register_print_string(pevent, printk, addr);
	}
}

int parse_ftrace_file(struct pevent *pevent, char *buf, unsigned long size)
{
	return pevent_parse_event(pevent, buf, size, "ftrace");
}

int parse_event_file(struct pevent *pevent,
		     char *buf, unsigned long size, char *sys)
{
	return pevent_parse_event(pevent, buf, size, sys);
}

struct event_format *trace_find_next_event(struct pevent *pevent,
					   struct event_format *event)
{
	static int idx;

	if (!pevent->events)
		return NULL;

	if (!event) {
		idx = 0;
		return pevent->events[0];
	}

	if (idx < pevent->nr_events && event == pevent->events[idx]) {
		idx++;
		if (idx == pevent->nr_events)
			return NULL;
		return pevent->events[idx];
	}

	for (idx = 1; idx < pevent->nr_events; idx++) {
		if (event == pevent->events[idx - 1])
			return pevent->events[idx];
	}
	return NULL;
}

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;
}
Commit	Line	Data
aaf045f7 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	*/
	21	#include <stdio.h>
	22	#include <stdlib.h>
	23	#include <string.h>
	24	#include <ctype.h>
	25	#include <errno.h>
	26
1ef2ed10	27	#include "../perf.h"
ea4010d1 SR	28	#include "util.h"
	29	#include "trace-event.h"
	30
aaf045f7 SR	31	int header_page_size_size;
	32	int header_page_ts_size;
	33	int header_page_data_offset;
	34
aaf045f7 SR	35	bool latency_format;
aaf045f7 SR	36
da378962	37	struct pevent *read_trace_init(int file_bigendian, int host_bigendian)
7397d80d	38	{
da378962	39	struct pevent *pevent = pevent_alloc();
aaf045f7	40
da378962 ACM	41	if (pevent != NULL) {
	42	pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
	43	pevent_set_file_bigendian(pevent, file_bigendian);
	44	pevent_set_host_bigendian(pevent, host_bigendian);
	45	}
aaf045f7	46
da378962	47	return pevent;
7397d80d TZ	48	}
7397d80d TZ	49
aaf045f7 SR	50	static int get_common_field(struct scripting_context *context,
aaf045f7 SR	51	int offset, int size, const char *type)
7397d80d	52	{
da378962	53	struct pevent *pevent = context->pevent;
aaf045f7 SR	54	struct event_format *event;
	55	struct format_field *field;
	56
	57	if (!*size) {
	58	if (!pevent->events)
	59	return 0;
	60
	61	event = pevent->events[0];
	62	field = pevent_find_common_field(event, type);
	63	if (!field)
	64	return 0;
	65	*offset = field->offset;
	66	*size = field->size;
	67	}
	68
	69	return pevent_read_number(pevent, context->event_data + offset, size);
7397d80d TZ	70	}
	71
	72	int common_lock_depth(struct scripting_context *context)
	73	{
aaf045f7 SR	74	static int offset;
	75	static int size;
	76	int ret;
	77
	78	ret = get_common_field(context, &size, &offset,
	79	"common_lock_depth");
	80	if (ret < 0)
	81	return -1;
	82
	83	return ret;
	84	}
	85
	86	int common_flags(struct scripting_context *context)
	87	{
	88	static int offset;
	89	static int size;
	90	int ret;
	91
	92	ret = get_common_field(context, &size, &offset,
	93	"common_flags");
	94	if (ret < 0)
	95	return -1;
	96
	97	return ret;
	98	}
	99
	100	int common_pc(struct scripting_context *context)
	101	{
	102	static int offset;
	103	static int size;
	104	int ret;
	105
	106	ret = get_common_field(context, &size, &offset,
	107	"common_preempt_count");
	108	if (ret < 0)
	109	return -1;
	110
	111	return ret;
	112	}
	113
	114	unsigned long long
	115	raw_field_value(struct event_format event, const char name, void *data)
	116	{
	117	struct format_field *field;
	118	unsigned long long val;
	119
	120	field = pevent_find_any_field(event, name);
	121	if (!field)
	122	return 0ULL;
	123
	124	pevent_read_number_field(field, data, &val);
	125
	126	return val;
	127	}
	128
	129	void raw_field_ptr(struct event_format event, const char name, void data)
	130	{
	131	struct format_field *field;
	132
	133	field = pevent_find_any_field(event, name);
	134	if (!field)
	135	return NULL;
	136
	137	if (field->flags & FIELD_IS_DYNAMIC) {
138	int offset;
139
140	offset = (int )(data + field->offset);
141	offset &= 0xffff;
142
143	return data + offset;
144	}
145
146	return data + field->offset;
147	}
148
da378962	149	int trace_parse_common_type(struct pevent pevent, void data)
aaf045f7	150	{
1c698186	151	struct pevent_record record;
aaf045f7 SR	152
	153	record.data = data;
	154	return pevent_data_type(pevent, &record);
	155	}
	156
da378962	157	int trace_parse_common_pid(struct pevent pevent, void data)
aaf045f7	158	{
1c698186	159	struct pevent_record record;
aaf045f7 SR	160
	161	record.data = data;
	162	return pevent_data_pid(pevent, &record);
	163	}
	164
da378962	165	unsigned long long read_size(struct pevent pevent, void ptr, int size)
aaf045f7 SR	166	{
	167	return pevent_read_number(pevent, ptr, size);
	168	}
	169
da378962	170	void print_trace_event(struct pevent pevent, int cpu, void data, int size)
aaf045f7 SR	171	{
aaf045f7 SR	172	struct event_format *event;
1c698186	173	struct pevent_record record;
aaf045f7 SR	174	struct trace_seq s;
	175	int type;
	176
da378962	177	type = trace_parse_common_type(pevent, data);
aaf045f7	178
da378962	179	event = pevent_find_event(pevent, type);
aaf045f7 SR	180	if (!event) {
	181	warning("ug! no event found for type %d", type);
	182	return;
	183	}
	184
	185	memset(&record, 0, sizeof(record));
	186	record.cpu = cpu;
	187	record.size = size;
	188	record.data = data;
	189
	190	trace_seq_init(&s);
76a8349d	191	pevent_event_info(&s, event, &record);
aaf045f7	192	trace_seq_do_printf(&s);
aaf045f7 SR	193	}
aaf045f7 SR	194
da378962 ACM	195	void print_event(struct pevent pevent, int cpu, void data, int size,
da378962 ACM	196	unsigned long long nsecs, char *comm)
aaf045f7	197	{
1c698186	198	struct pevent_record record;
aaf045f7 SR	199	struct trace_seq s;
	200	int pid;
	201
	202	pevent->latency_format = latency_format;
	203
	204	record.ts = nsecs;
	205	record.cpu = cpu;
	206	record.size = size;
	207	record.data = data;
	208	pid = pevent_data_pid(pevent, &record);
	209
	210	if (!pevent_pid_is_registered(pevent, pid))
	211	pevent_register_comm(pevent, comm, pid);
	212
	213	trace_seq_init(&s);
	214	pevent_print_event(pevent, &s, &record);
	215	trace_seq_do_printf(&s);
	216	printf("\n");
	217	}
	218
da378962 ACM	219	void parse_proc_kallsyms(struct pevent *pevent,
da378962 ACM	220	char *file, unsigned int size __unused)
aaf045f7 SR	221	{
	222	unsigned long long addr;
	223	char *func;
	224	char *line;
	225	char *next = NULL;
	226	char *addr_str;
	227	char *mod;
	228	char ch;
	229
	230	line = strtok_r(file, "\n", &next);
	231	while (line) {
	232	mod = NULL;
	233	sscanf(line, "%as %c %as\t[%as",
	234	(float )(void )&addr_str, /* workaround gcc warning */
	235	&ch, (float )(void )&func, (float )(void )&mod);
	236	addr = strtoull(addr_str, NULL, 16);
	237	free(addr_str);
	238
	239	/* truncate the extra ']' */
	240	if (mod)
	241	mod[strlen(mod) - 1] = 0;
	242
	243	pevent_register_function(pevent, func, addr, mod);
	244	free(func);
	245	free(mod);
	246
	247	line = strtok_r(NULL, "\n", &next);
	248	}
	249	}
	250
da378962 ACM	251	void parse_ftrace_printk(struct pevent *pevent,
da378962 ACM	252	char *file, unsigned int size __unused)
aaf045f7 SR	253	{
	254	unsigned long long addr;
	255	char *printk;
	256	char *line;
	257	char *next = NULL;
	258	char *addr_str;
	259	char *fmt;
	260
	261	line = strtok_r(file, "\n", &next);
	262	while (line) {
	263	addr_str = strtok_r(line, ":", &fmt);
	264	if (!addr_str) {
	265	warning("printk format with empty entry");
	266	break;
	267	}
	268	addr = strtoull(addr_str, NULL, 16);
	269	/* fmt still has a space, skip it */
	270	printk = strdup(fmt+1);
	271	line = strtok_r(NULL, "\n", &next);
	272	pevent_register_print_string(pevent, printk, addr);
	273	}
	274	}
	275
da378962	276	int parse_ftrace_file(struct pevent pevent, char buf, unsigned long size)
aaf045f7 SR	277	{
	278	return pevent_parse_event(pevent, buf, size, "ftrace");
	279	}
	280
da378962 ACM	281	int parse_event_file(struct pevent *pevent,
da378962 ACM	282	char buf, unsigned long size, char sys)
aaf045f7 SR	283	{
	284	return pevent_parse_event(pevent, buf, size, sys);
	285	}
	286
da378962 ACM	287	struct event_format trace_find_next_event(struct pevent pevent,
da378962 ACM	288	struct event_format *event)
aaf045f7 SR	289	{
	290	static int idx;
	291
	292	if (!pevent->events)
	293	return NULL;
	294
	295	if (!event) {
	296	idx = 0;
	297	return pevent->events[0];
	298	}
	299
	300	if (idx < pevent->nr_events && event == pevent->events[idx]) {
	301	idx++;
	302	if (idx == pevent->nr_events)
	303	return NULL;
	304	return pevent->events[idx];
	305	}
	306
	307	for (idx = 1; idx < pevent->nr_events; idx++) {
	308	if (event == pevent->events[idx - 1])
	309	return pevent->events[idx];
	310	}
	311	return NULL;
	312	}
	313
	314	struct flag {
	315	const char *name;
	316	unsigned long long value;
	317	};
	318
	319	static const struct flag flags[] = {
	320	{ "HI_SOFTIRQ", 0 },
	321	{ "TIMER_SOFTIRQ", 1 },
	322	{ "NET_TX_SOFTIRQ", 2 },
	323	{ "NET_RX_SOFTIRQ", 3 },
	324	{ "BLOCK_SOFTIRQ", 4 },
	325	{ "BLOCK_IOPOLL_SOFTIRQ", 5 },
	326	{ "TASKLET_SOFTIRQ", 6 },
	327	{ "SCHED_SOFTIRQ", 7 },
	328	{ "HRTIMER_SOFTIRQ", 8 },
	329	{ "RCU_SOFTIRQ", 9 },
	330
	331	{ "HRTIMER_NORESTART", 0 },
	332	{ "HRTIMER_RESTART", 1 },
	333	};
	334
	335	unsigned long long eval_flag(const char *flag)
	336	{
	337	int i;
	338
	339	/*
	340	* Some flags in the format files do not get converted.
	341	* If the flag is not numeric, see if it is something that
	342	* we already know about.
	343	*/
	344	if (isdigit(flag[0]))
	345	return strtoull(flag, NULL, 0);
	346
	347	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
	348	if (strcmp(flags[i].name, flag) == 0)
	349	return flags[i].value;
	350
	351	return 0;
7397d80d	352	}