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