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