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