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 *  The parts for function graph printing was taken and modified from the
  22 *  Linux Kernel that were written by Frederic Weisbecker.
  23 */
  24#define _GNU_SOURCE
  25#include <stdio.h>
  26#include <stdlib.h>
  27#include <string.h>
  28#include <ctype.h>
  29#include <errno.h>
  30
  31#undef _GNU_SOURCE
  32#include "../perf.h"
  33#include "util.h"
  34#include "trace-event.h"
  35
  36int header_page_ts_offset;
  37int header_page_ts_size;
  38int header_page_size_offset;
  39int header_page_size_size;
  40int header_page_overwrite_offset;
  41int header_page_overwrite_size;
  42int header_page_data_offset;
  43int header_page_data_size;
  44
  45bool latency_format;
  46
  47static char *input_buf;
  48static unsigned long long input_buf_ptr;
  49static unsigned long long input_buf_siz;
  50
  51static int cpus;
  52static int long_size;
  53static int is_flag_field;
  54static int is_symbolic_field;
  55
  56static struct format_field *
  57find_any_field(struct event *event, const char *name);
  58
  59static void init_input_buf(char *buf, unsigned long long size)
  60{
  61	input_buf = buf;
  62	input_buf_siz = size;
  63	input_buf_ptr = 0;
  64}
  65
  66struct cmdline {
  67	char *comm;
  68	int pid;
  69};
  70
  71static struct cmdline *cmdlines;
  72static int cmdline_count;
  73
  74static int cmdline_cmp(const void *a, const void *b)
  75{
  76	const struct cmdline *ca = a;
  77	const struct cmdline *cb = b;
  78
  79	if (ca->pid < cb->pid)
  80		return -1;
  81	if (ca->pid > cb->pid)
  82		return 1;
  83
  84	return 0;
  85}
  86
  87void parse_cmdlines(char *file, int size __unused)
  88{
  89	struct cmdline_list {
  90		struct cmdline_list	*next;
  91		char			*comm;
  92		int			pid;
  93	} *list = NULL, *item;
  94	char *line;
  95	char *next = NULL;
  96	int i;
  97
  98	line = strtok_r(file, "\n", &next);
  99	while (line) {
 100		item = malloc_or_die(sizeof(*item));
 101		sscanf(line, "%d %as", &item->pid,
 102		       (float *)(void *)&item->comm); /* workaround gcc warning */
 103		item->next = list;
 104		list = item;
 105		line = strtok_r(NULL, "\n", &next);
 106		cmdline_count++;
 107	}
 108
 109	cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count);
 110
 111	i = 0;
 112	while (list) {
 113		cmdlines[i].pid = list->pid;
 114		cmdlines[i].comm = list->comm;
 115		i++;
 116		item = list;
 117		list = list->next;
 118		free(item);
 119	}
 120
 121	qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp);
 122}
 123
 124static struct func_map {
 125	unsigned long long		addr;
 126	char				*func;
 127	char				*mod;
 128} *func_list;
 129static unsigned int func_count;
 130
 131static int func_cmp(const void *a, const void *b)
 132{
 133	const struct func_map *fa = a;
 134	const struct func_map *fb = b;
 135
 136	if (fa->addr < fb->addr)
 137		return -1;
 138	if (fa->addr > fb->addr)
 139		return 1;
 140
 141	return 0;
 142}
 143
 144void parse_proc_kallsyms(char *file, unsigned int size __unused)
 145{
 146	struct func_list {
 147		struct func_list	*next;
 148		unsigned long long	addr;
 149		char			*func;
 150		char			*mod;
 151	} *list = NULL, *item;
 152	char *line;
 153	char *next = NULL;
 154	char *addr_str;
 155	char ch;
 156	int ret __used;
 157	int i;
 158
 159	line = strtok_r(file, "\n", &next);
 160	while (line) {
 161		item = malloc_or_die(sizeof(*item));
 162		item->mod = NULL;
 163		ret = sscanf(line, "%as %c %as\t[%as",
 164			     (float *)(void *)&addr_str, /* workaround gcc warning */
 165			     &ch,
 166			     (float *)(void *)&item->func,
 167			     (float *)(void *)&item->mod);
 168		item->addr = strtoull(addr_str, NULL, 16);
 169		free(addr_str);
 170
 171		/* truncate the extra ']' */
 172		if (item->mod)
 173			item->mod[strlen(item->mod) - 1] = 0;
 174
 175
 176		item->next = list;
 177		list = item;
 178		line = strtok_r(NULL, "\n", &next);
 179		func_count++;
 180	}
 181
 182	func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1));
 183
 184	i = 0;
 185	while (list) {
 186		func_list[i].func = list->func;
 187		func_list[i].addr = list->addr;
 188		func_list[i].mod = list->mod;
 189		i++;
 190		item = list;
 191		list = list->next;
 192		free(item);
 193	}
 194
 195	qsort(func_list, func_count, sizeof(*func_list), func_cmp);
 196
 197	/*
 198	 * Add a special record at the end.
 199	 */
 200	func_list[func_count].func = NULL;
 201	func_list[func_count].addr = 0;
 202	func_list[func_count].mod = NULL;
 203}
 204
 205/*
 206 * We are searching for a record in between, not an exact
 207 * match.
 208 */
 209static int func_bcmp(const void *a, const void *b)
 210{
 211	const struct func_map *fa = a;
 212	const struct func_map *fb = b;
 213
 214	if ((fa->addr == fb->addr) ||
 215
 216	    (fa->addr > fb->addr &&
 217	     fa->addr < (fb+1)->addr))
 218		return 0;
 219
 220	if (fa->addr < fb->addr)
 221		return -1;
 222
 223	return 1;
 224}
 225
 226static struct func_map *find_func(unsigned long long addr)
 227{
 228	struct func_map *func;
 229	struct func_map key;
 230
 231	key.addr = addr;
 232
 233	func = bsearch(&key, func_list, func_count, sizeof(*func_list),
 234		       func_bcmp);
 235
 236	return func;
 237}
 238
 239void print_funcs(void)
 240{
 241	int i;
 242
 243	for (i = 0; i < (int)func_count; i++) {
 244		printf("%016llx %s",
 245		       func_list[i].addr,
 246		       func_list[i].func);
 247		if (func_list[i].mod)
 248			printf(" [%s]\n", func_list[i].mod);
 249		else
 250			printf("\n");
 251	}
 252}
 253
 254static struct printk_map {
 255	unsigned long long		addr;
 256	char				*printk;
 257} *printk_list;
 258static unsigned int printk_count;
 259
 260static int printk_cmp(const void *a, const void *b)
 261{
 262	const struct func_map *fa = a;
 263	const struct func_map *fb = b;
 264
 265	if (fa->addr < fb->addr)
 266		return -1;
 267	if (fa->addr > fb->addr)
 268		return 1;
 269
 270	return 0;
 271}
 272
 273static struct printk_map *find_printk(unsigned long long addr)
 274{
 275	struct printk_map *printk;
 276	struct printk_map key;
 277
 278	key.addr = addr;
 279
 280	printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list),
 281			 printk_cmp);
 282
 283	return printk;
 284}
 285
 286void parse_ftrace_printk(char *file, unsigned int size __unused)
 287{
 288	struct printk_list {
 289		struct printk_list	*next;
 290		unsigned long long	addr;
 291		char			*printk;
 292	} *list = NULL, *item;
 293	char *line;
 294	char *next = NULL;
 295	char *addr_str;
 296	int i;
 297
 298	line = strtok_r(file, "\n", &next);
 299	while (line) {
 300		addr_str = strsep(&line, ":");
 301		if (!line) {
 302			warning("error parsing print strings");
 303			break;
 304		}
 305		item = malloc_or_die(sizeof(*item));
 306		item->addr = strtoull(addr_str, NULL, 16);
 307		/* fmt still has a space, skip it */
 308		item->printk = strdup(line+1);
 309		item->next = list;
 310		list = item;
 311		line = strtok_r(NULL, "\n", &next);
 312		printk_count++;
 313	}
 314
 315	printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1);
 316
 317	i = 0;
 318	while (list) {
 319		printk_list[i].printk = list->printk;
 320		printk_list[i].addr = list->addr;
 321		i++;
 322		item = list;
 323		list = list->next;
 324		free(item);
 325	}
 326
 327	qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp);
 328}
 329
 330void print_printk(void)
 331{
 332	int i;
 333
 334	for (i = 0; i < (int)printk_count; i++) {
 335		printf("%016llx %s\n",
 336		       printk_list[i].addr,
 337		       printk_list[i].printk);
 338	}
 339}
 340
 341static struct event *alloc_event(void)
 342{
 343	struct event *event;
 344
 345	event = malloc_or_die(sizeof(*event));
 346	memset(event, 0, sizeof(*event));
 347
 348	return event;
 349}
 350
 351enum event_type {
 352	EVENT_ERROR,
 353	EVENT_NONE,
 354	EVENT_SPACE,
 355	EVENT_NEWLINE,
 356	EVENT_OP,
 357	EVENT_DELIM,
 358	EVENT_ITEM,
 359	EVENT_DQUOTE,
 360	EVENT_SQUOTE,
 361};
 362
 363static struct event *event_list;
 364
 365static void add_event(struct event *event)
 366{
 367	event->next = event_list;
 368	event_list = event;
 369}
 370
 371static int event_item_type(enum event_type type)
 372{
 373	switch (type) {
 374	case EVENT_ITEM ... EVENT_SQUOTE:
 375		return 1;
 376	case EVENT_ERROR ... EVENT_DELIM:
 377	default:
 378		return 0;
 379	}
 380}
 381
 382static void free_arg(struct print_arg *arg)
 383{
 384	if (!arg)
 385		return;
 386
 387	switch (arg->type) {
 388	case PRINT_ATOM:
 389		if (arg->atom.atom)
 390			free(arg->atom.atom);
 391		break;
 392	case PRINT_NULL:
 393	case PRINT_FIELD ... PRINT_OP:
 394	default:
 395		/* todo */
 396		break;
 397	}
 398
 399	free(arg);
 400}
 401
 402static enum event_type get_type(int ch)
 403{
 404	if (ch == '\n')
 405		return EVENT_NEWLINE;
 406	if (isspace(ch))
 407		return EVENT_SPACE;
 408	if (isalnum(ch) || ch == '_')
 409		return EVENT_ITEM;
 410	if (ch == '\'')
 411		return EVENT_SQUOTE;
 412	if (ch == '"')
 413		return EVENT_DQUOTE;
 414	if (!isprint(ch))
 415		return EVENT_NONE;
 416	if (ch == '(' || ch == ')' || ch == ',')
 417		return EVENT_DELIM;
 418
 419	return EVENT_OP;
 420}
 421
 422static int __read_char(void)
 423{
 424	if (input_buf_ptr >= input_buf_siz)
 425		return -1;
 426
 427	return input_buf[input_buf_ptr++];
 428}
 429
 430static int __peek_char(void)
 431{
 432	if (input_buf_ptr >= input_buf_siz)
 433		return -1;
 434
 435	return input_buf[input_buf_ptr];
 436}
 437
 438static enum event_type __read_token(char **tok)
 439{
 440	char buf[BUFSIZ];
 441	int ch, last_ch, quote_ch, next_ch;
 442	int i = 0;
 443	int tok_size = 0;
 444	enum event_type type;
 445
 446	*tok = NULL;
 447
 448
 449	ch = __read_char();
 450	if (ch < 0)
 451		return EVENT_NONE;
 452
 453	type = get_type(ch);
 454	if (type == EVENT_NONE)
 455		return type;
 456
 457	buf[i++] = ch;
 458
 459	switch (type) {
 460	case EVENT_NEWLINE:
 461	case EVENT_DELIM:
 462		*tok = malloc_or_die(2);
 463		(*tok)[0] = ch;
 464		(*tok)[1] = 0;
 465		return type;
 466
 467	case EVENT_OP:
 468		switch (ch) {
 469		case '-':
 470			next_ch = __peek_char();
 471			if (next_ch == '>') {
 472				buf[i++] = __read_char();
 473				break;
 474			}
 475			/* fall through */
 476		case '+':
 477		case '|':
 478		case '&':
 479		case '>':
 480		case '<':
 481			last_ch = ch;
 482			ch = __peek_char();
 483			if (ch != last_ch)
 484				goto test_equal;
 485			buf[i++] = __read_char();
 486			switch (last_ch) {
 487			case '>':
 488			case '<':
 489				goto test_equal;
 490			default:
 491				break;
 492			}
 493			break;
 494		case '!':
 495		case '=':
 496			goto test_equal;
 497		default: /* what should we do instead? */
 498			break;
 499		}
 500		buf[i] = 0;
 501		*tok = strdup(buf);
 502		return type;
 503
 504 test_equal:
 505		ch = __peek_char();
 506		if (ch == '=')
 507			buf[i++] = __read_char();
 508		break;
 509
 510	case EVENT_DQUOTE:
 511	case EVENT_SQUOTE:
 512		/* don't keep quotes */
 513		i--;
 514		quote_ch = ch;
 515		last_ch = 0;
 516		do {
 517			if (i == (BUFSIZ - 1)) {
 518				buf[i] = 0;
 519				if (*tok) {
 520					*tok = realloc(*tok, tok_size + BUFSIZ);
 521					if (!*tok)
 522						return EVENT_NONE;
 523					strcat(*tok, buf);
 524				} else
 525					*tok = strdup(buf);
 526
 527				if (!*tok)
 528					return EVENT_NONE;
 529				tok_size += BUFSIZ;
 530				i = 0;
 531			}
 532			last_ch = ch;
 533			ch = __read_char();
 534			buf[i++] = ch;
 535			/* the '\' '\' will cancel itself */
 536			if (ch == '\\' && last_ch == '\\')
 537				last_ch = 0;
 538		} while (ch != quote_ch || last_ch == '\\');
 539		/* remove the last quote */
 540		i--;
 541		goto out;
 542
 543	case EVENT_ERROR ... EVENT_SPACE:
 544	case EVENT_ITEM:
 545	default:
 546		break;
 547	}
 548
 549	while (get_type(__peek_char()) == type) {
 550		if (i == (BUFSIZ - 1)) {
 551			buf[i] = 0;
 552			if (*tok) {
 553				*tok = realloc(*tok, tok_size + BUFSIZ);
 554				if (!*tok)
 555					return EVENT_NONE;
 556				strcat(*tok, buf);
 557			} else
 558				*tok = strdup(buf);
 559
 560			if (!*tok)
 561				return EVENT_NONE;
 562			tok_size += BUFSIZ;
 563			i = 0;
 564		}
 565		ch = __read_char();
 566		buf[i++] = ch;
 567	}
 568
 569 out:
 570	buf[i] = 0;
 571	if (*tok) {
 572		*tok = realloc(*tok, tok_size + i);
 573		if (!*tok)
 574			return EVENT_NONE;
 575		strcat(*tok, buf);
 576	} else
 577		*tok = strdup(buf);
 578	if (!*tok)
 579		return EVENT_NONE;
 580
 581	return type;
 582}
 583
 584static void free_token(char *tok)
 585{
 586	if (tok)
 587		free(tok);
 588}
 589
 590static enum event_type read_token(char **tok)
 591{
 592	enum event_type type;
 593
 594	for (;;) {
 595		type = __read_token(tok);
 596		if (type != EVENT_SPACE)
 597			return type;
 598
 599		free_token(*tok);
 600	}
 601
 602	/* not reached */
 603	return EVENT_NONE;
 604}
 605
 606/* no newline */
 607static enum event_type read_token_item(char **tok)
 608{
 609	enum event_type type;
 610
 611	for (;;) {
 612		type = __read_token(tok);
 613		if (type != EVENT_SPACE && type != EVENT_NEWLINE)
 614			return type;
 615
 616		free_token(*tok);
 617	}
 618
 619	/* not reached */
 620	return EVENT_NONE;
 621}
 622
 623static int test_type(enum event_type type, enum event_type expect)
 624{
 625	if (type != expect) {
 626		warning("Error: expected type %d but read %d",
 627		    expect, type);
 628		return -1;
 629	}
 630	return 0;
 631}
 632
 633static int __test_type_token(enum event_type type, char *token,
 634			     enum event_type expect, const char *expect_tok,
 635			     bool warn)
 636{
 637	if (type != expect) {
 638		if (warn)
 639			warning("Error: expected type %d but read %d",
 640				expect, type);
 641		return -1;
 642	}
 643
 644	if (strcmp(token, expect_tok) != 0) {
 645		if (warn)
 646			warning("Error: expected '%s' but read '%s'",
 647				expect_tok, token);
 648		return -1;
 649	}
 650	return 0;
 651}
 652
 653static int test_type_token(enum event_type type, char *token,
 654			   enum event_type expect, const char *expect_tok)
 655{
 656	return __test_type_token(type, token, expect, expect_tok, true);
 657}
 658
 659static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
 660{
 661	enum event_type type;
 662
 663	if (newline_ok)
 664		type = read_token(tok);
 665	else
 666		type = read_token_item(tok);
 667	return test_type(type, expect);
 668}
 669
 670static int read_expect_type(enum event_type expect, char **tok)
 671{
 672	return __read_expect_type(expect, tok, 1);
 673}
 674
 675static int __read_expected(enum event_type expect, const char *str,
 676			   int newline_ok, bool warn)
 677{
 678	enum event_type type;
 679	char *token;
 680	int ret;
 681
 682	if (newline_ok)
 683		type = read_token(&token);
 684	else
 685		type = read_token_item(&token);
 686
 687	ret = __test_type_token(type, token, expect, str, warn);
 688
 689	free_token(token);
 690
 691	return ret;
 692}
 693
 694static int read_expected(enum event_type expect, const char *str)
 695{
 696	return __read_expected(expect, str, 1, true);
 697}
 698
 699static int read_expected_item(enum event_type expect, const char *str)
 700{
 701	return __read_expected(expect, str, 0, true);
 702}
 703
 704static char *event_read_name(void)
 705{
 706	char *token;
 707
 708	if (read_expected(EVENT_ITEM, "name") < 0)
 709		return NULL;
 710
 711	if (read_expected(EVENT_OP, ":") < 0)
 712		return NULL;
 713
 714	if (read_expect_type(EVENT_ITEM, &token) < 0)
 715		goto fail;
 716
 717	return token;
 718
 719 fail:
 720	free_token(token);
 721	return NULL;
 722}
 723
 724static int event_read_id(void)
 725{
 726	char *token;
 727	int id;
 728
 729	if (read_expected_item(EVENT_ITEM, "ID") < 0)
 730		return -1;
 731
 732	if (read_expected(EVENT_OP, ":") < 0)
 
 
 733		return -1;
 734
 735	if (read_expect_type(EVENT_ITEM, &token) < 0)
 736		goto fail;
 737
 738	id = strtoul(token, NULL, 0);
 739	free_token(token);
 740	return id;
 741
 742 fail:
 743	free_token(token);
 744	return -1;
 745}
 746
 747static int field_is_string(struct format_field *field)
 748{
 749	if ((field->flags & FIELD_IS_ARRAY) &&
 750	    (!strstr(field->type, "char") || !strstr(field->type, "u8") ||
 751	     !strstr(field->type, "s8")))
 752		return 1;
 753
 754	return 0;
 755}
 756
 757static int field_is_dynamic(struct format_field *field)
 758{
 759	if (!strncmp(field->type, "__data_loc", 10))
 760		return 1;
 761
 762	return 0;
 763}
 764
 765static int event_read_fields(struct event *event, struct format_field **fields)
 766{
 767	struct format_field *field = NULL;
 768	enum event_type type;
 769	char *token;
 770	char *last_token;
 771	int count = 0;
 772
 773	do {
 774		type = read_token(&token);
 775		if (type == EVENT_NEWLINE) {
 776			free_token(token);
 777			return count;
 778		}
 779
 780		count++;
 781
 782		if (test_type_token(type, token, EVENT_ITEM, "field"))
 783			goto fail;
 784		free_token(token);
 785
 786		type = read_token(&token);
 787		/*
 788		 * The ftrace fields may still use the "special" name.
 789		 * Just ignore it.
 790		 */
 791		if (event->flags & EVENT_FL_ISFTRACE &&
 792		    type == EVENT_ITEM && strcmp(token, "special") == 0) {
 793			free_token(token);
 794			type = read_token(&token);
 795		}
 796
 797		if (test_type_token(type, token, EVENT_OP, ":") < 0)
 798			return -1;
 799
 800		if (read_expect_type(EVENT_ITEM, &token) < 0)
 801			goto fail;
 802
 803		last_token = token;
 804
 805		field = malloc_or_die(sizeof(*field));
 806		memset(field, 0, sizeof(*field));
 807
 808		/* read the rest of the type */
 809		for (;;) {
 810			type = read_token(&token);
 811			if (type == EVENT_ITEM ||
 812			    (type == EVENT_OP && strcmp(token, "*") == 0) ||
 813			    /*
 814			     * Some of the ftrace fields are broken and have
 815			     * an illegal "." in them.
 816			     */
 817			    (event->flags & EVENT_FL_ISFTRACE &&
 818			     type == EVENT_OP && strcmp(token, ".") == 0)) {
 819
 820				if (strcmp(token, "*") == 0)
 821					field->flags |= FIELD_IS_POINTER;
 822
 823				if (field->type) {
 824					field->type = realloc(field->type,
 825							      strlen(field->type) +
 826							      strlen(last_token) + 2);
 827					strcat(field->type, " ");
 828					strcat(field->type, last_token);
 829				} else
 830					field->type = last_token;
 831				last_token = token;
 832				continue;
 833			}
 834
 835			break;
 836		}
 837
 838		if (!field->type) {
 839			die("no type found");
 840			goto fail;
 841		}
 842		field->name = last_token;
 843
 844		if (test_type(type, EVENT_OP))
 845			goto fail;
 846
 847		if (strcmp(token, "[") == 0) {
 848			enum event_type last_type = type;
 849			char *brackets = token;
 850			int len;
 851
 852			field->flags |= FIELD_IS_ARRAY;
 853
 854			type = read_token(&token);
 855		        while (strcmp(token, "]") != 0) {
 856				if (last_type == EVENT_ITEM &&
 857				    type == EVENT_ITEM)
 858					len = 2;
 859				else
 860					len = 1;
 861				last_type = type;
 862
 863				brackets = realloc(brackets,
 864						   strlen(brackets) +
 865						   strlen(token) + len);
 866				if (len == 2)
 867					strcat(brackets, " ");
 868				strcat(brackets, token);
 869				free_token(token);
 870				type = read_token(&token);
 871				if (type == EVENT_NONE) {
 872					die("failed to find token");
 873					goto fail;
 874				}
 875			}
 876
 877			free_token(token);
 878
 879			brackets = realloc(brackets, strlen(brackets) + 2);
 880			strcat(brackets, "]");
 881
 882			/* add brackets to type */
 883
 884			type = read_token(&token);
 885			/*
 886			 * If the next token is not an OP, then it is of
 887			 * the format: type [] item;
 888			 */
 889			if (type == EVENT_ITEM) {
 890				field->type = realloc(field->type,
 891						      strlen(field->type) +
 892						      strlen(field->name) +
 893						      strlen(brackets) + 2);
 894				strcat(field->type, " ");
 895				strcat(field->type, field->name);
 896				free_token(field->name);
 897				strcat(field->type, brackets);
 898				field->name = token;
 899				type = read_token(&token);
 900			} else {
 901				field->type = realloc(field->type,
 902						      strlen(field->type) +
 903						      strlen(brackets) + 1);
 904				strcat(field->type, brackets);
 905			}
 906			free(brackets);
 907		}
 908
 909		if (field_is_string(field)) {
 910			field->flags |= FIELD_IS_STRING;
 911			if (field_is_dynamic(field))
 912				field->flags |= FIELD_IS_DYNAMIC;
 913		}
 914
 915		if (test_type_token(type, token,  EVENT_OP, ";"))
 916			goto fail;
 917		free_token(token);
 918
 919		if (read_expected(EVENT_ITEM, "offset") < 0)
 920			goto fail_expect;
 921
 922		if (read_expected(EVENT_OP, ":") < 0)
 923			goto fail_expect;
 924
 925		if (read_expect_type(EVENT_ITEM, &token))
 926			goto fail;
 927		field->offset = strtoul(token, NULL, 0);
 928		free_token(token);
 929
 930		if (read_expected(EVENT_OP, ";") < 0)
 931			goto fail_expect;
 932
 933		if (read_expected(EVENT_ITEM, "size") < 0)
 934			goto fail_expect;
 935
 936		if (read_expected(EVENT_OP, ":") < 0)
 937			goto fail_expect;
 938
 939		if (read_expect_type(EVENT_ITEM, &token))
 940			goto fail;
 941		field->size = strtoul(token, NULL, 0);
 942		free_token(token);
 943
 944		if (read_expected(EVENT_OP, ";") < 0)
 945			goto fail_expect;
 946
 947		type = read_token(&token);
 948		if (type != EVENT_NEWLINE) {
 949			/* newer versions of the kernel have a "signed" type */
 950			if (test_type_token(type, token, EVENT_ITEM, "signed"))
 951				goto fail;
 952
 953			free_token(token);
 954
 955			if (read_expected(EVENT_OP, ":") < 0)
 956				goto fail_expect;
 957
 958			if (read_expect_type(EVENT_ITEM, &token))
 959				goto fail;
 960
 961			if (strtoul(token, NULL, 0))
 962				field->flags |= FIELD_IS_SIGNED;
 963
 964			free_token(token);
 965			if (read_expected(EVENT_OP, ";") < 0)
 966				goto fail_expect;
 967
 968			if (read_expect_type(EVENT_NEWLINE, &token))
 969				goto fail;
 970		}
 971
 972		free_token(token);
 973
 974		*fields = field;
 975		fields = &field->next;
 976
 977	} while (1);
 978
 979	return 0;
 980
 981fail:
 982	free_token(token);
 983fail_expect:
 984	if (field)
 985		free(field);
 986	return -1;
 987}
 988
 989static int event_read_format(struct event *event)
 990{
 991	char *token;
 
 992	int ret;
 993
 994	if (read_expected_item(EVENT_ITEM, "format") < 0)
 995		return -1;
 996
 997	if (read_expected(EVENT_OP, ":") < 0)
 998		return -1;
 999
1000	if (read_expect_type(EVENT_NEWLINE, &token))
1001		goto fail;
1002	free_token(token);
1003
1004	ret = event_read_fields(event, &event->format.common_fields);
1005	if (ret < 0)
1006		return ret;
1007	event->format.nr_common = ret;
1008
1009	ret = event_read_fields(event, &event->format.fields);
1010	if (ret < 0)
1011		return ret;
1012	event->format.nr_fields = ret;
1013
1014	return 0;
1015
1016 fail:
1017	free_token(token);
1018	return -1;
1019}
1020
1021enum event_type
1022process_arg_token(struct event *event, struct print_arg *arg,
1023		  char **tok, enum event_type type);
1024
1025static enum event_type
1026process_arg(struct event *event, struct print_arg *arg, char **tok)
1027{
1028	enum event_type type;
1029	char *token;
1030
1031	type = read_token(&token);
1032	*tok = token;
1033
1034	return process_arg_token(event, arg, tok, type);
1035}
1036
1037static enum event_type
1038process_cond(struct event *event, struct print_arg *top, char **tok)
1039{
1040	struct print_arg *arg, *left, *right;
1041	enum event_type type;
1042	char *token = NULL;
1043
1044	arg = malloc_or_die(sizeof(*arg));
1045	memset(arg, 0, sizeof(*arg));
1046
1047	left = malloc_or_die(sizeof(*left));
1048
1049	right = malloc_or_die(sizeof(*right));
1050
1051	arg->type = PRINT_OP;
1052	arg->op.left = left;
1053	arg->op.right = right;
1054
1055	*tok = NULL;
1056	type = process_arg(event, left, &token);
1057	if (test_type_token(type, token, EVENT_OP, ":"))
1058		goto out_free;
1059
1060	arg->op.op = token;
1061
1062	type = process_arg(event, right, &token);
1063
1064	top->op.right = arg;
1065
1066	*tok = token;
1067	return type;
1068
1069out_free:
1070	free_token(*tok);
1071	free(right);
1072	free(left);
1073	free_arg(arg);
1074	return EVENT_ERROR;
1075}
1076
1077static enum event_type
1078process_array(struct event *event, struct print_arg *top, char **tok)
1079{
1080	struct print_arg *arg;
1081	enum event_type type;
1082	char *token = NULL;
1083
1084	arg = malloc_or_die(sizeof(*arg));
1085	memset(arg, 0, sizeof(*arg));
1086
1087	*tok = NULL;
1088	type = process_arg(event, arg, &token);
1089	if (test_type_token(type, token, EVENT_OP, "]"))
1090		goto out_free;
1091
1092	top->op.right = arg;
1093
1094	free_token(token);
1095	type = read_token_item(&token);
1096	*tok = token;
1097
1098	return type;
1099
1100out_free:
1101	free_token(*tok);
1102	free_arg(arg);
1103	return EVENT_ERROR;
1104}
1105
1106static int get_op_prio(char *op)
1107{
1108	if (!op[1]) {
1109		switch (op[0]) {
1110		case '*':
1111		case '/':
1112		case '%':
1113			return 6;
1114		case '+':
1115		case '-':
1116			return 7;
1117			/* '>>' and '<<' are 8 */
1118		case '<':
1119		case '>':
1120			return 9;
1121			/* '==' and '!=' are 10 */
1122		case '&':
1123			return 11;
1124		case '^':
1125			return 12;
1126		case '|':
1127			return 13;
1128		case '?':
1129			return 16;
1130		default:
1131			die("unknown op '%c'", op[0]);
1132			return -1;
1133		}
1134	} else {
1135		if (strcmp(op, "++") == 0 ||
1136		    strcmp(op, "--") == 0) {
1137			return 3;
1138		} else if (strcmp(op, ">>") == 0 ||
1139			   strcmp(op, "<<") == 0) {
1140			return 8;
1141		} else if (strcmp(op, ">=") == 0 ||
1142			   strcmp(op, "<=") == 0) {
1143			return 9;
1144		} else if (strcmp(op, "==") == 0 ||
1145			   strcmp(op, "!=") == 0) {
1146			return 10;
1147		} else if (strcmp(op, "&&") == 0) {
1148			return 14;
1149		} else if (strcmp(op, "||") == 0) {
1150			return 15;
1151		} else {
1152			die("unknown op '%s'", op);
1153			return -1;
1154		}
1155	}
1156}
1157
1158static void set_op_prio(struct print_arg *arg)
1159{
1160
1161	/* single ops are the greatest */
1162	if (!arg->op.left || arg->op.left->type == PRINT_NULL) {
1163		arg->op.prio = 0;
1164		return;
1165	}
1166
1167	arg->op.prio = get_op_prio(arg->op.op);
1168}
1169
1170static enum event_type
1171process_op(struct event *event, struct print_arg *arg, char **tok)
1172{
1173	struct print_arg *left, *right = NULL;
1174	enum event_type type;
1175	char *token;
1176
1177	/* the op is passed in via tok */
1178	token = *tok;
1179
1180	if (arg->type == PRINT_OP && !arg->op.left) {
1181		/* handle single op */
1182		if (token[1]) {
1183			die("bad op token %s", token);
1184			return EVENT_ERROR;
1185		}
1186		switch (token[0]) {
1187		case '!':
1188		case '+':
1189		case '-':
1190			break;
1191		default:
1192			die("bad op token %s", token);
1193			return EVENT_ERROR;
1194		}
1195
1196		/* make an empty left */
1197		left = malloc_or_die(sizeof(*left));
1198		left->type = PRINT_NULL;
1199		arg->op.left = left;
1200
1201		right = malloc_or_die(sizeof(*right));
1202		arg->op.right = right;
1203
1204		type = process_arg(event, right, tok);
1205
1206	} else if (strcmp(token, "?") == 0) {
1207
1208		left = malloc_or_die(sizeof(*left));
1209		/* copy the top arg to the left */
1210		*left = *arg;
1211
1212		arg->type = PRINT_OP;
1213		arg->op.op = token;
1214		arg->op.left = left;
1215		arg->op.prio = 0;
1216
1217		type = process_cond(event, arg, tok);
1218
1219	} else if (strcmp(token, ">>") == 0 ||
1220		   strcmp(token, "<<") == 0 ||
1221		   strcmp(token, "&") == 0 ||
1222		   strcmp(token, "|") == 0 ||
1223		   strcmp(token, "&&") == 0 ||
1224		   strcmp(token, "||") == 0 ||
1225		   strcmp(token, "-") == 0 ||
1226		   strcmp(token, "+") == 0 ||
1227		   strcmp(token, "*") == 0 ||
1228		   strcmp(token, "^") == 0 ||
1229		   strcmp(token, "/") == 0 ||
1230		   strcmp(token, "<") == 0 ||
1231		   strcmp(token, ">") == 0 ||
1232		   strcmp(token, "==") == 0 ||
1233		   strcmp(token, "!=") == 0) {
1234
1235		left = malloc_or_die(sizeof(*left));
1236
1237		/* copy the top arg to the left */
1238		*left = *arg;
1239
1240		arg->type = PRINT_OP;
1241		arg->op.op = token;
1242		arg->op.left = left;
1243
1244		set_op_prio(arg);
1245
1246		right = malloc_or_die(sizeof(*right));
1247
1248		type = read_token_item(&token);
1249		*tok = token;
1250
1251		/* could just be a type pointer */
1252		if ((strcmp(arg->op.op, "*") == 0) &&
1253		    type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
1254			if (left->type != PRINT_ATOM)
1255				die("bad pointer type");
1256			left->atom.atom = realloc(left->atom.atom,
1257					    sizeof(left->atom.atom) + 3);
1258			strcat(left->atom.atom, " *");
1259			*arg = *left;
1260			free(arg);
1261
1262			return type;
1263		}
1264
1265		type = process_arg_token(event, right, tok, type);
1266
1267		arg->op.right = right;
1268
1269	} else if (strcmp(token, "[") == 0) {
1270
1271		left = malloc_or_die(sizeof(*left));
1272		*left = *arg;
1273
1274		arg->type = PRINT_OP;
1275		arg->op.op = token;
1276		arg->op.left = left;
1277
1278		arg->op.prio = 0;
1279		type = process_array(event, arg, tok);
1280
1281	} else {
1282		warning("unknown op '%s'", token);
1283		event->flags |= EVENT_FL_FAILED;
1284		/* the arg is now the left side */
1285		return EVENT_NONE;
1286	}
1287
1288	if (type == EVENT_OP) {
1289		int prio;
1290
1291		/* higher prios need to be closer to the root */
1292		prio = get_op_prio(*tok);
1293
1294		if (prio > arg->op.prio)
1295			return process_op(event, arg, tok);
1296
1297		return process_op(event, right, tok);
1298	}
1299
1300	return type;
1301}
1302
1303static enum event_type
1304process_entry(struct event *event __unused, struct print_arg *arg,
1305	      char **tok)
1306{
1307	enum event_type type;
1308	char *field;
1309	char *token;
1310
1311	if (read_expected(EVENT_OP, "->") < 0)
1312		return EVENT_ERROR;
1313
1314	if (read_expect_type(EVENT_ITEM, &token) < 0)
1315		goto fail;
1316	field = token;
1317
1318	arg->type = PRINT_FIELD;
1319	arg->field.name = field;
1320
1321	if (is_flag_field) {
1322		arg->field.field = find_any_field(event, arg->field.name);
1323		arg->field.field->flags |= FIELD_IS_FLAG;
1324		is_flag_field = 0;
1325	} else if (is_symbolic_field) {
1326		arg->field.field = find_any_field(event, arg->field.name);
1327		arg->field.field->flags |= FIELD_IS_SYMBOLIC;
1328		is_symbolic_field = 0;
1329	}
1330
1331	type = read_token(&token);
1332	*tok = token;
1333
1334	return type;
1335
1336fail:
1337	free_token(token);
1338	return EVENT_ERROR;
1339}
1340
1341static char *arg_eval (struct print_arg *arg);
1342
1343static long long arg_num_eval(struct print_arg *arg)
1344{
1345	long long left, right;
1346	long long val = 0;
1347
1348	switch (arg->type) {
1349	case PRINT_ATOM:
1350		val = strtoll(arg->atom.atom, NULL, 0);
1351		break;
1352	case PRINT_TYPE:
1353		val = arg_num_eval(arg->typecast.item);
1354		break;
1355	case PRINT_OP:
1356		switch (arg->op.op[0]) {
1357		case '|':
1358			left = arg_num_eval(arg->op.left);
1359			right = arg_num_eval(arg->op.right);
1360			if (arg->op.op[1])
1361				val = left || right;
1362			else
1363				val = left | right;
1364			break;
1365		case '&':
1366			left = arg_num_eval(arg->op.left);
1367			right = arg_num_eval(arg->op.right);
1368			if (arg->op.op[1])
1369				val = left && right;
1370			else
1371				val = left & right;
1372			break;
1373		case '<':
1374			left = arg_num_eval(arg->op.left);
1375			right = arg_num_eval(arg->op.right);
1376			switch (arg->op.op[1]) {
1377			case 0:
1378				val = left < right;
1379				break;
1380			case '<':
1381				val = left << right;
1382				break;
1383			case '=':
1384				val = left <= right;
1385				break;
1386			default:
1387				die("unknown op '%s'", arg->op.op);
1388			}
1389			break;
1390		case '>':
1391			left = arg_num_eval(arg->op.left);
1392			right = arg_num_eval(arg->op.right);
1393			switch (arg->op.op[1]) {
1394			case 0:
1395				val = left > right;
1396				break;
1397			case '>':
1398				val = left >> right;
1399				break;
1400			case '=':
1401				val = left >= right;
1402				break;
1403			default:
1404				die("unknown op '%s'", arg->op.op);
1405			}
1406			break;
1407		case '=':
1408			left = arg_num_eval(arg->op.left);
1409			right = arg_num_eval(arg->op.right);
1410
1411			if (arg->op.op[1] != '=')
1412				die("unknown op '%s'", arg->op.op);
1413
1414			val = left == right;
1415			break;
1416		case '!':
1417			left = arg_num_eval(arg->op.left);
1418			right = arg_num_eval(arg->op.right);
1419
1420			switch (arg->op.op[1]) {
1421			case '=':
1422				val = left != right;
1423				break;
1424			default:
1425				die("unknown op '%s'", arg->op.op);
1426			}
1427			break;
1428		default:
1429			die("unknown op '%s'", arg->op.op);
1430		}
1431		break;
1432
1433	case PRINT_NULL:
1434	case PRINT_FIELD ... PRINT_SYMBOL:
1435	case PRINT_STRING:
1436	default:
1437		die("invalid eval type %d", arg->type);
1438
1439	}
1440	return val;
1441}
1442
1443static char *arg_eval (struct print_arg *arg)
1444{
1445	long long val;
1446	static char buf[20];
1447
1448	switch (arg->type) {
1449	case PRINT_ATOM:
1450		return arg->atom.atom;
1451	case PRINT_TYPE:
1452		return arg_eval(arg->typecast.item);
1453	case PRINT_OP:
1454		val = arg_num_eval(arg);
1455		sprintf(buf, "%lld", val);
1456		return buf;
1457
1458	case PRINT_NULL:
1459	case PRINT_FIELD ... PRINT_SYMBOL:
1460	case PRINT_STRING:
1461	default:
1462		die("invalid eval type %d", arg->type);
1463		break;
1464	}
1465
1466	return NULL;
1467}
1468
1469static enum event_type
1470process_fields(struct event *event, struct print_flag_sym **list, char **tok)
1471{
1472	enum event_type type;
1473	struct print_arg *arg = NULL;
1474	struct print_flag_sym *field;
1475	char *token = NULL;
1476	char *value;
1477
1478	do {
1479		free_token(token);
1480		type = read_token_item(&token);
1481		if (test_type_token(type, token, EVENT_OP, "{"))
1482			break;
1483
1484		arg = malloc_or_die(sizeof(*arg));
1485
1486		free_token(token);
1487		type = process_arg(event, arg, &token);
1488		if (test_type_token(type, token, EVENT_DELIM, ","))
1489			goto out_free;
1490
1491		field = malloc_or_die(sizeof(*field));
1492		memset(field, 0, sizeof(*field));
1493
1494		value = arg_eval(arg);
1495		field->value = strdup(value);
1496
1497		free_token(token);
1498		type = process_arg(event, arg, &token);
1499		if (test_type_token(type, token, EVENT_OP, "}"))
1500			goto out_free;
1501
1502		value = arg_eval(arg);
1503		field->str = strdup(value);
1504		free_arg(arg);
1505		arg = NULL;
1506
1507		*list = field;
1508		list = &field->next;
1509
1510		free_token(token);
1511		type = read_token_item(&token);
1512	} while (type == EVENT_DELIM && strcmp(token, ",") == 0);
1513
1514	*tok = token;
1515	return type;
1516
1517out_free:
1518	free_arg(arg);
1519	free_token(token);
1520
1521	return EVENT_ERROR;
1522}
1523
1524static enum event_type
1525process_flags(struct event *event, struct print_arg *arg, char **tok)
1526{
1527	struct print_arg *field;
1528	enum event_type type;
1529	char *token;
1530
1531	memset(arg, 0, sizeof(*arg));
1532	arg->type = PRINT_FLAGS;
1533
1534	if (read_expected_item(EVENT_DELIM, "(") < 0)
1535		return EVENT_ERROR;
1536
1537	field = malloc_or_die(sizeof(*field));
1538
1539	type = process_arg(event, field, &token);
1540	if (test_type_token(type, token, EVENT_DELIM, ","))
1541		goto out_free;
1542
1543	arg->flags.field = field;
1544
1545	type = read_token_item(&token);
1546	if (event_item_type(type)) {
1547		arg->flags.delim = token;
1548		type = read_token_item(&token);
1549	}
1550
1551	if (test_type_token(type, token, EVENT_DELIM, ","))
1552		goto out_free;
1553
1554	type = process_fields(event, &arg->flags.flags, &token);
1555	if (test_type_token(type, token, EVENT_DELIM, ")"))
1556		goto out_free;
1557
1558	free_token(token);
1559	type = read_token_item(tok);
1560	return type;
1561
1562out_free:
1563	free_token(token);
1564	return EVENT_ERROR;
1565}
1566
1567static enum event_type
1568process_symbols(struct event *event, struct print_arg *arg, char **tok)
1569{
1570	struct print_arg *field;
1571	enum event_type type;
1572	char *token;
1573
1574	memset(arg, 0, sizeof(*arg));
1575	arg->type = PRINT_SYMBOL;
1576
1577	if (read_expected_item(EVENT_DELIM, "(") < 0)
1578		return EVENT_ERROR;
1579
1580	field = malloc_or_die(sizeof(*field));
1581
1582	type = process_arg(event, field, &token);
1583	if (test_type_token(type, token, EVENT_DELIM, ","))
1584		goto out_free;
1585
1586	arg->symbol.field = field;
1587
1588	type = process_fields(event, &arg->symbol.symbols, &token);
1589	if (test_type_token(type, token, EVENT_DELIM, ")"))
1590		goto out_free;
1591
1592	free_token(token);
1593	type = read_token_item(tok);
1594	return type;
1595
1596out_free:
1597	free_token(token);
1598	return EVENT_ERROR;
1599}
1600
1601static enum event_type
1602process_paren(struct event *event, struct print_arg *arg, char **tok)
1603{
1604	struct print_arg *item_arg;
1605	enum event_type type;
1606	char *token;
1607
1608	type = process_arg(event, arg, &token);
1609
1610	if (type == EVENT_ERROR)
1611		return EVENT_ERROR;
1612
1613	if (type == EVENT_OP)
1614		type = process_op(event, arg, &token);
1615
1616	if (type == EVENT_ERROR)
1617		return EVENT_ERROR;
1618
1619	if (test_type_token(type, token, EVENT_DELIM, ")")) {
1620		free_token(token);
1621		return EVENT_ERROR;
1622	}
1623
1624	free_token(token);
1625	type = read_token_item(&token);
1626
1627	/*
1628	 * If the next token is an item or another open paren, then
1629	 * this was a typecast.
1630	 */
1631	if (event_item_type(type) ||
1632	    (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
1633
1634		/* make this a typecast and contine */
1635
1636		/* prevous must be an atom */
1637		if (arg->type != PRINT_ATOM)
1638			die("previous needed to be PRINT_ATOM");
1639
1640		item_arg = malloc_or_die(sizeof(*item_arg));
1641
1642		arg->type = PRINT_TYPE;
1643		arg->typecast.type = arg->atom.atom;
1644		arg->typecast.item = item_arg;
1645		type = process_arg_token(event, item_arg, &token, type);
1646
1647	}
1648
1649	*tok = token;
1650	return type;
1651}
1652
1653
1654static enum event_type
1655process_str(struct event *event __unused, struct print_arg *arg, char **tok)
1656{
1657	enum event_type type;
1658	char *token;
1659
1660	if (read_expected(EVENT_DELIM, "(") < 0)
1661		return EVENT_ERROR;
1662
1663	if (read_expect_type(EVENT_ITEM, &token) < 0)
1664		goto fail;
1665
1666	arg->type = PRINT_STRING;
1667	arg->string.string = token;
1668	arg->string.offset = -1;
1669
1670	if (read_expected(EVENT_DELIM, ")") < 0)
1671		return EVENT_ERROR;
1672
1673	type = read_token(&token);
1674	*tok = token;
1675
1676	return type;
1677fail:
1678	free_token(token);
1679	return EVENT_ERROR;
1680}
1681
1682enum event_type
1683process_arg_token(struct event *event, struct print_arg *arg,
1684		  char **tok, enum event_type type)
1685{
1686	char *token;
1687	char *atom;
1688
1689	token = *tok;
1690
1691	switch (type) {
1692	case EVENT_ITEM:
1693		if (strcmp(token, "REC") == 0) {
1694			free_token(token);
1695			type = process_entry(event, arg, &token);
1696		} else if (strcmp(token, "__print_flags") == 0) {
1697			free_token(token);
1698			is_flag_field = 1;
1699			type = process_flags(event, arg, &token);
1700		} else if (strcmp(token, "__print_symbolic") == 0) {
1701			free_token(token);
1702			is_symbolic_field = 1;
1703			type = process_symbols(event, arg, &token);
1704		} else if (strcmp(token, "__get_str") == 0) {
1705			free_token(token);
1706			type = process_str(event, arg, &token);
1707		} else {
1708			atom = token;
1709			/* test the next token */
1710			type = read_token_item(&token);
1711
1712			/* atoms can be more than one token long */
1713			while (type == EVENT_ITEM) {
1714				atom = realloc(atom, strlen(atom) + strlen(token) + 2);
1715				strcat(atom, " ");
1716				strcat(atom, token);
1717				free_token(token);
1718				type = read_token_item(&token);
1719			}
1720
1721			/* todo, test for function */
1722
1723			arg->type = PRINT_ATOM;
1724			arg->atom.atom = atom;
1725		}
1726		break;
1727	case EVENT_DQUOTE:
1728	case EVENT_SQUOTE:
1729		arg->type = PRINT_ATOM;
1730		arg->atom.atom = token;
1731		type = read_token_item(&token);
1732		break;
1733	case EVENT_DELIM:
1734		if (strcmp(token, "(") == 0) {
1735			free_token(token);
1736			type = process_paren(event, arg, &token);
1737			break;
1738		}
1739	case EVENT_OP:
1740		/* handle single ops */
1741		arg->type = PRINT_OP;
1742		arg->op.op = token;
1743		arg->op.left = NULL;
1744		type = process_op(event, arg, &token);
1745
1746		break;
1747
1748	case EVENT_ERROR ... EVENT_NEWLINE:
1749	default:
1750		die("unexpected type %d", type);
1751	}
1752	*tok = token;
1753
1754	return type;
1755}
1756
1757static int event_read_print_args(struct event *event, struct print_arg **list)
1758{
1759	enum event_type type = EVENT_ERROR;
1760	struct print_arg *arg;
1761	char *token;
1762	int args = 0;
1763
1764	do {
1765		if (type == EVENT_NEWLINE) {
1766			free_token(token);
1767			type = read_token_item(&token);
1768			continue;
1769		}
1770
1771		arg = malloc_or_die(sizeof(*arg));
1772		memset(arg, 0, sizeof(*arg));
1773
1774		type = process_arg(event, arg, &token);
 
 
 
1775
1776		if (type == EVENT_ERROR) {
1777			free_arg(arg);
1778			return -1;
1779		}
1780
1781		*list = arg;
1782		args++;
1783
1784		if (type == EVENT_OP) {
1785			type = process_op(event, arg, &token);
1786			list = &arg->next;
1787			continue;
1788		}
1789
1790		if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
1791			free_token(token);
1792			*list = arg;
1793			list = &arg->next;
1794			continue;
1795		}
1796		break;
1797	} while (type != EVENT_NONE);
1798
1799	if (type != EVENT_NONE)
1800		free_token(token);
1801
1802	return args;
1803}
1804
1805static int event_read_print(struct event *event)
1806{
1807	enum event_type type;
1808	char *token;
1809	int ret;
1810
1811	if (read_expected_item(EVENT_ITEM, "print") < 0)
1812		return -1;
1813
1814	if (read_expected(EVENT_ITEM, "fmt") < 0)
1815		return -1;
1816
1817	if (read_expected(EVENT_OP, ":") < 0)
1818		return -1;
1819
1820	if (read_expect_type(EVENT_DQUOTE, &token) < 0)
1821		goto fail;
1822
1823 concat:
1824	event->print_fmt.format = token;
1825	event->print_fmt.args = NULL;
1826
1827	/* ok to have no arg */
1828	type = read_token_item(&token);
1829
1830	if (type == EVENT_NONE)
1831		return 0;
1832
1833	/* Handle concatination of print lines */
1834	if (type == EVENT_DQUOTE) {
1835		char *cat;
1836
1837		cat = malloc_or_die(strlen(event->print_fmt.format) +
1838				    strlen(token) + 1);
1839		strcpy(cat, event->print_fmt.format);
1840		strcat(cat, token);
1841		free_token(token);
1842		free_token(event->print_fmt.format);
1843		event->print_fmt.format = NULL;
1844		token = cat;
1845		goto concat;
1846	}
1847
1848	if (test_type_token(type, token, EVENT_DELIM, ","))
1849		goto fail;
1850
1851	free_token(token);
1852
1853	ret = event_read_print_args(event, &event->print_fmt.args);
1854	if (ret < 0)
1855		return -1;
1856
1857	return ret;
1858
1859 fail:
1860	free_token(token);
1861	return -1;
1862}
1863
1864static struct format_field *
1865find_common_field(struct event *event, const char *name)
1866{
1867	struct format_field *format;
1868
1869	for (format = event->format.common_fields;
1870	     format; format = format->next) {
1871		if (strcmp(format->name, name) == 0)
1872			break;
1873	}
1874
1875	return format;
1876}
1877
1878static struct format_field *
1879find_field(struct event *event, const char *name)
1880{
1881	struct format_field *format;
1882
1883	for (format = event->format.fields;
1884	     format; format = format->next) {
1885		if (strcmp(format->name, name) == 0)
1886			break;
1887	}
1888
1889	return format;
1890}
1891
1892static struct format_field *
1893find_any_field(struct event *event, const char *name)
1894{
1895	struct format_field *format;
1896
1897	format = find_common_field(event, name);
1898	if (format)
1899		return format;
1900	return find_field(event, name);
1901}
1902
1903unsigned long long read_size(void *ptr, int size)
1904{
1905	switch (size) {
1906	case 1:
1907		return *(unsigned char *)ptr;
1908	case 2:
1909		return data2host2(ptr);
1910	case 4:
1911		return data2host4(ptr);
1912	case 8:
1913		return data2host8(ptr);
1914	default:
1915		/* BUG! */
1916		return 0;
1917	}
 
1918}
1919
1920unsigned long long
1921raw_field_value(struct event *event, const char *name, void *data)
1922{
1923	struct format_field *field;
1924
1925	field = find_any_field(event, name);
1926	if (!field)
1927		return 0ULL;
1928
1929	return read_size(data + field->offset, field->size);
1930}
1931
1932void *raw_field_ptr(struct event *event, const char *name, void *data)
 
