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