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

Archive Download this file



interactive