1933{
1934	struct format_field *field;
1935
1936	field = find_any_field(event, name);
1937	if (!field)
1938		return NULL;
1939
1940	if (field->flags & FIELD_IS_DYNAMIC) {
1941		int offset;
1942
1943		offset = *(int *)(data + field->offset);
1944		offset &= 0xffff;
1945
1946		return data + offset;
 
 
 
 
1947	}
1948
1949	return data + field->offset;
1950}
1951
1952static int get_common_info(const char *type, int *offset, int *size)
1953{
1954	struct event *event;
1955	struct format_field *field;
 
 
 
1956
1957	/*
1958	 * All events should have the same common elements.
1959	 * Pick any event to find where the type is;
1960	 */
1961	if (!event_list)
1962		die("no event_list!");
1963
1964	event = event_list;
1965	field = find_common_field(event, type);
1966	if (!field)
1967		die("field '%s' not found", type);
1968
1969	*offset = field->offset;
1970	*size = field->size;
1971
1972	return 0;
1973}
1974
1975static int __parse_common(void *data, int *size, int *offset,
1976			  const char *name)
1977{
1978	int ret;
1979
1980	if (!*size) {
1981		ret = get_common_info(name, offset, size);
1982		if (ret < 0)
1983			return ret;
1984	}
1985	return read_size(data + *offset, *size);
1986}
1987
1988int trace_parse_common_type(void *data)
1989{
1990	static int type_offset;
1991	static int type_size;
1992
1993	return __parse_common(data, &type_size, &type_offset,
1994			      "common_type");
1995}
1996
1997int trace_parse_common_pid(void *data)
1998{
1999	static int pid_offset;
2000	static int pid_size;
2001
2002	return __parse_common(data, &pid_size, &pid_offset,
2003			      "common_pid");
2004}
2005
2006int parse_common_pc(void *data)
2007{
2008	static int pc_offset;
2009	static int pc_size;
2010
2011	return __parse_common(data, &pc_size, &pc_offset,
2012			      "common_preempt_count");
2013}
2014
2015int parse_common_flags(void *data)
2016{
2017	static int flags_offset;
2018	static int flags_size;
2019
2020	return __parse_common(data, &flags_size, &flags_offset,
2021			      "common_flags");
2022}
2023
2024int parse_common_lock_depth(void *data)
 
