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