2025{
2026	static int ld_offset;
2027	static int ld_size;
2028	int ret;
2029
2030	ret = __parse_common(data, &ld_size, &ld_offset,
2031			     "common_lock_depth");
2032	if (ret < 0)
2033		return -1;
2034
2035	return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
2036}
2037
2038struct event *trace_find_event(int id)
 
2039{
2040	struct event *event;
 
 
 
2041
2042	for (event = event_list; event; event = event->next) {
2043		if (event->id == id)
2044			break;
 
 
2045	}
2046	return event;
2047}
2048
2049struct event *trace_find_next_event(struct event *event)
2050{
2051	if (!event)
2052		return event_list;
2053
2054	return event->next;
2055}
2056
2057static unsigned long long eval_num_arg(void *data, int size,
2058				   struct event *event, struct print_arg *arg)
2059{
2060	unsigned long long val = 0;
2061	unsigned long long left, right;
2062	struct print_arg *larg;
2063
2064	switch (arg->type) {
2065	case PRINT_NULL:
2066		/* ?? */
2067		return 0;
2068	case PRINT_ATOM:
2069		return strtoull(arg->atom.atom, NULL, 0);
2070	case PRINT_FIELD:
2071		if (!arg->field.field) {
2072			arg->field.field = find_any_field(event, arg->field.name);
2073			if (!arg->field.field)
2074				die("field %s not found", arg->field.name);
2075		}
2076		/* must be a number */
2077		val = read_size(data + arg->field.field->offset,
2078				arg->field.field->size);
2079		break;
2080	case PRINT_FLAGS:
2081	case PRINT_SYMBOL:
2082		break;
2083	case PRINT_TYPE:
2084		return eval_num_arg(data, size, event, arg->typecast.item);
2085	case PRINT_STRING:
2086		return 0;
2087		break;
2088	case PRINT_OP:
2089		if (strcmp(arg->op.op, "[") == 0) {
2090			/*
2091			 * Arrays are special, since we don't want
2092			 * to read the arg as is.
2093			 */
2094			if (arg->op.left->type != PRINT_FIELD)
2095				goto default_op; /* oops, all bets off */
2096			larg = arg->op.left;
2097			if (!larg->field.field) {
2098				larg->field.field =
2099					find_any_field(event, larg->field.name);
2100				if (!larg->field.field)
2101					die("field %s not found", larg->field.name);
2102			}
2103			right = eval_num_arg(data, size, event, arg->op.right);
2104			val = read_size(data + larg->field.field->offset +
2105					right * long_size, long_size);
2106			break;
2107		}
2108 default_op:
2109		left = eval_num_arg(data, size, event, arg->op.left);
2110		right = eval_num_arg(data, size, event, arg->op.right);
2111		switch (arg->op.op[0]) {
2112		case '|':
2113			if (arg->op.op[1])
2114				val = left || right;
2115			else
2116				val = left | right;
2117			break;
2118		case '&':
2119			if (arg->op.op[1])
2120				val = left && right;
2121			else
2122				val = left & right;
2123			break;
2124		case '<':
2125			switch (arg->op.op[1]) {
2126			case 0:
2127				val = left < right;
2128				break;
2129			case '<':
2130				val = left << right;
2131				break;
2132			case '=':
2133				val = left <= right;
2134				break;
2135			default:
2136				die("unknown op '%s'", arg->op.op);
2137			}
2138			break;
2139		case '>':
2140			switch (arg->op.op[1]) {
2141			case 0:
2142				val = left > right;
2143				break;
2144			case '>':
2145				val = left >> right;
2146				break;
2147			case '=':
2148				val = left >= right;
2149				break;
2150			default:
2151				die("unknown op '%s'", arg->op.op);
2152			}
2153			break;
2154		case '=':
2155			if (arg->op.op[1] != '=')
2156				die("unknown op '%s'", arg->op.op);
2157			val = left == right;
2158			break;
2159		case '-':
2160			val = left - right;
2161			break;
2162		case '+':
2163			val = left + right;
2164			break;
2165		default:
2166			die("unknown op '%s'", arg->op.op);
2167		}
2168		break;
2169	default: /* not sure what to do there */
2170		return 0;
2171	}
2172	return val;
2173}
2174
2175struct flag {
2176	const char *name;
2177	unsigned long long value;
2178};
2179
2180static const struct flag flags[] = {
2181	{ "HI_SOFTIRQ", 0 },
2182	{ "TIMER_SOFTIRQ", 1 },
2183	{ "NET_TX_SOFTIRQ", 2 },
2184	{ "NET_RX_SOFTIRQ", 3 },
2185	{ "BLOCK_SOFTIRQ", 4 },
2186	{ "BLOCK_IOPOLL_SOFTIRQ", 5 },
2187	{ "TASKLET_SOFTIRQ", 6 },
2188	{ "SCHED_SOFTIRQ", 7 },
2189	{ "HRTIMER_SOFTIRQ", 8 },
2190	{ "RCU_SOFTIRQ", 9 },
2191
2192	{ "HRTIMER_NORESTART", 0 },
2193	{ "HRTIMER_RESTART", 1 },
2194};
2195
2196unsigned long long eval_flag(const char *flag)
2197{
2198	int i;
2199
2200	/*
2201	 * Some flags in the format files do not get converted.
2202	 * If the flag is not numeric, see if it is something that
2203	 * we already know about.
2204	 */
2205	if (isdigit(flag[0]))
2206		return strtoull(flag, NULL, 0);
2207
2208	for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
2209		if (strcmp(flags[i].name, flag) == 0)
2210			return flags[i].value;
2211
2212	return 0;
2213}
2214
2215static void print_str_arg(void *data, int size,
2216			  struct event *event, struct print_arg *arg)
2217{
2218	struct print_flag_sym *flag;
2219	unsigned long long val, fval;
2220	char *str;
2221	int print;
2222
2223	switch (arg->type) {
2224	case PRINT_NULL:
2225		/* ?? */
2226		return;
2227	case PRINT_ATOM:
2228		printf("%s", arg->atom.atom);
2229		return;
2230	case PRINT_FIELD:
2231		if (!arg->field.field) {
2232			arg->field.field = find_any_field(event, arg->field.name);
2233			if (!arg->field.field)
2234				die("field %s not found", arg->field.name);
2235		}
2236		str = malloc_or_die(arg->field.field->size + 1);
2237		memcpy(str, data + arg->field.field->offset,
2238		       arg->field.field->size);
2239		str[arg->field.field->size] = 0;
2240		printf("%s", str);
2241		free(str);
2242		break;
2243	case PRINT_FLAGS:
2244		val = eval_num_arg(data, size, event, arg->flags.field);
2245		print = 0;
2246		for (flag = arg->flags.flags; flag; flag = flag->next) {
2247			fval = eval_flag(flag->value);
2248			if (!val && !fval) {
2249				printf("%s", flag->str);
2250				break;
2251			}
2252			if (fval && (val & fval) == fval) {
2253				if (print && arg->flags.delim)
2254					printf("%s", arg->flags.delim);
2255				printf("%s", flag->str);
2256				print = 1;
2257				val &= ~fval;
2258			}
2259		}
2260		break;
2261	case PRINT_SYMBOL:
2262		val = eval_num_arg(data, size, event, arg->symbol.field);
2263		for (flag = arg->symbol.symbols; flag; flag = flag->next) {
2264			fval = eval_flag(flag->value);
2265			if (val == fval) {
2266				printf("%s", flag->str);
2267				break;
2268			}
2269		}
2270		break;
2271
2272	case PRINT_TYPE:
2273		break;
2274	case PRINT_STRING: {
2275		int str_offset;
2276
2277		if (arg->string.offset == -1) {
2278			struct format_field *f;
2279
2280			f = find_any_field(event, arg->string.string);
2281			arg->string.offset = f->offset;
2282		}
2283		str_offset = *(int *)(data + arg->string.offset);
2284		str_offset &= 0xffff;
2285		printf("%s", ((char *)data) + str_offset);
2286		break;
2287	}
2288	case PRINT_OP:
2289		/*
2290		 * The only op for string should be ? :
2291		 */
2292		if (arg->op.op[0] != '?')
2293			return;
2294		val = eval_num_arg(data, size, event, arg->op.left);
2295		if (val)
2296			print_str_arg(data, size, event, arg->op.right->op.left);
2297		else
2298			print_str_arg(data, size, event, arg->op.right->op.right);
2299		break;
2300	default:
2301		/* well... */
2302		break;
2303	}
2304}
2305
2306static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event)
2307{
2308	static struct format_field *field, *ip_field;
2309	struct print_arg *args, *arg, **next;
2310	unsigned long long ip, val;
2311	char *ptr;
2312	void *bptr;
2313
2314	if (!field) {
2315		field = find_field(event, "buf");
2316		if (!field)
2317			die("can't find buffer field for binary printk");
2318		ip_field = find_field(event, "ip");
2319		if (!ip_field)
2320			die("can't find ip field for binary printk");
2321	}
2322
2323	ip = read_size(data + ip_field->offset, ip_field->size);
2324
2325	/*
2326	 * The first arg is the IP pointer.
2327	 */
2328	args = malloc_or_die(sizeof(*args));
2329	arg = args;
2330	arg->next = NULL;
2331	next = &arg->next;
2332
2333	arg->type = PRINT_ATOM;
2334	arg->atom.atom = malloc_or_die(32);
2335	sprintf(arg->atom.atom, "%lld", ip);
2336
2337	/* skip the first "%pf : " */
2338	for (ptr = fmt + 6, bptr = data + field->offset;
2339	     bptr < data + size && *ptr; ptr++) {
2340		int ls = 0;
2341
2342		if (*ptr == '%') {
2343 process_again:
2344			ptr++;
2345			switch (*ptr) {
2346			case '%':
2347				break;
2348			case 'l':
2349				ls++;
2350				goto process_again;
2351			case 'L':
2352				ls = 2;
2353				goto process_again;
2354			case '0' ... '9':
2355				goto process_again;
2356			case 'p':
2357				ls = 1;
2358				/* fall through */
2359			case 'd':
2360			case 'u':
2361			case 'x':
2362			case 'i':
2363				/* the pointers are always 4 bytes aligned */
2364				bptr = (void *)(((unsigned long)bptr + 3) &
2365						~3);
2366				switch (ls) {
2367				case 0:
2368				case 1:
2369					ls = long_size;
2370					break;
2371				case 2:
2372					ls = 8;
2373				default:
2374					break;
2375				}
2376				val = read_size(bptr, ls);
2377				bptr += ls;
2378				arg = malloc_or_die(sizeof(*arg));
2379				arg->next = NULL;
2380				arg->type = PRINT_ATOM;
2381				arg->atom.atom = malloc_or_die(32);
2382				sprintf(arg->atom.atom, "%lld", val);
2383				*next = arg;
2384				next = &arg->next;
2385				break;
2386			case 's':
2387				arg = malloc_or_die(sizeof(*arg));
2388				arg->next = NULL;
2389				arg->type = PRINT_STRING;
2390				arg->string.string = strdup(bptr);
2391				bptr += strlen(bptr) + 1;
2392				*next = arg;
2393				next = &arg->next;
2394			default:
2395				break;
2396			}
2397		}
2398	}
2399
2400	return args;
2401}
2402
2403static void free_args(struct print_arg *args)
2404{
2405	struct print_arg *next;
2406
2407	while (args) {
2408		next = args->next;
2409
2410		if (args->type == PRINT_ATOM)
2411			free(args->atom.atom);
2412		else
2413			free(args->string.string);
2414		free(args);
2415		args = next;
2416	}
2417}
2418
2419static char *get_bprint_format(void *data, int size __unused, struct event *event)
2420{
2421	unsigned long long addr;
2422	static struct format_field *field;
2423	struct printk_map *printk;
2424	char *format;
2425	char *p;
2426
2427	if (!field) {
2428		field = find_field(event, "fmt");
2429		if (!field)
2430			die("can't find format field for binary printk");
2431		printf("field->offset = %d size=%d\n", field->offset, field->size);
2432	}
2433
2434	addr = read_size(data + field->offset, field->size);
2435
2436	printk = find_printk(addr);
2437	if (!printk) {
2438		format = malloc_or_die(45);
2439		sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
2440			addr);
2441		return format;
2442	}
2443
2444	p = printk->printk;
2445	/* Remove any quotes. */
2446	if (*p == '"')
2447		p++;
2448	format = malloc_or_die(strlen(p) + 10);
2449	sprintf(format, "%s : %s", "%pf", p);
2450	/* remove ending quotes and new line since we will add one too */
2451	p = format + strlen(format) - 1;
2452	if (*p == '"')
2453		*p = 0;
2454
2455	p -= 2;
2456	if (strcmp(p, "\\n") == 0)
2457		*p = 0;
2458
2459	return format;
2460}
2461
2462static void pretty_print(void *data, int size, struct event *event)
2463{
2464	struct print_fmt *print_fmt = &event->print_fmt;
2465	struct print_arg *arg = print_fmt->args;
2466	struct print_arg *args = NULL;
2467	const char *ptr = print_fmt->format;
2468	unsigned long long val;
2469	struct func_map *func;
2470	const char *saveptr;
2471	char *bprint_fmt = NULL;
2472	char format[32];
2473	int show_func;
2474	int len;
2475	int ls;
2476
2477	if (event->flags & EVENT_FL_ISFUNC)
2478		ptr = " %pF <-- %pF";
2479
2480	if (event->flags & EVENT_FL_ISBPRINT) {
2481		bprint_fmt = get_bprint_format(data, size, event);
2482		args = make_bprint_args(bprint_fmt, data, size, event);
2483		arg = args;
2484		ptr = bprint_fmt;
2485	}
2486
2487	for (; *ptr; ptr++) {
2488		ls = 0;
2489		if (*ptr == '\\') {
2490			ptr++;
2491			switch (*ptr) {
2492			case 'n':
2493				printf("\n");
2494				break;
2495			case 't':
2496				printf("\t");
2497				break;
2498			case 'r':
2499				printf("\r");
2500				break;
2501			case '\\':
2502				printf("\\");
2503				break;
2504			default:
2505				printf("%c", *ptr);
2506				break;
2507			}
2508
2509		} else if (*ptr == '%') {
2510			saveptr = ptr;
2511			show_func = 0;
2512 cont_process:
2513			ptr++;
2514			switch (*ptr) {
2515			case '%':
2516				printf("%%");
2517				break;
2518			case 'l':
2519				ls++;
2520				goto cont_process;
2521			case 'L':
2522				ls = 2;
2523				goto cont_process;
2524			case 'z':
2525			case 'Z':
2526			case '0' ... '9':
2527				goto cont_process;
2528			case 'p':
2529				if (long_size == 4)
2530					ls = 1;
2531				else
2532					ls = 2;
2533
2534				if (*(ptr+1) == 'F' ||
2535				    *(ptr+1) == 'f') {
2536					ptr++;
2537					show_func = *ptr;
2538				}
2539
2540				/* fall through */
2541			case 'd':
2542			case 'i':
2543			case 'x':
2544			case 'X':
2545			case 'u':
2546				if (!arg)
2547					die("no argument match");
2548
2549				len = ((unsigned long)ptr + 1) -
2550					(unsigned long)saveptr;
2551
2552				/* should never happen */
2553				if (len > 32)
2554					die("bad format!");
2555
2556				memcpy(format, saveptr, len);
2557				format[len] = 0;
2558
2559				val = eval_num_arg(data, size, event, arg);
2560				arg = arg->next;
2561
2562				if (show_func) {
2563					func = find_func(val);
2564					if (func) {
2565						printf("%s", func->func);
2566						if (show_func == 'F')
2567							printf("+0x%llx",
2568							       val - func->addr);
2569						break;
2570					}
2571				}
2572				switch (ls) {
2573				case 0:
2574					printf(format, (int)val);
2575					break;
2576				case 1:
2577					printf(format, (long)val);
2578					break;
2579				case 2:
2580					printf(format, (long long)val);
2581					break;
2582				default:
2583					die("bad count (%d)", ls);
2584				}
2585				break;
2586			case 's':
2587				if (!arg)
2588					die("no matching argument");
2589
2590				print_str_arg(data, size, event, arg);
2591				arg = arg->next;
2592				break;
2593			default:
2594				printf(">%c<", *ptr);
2595
2596			}
2597		} else
2598			printf("%c", *ptr);
2599	}
2600
2601	if (args) {
2602		free_args(args);
2603		free(bprint_fmt);
2604	}
2605}
2606
2607static inline int log10_cpu(int nb)
2608{
2609	if (nb / 100)
2610		return 3;
2611	if (nb / 10)
2612		return 2;
2613	return 1;
2614}
2615
2616static void print_lat_fmt(void *data, int size __unused)
2617{
2618	unsigned int lat_flags;
2619	unsigned int pc;
2620	int lock_depth;
2621	int hardirq;
2622	int softirq;
2623
2624	lat_flags = parse_common_flags(data);
2625	pc = parse_common_pc(data);
2626	lock_depth = parse_common_lock_depth(data);
2627
2628	hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
2629	softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
2630
2631	printf("%c%c%c",
2632	       (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
2633	       (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
2634	       'X' : '.',
2635	       (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
2636	       'N' : '.',
2637	       (hardirq && softirq) ? 'H' :
2638	       hardirq ? 'h' : softirq ? 's' : '.');
2639
2640	if (pc)
2641		printf("%x", pc);
2642	else
2643		printf(".");
2644
2645	if (lock_depth < 0)
2646		printf(". ");
2647	else
2648		printf("%d ", lock_depth);
2649}
2650
2651#define TRACE_GRAPH_INDENT	2
2652
2653static struct record *
2654get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
2655		    struct record *next)
2656{
2657	struct format_field *field;
2658	struct event *event;
2659	unsigned long val;
2660	int type;
2661	int pid;
2662
2663	type = trace_parse_common_type(next->data);
2664	event = trace_find_event(type);
2665	if (!event)
2666		return NULL;
2667
2668	if (!(event->flags & EVENT_FL_ISFUNCRET))
2669		return NULL;
2670
2671	pid = trace_parse_common_pid(next->data);
2672	field = find_field(event, "func");
2673	if (!field)
2674		die("function return does not have field func");
2675
2676	val = read_size(next->data + field->offset, field->size);
2677
2678	if (cur_pid != pid || cur_func != val)
2679		return NULL;
2680
2681	/* this is a leaf, now advance the iterator */
2682	return trace_read_data(cpu);
2683}
2684
2685/* Signal a overhead of time execution to the output */
2686static void print_graph_overhead(unsigned long long duration)
2687{
2688	/* Non nested entry or return */
2689	if (duration == ~0ULL)
2690		return (void)printf("  ");
2691
2692	/* Duration exceeded 100 msecs */
2693	if (duration > 100000ULL)
2694		return (void)printf("! ");
2695
2696	/* Duration exceeded 10 msecs */
2697	if (duration > 10000ULL)
2698		return (void)printf("+ ");
2699
2700	printf("  ");
2701}
2702
2703static void print_graph_duration(unsigned long long duration)
2704{
2705	unsigned long usecs = duration / 1000;
2706	unsigned long nsecs_rem = duration % 1000;
2707	/* log10(ULONG_MAX) + '\0' */
2708	char msecs_str[21];
2709	char nsecs_str[5];
2710	int len;
2711	int i;
2712
2713	sprintf(msecs_str, "%lu", usecs);
2714
2715	/* Print msecs */
2716	len = printf("%lu", usecs);
2717
2718	/* Print nsecs (we don't want to exceed 7 numbers) */
2719	if (len < 7) {
2720		snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
2721		len += printf(".%s", nsecs_str);
2722	}
2723
2724	printf(" us ");
2725
2726	/* Print remaining spaces to fit the row's width */
2727	for (i = len; i < 7; i++)
2728		printf(" ");
2729
2730	printf("|  ");
2731}
2732
2733static void
2734print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec)
2735{
2736	unsigned long long rettime, calltime;
2737	unsigned long long duration, depth;
2738	unsigned long long val;
2739	struct format_field *field;
2740	struct func_map *func;
2741	struct event *ret_event;
2742	int type;
2743	int i;
2744
2745	type = trace_parse_common_type(ret_rec->data);
2746	ret_event = trace_find_event(type);
2747
2748	field = find_field(ret_event, "rettime");
2749	if (!field)
2750		die("can't find rettime in return graph");
2751	rettime = read_size(ret_rec->data + field->offset, field->size);
2752
2753	field = find_field(ret_event, "calltime");
2754	if (!field)
2755		die("can't find rettime in return graph");
2756	calltime = read_size(ret_rec->data + field->offset, field->size);
2757
2758	duration = rettime - calltime;
2759
2760	/* Overhead */
2761	print_graph_overhead(duration);
2762
2763	/* Duration */
2764	print_graph_duration(duration);
2765
2766	field = find_field(event, "depth");
2767	if (!field)
2768		die("can't find depth in entry graph");
2769	depth = read_size(data + field->offset, field->size);
2770
2771	/* Function */
2772	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2773		printf(" ");
2774
2775	field = find_field(event, "func");
2776	if (!field)
2777		die("can't find func in entry graph");
2778	val = read_size(data + field->offset, field->size);
2779	func = find_func(val);
2780
2781	if (func)
2782		printf("%s();", func->func);
2783	else
2784		printf("%llx();", val);
2785}
2786
2787static void print_graph_nested(struct event *event, void *data)
2788{
2789	struct format_field *field;
2790	unsigned long long depth;
2791	unsigned long long val;
2792	struct func_map *func;
2793	int i;
2794
2795	/* No overhead */
2796	print_graph_overhead(-1);
2797
2798	/* No time */
2799	printf("           |  ");
2800
2801	field = find_field(event, "depth");
2802	if (!field)
2803		die("can't find depth in entry graph");
2804	depth = read_size(data + field->offset, field->size);
2805
2806	/* Function */
2807	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2808		printf(" ");
2809
2810	field = find_field(event, "func");
2811	if (!field)
2812		die("can't find func in entry graph");
2813	val = read_size(data + field->offset, field->size);
2814	func = find_func(val);
2815
2816	if (func)
2817		printf("%s() {", func->func);
2818	else
2819		printf("%llx() {", val);
2820}
2821
2822static void
2823pretty_print_func_ent(void *data, int size, struct event *event,
2824		      int cpu, int pid)
2825{
2826	struct format_field *field;
2827	struct record *rec;
2828	void *copy_data;
2829	unsigned long val;
2830
2831	if (latency_format) {
2832		print_lat_fmt(data, size);
2833		printf(" | ");
2834	}
2835
2836	field = find_field(event, "func");
2837	if (!field)
2838		die("function entry does not have func field");
2839
2840	val = read_size(data + field->offset, field->size);
2841
2842	/*
2843	 * peek_data may unmap the data pointer. Copy it first.
2844	 */
2845	copy_data = malloc_or_die(size);
2846	memcpy(copy_data, data, size);
2847	data = copy_data;
2848
2849	rec = trace_peek_data(cpu);
2850	if (rec) {
2851		rec = get_return_for_leaf(cpu, pid, val, rec);
2852		if (rec) {
2853			print_graph_entry_leaf(event, data, rec);
2854			goto out_free;
2855		}
2856	}
2857	print_graph_nested(event, data);
2858out_free:
2859	free(data);
2860}
2861
2862static void
2863pretty_print_func_ret(void *data, int size __unused, struct event *event)
2864{
2865	unsigned long long rettime, calltime;
2866	unsigned long long duration, depth;
2867	struct format_field *field;
2868	int i;
2869
2870	if (latency_format) {
2871		print_lat_fmt(data, size);
2872		printf(" | ");
2873	}
2874
2875	field = find_field(event, "rettime");
2876	if (!field)
2877		die("can't find rettime in return graph");
2878	rettime = read_size(data + field->offset, field->size);
2879
2880	field = find_field(event, "calltime");
2881	if (!field)
2882		die("can't find calltime in return graph");
2883	calltime = read_size(data + field->offset, field->size);
2884
2885	duration = rettime - calltime;
2886
2887	/* Overhead */
2888	print_graph_overhead(duration);
2889
2890	/* Duration */
2891	print_graph_duration(duration);
2892
2893	field = find_field(event, "depth");
2894	if (!field)
2895		die("can't find depth in entry graph");
2896	depth = read_size(data + field->offset, field->size);
2897
2898	/* Function */
2899	for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
2900		printf(" ");
2901
2902	printf("}");
2903}
2904
2905static void
2906pretty_print_func_graph(void *data, int size, struct event *event,
2907			int cpu, int pid)
2908{
2909	if (event->flags & EVENT_FL_ISFUNCENT)
2910		pretty_print_func_ent(data, size, event, cpu, pid);
2911	else if (event->flags & EVENT_FL_ISFUNCRET)
2912		pretty_print_func_ret(data, size, event);
2913	printf("\n");
2914}
2915
2916void print_trace_event(int cpu, void *data, int size)
2917{
2918	struct event *event;
2919	int type;
2920	int pid;
2921
2922	type = trace_parse_common_type(data);
2923
2924	event = trace_find_event(type);
2925	if (!event) {
2926		warning("ug! no event found for type %d", type);
2927		return;
2928	}
2929
2930	pid = trace_parse_common_pid(data);
2931
2932	if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
2933		return pretty_print_func_graph(data, size, event, cpu, pid);
2934
2935	if (latency_format)
2936		print_lat_fmt(data, size);
2937
2938	if (event->flags & EVENT_FL_FAILED) {
2939		printf("EVENT '%s' FAILED TO PARSE\n",
2940		       event->name);
2941		return;
2942	}
2943
2944	pretty_print(data, size, event);
2945}
2946
2947static void print_fields(struct print_flag_sym *field)
2948{
2949	printf("{ %s, %s }", field->value, field->str);
2950	if (field->next) {
2951		printf(", ");
2952		print_fields(field->next);
2953	}
2954}
2955
2956static void print_args(struct print_arg *args)
2957{
2958	int print_paren = 1;
2959
2960	switch (args->type) {
2961	case PRINT_NULL:
2962		printf("null");
2963		break;
2964	case PRINT_ATOM:
2965		printf("%s", args->atom.atom);
2966		break;
2967	case PRINT_FIELD:
2968		printf("REC->%s", args->field.name);
2969		break;
2970	case PRINT_FLAGS:
2971		printf("__print_flags(");
2972		print_args(args->flags.field);
2973		printf(", %s, ", args->flags.delim);
2974		print_fields(args->flags.flags);
2975		printf(")");
2976		break;
2977	case PRINT_SYMBOL:
2978		printf("__print_symbolic(");
2979		print_args(args->symbol.field);
2980		printf(", ");
2981		print_fields(args->symbol.symbols);
2982		printf(")");
2983		break;
2984	case PRINT_STRING:
2985		printf("__get_str(%s)", args->string.string);
2986		break;
2987	case PRINT_TYPE:
2988		printf("(%s)", args->typecast.type);
2989		print_args(args->typecast.item);
2990		break;
2991	case PRINT_OP:
2992		if (strcmp(args->op.op, ":") == 0)
2993			print_paren = 0;
2994		if (print_paren)
2995			printf("(");
2996		print_args(args->op.left);
2997		printf(" %s ", args->op.op);
2998		print_args(args->op.right);
2999		if (print_paren)
3000			printf(")");
3001		break;
3002	default:
3003		/* we should warn... */
3004		return;
3005	}
3006	if (args->next) {
3007		printf("\n");
3008		print_args(args->next);
3009	}
3010}
3011
3012int parse_ftrace_file(char *buf, unsigned long size)
3013{
3014	struct format_field *field;
3015	struct print_arg *arg, **list;
3016	struct event *event;
3017	int ret;
3018
3019	init_input_buf(buf, size);
3020
3021	event = alloc_event();
3022	if (!event)
3023		return -ENOMEM;
3024
3025	event->flags |= EVENT_FL_ISFTRACE;
3026
3027	event->name = event_read_name();
3028	if (!event->name)
3029		die("failed to read ftrace event name");
3030
3031	if (strcmp(event->name, "function") == 0)
3032		event->flags |= EVENT_FL_ISFUNC;
3033
3034	else if (strcmp(event->name, "funcgraph_entry") == 0)
3035		event->flags |= EVENT_FL_ISFUNCENT;
3036
3037	else if (strcmp(event->name, "funcgraph_exit") == 0)
3038		event->flags |= EVENT_FL_ISFUNCRET;
3039
3040	else if (strcmp(event->name, "bprint") == 0)
3041		event->flags |= EVENT_FL_ISBPRINT;
3042
3043	event->id = event_read_id();
3044	if (event->id < 0)
3045		die("failed to read ftrace event id");
3046
3047	add_event(event);
3048
3049	ret = event_read_format(event);
3050	if (ret < 0)
3051		die("failed to read ftrace event format");
3052
3053	ret = event_read_print(event);
3054	if (ret < 0)
3055		die("failed to read ftrace event print fmt");
3056
3057	/* New ftrace handles args */
3058	if (ret > 0)
3059		return 0;
3060	/*
3061	 * The arguments for ftrace files are parsed by the fields.
3062	 * Set up the fields as their arguments.
3063	 */
3064	list = &event->print_fmt.args;
3065	for (field = event->format.fields; field; field = field->next) {
3066		arg = malloc_or_die(sizeof(*arg));
3067		memset(arg, 0, sizeof(*arg));
3068		*list = arg;
3069		list = &arg->next;
3070		arg->type = PRINT_FIELD;
3071		arg->field.name = field->name;
3072		arg->field.field = field;
3073	}
3074	return 0;
3075}
3076
3077int parse_event_file(char *buf, unsigned long size, char *sys)
3078{
3079	struct event *event;
3080	int ret;
3081
3082	init_input_buf(buf, size);
3083
3084	event = alloc_event();
3085	if (!event)
3086		return -ENOMEM;
3087
3088	event->name = event_read_name();
3089	if (!event->name)
3090		die("failed to read event name");
3091
3092	event->id = event_read_id();
3093	if (event->id < 0)
3094		die("failed to read event id");
3095
3096	ret = event_read_format(event);
3097	if (ret < 0) {
3098		warning("failed to read event format for %s", event->name);
3099		goto event_failed;
3100	}
3101
3102	ret = event_read_print(event);
3103	if (ret < 0) {
3104		warning("failed to read event print fmt for %s", event->name);
3105		goto event_failed;
3106	}
3107
3108	event->system = strdup(sys);
3109
3110#define PRINT_ARGS 0
3111	if (PRINT_ARGS && event->print_fmt.args)
3112		print_args(event->print_fmt.args);
3113
3114	add_event(event);
3115	return 0;
3116
3117 event_failed:
3118	event->flags |= EVENT_FL_FAILED;
3119	/* still add it even if it failed */
3120	add_event(event);
3121	return -1;
3122}
3123
3124void parse_set_info(int nr_cpus, int long_sz)
3125{
3126	cpus = nr_cpus;
3127	long_size = long_sz;
3128}
3129
3130int common_pc(struct scripting_context *context)
3131{
3132	return parse_common_pc(context->event_data);
3133}
3134
3135int common_flags(struct scripting_context *context)
3136{
3137	return parse_common_flags(context->event_data);
3138}
3139
3140int common_lock_depth(struct scripting_context *context)
3141{
3142	return parse_common_lock_depth(context->event_data);
3143}