linux/tools/lib/traceevent/event-parse.c
<<
>>
Prefs
   1// SPDX-License-Identifier: LGPL-2.1
   2/*
   3 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
   4 *
   5 *
   6 *  The parts for function graph printing was taken and modified from the
   7 *  Linux Kernel that were written by
   8 *    - Copyright (C) 2009  Frederic Weisbecker,
   9 *  Frederic Weisbecker gave his permission to relicense the code to
  10 *  the Lesser General Public License.
  11 */
  12#include <inttypes.h>
  13#include <stdio.h>
  14#include <stdlib.h>
  15#include <string.h>
  16#include <stdarg.h>
  17#include <ctype.h>
  18#include <errno.h>
  19#include <stdint.h>
  20#include <limits.h>
  21#include <linux/time64.h>
  22
  23#include <netinet/in.h>
  24#include "event-parse.h"
  25
  26#include "event-parse-local.h"
  27#include "event-utils.h"
  28#include "trace-seq.h"
  29
  30static const char *input_buf;
  31static unsigned long long input_buf_ptr;
  32static unsigned long long input_buf_siz;
  33
  34static int is_flag_field;
  35static int is_symbolic_field;
  36
  37static int show_warning = 1;
  38
  39#define do_warning(fmt, ...)                            \
  40        do {                                            \
  41                if (show_warning)                       \
  42                        warning(fmt, ##__VA_ARGS__);    \
  43        } while (0)
  44
  45#define do_warning_event(event, fmt, ...)                       \
  46        do {                                                    \
  47                if (!show_warning)                              \
  48                        continue;                               \
  49                                                                \
  50                if (event)                                      \
  51                        warning("[%s:%s] " fmt, event->system,  \
  52                                event->name, ##__VA_ARGS__);    \
  53                else                                            \
  54                        warning(fmt, ##__VA_ARGS__);            \
  55        } while (0)
  56
  57static void init_input_buf(const char *buf, unsigned long long size)
  58{
  59        input_buf = buf;
  60        input_buf_siz = size;
  61        input_buf_ptr = 0;
  62}
  63
  64const char *tep_get_input_buf(void)
  65{
  66        return input_buf;
  67}
  68
  69unsigned long long tep_get_input_buf_ptr(void)
  70{
  71        return input_buf_ptr;
  72}
  73
  74struct event_handler {
  75        struct event_handler            *next;
  76        int                             id;
  77        const char                      *sys_name;
  78        const char                      *event_name;
  79        tep_event_handler_func          func;
  80        void                            *context;
  81};
  82
  83struct func_params {
  84        struct func_params      *next;
  85        enum tep_func_arg_type  type;
  86};
  87
  88struct tep_function_handler {
  89        struct tep_function_handler     *next;
  90        enum tep_func_arg_type          ret_type;
  91        char                            *name;
  92        tep_func_handler                func;
  93        struct func_params              *params;
  94        int                             nr_args;
  95};
  96
  97static unsigned long long
  98process_defined_func(struct trace_seq *s, void *data, int size,
  99                     struct tep_event *event, struct tep_print_arg *arg);
 100
 101static void free_func_handle(struct tep_function_handler *func);
 102
 103/**
 104 * tep_buffer_init - init buffer for parsing
 105 * @buf: buffer to parse
 106 * @size: the size of the buffer
 107 *
 108 * For use with tep_read_token(), this initializes the internal
 109 * buffer that tep_read_token() will parse.
 110 */
 111void tep_buffer_init(const char *buf, unsigned long long size)
 112{
 113        init_input_buf(buf, size);
 114}
 115
 116void breakpoint(void)
 117{
 118        static int x;
 119        x++;
 120}
 121
 122struct tep_print_arg *alloc_arg(void)
 123{
 124        return calloc(1, sizeof(struct tep_print_arg));
 125}
 126
 127struct tep_cmdline {
 128        char *comm;
 129        int pid;
 130};
 131
 132static int cmdline_cmp(const void *a, const void *b)
 133{
 134        const struct tep_cmdline *ca = a;
 135        const struct tep_cmdline *cb = b;
 136
 137        if (ca->pid < cb->pid)
 138                return -1;
 139        if (ca->pid > cb->pid)
 140                return 1;
 141
 142        return 0;
 143}
 144
 145/* Looking for where to place the key */
 146static int cmdline_slot_cmp(const void *a, const void *b)
 147{
 148        const struct tep_cmdline *ca = a;
 149        const struct tep_cmdline *cb = b;
 150        const struct tep_cmdline *cb1 = cb + 1;
 151
 152        if (ca->pid < cb->pid)
 153                return -1;
 154
 155        if (ca->pid > cb->pid) {
 156                if (ca->pid <= cb1->pid)
 157                        return 0;
 158                return 1;
 159        }
 160
 161        return 0;
 162}
 163
 164struct cmdline_list {
 165        struct cmdline_list     *next;
 166        char                    *comm;
 167        int                     pid;
 168};
 169
 170static int cmdline_init(struct tep_handle *tep)
 171{
 172        struct cmdline_list *cmdlist = tep->cmdlist;
 173        struct cmdline_list *item;
 174        struct tep_cmdline *cmdlines;
 175        int i;
 176
 177        cmdlines = malloc(sizeof(*cmdlines) * tep->cmdline_count);
 178        if (!cmdlines)
 179                return -1;
 180
 181        i = 0;
 182        while (cmdlist) {
 183                cmdlines[i].pid = cmdlist->pid;
 184                cmdlines[i].comm = cmdlist->comm;
 185                i++;
 186                item = cmdlist;
 187                cmdlist = cmdlist->next;
 188                free(item);
 189        }
 190
 191        qsort(cmdlines, tep->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
 192
 193        tep->cmdlines = cmdlines;
 194        tep->cmdlist = NULL;
 195
 196        return 0;
 197}
 198
 199static const char *find_cmdline(struct tep_handle *tep, int pid)
 200{
 201        const struct tep_cmdline *comm;
 202        struct tep_cmdline key;
 203
 204        if (!pid)
 205                return "<idle>";
 206
 207        if (!tep->cmdlines && cmdline_init(tep))
 208                return "<not enough memory for cmdlines!>";
 209
 210        key.pid = pid;
 211
 212        comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 213                       sizeof(*tep->cmdlines), cmdline_cmp);
 214
 215        if (comm)
 216                return comm->comm;
 217        return "<...>";
 218}
 219
 220/**
 221 * tep_is_pid_registered - return if a pid has a cmdline registered
 222 * @tep: a handle to the trace event parser context
 223 * @pid: The pid to check if it has a cmdline registered with.
 224 *
 225 * Returns true if the pid has a cmdline mapped to it
 226 * false otherwise.
 227 */
 228bool tep_is_pid_registered(struct tep_handle *tep, int pid)
 229{
 230        const struct tep_cmdline *comm;
 231        struct tep_cmdline key;
 232
 233        if (!pid)
 234                return true;
 235
 236        if (!tep->cmdlines && cmdline_init(tep))
 237                return false;
 238
 239        key.pid = pid;
 240
 241        comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 242                       sizeof(*tep->cmdlines), cmdline_cmp);
 243
 244        if (comm)
 245                return true;
 246        return false;
 247}
 248
 249/*
 250 * If the command lines have been converted to an array, then
 251 * we must add this pid. This is much slower than when cmdlines
 252 * are added before the array is initialized.
 253 */
 254static int add_new_comm(struct tep_handle *tep,
 255                        const char *comm, int pid, bool override)
 256{
 257        struct tep_cmdline *cmdlines = tep->cmdlines;
 258        struct tep_cmdline *cmdline;
 259        struct tep_cmdline key;
 260        char *new_comm;
 261        int cnt;
 262
 263        if (!pid)
 264                return 0;
 265
 266        /* avoid duplicates */
 267        key.pid = pid;
 268
 269        cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 270                          sizeof(*tep->cmdlines), cmdline_cmp);
 271        if (cmdline) {
 272                if (!override) {
 273                        errno = EEXIST;
 274                        return -1;
 275                }
 276                new_comm = strdup(comm);
 277                if (!new_comm) {
 278                        errno = ENOMEM;
 279                        return -1;
 280                }
 281                free(cmdline->comm);
 282                cmdline->comm = new_comm;
 283
 284                return 0;
 285        }
 286
 287        cmdlines = realloc(cmdlines, sizeof(*cmdlines) * (tep->cmdline_count + 1));
 288        if (!cmdlines) {
 289                errno = ENOMEM;
 290                return -1;
 291        }
 292        tep->cmdlines = cmdlines;
 293
 294        key.comm = strdup(comm);
 295        if (!key.comm) {
 296                errno = ENOMEM;
 297                return -1;
 298        }
 299
 300        if (!tep->cmdline_count) {
 301                /* no entries yet */
 302                tep->cmdlines[0] = key;
 303                tep->cmdline_count++;
 304                return 0;
 305        }
 306
 307        /* Now find where we want to store the new cmdline */
 308        cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count - 1,
 309                          sizeof(*tep->cmdlines), cmdline_slot_cmp);
 310
 311        cnt = tep->cmdline_count;
 312        if (cmdline) {
 313                /* cmdline points to the one before the spot we want */
 314                cmdline++;
 315                cnt -= cmdline - tep->cmdlines;
 316
 317        } else {
 318                /* The new entry is either before or after the list */
 319                if (key.pid > tep->cmdlines[tep->cmdline_count - 1].pid) {
 320                        tep->cmdlines[tep->cmdline_count++] = key;
 321                        return 0;
 322                }
 323                cmdline = &tep->cmdlines[0];
 324        }
 325        memmove(cmdline + 1, cmdline, (cnt * sizeof(*cmdline)));
 326        *cmdline = key;
 327
 328        tep->cmdline_count++;
 329
 330        return 0;
 331}
 332
 333static int _tep_register_comm(struct tep_handle *tep,
 334                              const char *comm, int pid, bool override)
 335{
 336        struct cmdline_list *item;
 337
 338        if (tep->cmdlines)
 339                return add_new_comm(tep, comm, pid, override);
 340
 341        item = malloc(sizeof(*item));
 342        if (!item)
 343                return -1;
 344
 345        if (comm)
 346                item->comm = strdup(comm);
 347        else
 348                item->comm = strdup("<...>");
 349        if (!item->comm) {
 350                free(item);
 351                return -1;
 352        }
 353        item->pid = pid;
 354        item->next = tep->cmdlist;
 355
 356        tep->cmdlist = item;
 357        tep->cmdline_count++;
 358
 359        return 0;
 360}
 361
 362/**
 363 * tep_register_comm - register a pid / comm mapping
 364 * @tep: a handle to the trace event parser context
 365 * @comm: the command line to register
 366 * @pid: the pid to map the command line to
 367 *
 368 * This adds a mapping to search for command line names with
 369 * a given pid. The comm is duplicated. If a command with the same pid
 370 * already exist, -1 is returned and errno is set to EEXIST
 371 */
 372int tep_register_comm(struct tep_handle *tep, const char *comm, int pid)
 373{
 374        return _tep_register_comm(tep, comm, pid, false);
 375}
 376
 377/**
 378 * tep_override_comm - register a pid / comm mapping
 379 * @tep: a handle to the trace event parser context
 380 * @comm: the command line to register
 381 * @pid: the pid to map the command line to
 382 *
 383 * This adds a mapping to search for command line names with
 384 * a given pid. The comm is duplicated. If a command with the same pid
 385 * already exist, the command string is udapted with the new one
 386 */
 387int tep_override_comm(struct tep_handle *tep, const char *comm, int pid)
 388{
 389        if (!tep->cmdlines && cmdline_init(tep)) {
 390                errno = ENOMEM;
 391                return -1;
 392        }
 393        return _tep_register_comm(tep, comm, pid, true);
 394}
 395
 396struct func_map {
 397        unsigned long long              addr;
 398        char                            *func;
 399        char                            *mod;
 400};
 401
 402struct func_list {
 403        struct func_list        *next;
 404        unsigned long long      addr;
 405        char                    *func;
 406        char                    *mod;
 407};
 408
 409static int func_cmp(const void *a, const void *b)
 410{
 411        const struct func_map *fa = a;
 412        const struct func_map *fb = b;
 413
 414        if (fa->addr < fb->addr)
 415                return -1;
 416        if (fa->addr > fb->addr)
 417                return 1;
 418
 419        return 0;
 420}
 421
 422/*
 423 * We are searching for a record in between, not an exact
 424 * match.
 425 */
 426static int func_bcmp(const void *a, const void *b)
 427{
 428        const struct func_map *fa = a;
 429        const struct func_map *fb = b;
 430
 431        if ((fa->addr == fb->addr) ||
 432
 433            (fa->addr > fb->addr &&
 434             fa->addr < (fb+1)->addr))
 435                return 0;
 436
 437        if (fa->addr < fb->addr)
 438                return -1;
 439
 440        return 1;
 441}
 442
 443static int func_map_init(struct tep_handle *tep)
 444{
 445        struct func_list *funclist;
 446        struct func_list *item;
 447        struct func_map *func_map;
 448        int i;
 449
 450        func_map = malloc(sizeof(*func_map) * (tep->func_count + 1));
 451        if (!func_map)
 452                return -1;
 453
 454        funclist = tep->funclist;
 455
 456        i = 0;
 457        while (funclist) {
 458                func_map[i].func = funclist->func;
 459                func_map[i].addr = funclist->addr;
 460                func_map[i].mod = funclist->mod;
 461                i++;
 462                item = funclist;
 463                funclist = funclist->next;
 464                free(item);
 465        }
 466
 467        qsort(func_map, tep->func_count, sizeof(*func_map), func_cmp);
 468
 469        /*
 470         * Add a special record at the end.
 471         */
 472        func_map[tep->func_count].func = NULL;
 473        func_map[tep->func_count].addr = 0;
 474        func_map[tep->func_count].mod = NULL;
 475
 476        tep->func_map = func_map;
 477        tep->funclist = NULL;
 478
 479        return 0;
 480}
 481
 482static struct func_map *
 483__find_func(struct tep_handle *tep, unsigned long long addr)
 484{
 485        struct func_map *func;
 486        struct func_map key;
 487
 488        if (!tep->func_map)
 489                func_map_init(tep);
 490
 491        key.addr = addr;
 492
 493        func = bsearch(&key, tep->func_map, tep->func_count,
 494                       sizeof(*tep->func_map), func_bcmp);
 495
 496        return func;
 497}
 498
 499struct func_resolver {
 500        tep_func_resolver_t     *func;
 501        void                    *priv;
 502        struct func_map         map;
 503};
 504
 505/**
 506 * tep_set_function_resolver - set an alternative function resolver
 507 * @tep: a handle to the trace event parser context
 508 * @resolver: function to be used
 509 * @priv: resolver function private state.
 510 *
 511 * Some tools may have already a way to resolve kernel functions, allow them to
 512 * keep using it instead of duplicating all the entries inside tep->funclist.
 513 */
 514int tep_set_function_resolver(struct tep_handle *tep,
 515                              tep_func_resolver_t *func, void *priv)
 516{
 517        struct func_resolver *resolver = malloc(sizeof(*resolver));
 518
 519        if (resolver == NULL)
 520                return -1;
 521
 522        resolver->func = func;
 523        resolver->priv = priv;
 524
 525        free(tep->func_resolver);
 526        tep->func_resolver = resolver;
 527
 528        return 0;
 529}
 530
 531/**
 532 * tep_reset_function_resolver - reset alternative function resolver
 533 * @tep: a handle to the trace event parser context
 534 *
 535 * Stop using whatever alternative resolver was set, use the default
 536 * one instead.
 537 */
 538void tep_reset_function_resolver(struct tep_handle *tep)
 539{
 540        free(tep->func_resolver);
 541        tep->func_resolver = NULL;
 542}
 543
 544static struct func_map *
 545find_func(struct tep_handle *tep, unsigned long long addr)
 546{
 547        struct func_map *map;
 548
 549        if (!tep->func_resolver)
 550                return __find_func(tep, addr);
 551
 552        map = &tep->func_resolver->map;
 553        map->mod  = NULL;
 554        map->addr = addr;
 555        map->func = tep->func_resolver->func(tep->func_resolver->priv,
 556                                             &map->addr, &map->mod);
 557        if (map->func == NULL)
 558                return NULL;
 559
 560        return map;
 561}
 562
 563/**
 564 * tep_find_function - find a function by a given address
 565 * @tep: a handle to the trace event parser context
 566 * @addr: the address to find the function with
 567 *
 568 * Returns a pointer to the function stored that has the given
 569 * address. Note, the address does not have to be exact, it
 570 * will select the function that would contain the address.
 571 */
 572const char *tep_find_function(struct tep_handle *tep, unsigned long long addr)
 573{
 574        struct func_map *map;
 575
 576        map = find_func(tep, addr);
 577        if (!map)
 578                return NULL;
 579
 580        return map->func;
 581}
 582
 583/**
 584 * tep_find_function_address - find a function address by a given address
 585 * @tep: a handle to the trace event parser context
 586 * @addr: the address to find the function with
 587 *
 588 * Returns the address the function starts at. This can be used in
 589 * conjunction with tep_find_function to print both the function
 590 * name and the function offset.
 591 */
 592unsigned long long
 593tep_find_function_address(struct tep_handle *tep, unsigned long long addr)
 594{
 595        struct func_map *map;
 596
 597        map = find_func(tep, addr);
 598        if (!map)
 599                return 0;
 600
 601        return map->addr;
 602}
 603
 604/**
 605 * tep_register_function - register a function with a given address
 606 * @tep: a handle to the trace event parser context
 607 * @function: the function name to register
 608 * @addr: the address the function starts at
 609 * @mod: the kernel module the function may be in (NULL for none)
 610 *
 611 * This registers a function name with an address and module.
 612 * The @func passed in is duplicated.
 613 */
 614int tep_register_function(struct tep_handle *tep, char *func,
 615                          unsigned long long addr, char *mod)
 616{
 617        struct func_list *item = malloc(sizeof(*item));
 618
 619        if (!item)
 620                return -1;
 621
 622        item->next = tep->funclist;
 623        item->func = strdup(func);
 624        if (!item->func)
 625                goto out_free;
 626
 627        if (mod) {
 628                item->mod = strdup(mod);
 629                if (!item->mod)
 630                        goto out_free_func;
 631        } else
 632                item->mod = NULL;
 633        item->addr = addr;
 634
 635        tep->funclist = item;
 636        tep->func_count++;
 637
 638        return 0;
 639
 640out_free_func:
 641        free(item->func);
 642        item->func = NULL;
 643out_free:
 644        free(item);
 645        errno = ENOMEM;
 646        return -1;
 647}
 648
 649/**
 650 * tep_print_funcs - print out the stored functions
 651 * @tep: a handle to the trace event parser context
 652 *
 653 * This prints out the stored functions.
 654 */
 655void tep_print_funcs(struct tep_handle *tep)
 656{
 657        int i;
 658
 659        if (!tep->func_map)
 660                func_map_init(tep);
 661
 662        for (i = 0; i < (int)tep->func_count; i++) {
 663                printf("%016llx %s",
 664                       tep->func_map[i].addr,
 665                       tep->func_map[i].func);
 666                if (tep->func_map[i].mod)
 667                        printf(" [%s]\n", tep->func_map[i].mod);
 668                else
 669                        printf("\n");
 670        }
 671}
 672
 673struct printk_map {
 674        unsigned long long              addr;
 675        char                            *printk;
 676};
 677
 678struct printk_list {
 679        struct printk_list      *next;
 680        unsigned long long      addr;
 681        char                    *printk;
 682};
 683
 684static int printk_cmp(const void *a, const void *b)
 685{
 686        const struct printk_map *pa = a;
 687        const struct printk_map *pb = b;
 688
 689        if (pa->addr < pb->addr)
 690                return -1;
 691        if (pa->addr > pb->addr)
 692                return 1;
 693
 694        return 0;
 695}
 696
 697static int printk_map_init(struct tep_handle *tep)
 698{
 699        struct printk_list *printklist;
 700        struct printk_list *item;
 701        struct printk_map *printk_map;
 702        int i;
 703
 704        printk_map = malloc(sizeof(*printk_map) * (tep->printk_count + 1));
 705        if (!printk_map)
 706                return -1;
 707
 708        printklist = tep->printklist;
 709
 710        i = 0;
 711        while (printklist) {
 712                printk_map[i].printk = printklist->printk;
 713                printk_map[i].addr = printklist->addr;
 714                i++;
 715                item = printklist;
 716                printklist = printklist->next;
 717                free(item);
 718        }
 719
 720        qsort(printk_map, tep->printk_count, sizeof(*printk_map), printk_cmp);
 721
 722        tep->printk_map = printk_map;
 723        tep->printklist = NULL;
 724
 725        return 0;
 726}
 727
 728static struct printk_map *
 729find_printk(struct tep_handle *tep, unsigned long long addr)
 730{
 731        struct printk_map *printk;
 732        struct printk_map key;
 733
 734        if (!tep->printk_map && printk_map_init(tep))
 735                return NULL;
 736
 737        key.addr = addr;
 738
 739        printk = bsearch(&key, tep->printk_map, tep->printk_count,
 740                         sizeof(*tep->printk_map), printk_cmp);
 741
 742        return printk;
 743}
 744
 745/**
 746 * tep_register_print_string - register a string by its address
 747 * @tep: a handle to the trace event parser context
 748 * @fmt: the string format to register
 749 * @addr: the address the string was located at
 750 *
 751 * This registers a string by the address it was stored in the kernel.
 752 * The @fmt passed in is duplicated.
 753 */
 754int tep_register_print_string(struct tep_handle *tep, const char *fmt,
 755                              unsigned long long addr)
 756{
 757        struct printk_list *item = malloc(sizeof(*item));
 758        char *p;
 759
 760        if (!item)
 761                return -1;
 762
 763        item->next = tep->printklist;
 764        item->addr = addr;
 765
 766        /* Strip off quotes and '\n' from the end */
 767        if (fmt[0] == '"')
 768                fmt++;
 769        item->printk = strdup(fmt);
 770        if (!item->printk)
 771                goto out_free;
 772
 773        p = item->printk + strlen(item->printk) - 1;
 774        if (*p == '"')
 775                *p = 0;
 776
 777        p -= 2;
 778        if (strcmp(p, "\\n") == 0)
 779                *p = 0;
 780
 781        tep->printklist = item;
 782        tep->printk_count++;
 783
 784        return 0;
 785
 786out_free:
 787        free(item);
 788        errno = ENOMEM;
 789        return -1;
 790}
 791
 792/**
 793 * tep_print_printk - print out the stored strings
 794 * @tep: a handle to the trace event parser context
 795 *
 796 * This prints the string formats that were stored.
 797 */
 798void tep_print_printk(struct tep_handle *tep)
 799{
 800        int i;
 801
 802        if (!tep->printk_map)
 803                printk_map_init(tep);
 804
 805        for (i = 0; i < (int)tep->printk_count; i++) {
 806                printf("%016llx %s\n",
 807                       tep->printk_map[i].addr,
 808                       tep->printk_map[i].printk);
 809        }
 810}
 811
 812static struct tep_event *alloc_event(void)
 813{
 814        return calloc(1, sizeof(struct tep_event));
 815}
 816
 817static int add_event(struct tep_handle *tep, struct tep_event *event)
 818{
 819        int i;
 820        struct tep_event **events = realloc(tep->events, sizeof(event) *
 821                                            (tep->nr_events + 1));
 822        if (!events)
 823                return -1;
 824
 825        tep->events = events;
 826
 827        for (i = 0; i < tep->nr_events; i++) {
 828                if (tep->events[i]->id > event->id)
 829                        break;
 830        }
 831        if (i < tep->nr_events)
 832                memmove(&tep->events[i + 1],
 833                        &tep->events[i],
 834                        sizeof(event) * (tep->nr_events - i));
 835
 836        tep->events[i] = event;
 837        tep->nr_events++;
 838
 839        event->tep = tep;
 840
 841        return 0;
 842}
 843
 844static int event_item_type(enum tep_event_type type)
 845{
 846        switch (type) {
 847        case TEP_EVENT_ITEM ... TEP_EVENT_SQUOTE:
 848                return 1;
 849        case TEP_EVENT_ERROR ... TEP_EVENT_DELIM:
 850        default:
 851                return 0;
 852        }
 853}
 854
 855static void free_flag_sym(struct tep_print_flag_sym *fsym)
 856{
 857        struct tep_print_flag_sym *next;
 858
 859        while (fsym) {
 860                next = fsym->next;
 861                free(fsym->value);
 862                free(fsym->str);
 863                free(fsym);
 864                fsym = next;
 865        }
 866}
 867
 868static void free_arg(struct tep_print_arg *arg)
 869{
 870        struct tep_print_arg *farg;
 871
 872        if (!arg)
 873                return;
 874
 875        switch (arg->type) {
 876        case TEP_PRINT_ATOM:
 877                free(arg->atom.atom);
 878                break;
 879        case TEP_PRINT_FIELD:
 880                free(arg->field.name);
 881                break;
 882        case TEP_PRINT_FLAGS:
 883                free_arg(arg->flags.field);
 884                free(arg->flags.delim);
 885                free_flag_sym(arg->flags.flags);
 886                break;
 887        case TEP_PRINT_SYMBOL:
 888                free_arg(arg->symbol.field);
 889                free_flag_sym(arg->symbol.symbols);
 890                break;
 891        case TEP_PRINT_HEX:
 892        case TEP_PRINT_HEX_STR:
 893                free_arg(arg->hex.field);
 894                free_arg(arg->hex.size);
 895                break;
 896        case TEP_PRINT_INT_ARRAY:
 897                free_arg(arg->int_array.field);
 898                free_arg(arg->int_array.count);
 899                free_arg(arg->int_array.el_size);
 900                break;
 901        case TEP_PRINT_TYPE:
 902                free(arg->typecast.type);
 903                free_arg(arg->typecast.item);
 904                break;
 905        case TEP_PRINT_STRING:
 906        case TEP_PRINT_BSTRING:
 907                free(arg->string.string);
 908                break;
 909        case TEP_PRINT_BITMASK:
 910                free(arg->bitmask.bitmask);
 911                break;
 912        case TEP_PRINT_DYNAMIC_ARRAY:
 913        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
 914                free(arg->dynarray.index);
 915                break;
 916        case TEP_PRINT_OP:
 917                free(arg->op.op);
 918                free_arg(arg->op.left);
 919                free_arg(arg->op.right);
 920                break;
 921        case TEP_PRINT_FUNC:
 922                while (arg->func.args) {
 923                        farg = arg->func.args;
 924                        arg->func.args = farg->next;
 925                        free_arg(farg);
 926                }
 927                break;
 928
 929        case TEP_PRINT_NULL:
 930        default:
 931                break;
 932        }
 933
 934        free(arg);
 935}
 936
 937static enum tep_event_type get_type(int ch)
 938{
 939        if (ch == '\n')
 940                return TEP_EVENT_NEWLINE;
 941        if (isspace(ch))
 942                return TEP_EVENT_SPACE;
 943        if (isalnum(ch) || ch == '_')
 944                return TEP_EVENT_ITEM;
 945        if (ch == '\'')
 946                return TEP_EVENT_SQUOTE;
 947        if (ch == '"')
 948                return TEP_EVENT_DQUOTE;
 949        if (!isprint(ch))
 950                return TEP_EVENT_NONE;
 951        if (ch == '(' || ch == ')' || ch == ',')
 952                return TEP_EVENT_DELIM;
 953
 954        return TEP_EVENT_OP;
 955}
 956
 957static int __read_char(void)
 958{
 959        if (input_buf_ptr >= input_buf_siz)
 960                return -1;
 961
 962        return input_buf[input_buf_ptr++];
 963}
 964
 965static int __peek_char(void)
 966{
 967        if (input_buf_ptr >= input_buf_siz)
 968                return -1;
 969
 970        return input_buf[input_buf_ptr];
 971}
 972
 973/**
 974 * tep_peek_char - peek at the next character that will be read
 975 *
 976 * Returns the next character read, or -1 if end of buffer.
 977 */
 978int tep_peek_char(void)
 979{
 980        return __peek_char();
 981}
 982
 983static int extend_token(char **tok, char *buf, int size)
 984{
 985        char *newtok = realloc(*tok, size);
 986
 987        if (!newtok) {
 988                free(*tok);
 989                *tok = NULL;
 990                return -1;
 991        }
 992
 993        if (!*tok)
 994                strcpy(newtok, buf);
 995        else
 996                strcat(newtok, buf);
 997        *tok = newtok;
 998
 999        return 0;
1000}
1001
1002static enum tep_event_type force_token(const char *str, char **tok);
1003
1004static enum tep_event_type __read_token(char **tok)
1005{
1006        char buf[BUFSIZ];
1007        int ch, last_ch, quote_ch, next_ch;
1008        int i = 0;
1009        int tok_size = 0;
1010        enum tep_event_type type;
1011
1012        *tok = NULL;
1013
1014
1015        ch = __read_char();
1016        if (ch < 0)
1017                return TEP_EVENT_NONE;
1018
1019        type = get_type(ch);
1020        if (type == TEP_EVENT_NONE)
1021                return type;
1022
1023        buf[i++] = ch;
1024
1025        switch (type) {
1026        case TEP_EVENT_NEWLINE:
1027        case TEP_EVENT_DELIM:
1028                if (asprintf(tok, "%c", ch) < 0)
1029                        return TEP_EVENT_ERROR;
1030
1031                return type;
1032
1033        case TEP_EVENT_OP:
1034                switch (ch) {
1035                case '-':
1036                        next_ch = __peek_char();
1037                        if (next_ch == '>') {
1038                                buf[i++] = __read_char();
1039                                break;
1040                        }
1041                        /* fall through */
1042                case '+':
1043                case '|':
1044                case '&':
1045                case '>':
1046                case '<':
1047                        last_ch = ch;
1048                        ch = __peek_char();
1049                        if (ch != last_ch)
1050                                goto test_equal;
1051                        buf[i++] = __read_char();
1052                        switch (last_ch) {
1053                        case '>':
1054                        case '<':
1055                                goto test_equal;
1056                        default:
1057                                break;
1058                        }
1059                        break;
1060                case '!':
1061                case '=':
1062                        goto test_equal;
1063                default: /* what should we do instead? */
1064                        break;
1065                }
1066                buf[i] = 0;
1067                *tok = strdup(buf);
1068                return type;
1069
1070 test_equal:
1071                ch = __peek_char();
1072                if (ch == '=')
1073                        buf[i++] = __read_char();
1074                goto out;
1075
1076        case TEP_EVENT_DQUOTE:
1077        case TEP_EVENT_SQUOTE:
1078                /* don't keep quotes */
1079                i--;
1080                quote_ch = ch;
1081                last_ch = 0;
1082 concat:
1083                do {
1084                        if (i == (BUFSIZ - 1)) {
1085                                buf[i] = 0;
1086                                tok_size += BUFSIZ;
1087
1088                                if (extend_token(tok, buf, tok_size) < 0)
1089                                        return TEP_EVENT_NONE;
1090                                i = 0;
1091                        }
1092                        last_ch = ch;
1093                        ch = __read_char();
1094                        buf[i++] = ch;
1095                        /* the '\' '\' will cancel itself */
1096                        if (ch == '\\' && last_ch == '\\')
1097                                last_ch = 0;
1098                } while (ch != quote_ch || last_ch == '\\');
1099                /* remove the last quote */
1100                i--;
1101
1102                /*
1103                 * For strings (double quotes) check the next token.
1104                 * If it is another string, concatinate the two.
1105                 */
1106                if (type == TEP_EVENT_DQUOTE) {
1107                        unsigned long long save_input_buf_ptr = input_buf_ptr;
1108
1109                        do {
1110                                ch = __read_char();
1111                        } while (isspace(ch));
1112                        if (ch == '"')
1113                                goto concat;
1114                        input_buf_ptr = save_input_buf_ptr;
1115                }
1116
1117                goto out;
1118
1119        case TEP_EVENT_ERROR ... TEP_EVENT_SPACE:
1120        case TEP_EVENT_ITEM:
1121        default:
1122                break;
1123        }
1124
1125        while (get_type(__peek_char()) == type) {
1126                if (i == (BUFSIZ - 1)) {
1127                        buf[i] = 0;
1128                        tok_size += BUFSIZ;
1129
1130                        if (extend_token(tok, buf, tok_size) < 0)
1131                                return TEP_EVENT_NONE;
1132                        i = 0;
1133                }
1134                ch = __read_char();
1135                buf[i++] = ch;
1136        }
1137
1138 out:
1139        buf[i] = 0;
1140        if (extend_token(tok, buf, tok_size + i + 1) < 0)
1141                return TEP_EVENT_NONE;
1142
1143        if (type == TEP_EVENT_ITEM) {
1144                /*
1145                 * Older versions of the kernel has a bug that
1146                 * creates invalid symbols and will break the mac80211
1147                 * parsing. This is a work around to that bug.
1148                 *
1149                 * See Linux kernel commit:
1150                 *  811cb50baf63461ce0bdb234927046131fc7fa8b
1151                 */
1152                if (strcmp(*tok, "LOCAL_PR_FMT") == 0) {
1153                        free(*tok);
1154                        *tok = NULL;
1155                        return force_token("\"%s\" ", tok);
1156                } else if (strcmp(*tok, "STA_PR_FMT") == 0) {
1157                        free(*tok);
1158                        *tok = NULL;
1159                        return force_token("\" sta:%pM\" ", tok);
1160                } else if (strcmp(*tok, "VIF_PR_FMT") == 0) {
1161                        free(*tok);
1162                        *tok = NULL;
1163                        return force_token("\" vif:%p(%d)\" ", tok);
1164                }
1165        }
1166
1167        return type;
1168}
1169
1170static enum tep_event_type force_token(const char *str, char **tok)
1171{
1172        const char *save_input_buf;
1173        unsigned long long save_input_buf_ptr;
1174        unsigned long long save_input_buf_siz;
1175        enum tep_event_type type;
1176        
1177        /* save off the current input pointers */
1178        save_input_buf = input_buf;
1179        save_input_buf_ptr = input_buf_ptr;
1180        save_input_buf_siz = input_buf_siz;
1181
1182        init_input_buf(str, strlen(str));
1183
1184        type = __read_token(tok);
1185
1186        /* reset back to original token */
1187        input_buf = save_input_buf;
1188        input_buf_ptr = save_input_buf_ptr;
1189        input_buf_siz = save_input_buf_siz;
1190
1191        return type;
1192}
1193
1194static void free_token(char *tok)
1195{
1196        if (tok)
1197                free(tok);
1198}
1199
1200static enum tep_event_type read_token(char **tok)
1201{
1202        enum tep_event_type type;
1203
1204        for (;;) {
1205                type = __read_token(tok);
1206                if (type != TEP_EVENT_SPACE)
1207                        return type;
1208
1209                free_token(*tok);
1210        }
1211
1212        /* not reached */
1213        *tok = NULL;
1214        return TEP_EVENT_NONE;
1215}
1216
1217/**
1218 * tep_read_token - access to utilities to use the tep parser
1219 * @tok: The token to return
1220 *
1221 * This will parse tokens from the string given by
1222 * tep_init_data().
1223 *
1224 * Returns the token type.
1225 */
1226enum tep_event_type tep_read_token(char **tok)
1227{
1228        return read_token(tok);
1229}
1230
1231/**
1232 * tep_free_token - free a token returned by tep_read_token
1233 * @token: the token to free
1234 */
1235void tep_free_token(char *token)
1236{
1237        free_token(token);
1238}
1239
1240/* no newline */
1241static enum tep_event_type read_token_item(char **tok)
1242{
1243        enum tep_event_type type;
1244
1245        for (;;) {
1246                type = __read_token(tok);
1247                if (type != TEP_EVENT_SPACE && type != TEP_EVENT_NEWLINE)
1248                        return type;
1249                free_token(*tok);
1250                *tok = NULL;
1251        }
1252
1253        /* not reached */
1254        *tok = NULL;
1255        return TEP_EVENT_NONE;
1256}
1257
1258static int test_type(enum tep_event_type type, enum tep_event_type expect)
1259{
1260        if (type != expect) {
1261                do_warning("Error: expected type %d but read %d",
1262                    expect, type);
1263                return -1;
1264        }
1265        return 0;
1266}
1267
1268static int test_type_token(enum tep_event_type type, const char *token,
1269                    enum tep_event_type expect, const char *expect_tok)
1270{
1271        if (type != expect) {
1272                do_warning("Error: expected type %d but read %d",
1273                    expect, type);
1274                return -1;
1275        }
1276
1277        if (strcmp(token, expect_tok) != 0) {
1278                do_warning("Error: expected '%s' but read '%s'",
1279                    expect_tok, token);
1280                return -1;
1281        }
1282        return 0;
1283}
1284
1285static int __read_expect_type(enum tep_event_type expect, char **tok, int newline_ok)
1286{
1287        enum tep_event_type type;
1288
1289        if (newline_ok)
1290                type = read_token(tok);
1291        else
1292                type = read_token_item(tok);
1293        return test_type(type, expect);
1294}
1295
1296static int read_expect_type(enum tep_event_type expect, char **tok)
1297{
1298        return __read_expect_type(expect, tok, 1);
1299}
1300
1301static int __read_expected(enum tep_event_type expect, const char *str,
1302                           int newline_ok)
1303{
1304        enum tep_event_type type;
1305        char *token;
1306        int ret;
1307
1308        if (newline_ok)
1309                type = read_token(&token);
1310        else
1311                type = read_token_item(&token);
1312
1313        ret = test_type_token(type, token, expect, str);
1314
1315        free_token(token);
1316
1317        return ret;
1318}
1319
1320static int read_expected(enum tep_event_type expect, const char *str)
1321{
1322        return __read_expected(expect, str, 1);
1323}
1324
1325static int read_expected_item(enum tep_event_type expect, const char *str)
1326{
1327        return __read_expected(expect, str, 0);
1328}
1329
1330static char *event_read_name(void)
1331{
1332        char *token;
1333
1334        if (read_expected(TEP_EVENT_ITEM, "name") < 0)
1335                return NULL;
1336
1337        if (read_expected(TEP_EVENT_OP, ":") < 0)
1338                return NULL;
1339
1340        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1341                goto fail;
1342
1343        return token;
1344
1345 fail:
1346        free_token(token);
1347        return NULL;
1348}
1349
1350static int event_read_id(void)
1351{
1352        char *token;
1353        int id;
1354
1355        if (read_expected_item(TEP_EVENT_ITEM, "ID") < 0)
1356                return -1;
1357
1358        if (read_expected(TEP_EVENT_OP, ":") < 0)
1359                return -1;
1360
1361        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1362                goto fail;
1363
1364        id = strtoul(token, NULL, 0);
1365        free_token(token);
1366        return id;
1367
1368 fail:
1369        free_token(token);
1370        return -1;
1371}
1372
1373static int field_is_string(struct tep_format_field *field)
1374{
1375        if ((field->flags & TEP_FIELD_IS_ARRAY) &&
1376            (strstr(field->type, "char") || strstr(field->type, "u8") ||
1377             strstr(field->type, "s8")))
1378                return 1;
1379
1380        return 0;
1381}
1382
1383static int field_is_dynamic(struct tep_format_field *field)
1384{
1385        if (strncmp(field->type, "__data_loc", 10) == 0)
1386                return 1;
1387
1388        return 0;
1389}
1390
1391static int field_is_long(struct tep_format_field *field)
1392{
1393        /* includes long long */
1394        if (strstr(field->type, "long"))
1395                return 1;
1396
1397        return 0;
1398}
1399
1400static unsigned int type_size(const char *name)
1401{
1402        /* This covers all TEP_FIELD_IS_STRING types. */
1403        static struct {
1404                const char *type;
1405                unsigned int size;
1406        } table[] = {
1407                { "u8",   1 },
1408                { "u16",  2 },
1409                { "u32",  4 },
1410                { "u64",  8 },
1411                { "s8",   1 },
1412                { "s16",  2 },
1413                { "s32",  4 },
1414                { "s64",  8 },
1415                { "char", 1 },
1416                { },
1417        };
1418        int i;
1419
1420        for (i = 0; table[i].type; i++) {
1421                if (!strcmp(table[i].type, name))
1422                        return table[i].size;
1423        }
1424
1425        return 0;
1426}
1427
1428static int event_read_fields(struct tep_event *event, struct tep_format_field **fields)
1429{
1430        struct tep_format_field *field = NULL;
1431        enum tep_event_type type;
1432        char *token;
1433        char *last_token;
1434        int count = 0;
1435
1436        do {
1437                unsigned int size_dynamic = 0;
1438
1439                type = read_token(&token);
1440                if (type == TEP_EVENT_NEWLINE) {
1441                        free_token(token);
1442                        return count;
1443                }
1444
1445                count++;
1446
1447                if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
1448                        goto fail;
1449                free_token(token);
1450
1451                type = read_token(&token);
1452                /*
1453                 * The ftrace fields may still use the "special" name.
1454                 * Just ignore it.
1455                 */
1456                if (event->flags & TEP_EVENT_FL_ISFTRACE &&
1457                    type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
1458                        free_token(token);
1459                        type = read_token(&token);
1460                }
1461
1462                if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
1463                        goto fail;
1464
1465                free_token(token);
1466                if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1467                        goto fail;
1468
1469                last_token = token;
1470
1471                field = calloc(1, sizeof(*field));
1472                if (!field)
1473                        goto fail;
1474
1475                field->event = event;
1476
1477                /* read the rest of the type */
1478                for (;;) {
1479                        type = read_token(&token);
1480                        if (type == TEP_EVENT_ITEM ||
1481                            (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
1482                            /*
1483                             * Some of the ftrace fields are broken and have
1484                             * an illegal "." in them.
1485                             */
1486                            (event->flags & TEP_EVENT_FL_ISFTRACE &&
1487                             type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
1488
1489                                if (strcmp(token, "*") == 0)
1490                                        field->flags |= TEP_FIELD_IS_POINTER;
1491
1492                                if (field->type) {
1493                                        char *new_type;
1494                                        new_type = realloc(field->type,
1495                                                           strlen(field->type) +
1496                                                           strlen(last_token) + 2);
1497                                        if (!new_type) {
1498                                                free(last_token);
1499                                                goto fail;
1500                                        }
1501                                        field->type = new_type;
1502                                        strcat(field->type, " ");
1503                                        strcat(field->type, last_token);
1504                                        free(last_token);
1505                                } else
1506                                        field->type = last_token;
1507                                last_token = token;
1508                                continue;
1509                        }
1510
1511                        break;
1512                }
1513
1514                if (!field->type) {
1515                        do_warning_event(event, "%s: no type found", __func__);
1516                        goto fail;
1517                }
1518                field->name = field->alias = last_token;
1519
1520                if (test_type(type, TEP_EVENT_OP))
1521                        goto fail;
1522
1523                if (strcmp(token, "[") == 0) {
1524                        enum tep_event_type last_type = type;
1525                        char *brackets = token;
1526                        char *new_brackets;
1527                        int len;
1528
1529                        field->flags |= TEP_FIELD_IS_ARRAY;
1530
1531                        type = read_token(&token);
1532
1533                        if (type == TEP_EVENT_ITEM)
1534                                field->arraylen = strtoul(token, NULL, 0);
1535                        else
1536                                field->arraylen = 0;
1537
1538                        while (strcmp(token, "]") != 0) {
1539                                if (last_type == TEP_EVENT_ITEM &&
1540                                    type == TEP_EVENT_ITEM)
1541                                        len = 2;
1542                                else
1543                                        len = 1;
1544                                last_type = type;
1545
1546                                new_brackets = realloc(brackets,
1547                                                       strlen(brackets) +
1548                                                       strlen(token) + len);
1549                                if (!new_brackets) {
1550                                        free(brackets);
1551                                        goto fail;
1552                                }
1553                                brackets = new_brackets;
1554                                if (len == 2)
1555                                        strcat(brackets, " ");
1556                                strcat(brackets, token);
1557                                /* We only care about the last token */
1558                                field->arraylen = strtoul(token, NULL, 0);
1559                                free_token(token);
1560                                type = read_token(&token);
1561                                if (type == TEP_EVENT_NONE) {
1562                                        do_warning_event(event, "failed to find token");
1563                                        goto fail;
1564                                }
1565                        }
1566
1567                        free_token(token);
1568
1569                        new_brackets = realloc(brackets, strlen(brackets) + 2);
1570                        if (!new_brackets) {
1571                                free(brackets);
1572                                goto fail;
1573                        }
1574                        brackets = new_brackets;
1575                        strcat(brackets, "]");
1576
1577                        /* add brackets to type */
1578
1579                        type = read_token(&token);
1580                        /*
1581                         * If the next token is not an OP, then it is of
1582                         * the format: type [] item;
1583                         */
1584                        if (type == TEP_EVENT_ITEM) {
1585                                char *new_type;
1586                                new_type = realloc(field->type,
1587                                                   strlen(field->type) +
1588                                                   strlen(field->name) +
1589                                                   strlen(brackets) + 2);
1590                                if (!new_type) {
1591                                        free(brackets);
1592                                        goto fail;
1593                                }
1594                                field->type = new_type;
1595                                strcat(field->type, " ");
1596                                strcat(field->type, field->name);
1597                                size_dynamic = type_size(field->name);
1598                                free_token(field->name);
1599                                strcat(field->type, brackets);
1600                                field->name = field->alias = token;
1601                                type = read_token(&token);
1602                        } else {
1603                                char *new_type;
1604                                new_type = realloc(field->type,
1605                                                   strlen(field->type) +
1606                                                   strlen(brackets) + 1);
1607                                if (!new_type) {
1608                                        free(brackets);
1609                                        goto fail;
1610                                }
1611                                field->type = new_type;
1612                                strcat(field->type, brackets);
1613                        }
1614                        free(brackets);
1615                }
1616
1617                if (field_is_string(field))
1618                        field->flags |= TEP_FIELD_IS_STRING;
1619                if (field_is_dynamic(field))
1620                        field->flags |= TEP_FIELD_IS_DYNAMIC;
1621                if (field_is_long(field))
1622                        field->flags |= TEP_FIELD_IS_LONG;
1623
1624                if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
1625                        goto fail;
1626                free_token(token);
1627
1628                if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
1629                        goto fail_expect;
1630
1631                if (read_expected(TEP_EVENT_OP, ":") < 0)
1632                        goto fail_expect;
1633
1634                if (read_expect_type(TEP_EVENT_ITEM, &token))
1635                        goto fail;
1636                field->offset = strtoul(token, NULL, 0);
1637                free_token(token);
1638
1639                if (read_expected(TEP_EVENT_OP, ";") < 0)
1640                        goto fail_expect;
1641
1642                if (read_expected(TEP_EVENT_ITEM, "size") < 0)
1643                        goto fail_expect;
1644
1645                if (read_expected(TEP_EVENT_OP, ":") < 0)
1646                        goto fail_expect;
1647
1648                if (read_expect_type(TEP_EVENT_ITEM, &token))
1649                        goto fail;
1650                field->size = strtoul(token, NULL, 0);
1651                free_token(token);
1652
1653                if (read_expected(TEP_EVENT_OP, ";") < 0)
1654                        goto fail_expect;
1655
1656                type = read_token(&token);
1657                if (type != TEP_EVENT_NEWLINE) {
1658                        /* newer versions of the kernel have a "signed" type */
1659                        if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
1660                                goto fail;
1661
1662                        free_token(token);
1663
1664                        if (read_expected(TEP_EVENT_OP, ":") < 0)
1665                                goto fail_expect;
1666
1667                        if (read_expect_type(TEP_EVENT_ITEM, &token))
1668                                goto fail;
1669
1670                        if (strtoul(token, NULL, 0))
1671                                field->flags |= TEP_FIELD_IS_SIGNED;
1672
1673                        free_token(token);
1674                        if (read_expected(TEP_EVENT_OP, ";") < 0)
1675                                goto fail_expect;
1676
1677                        if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1678                                goto fail;
1679                }
1680
1681                free_token(token);
1682
1683                if (field->flags & TEP_FIELD_IS_ARRAY) {
1684                        if (field->arraylen)
1685                                field->elementsize = field->size / field->arraylen;
1686                        else if (field->flags & TEP_FIELD_IS_DYNAMIC)
1687                                field->elementsize = size_dynamic;
1688                        else if (field->flags & TEP_FIELD_IS_STRING)
1689                                field->elementsize = 1;
1690                        else if (field->flags & TEP_FIELD_IS_LONG)
1691                                field->elementsize = event->tep ?
1692                                                     event->tep->long_size :
1693                                                     sizeof(long);
1694                } else
1695                        field->elementsize = field->size;
1696
1697                *fields = field;
1698                fields = &field->next;
1699
1700        } while (1);
1701
1702        return 0;
1703
1704fail:
1705        free_token(token);
1706fail_expect:
1707        if (field) {
1708                free(field->type);
1709                free(field->name);
1710                free(field);
1711        }
1712        return -1;
1713}
1714
1715static int event_read_format(struct tep_event *event)
1716{
1717        char *token;
1718        int ret;
1719
1720        if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
1721                return -1;
1722
1723        if (read_expected(TEP_EVENT_OP, ":") < 0)
1724                return -1;
1725
1726        if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1727                goto fail;
1728        free_token(token);
1729
1730        ret = event_read_fields(event, &event->format.common_fields);
1731        if (ret < 0)
1732                return ret;
1733        event->format.nr_common = ret;
1734
1735        ret = event_read_fields(event, &event->format.fields);
1736        if (ret < 0)
1737                return ret;
1738        event->format.nr_fields = ret;
1739
1740        return 0;
1741
1742 fail:
1743        free_token(token);
1744        return -1;
1745}
1746
1747static enum tep_event_type
1748process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
1749                  char **tok, enum tep_event_type type);
1750
1751static enum tep_event_type
1752process_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1753{
1754        enum tep_event_type type;
1755        char *token;
1756
1757        type = read_token(&token);
1758        *tok = token;
1759
1760        return process_arg_token(event, arg, tok, type);
1761}
1762
1763static enum tep_event_type
1764process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok);
1765
1766/*
1767 * For __print_symbolic() and __print_flags, we need to completely
1768 * evaluate the first argument, which defines what to print next.
1769 */
1770static enum tep_event_type
1771process_field_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1772{
1773        enum tep_event_type type;
1774
1775        type = process_arg(event, arg, tok);
1776
1777        while (type == TEP_EVENT_OP) {
1778                type = process_op(event, arg, tok);
1779        }
1780
1781        return type;
1782}
1783
1784static enum tep_event_type
1785process_cond(struct tep_event *event, struct tep_print_arg *top, char **tok)
1786{
1787        struct tep_print_arg *arg, *left, *right;
1788        enum tep_event_type type;
1789        char *token = NULL;
1790
1791        arg = alloc_arg();
1792        left = alloc_arg();
1793        right = alloc_arg();
1794
1795        if (!arg || !left || !right) {
1796                do_warning_event(event, "%s: not enough memory!", __func__);
1797                /* arg will be freed at out_free */
1798                free_arg(left);
1799                free_arg(right);
1800                goto out_free;
1801        }
1802
1803        arg->type = TEP_PRINT_OP;
1804        arg->op.left = left;
1805        arg->op.right = right;
1806
1807        *tok = NULL;
1808        type = process_arg(event, left, &token);
1809
1810 again:
1811        if (type == TEP_EVENT_ERROR)
1812                goto out_free;
1813
1814        /* Handle other operations in the arguments */
1815        if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
1816                type = process_op(event, left, &token);
1817                goto again;
1818        }
1819
1820        if (test_type_token(type, token, TEP_EVENT_OP, ":"))
1821                goto out_free;
1822
1823        arg->op.op = token;
1824
1825        type = process_arg(event, right, &token);
1826
1827        top->op.right = arg;
1828
1829        *tok = token;
1830        return type;
1831
1832out_free:
1833        /* Top may point to itself */
1834        top->op.right = NULL;
1835        free_token(token);
1836        free_arg(arg);
1837        return TEP_EVENT_ERROR;
1838}
1839
1840static enum tep_event_type
1841process_array(struct tep_event *event, struct tep_print_arg *top, char **tok)
1842{
1843        struct tep_print_arg *arg;
1844        enum tep_event_type type;
1845        char *token = NULL;
1846
1847        arg = alloc_arg();
1848        if (!arg) {
1849                do_warning_event(event, "%s: not enough memory!", __func__);
1850                /* '*tok' is set to top->op.op.  No need to free. */
1851                *tok = NULL;
1852                return TEP_EVENT_ERROR;
1853        }
1854
1855        *tok = NULL;
1856        type = process_arg(event, arg, &token);
1857        if (test_type_token(type, token, TEP_EVENT_OP, "]"))
1858                goto out_free;
1859
1860        top->op.right = arg;
1861
1862        free_token(token);
1863        type = read_token_item(&token);
1864        *tok = token;
1865
1866        return type;
1867
1868out_free:
1869        free_token(token);
1870        free_arg(arg);
1871        return TEP_EVENT_ERROR;
1872}
1873
1874static int get_op_prio(char *op)
1875{
1876        if (!op[1]) {
1877                switch (op[0]) {
1878                case '~':
1879                case '!':
1880                        return 4;
1881                case '*':
1882                case '/':
1883                case '%':
1884                        return 6;
1885                case '+':
1886                case '-':
1887                        return 7;
1888                        /* '>>' and '<<' are 8 */
1889                case '<':
1890                case '>':
1891                        return 9;
1892                        /* '==' and '!=' are 10 */
1893                case '&':
1894                        return 11;
1895                case '^':
1896                        return 12;
1897                case '|':
1898                        return 13;
1899                case '?':
1900                        return 16;
1901                default:
1902                        do_warning("unknown op '%c'", op[0]);
1903                        return -1;
1904                }
1905        } else {
1906                if (strcmp(op, "++") == 0 ||
1907                    strcmp(op, "--") == 0) {
1908                        return 3;
1909                } else if (strcmp(op, ">>") == 0 ||
1910                           strcmp(op, "<<") == 0) {
1911                        return 8;
1912                } else if (strcmp(op, ">=") == 0 ||
1913                           strcmp(op, "<=") == 0) {
1914                        return 9;
1915                } else if (strcmp(op, "==") == 0 ||
1916                           strcmp(op, "!=") == 0) {
1917                        return 10;
1918                } else if (strcmp(op, "&&") == 0) {
1919                        return 14;
1920                } else if (strcmp(op, "||") == 0) {
1921                        return 15;
1922                } else {
1923                        do_warning("unknown op '%s'", op);
1924                        return -1;
1925                }
1926        }
1927}
1928
1929static int set_op_prio(struct tep_print_arg *arg)
1930{
1931
1932        /* single ops are the greatest */
1933        if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1934                arg->op.prio = 0;
1935        else
1936                arg->op.prio = get_op_prio(arg->op.op);
1937
1938        return arg->op.prio;
1939}
1940
1941/* Note, *tok does not get freed, but will most likely be saved */
1942static enum tep_event_type
1943process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1944{
1945        struct tep_print_arg *left, *right = NULL;
1946        enum tep_event_type type;
1947        char *token;
1948
1949        /* the op is passed in via tok */
1950        token = *tok;
1951
1952        if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1953                /* handle single op */
1954                if (token[1]) {
1955                        do_warning_event(event, "bad op token %s", token);
1956                        goto out_free;
1957                }
1958                switch (token[0]) {
1959                case '~':
1960                case '!':
1961                case '+':
1962                case '-':
1963                        break;
1964                default:
1965                        do_warning_event(event, "bad op token %s", token);
1966                        goto out_free;
1967
1968                }
1969
1970                /* make an empty left */
1971                left = alloc_arg();
1972                if (!left)
1973                        goto out_warn_free;
1974
1975                left->type = TEP_PRINT_NULL;
1976                arg->op.left = left;
1977
1978                right = alloc_arg();
1979                if (!right)
1980                        goto out_warn_free;
1981
1982                arg->op.right = right;
1983
1984                /* do not free the token, it belongs to an op */
1985                *tok = NULL;
1986                type = process_arg(event, right, tok);
1987
1988        } else if (strcmp(token, "?") == 0) {
1989
1990                left = alloc_arg();
1991                if (!left)
1992                        goto out_warn_free;
1993
1994                /* copy the top arg to the left */
1995                *left = *arg;
1996
1997                arg->type = TEP_PRINT_OP;
1998                arg->op.op = token;
1999                arg->op.left = left;
2000                arg->op.prio = 0;
2001
2002                /* it will set arg->op.right */
2003                type = process_cond(event, arg, tok);
2004
2005        } else if (strcmp(token, ">>") == 0 ||
2006                   strcmp(token, "<<") == 0 ||
2007                   strcmp(token, "&") == 0 ||
2008                   strcmp(token, "|") == 0 ||
2009                   strcmp(token, "&&") == 0 ||
2010                   strcmp(token, "||") == 0 ||
2011                   strcmp(token, "-") == 0 ||
2012                   strcmp(token, "+") == 0 ||
2013                   strcmp(token, "*") == 0 ||
2014                   strcmp(token, "^") == 0 ||
2015                   strcmp(token, "/") == 0 ||
2016                   strcmp(token, "%") == 0 ||
2017                   strcmp(token, "<") == 0 ||
2018                   strcmp(token, ">") == 0 ||
2019                   strcmp(token, "<=") == 0 ||
2020                   strcmp(token, ">=") == 0 ||
2021                   strcmp(token, "==") == 0 ||
2022                   strcmp(token, "!=") == 0) {
2023
2024                left = alloc_arg();
2025                if (!left)
2026                        goto out_warn_free;
2027
2028                /* copy the top arg to the left */
2029                *left = *arg;
2030
2031                arg->type = TEP_PRINT_OP;
2032                arg->op.op = token;
2033                arg->op.left = left;
2034                arg->op.right = NULL;
2035
2036                if (set_op_prio(arg) == -1) {
2037                        event->flags |= TEP_EVENT_FL_FAILED;
2038                        /* arg->op.op (= token) will be freed at out_free */
2039                        arg->op.op = NULL;
2040                        goto out_free;
2041                }
2042
2043                type = read_token_item(&token);
2044                *tok = token;
2045
2046                /* could just be a type pointer */
2047                if ((strcmp(arg->op.op, "*") == 0) &&
2048                    type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
2049                        char *new_atom;
2050
2051                        if (left->type != TEP_PRINT_ATOM) {
2052                                do_warning_event(event, "bad pointer type");
2053                                goto out_free;
2054                        }
2055                        new_atom = realloc(left->atom.atom,
2056                                            strlen(left->atom.atom) + 3);
2057                        if (!new_atom)
2058                                goto out_warn_free;
2059
2060                        left->atom.atom = new_atom;
2061                        strcat(left->atom.atom, " *");
2062                        free(arg->op.op);
2063                        *arg = *left;
2064                        free(left);
2065
2066                        return type;
2067                }
2068
2069                right = alloc_arg();
2070                if (!right)
2071                        goto out_warn_free;
2072
2073                type = process_arg_token(event, right, tok, type);
2074                if (type == TEP_EVENT_ERROR) {
2075                        free_arg(right);
2076                        /* token was freed in process_arg_token() via *tok */
2077                        token = NULL;
2078                        goto out_free;
2079                }
2080
2081                if (right->type == TEP_PRINT_OP &&
2082                    get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2083                        struct tep_print_arg tmp;
2084
2085                        /* rotate ops according to the priority */
2086                        arg->op.right = right->op.left;
2087
2088                        tmp = *arg;
2089                        *arg = *right;
2090                        *right = tmp;
2091
2092                        arg->op.left = right;
2093                } else {
2094                        arg->op.right = right;
2095                }
2096
2097        } else if (strcmp(token, "[") == 0) {
2098
2099                left = alloc_arg();
2100                if (!left)
2101                        goto out_warn_free;
2102
2103                *left = *arg;
2104
2105                arg->type = TEP_PRINT_OP;
2106                arg->op.op = token;
2107                arg->op.left = left;
2108
2109                arg->op.prio = 0;
2110
2111                /* it will set arg->op.right */
2112                type = process_array(event, arg, tok);
2113
2114        } else {
2115                do_warning_event(event, "unknown op '%s'", token);
2116                event->flags |= TEP_EVENT_FL_FAILED;
2117                /* the arg is now the left side */
2118                goto out_free;
2119        }
2120
2121        if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
2122                int prio;
2123
2124                /* higher prios need to be closer to the root */
2125                prio = get_op_prio(*tok);
2126
2127                if (prio > arg->op.prio)
2128                        return process_op(event, arg, tok);
2129
2130                return process_op(event, right, tok);
2131        }
2132
2133        return type;
2134
2135out_warn_free:
2136        do_warning_event(event, "%s: not enough memory!", __func__);
2137out_free:
2138        free_token(token);
2139        *tok = NULL;
2140        return TEP_EVENT_ERROR;
2141}
2142
2143static enum tep_event_type
2144process_entry(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2145              char **tok)
2146{
2147        enum tep_event_type type;
2148        char *field;
2149        char *token;
2150
2151        if (read_expected(TEP_EVENT_OP, "->") < 0)
2152                goto out_err;
2153
2154        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2155                goto out_free;
2156        field = token;
2157
2158        arg->type = TEP_PRINT_FIELD;
2159        arg->field.name = field;
2160
2161        if (is_flag_field) {
2162                arg->field.field = tep_find_any_field(event, arg->field.name);
2163                arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2164                is_flag_field = 0;
2165        } else if (is_symbolic_field) {
2166                arg->field.field = tep_find_any_field(event, arg->field.name);
2167                arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2168                is_symbolic_field = 0;
2169        }
2170
2171        type = read_token(&token);
2172        *tok = token;
2173
2174        return type;
2175
2176 out_free:
2177        free_token(token);
2178 out_err:
2179        *tok = NULL;
2180        return TEP_EVENT_ERROR;
2181}
2182
2183static int alloc_and_process_delim(struct tep_event *event, char *next_token,
2184                                   struct tep_print_arg **print_arg)
2185{
2186        struct tep_print_arg *field;
2187        enum tep_event_type type;
2188        char *token;
2189        int ret = 0;
2190
2191        field = alloc_arg();
2192        if (!field) {
2193                do_warning_event(event, "%s: not enough memory!", __func__);
2194                errno = ENOMEM;
2195                return -1;
2196        }
2197
2198        type = process_arg(event, field, &token);
2199
2200        if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
2201                errno = EINVAL;
2202                ret = -1;
2203                free_arg(field);
2204                goto out_free_token;
2205        }
2206
2207        *print_arg = field;
2208
2209out_free_token:
2210        free_token(token);
2211
2212        return ret;
2213}
2214
2215static char *arg_eval (struct tep_print_arg *arg);
2216
2217static unsigned long long
2218eval_type_str(unsigned long long val, const char *type, int pointer)
2219{
2220        int sign = 0;
2221        char *ref;
2222        int len;
2223
2224        len = strlen(type);
2225
2226        if (pointer) {
2227
2228                if (type[len-1] != '*') {
2229                        do_warning("pointer expected with non pointer type");
2230                        return val;
2231                }
2232
2233                ref = malloc(len);
2234                if (!ref) {
2235                        do_warning("%s: not enough memory!", __func__);
2236                        return val;
2237                }
2238                memcpy(ref, type, len);
2239
2240                /* chop off the " *" */
2241                ref[len - 2] = 0;
2242
2243                val = eval_type_str(val, ref, 0);
2244                free(ref);
2245                return val;
2246        }
2247
2248        /* check if this is a pointer */
2249        if (type[len - 1] == '*')
2250                return val;
2251
2252        /* Try to figure out the arg size*/
2253        if (strncmp(type, "struct", 6) == 0)
2254                /* all bets off */
2255                return val;
2256
2257        if (strcmp(type, "u8") == 0)
2258                return val & 0xff;
2259
2260        if (strcmp(type, "u16") == 0)
2261                return val & 0xffff;
2262
2263        if (strcmp(type, "u32") == 0)
2264                return val & 0xffffffff;
2265
2266        if (strcmp(type, "u64") == 0 ||
2267            strcmp(type, "s64") == 0)
2268                return val;
2269
2270        if (strcmp(type, "s8") == 0)
2271                return (unsigned long long)(char)val & 0xff;
2272
2273        if (strcmp(type, "s16") == 0)
2274                return (unsigned long long)(short)val & 0xffff;
2275
2276        if (strcmp(type, "s32") == 0)
2277                return (unsigned long long)(int)val & 0xffffffff;
2278
2279        if (strncmp(type, "unsigned ", 9) == 0) {
2280                sign = 0;
2281                type += 9;
2282        }
2283
2284        if (strcmp(type, "char") == 0) {
2285                if (sign)
2286                        return (unsigned long long)(char)val & 0xff;
2287                else
2288                        return val & 0xff;
2289        }
2290
2291        if (strcmp(type, "short") == 0) {
2292                if (sign)
2293                        return (unsigned long long)(short)val & 0xffff;
2294                else
2295                        return val & 0xffff;
2296        }
2297
2298        if (strcmp(type, "int") == 0) {
2299                if (sign)
2300                        return (unsigned long long)(int)val & 0xffffffff;
2301                else
2302                        return val & 0xffffffff;
2303        }
2304
2305        return val;
2306}
2307
2308/*
2309 * Try to figure out the type.
2310 */
2311static unsigned long long
2312eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2313{
2314        if (arg->type != TEP_PRINT_TYPE) {
2315                do_warning("expected type argument");
2316                return 0;
2317        }
2318
2319        return eval_type_str(val, arg->typecast.type, pointer);
2320}
2321
2322static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2323{
2324        long long left, right;
2325        int ret = 1;
2326
2327        switch (arg->type) {
2328        case TEP_PRINT_ATOM:
2329                *val = strtoll(arg->atom.atom, NULL, 0);
2330                break;
2331        case TEP_PRINT_TYPE:
2332                ret = arg_num_eval(arg->typecast.item, val);
2333                if (!ret)
2334                        break;
2335                *val = eval_type(*val, arg, 0);
2336                break;
2337        case TEP_PRINT_OP:
2338                switch (arg->op.op[0]) {
2339                case '|':
2340                        ret = arg_num_eval(arg->op.left, &left);
2341                        if (!ret)
2342                                break;
2343                        ret = arg_num_eval(arg->op.right, &right);
2344                        if (!ret)
2345                                break;
2346                        if (arg->op.op[1])
2347                                *val = left || right;
2348                        else
2349                                *val = left | right;
2350                        break;
2351                case '&':
2352                        ret = arg_num_eval(arg->op.left, &left);
2353                        if (!ret)
2354                                break;
2355                        ret = arg_num_eval(arg->op.right, &right);
2356                        if (!ret)
2357                                break;
2358                        if (arg->op.op[1])
2359                                *val = left && right;
2360                        else
2361                                *val = left & right;
2362                        break;
2363                case '<':
2364                        ret = arg_num_eval(arg->op.left, &left);
2365                        if (!ret)
2366                                break;
2367                        ret = arg_num_eval(arg->op.right, &right);
2368                        if (!ret)
2369                                break;
2370                        switch (arg->op.op[1]) {
2371                        case 0:
2372                                *val = left < right;
2373                                break;
2374                        case '<':
2375                                *val = left << right;
2376                                break;
2377                        case '=':
2378                                *val = left <= right;
2379                                break;
2380                        default:
2381                                do_warning("unknown op '%s'", arg->op.op);
2382                                ret = 0;
2383                        }
2384                        break;
2385                case '>':
2386                        ret = arg_num_eval(arg->op.left, &left);
2387                        if (!ret)
2388                                break;
2389                        ret = arg_num_eval(arg->op.right, &right);
2390                        if (!ret)
2391                                break;
2392                        switch (arg->op.op[1]) {
2393                        case 0:
2394                                *val = left > right;
2395                                break;
2396                        case '>':
2397                                *val = left >> right;
2398                                break;
2399                        case '=':
2400                                *val = left >= right;
2401                                break;
2402                        default:
2403                                do_warning("unknown op '%s'", arg->op.op);
2404                                ret = 0;
2405                        }
2406                        break;
2407                case '=':
2408                        ret = arg_num_eval(arg->op.left, &left);
2409                        if (!ret)
2410                                break;
2411                        ret = arg_num_eval(arg->op.right, &right);
2412                        if (!ret)
2413                                break;
2414
2415                        if (arg->op.op[1] != '=') {
2416                                do_warning("unknown op '%s'", arg->op.op);
2417                                ret = 0;
2418                        } else
2419                                *val = left == right;
2420                        break;
2421                case '!':
2422                        ret = arg_num_eval(arg->op.left, &left);
2423                        if (!ret)
2424                                break;
2425                        ret = arg_num_eval(arg->op.right, &right);
2426                        if (!ret)
2427                                break;
2428
2429                        switch (arg->op.op[1]) {
2430                        case '=':
2431                                *val = left != right;
2432                                break;
2433                        default:
2434                                do_warning("unknown op '%s'", arg->op.op);
2435                                ret = 0;
2436                        }
2437                        break;
2438                case '-':
2439                        /* check for negative */
2440                        if (arg->op.left->type == TEP_PRINT_NULL)
2441                                left = 0;
2442                        else
2443                                ret = arg_num_eval(arg->op.left, &left);
2444                        if (!ret)
2445                                break;
2446                        ret = arg_num_eval(arg->op.right, &right);
2447                        if (!ret)
2448                                break;
2449                        *val = left - right;
2450                        break;
2451                case '+':
2452                        if (arg->op.left->type == TEP_PRINT_NULL)
2453                                left = 0;
2454                        else
2455                                ret = arg_num_eval(arg->op.left, &left);
2456                        if (!ret)
2457                                break;
2458                        ret = arg_num_eval(arg->op.right, &right);
2459                        if (!ret)
2460                                break;
2461                        *val = left + right;
2462                        break;
2463                case '~':
2464                        ret = arg_num_eval(arg->op.right, &right);
2465                        if (!ret)
2466                                break;
2467                        *val = ~right;
2468                        break;
2469                default:
2470                        do_warning("unknown op '%s'", arg->op.op);
2471                        ret = 0;
2472                }
2473                break;
2474
2475        case TEP_PRINT_NULL:
2476        case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2477        case TEP_PRINT_STRING:
2478        case TEP_PRINT_BSTRING:
2479        case TEP_PRINT_BITMASK:
2480        default:
2481                do_warning("invalid eval type %d", arg->type);
2482                ret = 0;
2483
2484        }
2485        return ret;
2486}
2487
2488static char *arg_eval (struct tep_print_arg *arg)
2489{
2490        long long val;
2491        static char buf[24];
2492
2493        switch (arg->type) {
2494        case TEP_PRINT_ATOM:
2495                return arg->atom.atom;
2496        case TEP_PRINT_TYPE:
2497                return arg_eval(arg->typecast.item);
2498        case TEP_PRINT_OP:
2499                if (!arg_num_eval(arg, &val))
2500                        break;
2501                sprintf(buf, "%lld", val);
2502                return buf;
2503
2504        case TEP_PRINT_NULL:
2505        case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2506        case TEP_PRINT_STRING:
2507        case TEP_PRINT_BSTRING:
2508        case TEP_PRINT_BITMASK:
2509        default:
2510                do_warning("invalid eval type %d", arg->type);
2511                break;
2512        }
2513
2514        return NULL;
2515}
2516
2517static enum tep_event_type
2518process_fields(struct tep_event *event, struct tep_print_flag_sym **list, char **tok)
2519{
2520        enum tep_event_type type;
2521        struct tep_print_arg *arg = NULL;
2522        struct tep_print_flag_sym *field;
2523        char *token = *tok;
2524        char *value;
2525
2526        do {
2527                free_token(token);
2528                type = read_token_item(&token);
2529                if (test_type_token(type, token, TEP_EVENT_OP, "{"))
2530                        break;
2531
2532                arg = alloc_arg();
2533                if (!arg)
2534                        goto out_free;
2535
2536                free_token(token);
2537                type = process_arg(event, arg, &token);
2538
2539                if (type == TEP_EVENT_OP)
2540                        type = process_op(event, arg, &token);
2541
2542                if (type == TEP_EVENT_ERROR)
2543                        goto out_free;
2544
2545                if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2546                        goto out_free;
2547
2548                field = calloc(1, sizeof(*field));
2549                if (!field)
2550                        goto out_free;
2551
2552                value = arg_eval(arg);
2553                if (value == NULL)
2554                        goto out_free_field;
2555                field->value = strdup(value);
2556                if (field->value == NULL)
2557                        goto out_free_field;
2558
2559                free_arg(arg);
2560                arg = alloc_arg();
2561                if (!arg)
2562                        goto out_free;
2563
2564                free_token(token);
2565                type = process_arg(event, arg, &token);
2566                if (test_type_token(type, token, TEP_EVENT_OP, "}"))
2567                        goto out_free_field;
2568
2569                value = arg_eval(arg);
2570                if (value == NULL)
2571                        goto out_free_field;
2572                field->str = strdup(value);
2573                if (field->str == NULL)
2574                        goto out_free_field;
2575                free_arg(arg);
2576                arg = NULL;
2577
2578                *list = field;
2579                list = &field->next;
2580
2581                free_token(token);
2582                type = read_token_item(&token);
2583        } while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
2584
2585        *tok = token;
2586        return type;
2587
2588out_free_field:
2589        free_flag_sym(field);
2590out_free:
2591        free_arg(arg);
2592        free_token(token);
2593        *tok = NULL;
2594
2595        return TEP_EVENT_ERROR;
2596}
2597
2598static enum tep_event_type
2599process_flags(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2600{
2601        struct tep_print_arg *field;
2602        enum tep_event_type type;
2603        char *token = NULL;
2604
2605        memset(arg, 0, sizeof(*arg));
2606        arg->type = TEP_PRINT_FLAGS;
2607
2608        field = alloc_arg();
2609        if (!field) {
2610                do_warning_event(event, "%s: not enough memory!", __func__);
2611                goto out_free;
2612        }
2613
2614        type = process_field_arg(event, field, &token);
2615
2616        /* Handle operations in the first argument */
2617        while (type == TEP_EVENT_OP)
2618                type = process_op(event, field, &token);
2619
2620        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2621                goto out_free_field;
2622        free_token(token);
2623
2624        arg->flags.field = field;
2625
2626        type = read_token_item(&token);
2627        if (event_item_type(type)) {
2628                arg->flags.delim = token;
2629                type = read_token_item(&token);
2630        }
2631
2632        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2633                goto out_free;
2634
2635        type = process_fields(event, &arg->flags.flags, &token);
2636        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2637                goto out_free;
2638
2639        free_token(token);
2640        type = read_token_item(tok);
2641        return type;
2642
2643out_free_field:
2644        free_arg(field);
2645out_free:
2646        free_token(token);
2647        *tok = NULL;
2648        return TEP_EVENT_ERROR;
2649}
2650
2651static enum tep_event_type
2652process_symbols(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2653{
2654        struct tep_print_arg *field;
2655        enum tep_event_type type;
2656        char *token = NULL;
2657
2658        memset(arg, 0, sizeof(*arg));
2659        arg->type = TEP_PRINT_SYMBOL;
2660
2661        field = alloc_arg();
2662        if (!field) {
2663                do_warning_event(event, "%s: not enough memory!", __func__);
2664                goto out_free;
2665        }
2666
2667        type = process_field_arg(event, field, &token);
2668
2669        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2670                goto out_free_field;
2671
2672        arg->symbol.field = field;
2673
2674        type = process_fields(event, &arg->symbol.symbols, &token);
2675        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2676                goto out_free;
2677
2678        free_token(token);
2679        type = read_token_item(tok);
2680        return type;
2681
2682out_free_field:
2683        free_arg(field);
2684out_free:
2685        free_token(token);
2686        *tok = NULL;
2687        return TEP_EVENT_ERROR;
2688}
2689
2690static enum tep_event_type
2691process_hex_common(struct tep_event *event, struct tep_print_arg *arg,
2692                   char **tok, enum tep_print_arg_type type)
2693{
2694        memset(arg, 0, sizeof(*arg));
2695        arg->type = type;
2696
2697        if (alloc_and_process_delim(event, ",", &arg->hex.field))
2698                goto out;
2699
2700        if (alloc_and_process_delim(event, ")", &arg->hex.size))
2701                goto free_field;
2702
2703        return read_token_item(tok);
2704
2705free_field:
2706        free_arg(arg->hex.field);
2707        arg->hex.field = NULL;
2708out:
2709        *tok = NULL;
2710        return TEP_EVENT_ERROR;
2711}
2712
2713static enum tep_event_type
2714process_hex(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2715{
2716        return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2717}
2718
2719static enum tep_event_type
2720process_hex_str(struct tep_event *event, struct tep_print_arg *arg,
2721                char **tok)
2722{
2723        return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2724}
2725
2726static enum tep_event_type
2727process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2728{
2729        memset(arg, 0, sizeof(*arg));
2730        arg->type = TEP_PRINT_INT_ARRAY;
2731
2732        if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2733                goto out;
2734
2735        if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2736                goto free_field;
2737
2738        if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2739                goto free_size;
2740
2741        return read_token_item(tok);
2742
2743free_size:
2744        free_arg(arg->int_array.count);
2745        arg->int_array.count = NULL;
2746free_field:
2747        free_arg(arg->int_array.field);
2748        arg->int_array.field = NULL;
2749out:
2750        *tok = NULL;
2751        return TEP_EVENT_ERROR;
2752}
2753
2754static enum tep_event_type
2755process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2756{
2757        struct tep_format_field *field;
2758        enum tep_event_type type;
2759        char *token;
2760
2761        memset(arg, 0, sizeof(*arg));
2762        arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2763
2764        /*
2765         * The item within the parenthesis is another field that holds
2766         * the index into where the array starts.
2767         */
2768        type = read_token(&token);
2769        *tok = token;
2770        if (type != TEP_EVENT_ITEM)
2771                goto out_free;
2772
2773        /* Find the field */
2774
2775        field = tep_find_field(event, token);
2776        if (!field)
2777                goto out_free;
2778
2779        arg->dynarray.field = field;
2780        arg->dynarray.index = 0;
2781
2782        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2783                goto out_free;
2784
2785        free_token(token);
2786        type = read_token_item(&token);
2787        *tok = token;
2788        if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
2789                return type;
2790
2791        free_token(token);
2792        arg = alloc_arg();
2793        if (!arg) {
2794                do_warning_event(event, "%s: not enough memory!", __func__);
2795                *tok = NULL;
2796                return TEP_EVENT_ERROR;
2797        }
2798
2799        type = process_arg(event, arg, &token);
2800        if (type == TEP_EVENT_ERROR)
2801                goto out_free_arg;
2802
2803        if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
2804                goto out_free_arg;
2805
2806        free_token(token);
2807        type = read_token_item(tok);
2808        return type;
2809
2810 out_free_arg:
2811        free_arg(arg);
2812 out_free:
2813        free_token(token);
2814        *tok = NULL;
2815        return TEP_EVENT_ERROR;
2816}
2817
2818static enum tep_event_type
2819process_dynamic_array_len(struct tep_event *event, struct tep_print_arg *arg,
2820                          char **tok)
2821{
2822        struct tep_format_field *field;
2823        enum tep_event_type type;
2824        char *token;
2825
2826        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2827                goto out_free;
2828
2829        arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2830
2831        /* Find the field */
2832        field = tep_find_field(event, token);
2833        if (!field)
2834                goto out_free;
2835
2836        arg->dynarray.field = field;
2837        arg->dynarray.index = 0;
2838
2839        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2840                goto out_err;
2841
2842        type = read_token(&token);
2843        *tok = token;
2844
2845        return type;
2846
2847 out_free:
2848        free_token(token);
2849 out_err:
2850        *tok = NULL;
2851        return TEP_EVENT_ERROR;
2852}
2853
2854static enum tep_event_type
2855process_paren(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2856{
2857        struct tep_print_arg *item_arg;
2858        enum tep_event_type type;
2859        char *token;
2860
2861        type = process_arg(event, arg, &token);
2862
2863        if (type == TEP_EVENT_ERROR)
2864                goto out_free;
2865
2866        if (type == TEP_EVENT_OP)
2867                type = process_op(event, arg, &token);
2868
2869        if (type == TEP_EVENT_ERROR)
2870                goto out_free;
2871
2872        if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2873                goto out_free;
2874
2875        free_token(token);
2876        type = read_token_item(&token);
2877
2878        /*
2879         * If the next token is an item or another open paren, then
2880         * this was a typecast.
2881         */
2882        if (event_item_type(type) ||
2883            (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
2884
2885                /* make this a typecast and contine */
2886
2887                /* prevous must be an atom */
2888                if (arg->type != TEP_PRINT_ATOM) {
2889                        do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
2890                        goto out_free;
2891                }
2892
2893                item_arg = alloc_arg();
2894                if (!item_arg) {
2895                        do_warning_event(event, "%s: not enough memory!",
2896                                         __func__);
2897                        goto out_free;
2898                }
2899
2900                arg->type = TEP_PRINT_TYPE;
2901                arg->typecast.type = arg->atom.atom;
2902                arg->typecast.item = item_arg;
2903                type = process_arg_token(event, item_arg, &token, type);
2904
2905        }
2906
2907        *tok = token;
2908        return type;
2909
2910 out_free:
2911        free_token(token);
2912        *tok = NULL;
2913        return TEP_EVENT_ERROR;
2914}
2915
2916
2917static enum tep_event_type
2918process_str(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2919            char **tok)
2920{
2921        enum tep_event_type type;
2922        char *token;
2923
2924        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2925                goto out_free;
2926
2927        arg->type = TEP_PRINT_STRING;
2928        arg->string.string = token;
2929        arg->string.offset = -1;
2930
2931        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2932                goto out_err;
2933
2934        type = read_token(&token);
2935        *tok = token;
2936
2937        return type;
2938
2939 out_free:
2940        free_token(token);
2941 out_err:
2942        *tok = NULL;
2943        return TEP_EVENT_ERROR;
2944}
2945
2946static enum tep_event_type
2947process_bitmask(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2948                char **tok)
2949{
2950        enum tep_event_type type;
2951        char *token;
2952
2953        if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2954                goto out_free;
2955
2956        arg->type = TEP_PRINT_BITMASK;
2957        arg->bitmask.bitmask = token;
2958        arg->bitmask.offset = -1;
2959
2960        if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2961                goto out_err;
2962
2963        type = read_token(&token);
2964        *tok = token;
2965
2966        return type;
2967
2968 out_free:
2969        free_token(token);
2970 out_err:
2971        *tok = NULL;
2972        return TEP_EVENT_ERROR;
2973}
2974
2975static struct tep_function_handler *
2976find_func_handler(struct tep_handle *tep, char *func_name)
2977{
2978        struct tep_function_handler *func;
2979
2980        if (!tep)
2981                return NULL;
2982
2983        for (func = tep->func_handlers; func; func = func->next) {
2984                if (strcmp(func->name, func_name) == 0)
2985                        break;
2986        }
2987
2988        return func;
2989}
2990
2991static void remove_func_handler(struct tep_handle *tep, char *func_name)
2992{
2993        struct tep_function_handler *func;
2994        struct tep_function_handler **next;
2995
2996        next = &tep->func_handlers;
2997        while ((func = *next)) {
2998                if (strcmp(func->name, func_name) == 0) {
2999                        *next = func->next;
3000                        free_func_handle(func);
3001                        break;
3002                }
3003                next = &func->next;
3004        }
3005}
3006
3007static enum tep_event_type
3008process_func_handler(struct tep_event *event, struct tep_function_handler *func,
3009                     struct tep_print_arg *arg, char **tok)
3010{
3011        struct tep_print_arg **next_arg;
3012        struct tep_print_arg *farg;
3013        enum tep_event_type type;
3014        char *token;
3015        int i;
3016
3017        arg->type = TEP_PRINT_FUNC;
3018        arg->func.func = func;
3019
3020        *tok = NULL;
3021
3022        next_arg = &(arg->func.args);
3023        for (i = 0; i < func->nr_args; i++) {
3024                farg = alloc_arg();
3025                if (!farg) {
3026                        do_warning_event(event, "%s: not enough memory!",
3027                                         __func__);
3028                        return TEP_EVENT_ERROR;
3029                }
3030
3031                type = process_arg(event, farg, &token);
3032                if (i < (func->nr_args - 1)) {
3033                        if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
3034                                do_warning_event(event,
3035                                        "Error: function '%s()' expects %d arguments but event %s only uses %d",
3036                                        func->name, func->nr_args,
3037                                        event->name, i + 1);
3038                                goto err;
3039                        }
3040                } else {
3041                        if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
3042                                do_warning_event(event,
3043                                        "Error: function '%s()' only expects %d arguments but event %s has more",
3044                                        func->name, func->nr_args, event->name);
3045                                goto err;
3046                        }
3047                }
3048
3049                *next_arg = farg;
3050                next_arg = &(farg->next);
3051                free_token(token);
3052        }
3053
3054        type = read_token(&token);
3055        *tok = token;
3056
3057        return type;
3058
3059err:
3060        free_arg(farg);
3061        free_token(token);
3062        return TEP_EVENT_ERROR;
3063}
3064
3065static enum tep_event_type
3066process_function(struct tep_event *event, struct tep_print_arg *arg,
3067                 char *token, char **tok)
3068{
3069        struct tep_function_handler *func;
3070
3071        if (strcmp(token, "__print_flags") == 0) {
3072                free_token(token);
3073                is_flag_field = 1;
3074                return process_flags(event, arg, tok);
3075        }
3076        if (strcmp(token, "__print_symbolic") == 0) {
3077                free_token(token);
3078                is_symbolic_field = 1;
3079                return process_symbols(event, arg, tok);
3080        }
3081        if (strcmp(token, "__print_hex") == 0) {
3082                free_token(token);
3083                return process_hex(event, arg, tok);
3084        }
3085        if (strcmp(token, "__print_hex_str") == 0) {
3086                free_token(token);
3087                return process_hex_str(event, arg, tok);
3088        }
3089        if (strcmp(token, "__print_array") == 0) {
3090                free_token(token);
3091                return process_int_array(event, arg, tok);
3092        }
3093        if (strcmp(token, "__get_str") == 0) {
3094                free_token(token);
3095                return process_str(event, arg, tok);
3096        }
3097        if (strcmp(token, "__get_bitmask") == 0) {
3098                free_token(token);
3099                return process_bitmask(event, arg, tok);
3100        }
3101        if (strcmp(token, "__get_dynamic_array") == 0) {
3102                free_token(token);
3103                return process_dynamic_array(event, arg, tok);
3104        }
3105        if (strcmp(token, "__get_dynamic_array_len") == 0) {
3106                free_token(token);
3107                return process_dynamic_array_len(event, arg, tok);
3108        }
3109
3110        func = find_func_handler(event->tep, token);
3111        if (func) {
3112                free_token(token);
3113                return process_func_handler(event, func, arg, tok);
3114        }
3115
3116        do_warning_event(event, "function %s not defined", token);
3117        free_token(token);
3118        return TEP_EVENT_ERROR;
3119}
3120
3121static enum tep_event_type
3122process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
3123                  char **tok, enum tep_event_type type)
3124{
3125        char *token;
3126        char *atom;
3127
3128        token = *tok;
3129
3130        switch (type) {
3131        case TEP_EVENT_ITEM:
3132                if (strcmp(token, "REC") == 0) {
3133                        free_token(token);
3134                        type = process_entry(event, arg, &token);
3135                        break;
3136                }
3137                atom = token;
3138                /* test the next token */
3139                type = read_token_item(&token);
3140
3141                /*
3142                 * If the next token is a parenthesis, then this
3143                 * is a function.
3144                 */
3145                if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
3146                        free_token(token);
3147                        token = NULL;
3148                        /* this will free atom. */
3149                        type = process_function(event, arg, atom, &token);
3150                        break;
3151                }
3152                /* atoms can be more than one token long */
3153                while (type == TEP_EVENT_ITEM) {
3154                        char *new_atom;
3155                        new_atom = realloc(atom,
3156                                           strlen(atom) + strlen(token) + 2);
3157                        if (!new_atom) {
3158                                free(atom);
3159                                *tok = NULL;
3160                                free_token(token);
3161                                return TEP_EVENT_ERROR;
3162                        }
3163                        atom = new_atom;
3164                        strcat(atom, " ");
3165                        strcat(atom, token);
3166                        free_token(token);
3167                        type = read_token_item(&token);
3168                }
3169
3170                arg->type = TEP_PRINT_ATOM;
3171                arg->atom.atom = atom;
3172                break;
3173
3174        case TEP_EVENT_DQUOTE:
3175        case TEP_EVENT_SQUOTE:
3176                arg->type = TEP_PRINT_ATOM;
3177                arg->atom.atom = token;
3178                type = read_token_item(&token);
3179                break;
3180        case TEP_EVENT_DELIM:
3181                if (strcmp(token, "(") == 0) {
3182                        free_token(token);
3183                        type = process_paren(event, arg, &token);
3184                        break;
3185                }
3186        case TEP_EVENT_OP:
3187                /* handle single ops */
3188                arg->type = TEP_PRINT_OP;
3189                arg->op.op = token;
3190                arg->op.left = NULL;
3191                type = process_op(event, arg, &token);
3192
3193                /* On error, the op is freed */
3194                if (type == TEP_EVENT_ERROR)
3195                        arg->op.op = NULL;
3196
3197                /* return error type if errored */
3198                break;
3199
3200        case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
3201        default:
3202                do_warning_event(event, "unexpected type %d", type);
3203                return TEP_EVENT_ERROR;
3204        }
3205        *tok = token;
3206
3207        return type;
3208}
3209
3210static int event_read_print_args(struct tep_event *event, struct tep_print_arg **list)
3211{
3212        enum tep_event_type type = TEP_EVENT_ERROR;
3213        struct tep_print_arg *arg;
3214        char *token;
3215        int args = 0;
3216
3217        do {
3218                if (type == TEP_EVENT_NEWLINE) {
3219                        type = read_token_item(&token);
3220                        continue;
3221                }
3222
3223                arg = alloc_arg();
3224                if (!arg) {
3225                        do_warning_event(event, "%s: not enough memory!",
3226                                         __func__);
3227                        return -1;
3228                }
3229
3230                type = process_arg(event, arg, &token);
3231
3232                if (type == TEP_EVENT_ERROR) {
3233                        free_token(token);
3234                        free_arg(arg);
3235                        return -1;
3236                }
3237
3238                *list = arg;
3239                args++;
3240
3241                if (type == TEP_EVENT_OP) {
3242                        type = process_op(event, arg, &token);
3243                        free_token(token);
3244                        if (type == TEP_EVENT_ERROR) {
3245                                *list = NULL;
3246                                free_arg(arg);
3247                                return -1;
3248                        }
3249                        list = &arg->next;
3250                        continue;
3251                }
3252
3253                if (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0) {
3254                        free_token(token);
3255                        *list = arg;
3256                        list = &arg->next;
3257                        continue;
3258                }
3259                break;
3260        } while (type != TEP_EVENT_NONE);
3261
3262        if (type != TEP_EVENT_NONE && type != TEP_EVENT_ERROR)
3263                free_token(token);
3264
3265        return args;
3266}
3267
3268static int event_read_print(struct tep_event *event)
3269{
3270        enum tep_event_type type;
3271        char *token;
3272        int ret;
3273
3274        if (read_expected_item(TEP_EVENT_ITEM, "print") < 0)
3275                return -1;
3276
3277        if (read_expected(TEP_EVENT_ITEM, "fmt") < 0)
3278                return -1;
3279
3280        if (read_expected(TEP_EVENT_OP, ":") < 0)
3281                return -1;
3282
3283        if (read_expect_type(TEP_EVENT_DQUOTE, &token) < 0)
3284                goto fail;
3285
3286 concat:
3287        event->print_fmt.format = token;
3288        event->print_fmt.args = NULL;
3289
3290        /* ok to have no arg */
3291        type = read_token_item(&token);
3292
3293        if (type == TEP_EVENT_NONE)
3294                return 0;
3295
3296        /* Handle concatenation of print lines */
3297        if (type == TEP_EVENT_DQUOTE) {
3298                char *cat;
3299
3300                if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
3301                        goto fail;
3302                free_token(token);
3303                free_token(event->print_fmt.format);
3304                event->print_fmt.format = NULL;
3305                token = cat;
3306                goto concat;
3307        }
3308                             
3309        if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
3310                goto fail;
3311
3312        free_token(token);
3313
3314        ret = event_read_print_args(event, &event->print_fmt.args);
3315        if (ret < 0)
3316                return -1;
3317
3318        return ret;
3319
3320 fail:
3321        free_token(token);
3322        return -1;
3323}
3324
3325/**
3326 * tep_find_common_field - return a common field by event
3327 * @event: handle for the event
3328 * @name: the name of the common field to return
3329 *
3330 * Returns a common field from the event by the given @name.
3331 * This only searches the common fields and not all field.
3332 */
3333struct tep_format_field *
3334tep_find_common_field(struct tep_event *event, const char *name)
3335{
3336        struct tep_format_field *format;
3337
3338        for (format = event->format.common_fields;
3339             format; format = format->next) {
3340                if (strcmp(format->name, name) == 0)
3341                        break;
3342        }
3343
3344        return format;
3345}
3346
3347/**
3348 * tep_find_field - find a non-common field
3349 * @event: handle for the event
3350 * @name: the name of the non-common field
3351 *
3352 * Returns a non-common field by the given @name.
3353 * This does not search common fields.
3354 */
3355struct tep_format_field *
3356tep_find_field(struct tep_event *event, const char *name)
3357{
3358        struct tep_format_field *format;
3359
3360        for (format = event->format.fields;
3361             format; format = format->next) {
3362                if (strcmp(format->name, name) == 0)
3363                        break;
3364        }
3365
3366        return format;
3367}
3368
3369/**
3370 * tep_find_any_field - find any field by name
3371 * @event: handle for the event
3372 * @name: the name of the field
3373 *
3374 * Returns a field by the given @name.
3375 * This searches the common field names first, then
3376 * the non-common ones if a common one was not found.
3377 */
3378struct tep_format_field *
3379tep_find_any_field(struct tep_event *event, const char *name)
3380{
3381        struct tep_format_field *format;
3382
3383        format = tep_find_common_field(event, name);
3384        if (format)
3385                return format;
3386        return tep_find_field(event, name);
3387}
3388
3389/**
3390 * tep_read_number - read a number from data
3391 * @tep: a handle to the trace event parser context
3392 * @ptr: the raw data
3393 * @size: the size of the data that holds the number
3394 *
3395 * Returns the number (converted to host) from the
3396 * raw data.
3397 */
3398unsigned long long tep_read_number(struct tep_handle *tep,
3399                                   const void *ptr, int size)
3400{
3401        unsigned long long val;
3402
3403        switch (size) {
3404        case 1:
3405                return *(unsigned char *)ptr;
3406        case 2:
3407                return tep_data2host2(tep, *(unsigned short *)ptr);
3408        case 4:
3409                return tep_data2host4(tep, *(unsigned int *)ptr);
3410        case 8:
3411                memcpy(&val, (ptr), sizeof(unsigned long long));
3412                return tep_data2host8(tep, val);
3413        default:
3414                /* BUG! */
3415                return 0;
3416        }
3417}
3418
3419/**
3420 * tep_read_number_field - read a number from data
3421 * @field: a handle to the field
3422 * @data: the raw data to read
3423 * @value: the value to place the number in
3424 *
3425 * Reads raw data according to a field offset and size,
3426 * and translates it into @value.
3427 *
3428 * Returns 0 on success, -1 otherwise.
3429 */
3430int tep_read_number_field(struct tep_format_field *field, const void *data,
3431                          unsigned long long *value)
3432{
3433        if (!field)
3434                return -1;
3435        switch (field->size) {
3436        case 1:
3437        case 2:
3438        case 4:
3439        case 8:
3440                *value = tep_read_number(field->event->tep,
3441                                         data + field->offset, field->size);
3442                return 0;
3443        default:
3444                return -1;
3445        }
3446}
3447
3448static int get_common_info(struct tep_handle *tep,
3449                           const char *type, int *offset, int *size)
3450{
3451        struct tep_event *event;
3452        struct tep_format_field *field;
3453
3454        /*
3455         * All events should have the same common elements.
3456         * Pick any event to find where the type is;
3457         */
3458        if (!tep->events) {
3459                do_warning("no event_list!");
3460                return -1;
3461        }
3462
3463        event = tep->events[0];
3464        field = tep_find_common_field(event, type);
3465        if (!field)
3466                return -1;
3467
3468        *offset = field->offset;
3469        *size = field->size;
3470
3471        return 0;
3472}
3473
3474static int __parse_common(struct tep_handle *tep, void *data,
3475                          int *size, int *offset, const char *name)
3476{
3477        int ret;
3478
3479        if (!*size) {
3480                ret = get_common_info(tep, name, offset, size);
3481                if (ret < 0)
3482                        return ret;
3483        }
3484        return tep_read_number(tep, data + *offset, *size);
3485}
3486
3487static int trace_parse_common_type(struct tep_handle *tep, void *data)
3488{
3489        return __parse_common(tep, data,
3490                              &tep->type_size, &tep->type_offset,
3491                              "common_type");
3492}
3493
3494static int parse_common_pid(struct tep_handle *tep, void *data)
3495{
3496        return __parse_common(tep, data,
3497                              &tep->pid_size, &tep->pid_offset,
3498                              "common_pid");
3499}
3500
3501static int parse_common_pc(struct tep_handle *tep, void *data)
3502{
3503        return __parse_common(tep, data,
3504                              &tep->pc_size, &tep->pc_offset,
3505                              "common_preempt_count");
3506}
3507
3508static int parse_common_flags(struct tep_handle *tep, void *data)
3509{
3510        return __parse_common(tep, data,
3511                              &tep->flags_size, &tep->flags_offset,
3512                              "common_flags");
3513}
3514
3515static int parse_common_lock_depth(struct tep_handle *tep, void *data)
3516{
3517        return __parse_common(tep, data,
3518                              &tep->ld_size, &tep->ld_offset,
3519                              "common_lock_depth");
3520}
3521
3522static int parse_common_migrate_disable(struct tep_handle *tep, void *data)
3523{
3524        return __parse_common(tep, data,
3525                              &tep->ld_size, &tep->ld_offset,
3526                              "common_migrate_disable");
3527}
3528
3529static int events_id_cmp(const void *a, const void *b);
3530
3531/**
3532 * tep_find_event - find an event by given id
3533 * @tep: a handle to the trace event parser context
3534 * @id: the id of the event
3535 *
3536 * Returns an event that has a given @id.
3537 */
3538struct tep_event *tep_find_event(struct tep_handle *tep, int id)
3539{
3540        struct tep_event **eventptr;
3541        struct tep_event key;
3542        struct tep_event *pkey = &key;
3543
3544        /* Check cache first */
3545        if (tep->last_event && tep->last_event->id == id)
3546                return tep->last_event;
3547
3548        key.id = id;
3549
3550        eventptr = bsearch(&pkey, tep->events, tep->nr_events,
3551                           sizeof(*tep->events), events_id_cmp);
3552
3553        if (eventptr) {
3554                tep->last_event = *eventptr;
3555                return *eventptr;
3556        }
3557
3558        return NULL;
3559}
3560
3561/**
3562 * tep_find_event_by_name - find an event by given name
3563 * @tep: a handle to the trace event parser context
3564 * @sys: the system name to search for
3565 * @name: the name of the event to search for
3566 *
3567 * This returns an event with a given @name and under the system
3568 * @sys. If @sys is NULL the first event with @name is returned.
3569 */
3570struct tep_event *
3571tep_find_event_by_name(struct tep_handle *tep,
3572                       const char *sys, const char *name)
3573{
3574        struct tep_event *event = NULL;
3575        int i;
3576
3577        if (tep->last_event &&
3578            strcmp(tep->last_event->name, name) == 0 &&
3579            (!sys || strcmp(tep->last_event->system, sys) == 0))
3580                return tep->last_event;
3581
3582        for (i = 0; i < tep->nr_events; i++) {
3583                event = tep->events[i];
3584                if (strcmp(event->name, name) == 0) {
3585                        if (!sys)
3586                                break;
3587                        if (strcmp(event->system, sys) == 0)
3588                                break;
3589                }
3590        }
3591        if (i == tep->nr_events)
3592                event = NULL;
3593
3594        tep->last_event = event;
3595        return event;
3596}
3597
3598static unsigned long long
3599eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg *arg)
3600{
3601        struct tep_handle *tep = event->tep;
3602        unsigned long long val = 0;
3603        unsigned long long left, right;
3604        struct tep_print_arg *typearg = NULL;
3605        struct tep_print_arg *larg;
3606        unsigned long offset;
3607        unsigned int field_size;
3608
3609        switch (arg->type) {
3610        case TEP_PRINT_NULL:
3611                /* ?? */
3612                return 0;
3613        case TEP_PRINT_ATOM:
3614                return strtoull(arg->atom.atom, NULL, 0);
3615        case TEP_PRINT_FIELD:
3616                if (!arg->field.field) {
3617                        arg->field.field = tep_find_any_field(event, arg->field.name);
3618                        if (!arg->field.field)
3619                                goto out_warning_field;
3620                        
3621                }
3622                /* must be a number */
3623                val = tep_read_number(tep, data + arg->field.field->offset,
3624                                      arg->field.field->size);
3625                break;
3626        case TEP_PRINT_FLAGS:
3627        case TEP_PRINT_SYMBOL:
3628        case TEP_PRINT_INT_ARRAY:
3629        case TEP_PRINT_HEX:
3630        case TEP_PRINT_HEX_STR:
3631                break;
3632        case TEP_PRINT_TYPE:
3633                val = eval_num_arg(data, size, event, arg->typecast.item);
3634                return eval_type(val, arg, 0);
3635        case TEP_PRINT_STRING:
3636        case TEP_PRINT_BSTRING:
3637        case TEP_PRINT_BITMASK:
3638                return 0;
3639        case TEP_PRINT_FUNC: {
3640                struct trace_seq s;
3641                trace_seq_init(&s);
3642                val = process_defined_func(&s, data, size, event, arg);
3643                trace_seq_destroy(&s);
3644                return val;
3645        }
3646        case TEP_PRINT_OP:
3647                if (strcmp(arg->op.op, "[") == 0) {
3648                        /*
3649                         * Arrays are special, since we don't want
3650                         * to read the arg as is.
3651                         */
3652                        right = eval_num_arg(data, size, event, arg->op.right);
3653
3654                        /* handle typecasts */
3655                        larg = arg->op.left;
3656                        while (larg->type == TEP_PRINT_TYPE) {
3657                                if (!typearg)
3658                                        typearg = larg;
3659                                larg = larg->typecast.item;
3660                        }
3661
3662                        /* Default to long size */
3663                        field_size = tep->long_size;
3664
3665                        switch (larg->type) {
3666                        case TEP_PRINT_DYNAMIC_ARRAY:
3667                                offset = tep_read_number(tep,
3668                                                   data + larg->dynarray.field->offset,
3669                                                   larg->dynarray.field->size);
3670                                if (larg->dynarray.field->elementsize)
3671                                        field_size = larg->dynarray.field->elementsize;
3672                                /*
3673                                 * The actual length of the dynamic array is stored
3674                                 * in the top half of the field, and the offset
3675                                 * is in the bottom half of the 32 bit field.
3676                                 */
3677                                offset &= 0xffff;
3678                                offset += right;
3679                                break;
3680                        case TEP_PRINT_FIELD:
3681                                if (!larg->field.field) {
3682                                        larg->field.field =
3683                                                tep_find_any_field(event, larg->field.name);
3684                                        if (!larg->field.field) {
3685                                                arg = larg;
3686                                                goto out_warning_field;
3687                                        }
3688                                }
3689                                field_size = larg->field.field->elementsize;
3690                                offset = larg->field.field->offset +
3691                                        right * larg->field.field->elementsize;
3692                                break;
3693                        default:
3694                                goto default_op; /* oops, all bets off */
3695                        }
3696                        val = tep_read_number(tep,
3697                                              data + offset, field_size);
3698                        if (typearg)
3699                                val = eval_type(val, typearg, 1);
3700                        break;
3701                } else if (strcmp(arg->op.op, "?") == 0) {
3702                        left = eval_num_arg(data, size, event, arg->op.left);
3703                        arg = arg->op.right;
3704                        if (left)
3705                                val = eval_num_arg(data, size, event, arg->op.left);
3706                        else
3707                                val = eval_num_arg(data, size, event, arg->op.right);
3708                        break;
3709                }
3710 default_op:
3711                left = eval_num_arg(data, size, event, arg->op.left);
3712                right = eval_num_arg(data, size, event, arg->op.right);
3713                switch (arg->op.op[0]) {
3714                case '!':
3715                        switch (arg->op.op[1]) {
3716                        case 0:
3717                                val = !right;
3718                                break;
3719                        case '=':
3720                                val = left != right;
3721                                break;
3722                        default:
3723                                goto out_warning_op;
3724                        }
3725                        break;
3726                case '~':
3727                        val = ~right;
3728                        break;
3729                case '|':
3730                        if (arg->op.op[1])
3731                                val = left || right;
3732                        else
3733                                val = left | right;
3734                        break;
3735                case '&':
3736                        if (arg->op.op[1])
3737                                val = left && right;
3738                        else
3739                                val = left & right;
3740                        break;
3741                case '<':
3742                        switch (arg->op.op[1]) {
3743                        case 0:
3744                                val = left < right;
3745                                break;
3746                        case '<':
3747                                val = left << right;
3748                                break;
3749                        case '=':
3750                                val = left <= right;
3751                                break;
3752                        default:
3753                                goto out_warning_op;
3754                        }
3755                        break;
3756                case '>':
3757                        switch (arg->op.op[1]) {
3758                        case 0:
3759                                val = left > right;
3760                                break;
3761                        case '>':
3762                                val = left >> right;
3763                                break;
3764                        case '=':
3765                                val = left >= right;
3766                                break;
3767                        default:
3768                                goto out_warning_op;
3769                        }
3770                        break;
3771                case '=':
3772                        if (arg->op.op[1] != '=')
3773                                goto out_warning_op;
3774
3775                        val = left == right;
3776                        break;
3777                case '-':
3778                        val = left - right;
3779                        break;
3780                case '+':
3781                        val = left + right;
3782                        break;
3783                case '/':
3784                        val = left / right;
3785                        break;
3786                case '%':
3787                        val = left % right;
3788                        break;
3789                case '*':
3790                        val = left * right;
3791                        break;
3792                default:
3793                        goto out_warning_op;
3794                }
3795                break;
3796        case TEP_PRINT_DYNAMIC_ARRAY_LEN:
3797                offset = tep_read_number(tep,
3798                                         data + arg->dynarray.field->offset,
3799                                         arg->dynarray.field->size);
3800                /*
3801                 * The total allocated length of the dynamic array is
3802                 * stored in the top half of the field, and the offset
3803                 * is in the bottom half of the 32 bit field.
3804                 */
3805                val = (unsigned long long)(offset >> 16);
3806                break;
3807        case TEP_PRINT_DYNAMIC_ARRAY:
3808                /* Without [], we pass the address to the dynamic data */
3809                offset = tep_read_number(tep,
3810                                         data + arg->dynarray.field->offset,
3811                                         arg->dynarray.field->size);
3812                /*
3813                 * The total allocated length of the dynamic array is
3814                 * stored in the top half of the field, and the offset
3815                 * is in the bottom half of the 32 bit field.
3816                 */
3817                offset &= 0xffff;
3818                val = (unsigned long long)((unsigned long)data + offset);
3819                break;
3820        default: /* not sure what to do there */
3821                return 0;
3822        }
3823        return val;
3824
3825out_warning_op:
3826        do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3827        return 0;
3828
3829out_warning_field:
3830        do_warning_event(event, "%s: field %s not found",
3831                         __func__, arg->field.name);
3832        return 0;
3833}
3834
3835struct flag {
3836        const char *name;
3837        unsigned long long value;
3838};
3839
3840static const struct flag flags[] = {
3841        { "HI_SOFTIRQ", 0 },
3842        { "TIMER_SOFTIRQ", 1 },
3843        { "NET_TX_SOFTIRQ", 2 },
3844        { "NET_RX_SOFTIRQ", 3 },
3845        { "BLOCK_SOFTIRQ", 4 },
3846        { "IRQ_POLL_SOFTIRQ", 5 },
3847        { "TASKLET_SOFTIRQ", 6 },
3848        { "SCHED_SOFTIRQ", 7 },
3849        { "HRTIMER_SOFTIRQ", 8 },
3850        { "RCU_SOFTIRQ", 9 },
3851
3852        { "HRTIMER_NORESTART", 0 },
3853        { "HRTIMER_RESTART", 1 },
3854};
3855
3856static long long eval_flag(const char *flag)
3857{
3858        int i;
3859
3860        /*
3861         * Some flags in the format files do not get converted.
3862         * If the flag is not numeric, see if it is something that
3863         * we already know about.
3864         */
3865        if (isdigit(flag[0]))
3866                return strtoull(flag, NULL, 0);
3867
3868        for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
3869                if (strcmp(flags[i].name, flag) == 0)
3870                        return flags[i].value;
3871
3872        return -1LL;
3873}
3874
3875static void print_str_to_seq(struct trace_seq *s, const char *format,
3876                             int len_arg, const char *str)
3877{
3878        if (len_arg >= 0)
3879                trace_seq_printf(s, format, len_arg, str);
3880        else
3881                trace_seq_printf(s, format, str);
3882}
3883
3884static void print_bitmask_to_seq(struct tep_handle *tep,
3885                                 struct trace_seq *s, const char *format,
3886                                 int len_arg, const void *data, int size)
3887{
3888        int nr_bits = size * 8;
3889        int str_size = (nr_bits + 3) / 4;
3890        int len = 0;
3891        char buf[3];
3892        char *str;
3893        int index;
3894        int i;
3895
3896        /*
3897         * The kernel likes to put in commas every 32 bits, we
3898         * can do the same.
3899         */
3900        str_size += (nr_bits - 1) / 32;
3901
3902        str = malloc(str_size + 1);
3903        if (!str) {
3904                do_warning("%s: not enough memory!", __func__);
3905                return;
3906        }
3907        str[str_size] = 0;
3908
3909        /* Start out with -2 for the two chars per byte */
3910        for (i = str_size - 2; i >= 0; i -= 2) {
3911                /*
3912                 * data points to a bit mask of size bytes.
3913                 * In the kernel, this is an array of long words, thus
3914                 * endianness is very important.
3915                 */
3916                if (tep->file_bigendian)
3917                        index = size - (len + 1);
3918                else
3919                        index = len;
3920
3921                snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
3922                memcpy(str + i, buf, 2);
3923                len++;
3924                if (!(len & 3) && i > 0) {
3925                        i--;
3926                        str[i] = ',';
3927                }
3928        }
3929
3930        if (len_arg >= 0)
3931                trace_seq_printf(s, format, len_arg, str);
3932        else
3933                trace_seq_printf(s, format, str);
3934
3935        free(str);
3936}
3937
3938static void print_str_arg(struct trace_seq *s, void *data, int size,
3939                          struct tep_event *event, const char *format,
3940                          int len_arg, struct tep_print_arg *arg)
3941{
3942        struct tep_handle *tep = event->tep;
3943        struct tep_print_flag_sym *flag;
3944        struct tep_format_field *field;
3945        struct printk_map *printk;
3946        long long val, fval;
3947        unsigned long long addr;
3948        char *str;
3949        unsigned char *hex;
3950        int print;
3951        int i, len;
3952
3953        switch (arg->type) {
3954        case TEP_PRINT_NULL:
3955                /* ?? */
3956                return;
3957        case TEP_PRINT_ATOM:
3958                print_str_to_seq(s, format, len_arg, arg->atom.atom);
3959                return;
3960        case TEP_PRINT_FIELD:
3961                field = arg->field.field;
3962                if (!field) {
3963                        field = tep_find_any_field(event, arg->field.name);
3964                        if (!field) {
3965                                str = arg->field.name;
3966                                goto out_warning_field;
3967                        }
3968                        arg->field.field = field;
3969                }
3970                /* Zero sized fields, mean the rest of the data */
3971                len = field->size ? : size - field->offset;
3972
3973                /*
3974                 * Some events pass in pointers. If this is not an array
3975                 * and the size is the same as long_size, assume that it
3976                 * is a pointer.
3977                 */
3978                if (!(field->flags & TEP_FIELD_IS_ARRAY) &&
3979                    field->size == tep->long_size) {
3980
3981                        /* Handle heterogeneous recording and processing
3982                         * architectures
3983                         *
3984                         * CASE I:
3985                         * Traces recorded on 32-bit devices (32-bit
3986                         * addressing) and processed on 64-bit devices:
3987                         * In this case, only 32 bits should be read.
3988                         *
3989                         * CASE II:
3990                         * Traces recorded on 64 bit devices and processed
3991                         * on 32-bit devices:
3992                         * In this case, 64 bits must be read.
3993                         */
3994                        addr = (tep->long_size == 8) ?
3995                                *(unsigned long long *)(data + field->offset) :
3996                                (unsigned long long)*(unsigned int *)(data + field->offset);
3997
3998                        /* Check if it matches a print format */
3999                        printk = find_printk(tep, addr);
4000                        if (printk)
4001                                trace_seq_puts(s, printk->printk);
4002                        else
4003                                trace_seq_printf(s, "%llx", addr);
4004                        break;
4005                }
4006                str = malloc(len + 1);
4007                if (!str) {
4008                        do_warning_event(event, "%s: not enough memory!",
4009                                         __func__);
4010                        return;
4011                }
4012                memcpy(str, data + field->offset, len);
4013                str[len] = 0;
4014                print_str_to_seq(s, format, len_arg, str);
4015                free(str);
4016                break;
4017        case TEP_PRINT_FLAGS:
4018                val = eval_num_arg(data, size, event, arg->flags.field);
4019                print = 0;
4020                for (flag = arg->flags.flags; flag; flag = flag->next) {
4021                        fval = eval_flag(flag->value);
4022                        if (!val && fval < 0) {
4023                                print_str_to_seq(s, format, len_arg, flag->str);
4024                                break;
4025                        }
4026                        if (fval > 0 && (val & fval) == fval) {
4027                                if (print && arg->flags.delim)
4028                                        trace_seq_puts(s, arg->flags.delim);
4029                                print_str_to_seq(s, format, len_arg, flag->str);
4030                                print = 1;
4031                                val &= ~fval;
4032                        }
4033                }
4034                if (val) {
4035                        if (print && arg->flags.delim)
4036                                trace_seq_puts(s, arg->flags.delim);
4037                        trace_seq_printf(s, "0x%llx", val);
4038                }
4039                break;
4040        case TEP_PRINT_SYMBOL:
4041                val = eval_num_arg(data, size, event, arg->symbol.field);
4042                for (flag = arg->symbol.symbols; flag; flag = flag->next) {
4043                        fval = eval_flag(flag->value);
4044                        if (val == fval) {
4045                                print_str_to_seq(s, format, len_arg, flag->str);
4046                                break;
4047                        }
4048                }
4049                if (!flag)
4050                        trace_seq_printf(s, "0x%llx", val);
4051                break;
4052        case TEP_PRINT_HEX:
4053        case TEP_PRINT_HEX_STR:
4054                if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4055                        unsigned long offset;
4056                        offset = tep_read_number(tep,
4057                                data + arg->hex.field->dynarray.field->offset,
4058                                arg->hex.field->dynarray.field->size);
4059                        hex = data + (offset & 0xffff);
4060                } else {
4061                        field = arg->hex.field->field.field;
4062                        if (!field) {
4063                                str = arg->hex.field->field.name;
4064                                field = tep_find_any_field(event, str);
4065                                if (!field)
4066                                        goto out_warning_field;
4067                                arg->hex.field->field.field = field;
4068                        }
4069                        hex = data + field->offset;
4070                }
4071                len = eval_num_arg(data, size, event, arg->hex.size);
4072                for (i = 0; i < len; i++) {
4073                        if (i && arg->type == TEP_PRINT_HEX)
4074                                trace_seq_putc(s, ' ');
4075                        trace_seq_printf(s, "%02x", hex[i]);
4076                }
4077                break;
4078
4079        case TEP_PRINT_INT_ARRAY: {
4080                void *num;
4081                int el_size;
4082
4083                if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4084                        unsigned long offset;
4085                        struct tep_format_field *field =
4086                                arg->int_array.field->dynarray.field;
4087                        offset = tep_read_number(tep,
4088                                                 data + field->offset,
4089                                                 field->size);
4090                        num = data + (offset & 0xffff);
4091                } else {
4092                        field = arg->int_array.field->field.field;
4093                        if (!field) {
4094                                str = arg->int_array.field->field.name;
4095                                field = tep_find_any_field(event, str);
4096                                if (!field)
4097                                        goto out_warning_field;
4098                                arg->int_array.field->field.field = field;
4099                        }
4100                        num = data + field->offset;
4101                }
4102                len = eval_num_arg(data, size, event, arg->int_array.count);
4103                el_size = eval_num_arg(data, size, event,
4104                                       arg->int_array.el_size);
4105                for (i = 0; i < len; i++) {
4106                        if (i)
4107                                trace_seq_putc(s, ' ');
4108
4109                        if (el_size == 1) {
4110                                trace_seq_printf(s, "%u", *(uint8_t *)num);
4111                        } else if (el_size == 2) {
4112                                trace_seq_printf(s, "%u", *(uint16_t *)num);
4113                        } else if (el_size == 4) {
4114                                trace_seq_printf(s, "%u", *(uint32_t *)num);
4115                        } else if (el_size == 8) {
4116                                trace_seq_printf(s, "%"PRIu64, *(uint64_t *)num);
4117                        } else {
4118                                trace_seq_printf(s, "BAD SIZE:%d 0x%x",
4119                                                 el_size, *(uint8_t *)num);
4120                                el_size = 1;
4121                        }
4122
4123                        num += el_size;
4124                }
4125                break;
4126        }
4127        case TEP_PRINT_TYPE:
4128                break;
4129        case TEP_PRINT_STRING: {
4130                int str_offset;
4131
4132                if (arg->string.offset == -1) {
4133                        struct tep_format_field *f;
4134
4135                        f = tep_find_any_field(event, arg->string.string);
4136                        arg->string.offset = f->offset;
4137                }
4138                str_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->string.offset));
4139                str_offset &= 0xffff;
4140                print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
4141                break;
4142        }
4143        case TEP_PRINT_BSTRING:
4144                print_str_to_seq(s, format, len_arg, arg->string.string);
4145                break;
4146        case TEP_PRINT_BITMASK: {
4147                int bitmask_offset;
4148                int bitmask_size;
4149
4150                if (arg->bitmask.offset == -1) {
4151                        struct tep_format_field *f;
4152
4153                        f = tep_find_any_field(event, arg->bitmask.bitmask);
4154                        arg->bitmask.offset = f->offset;
4155                }
4156                bitmask_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->bitmask.offset));
4157                bitmask_size = bitmask_offset >> 16;
4158                bitmask_offset &= 0xffff;
4159                print_bitmask_to_seq(tep, s, format, len_arg,
4160                                     data + bitmask_offset, bitmask_size);
4161                break;
4162        }
4163        case TEP_PRINT_OP:
4164                /*
4165                 * The only op for string should be ? :
4166                 */
4167                if (arg->op.op[0] != '?')
4168                        return;
4169                val = eval_num_arg(data, size, event, arg->op.left);
4170                if (val)
4171                        print_str_arg(s, data, size, event,
4172                                      format, len_arg, arg->op.right->op.left);
4173                else
4174                        print_str_arg(s, data, size, event,
4175                                      format, len_arg, arg->op.right->op.right);
4176                break;
4177        case TEP_PRINT_FUNC:
4178                process_defined_func(s, data, size, event, arg);
4179                break;
4180        default:
4181                /* well... */
4182                break;
4183        }
4184
4185        return;
4186
4187out_warning_field:
4188        do_warning_event(event, "%s: field %s not found",
4189                         __func__, arg->field.name);
4190}
4191
4192static unsigned long long
4193process_defined_func(struct trace_seq *s, void *data, int size,
4194                     struct tep_event *event, struct tep_print_arg *arg)
4195{
4196        struct tep_function_handler *func_handle = arg->func.func;
4197        struct func_params *param;
4198        unsigned long long *args;
4199        unsigned long long ret;
4200        struct tep_print_arg *farg;
4201        struct trace_seq str;
4202        struct save_str {
4203                struct save_str *next;
4204                char *str;
4205        } *strings = NULL, *string;
4206        int i;
4207
4208        if (!func_handle->nr_args) {
4209                ret = (*func_handle->func)(s, NULL);
4210                goto out;
4211        }
4212
4213        farg = arg->func.args;
4214        param = func_handle->params;
4215
4216        ret = ULLONG_MAX;
4217        args = malloc(sizeof(*args) * func_handle->nr_args);
4218        if (!args)
4219                goto out;
4220
4221        for (i = 0; i < func_handle->nr_args; i++) {
4222                switch (param->type) {
4223                case TEP_FUNC_ARG_INT:
4224                case TEP_FUNC_ARG_LONG:
4225                case TEP_FUNC_ARG_PTR:
4226                        args[i] = eval_num_arg(data, size, event, farg);
4227                        break;
4228                case TEP_FUNC_ARG_STRING:
4229                        trace_seq_init(&str);
4230                        print_str_arg(&str, data, size, event, "%s", -1, farg);
4231                        trace_seq_terminate(&str);
4232                        string = malloc(sizeof(*string));
4233                        if (!string) {
4234                                do_warning_event(event, "%s(%d): malloc str",
4235                                                 __func__, __LINE__);
4236                                goto out_free;
4237                        }
4238                        string->next = strings;
4239                        string->str = strdup(str.buffer);
4240                        if (!string->str) {
4241                                free(string);
4242                                do_warning_event(event, "%s(%d): malloc str",
4243                                                 __func__, __LINE__);
4244                                goto out_free;
4245                        }
4246                        args[i] = (uintptr_t)string->str;
4247                        strings = string;
4248                        trace_seq_destroy(&str);
4249                        break;
4250                default:
4251                        /*
4252                         * Something went totally wrong, this is not
4253                         * an input error, something in this code broke.
4254                         */
4255                        do_warning_event(event, "Unexpected end of arguments\n");
4256                        goto out_free;
4257                }
4258                farg = farg->next;
4259                param = param->next;
4260        }
4261
4262        ret = (*func_handle->func)(s, args);
4263out_free:
4264        free(args);
4265        while (strings) {
4266                string = strings;
4267                strings = string->next;
4268                free(string->str);
4269                free(string);
4270        }
4271
4272 out:
4273        /* TBD : handle return type here */
4274        return ret;
4275}
4276
4277static void free_args(struct tep_print_arg *args)
4278{
4279        struct tep_print_arg *next;
4280
4281        while (args) {
4282                next = args->next;
4283
4284                free_arg(args);
4285                args = next;
4286        }
4287}
4288
4289static struct tep_print_arg *make_bprint_args(char *fmt, void *data, int size, struct tep_event *event)
4290{
4291        struct tep_handle *tep = event->tep;
4292        struct tep_format_field *field, *ip_field;
4293        struct tep_print_arg *args, *arg, **next;
4294        unsigned long long ip, val;
4295        char *ptr;
4296        void *bptr;
4297        int vsize = 0;
4298
4299        field = tep->bprint_buf_field;
4300        ip_field = tep->bprint_ip_field;
4301
4302        if (!field) {
4303                field = tep_find_field(event, "buf");
4304                if (!field) {
4305                        do_warning_event(event, "can't find buffer field for binary printk");
4306                        return NULL;
4307                }
4308                ip_field = tep_find_field(event, "ip");
4309                if (!ip_field) {
4310                        do_warning_event(event, "can't find ip field for binary printk");
4311                        return NULL;
4312                }
4313                tep->bprint_buf_field = field;
4314                tep->bprint_ip_field = ip_field;
4315        }
4316
4317        ip = tep_read_number(tep, data + ip_field->offset, ip_field->size);
4318
4319        /*
4320         * The first arg is the IP pointer.
4321         */
4322        args = alloc_arg();
4323        if (!args) {
4324                do_warning_event(event, "%s(%d): not enough memory!",
4325                                 __func__, __LINE__);
4326                return NULL;
4327        }
4328        arg = args;
4329        arg->next = NULL;
4330        next = &arg->next;
4331
4332        arg->type = TEP_PRINT_ATOM;
4333                
4334        if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4335                goto out_free;
4336
4337        /* skip the first "%ps: " */
4338        for (ptr = fmt + 5, bptr = data + field->offset;
4339             bptr < data + size && *ptr; ptr++) {
4340                int ls = 0;
4341
4342                if (*ptr == '%') {
4343 process_again:
4344                        ptr++;
4345                        switch (*ptr) {
4346                        case '%':
4347                                break;
4348                        case 'l':
4349                                ls++;
4350                                goto process_again;
4351                        case 'L':
4352                                ls = 2;
4353                                goto process_again;
4354                        case '0' ... '9':
4355                                goto process_again;
4356                        case '.':
4357                                goto process_again;
4358                        case 'z':
4359                        case 'Z':
4360                                ls = 1;
4361                                goto process_again;
4362                        case 'p':
4363                                ls = 1;
4364                                if (isalnum(ptr[1])) {
4365                                        ptr++;
4366                                        /* Check for special pointers */
4367                                        switch (*ptr) {
4368                                        case 's':
4369                                        case 'S':
4370                                        case 'x':
4371                                                break;
4372                                        case 'f':
4373                                        case 'F':
4374                                                /*
4375                                                 * Pre-5.5 kernels use %pf and
4376                                                 * %pF for printing symbols
4377                                                 * while kernels since 5.5 use
4378                                                 * %pfw for fwnodes. So check
4379                                                 * %p[fF] isn't followed by 'w'.
4380                                                 */
4381                                                if (ptr[1] != 'w')
4382                                                        break;
4383                                                /* fall through */
4384                                        default:
4385                                                /*
4386                                                 * Older kernels do not process
4387                                                 * dereferenced pointers.
4388                                                 * Only process if the pointer
4389                                                 * value is a printable.
4390                                                 */
4391                                                if (isprint(*(char *)bptr))
4392                                                        goto process_string;
4393                                        }
4394                                }
4395                                /* fall through */
4396                        case 'd':
4397                        case 'u':
4398                        case 'x':
4399                        case 'i':
4400                                switch (ls) {
4401                                case 0:
4402                                        vsize = 4;
4403                                        break;
4404                                case 1:
4405                                        vsize = tep->long_size;
4406                                        break;
4407                                case 2:
4408                                        vsize = 8;
4409                                        break;
4410                                default:
4411                                        vsize = ls; /* ? */
4412                                        break;
4413                                }
4414                        /* fall through */
4415                        case '*':
4416                                if (*ptr == '*')
4417                                        vsize = 4;
4418
4419                                /* the pointers are always 4 bytes aligned */
4420                                bptr = (void *)(((unsigned long)bptr + 3) &
4421                                                ~3);
4422                                val = tep_read_number(tep, bptr, vsize);
4423                                bptr += vsize;
4424                                arg = alloc_arg();
4425                                if (!arg) {
4426                                        do_warning_event(event, "%s(%d): not enough memory!",
4427                                                   __func__, __LINE__);
4428                                        goto out_free;
4429                                }
4430                                arg->next = NULL;
4431                                arg->type = TEP_PRINT_ATOM;
4432                                if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4433                                        free(arg);
4434                                        goto out_free;
4435                                }
4436                                *next = arg;
4437                                next = &arg->next;
4438                                /*
4439                                 * The '*' case means that an arg is used as the length.
4440                                 * We need to continue to figure out for what.
4441                                 */
4442                                if (*ptr == '*')
4443                                        goto process_again;
4444
4445                                break;
4446                        case 's':
4447 process_string:
4448                                arg = alloc_arg();
4449                                if (!arg) {
4450                                        do_warning_event(event, "%s(%d): not enough memory!",
4451                                                   __func__, __LINE__);
4452                                        goto out_free;
4453                                }
4454                                arg->next = NULL;
4455                                arg->type = TEP_PRINT_BSTRING;
4456                                arg->string.string = strdup(bptr);
4457                                if (!arg->string.string)
4458                                        goto out_free;
4459                                bptr += strlen(bptr) + 1;
4460                                *next = arg;
4461                                next = &arg->next;
4462                        default:
4463                                break;
4464                        }
4465                }
4466        }
4467
4468        return args;
4469
4470out_free:
4471        free_args(args);
4472        return NULL;
4473}
4474
4475static char *
4476get_bprint_format(void *data, int size __maybe_unused,
4477                  struct tep_event *event)
4478{
4479        struct tep_handle *tep = event->tep;
4480        unsigned long long addr;
4481        struct tep_format_field *field;
4482        struct printk_map *printk;
4483        char *format;
4484
4485        field = tep->bprint_fmt_field;
4486
4487        if (!field) {
4488                field = tep_find_field(event, "fmt");
4489                if (!field) {
4490                        do_warning_event(event, "can't find format field for binary printk");
4491                        return NULL;
4492                }
4493                tep->bprint_fmt_field = field;
4494        }
4495
4496        addr = tep_read_number(tep, data + field->offset, field->size);
4497
4498        printk = find_printk(tep, addr);
4499        if (!printk) {
4500                if (asprintf(&format, "%%ps: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4501                        return NULL;
4502                return format;
4503        }
4504
4505        if (asprintf(&format, "%s: %s", "%ps", printk->printk) < 0)
4506                return NULL;
4507
4508        return format;
4509}
4510
4511static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
4512                          struct tep_event *event, struct tep_print_arg *arg)
4513{
4514        unsigned char *buf;
4515        const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4516
4517        if (arg->type == TEP_PRINT_FUNC) {
4518                process_defined_func(s, data, size, event, arg);
4519                return;
4520        }
4521
4522        if (arg->type != TEP_PRINT_FIELD) {
4523                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4524                                 arg->type);
4525                return;
4526        }
4527
4528        if (mac == 'm')
4529                fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4530        if (!arg->field.field) {
4531                arg->field.field =
4532                        tep_find_any_field(event, arg->field.name);
4533                if (!arg->field.field) {
4534                        do_warning_event(event, "%s: field %s not found",
4535                                         __func__, arg->field.name);
4536                        return;
4537                }
4538        }
4539        if (arg->field.field->size != 6) {
4540                trace_seq_printf(s, "INVALIDMAC");
4541                return;
4542        }
4543        buf = data + arg->field.field->offset;
4544        trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4545}
4546
4547static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
4548{
4549        const char *fmt;
4550
4551        if (i == 'i')
4552                fmt = "%03d.%03d.%03d.%03d";
4553        else
4554                fmt = "%d.%d.%d.%d";
4555
4556        trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4557}
4558
4559static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4560{
4561        return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4562                (unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4563}
4564
4565static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4566{
4567        return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4568}
4569
4570static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4571{
4572        int i, j, range;
4573        unsigned char zerolength[8];
4574        int longest = 1;
4575        int colonpos = -1;
4576        uint16_t word;
4577        uint8_t hi, lo;
4578        bool needcolon = false;
4579        bool useIPv4;
4580        struct in6_addr in6;
4581
4582        memcpy(&in6, addr, sizeof(struct in6_addr));
4583
4584        useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4585
4586        memset(zerolength, 0, sizeof(zerolength));
4587
4588        if (useIPv4)
4589                range = 6;
4590        else
4591                range = 8;
4592
4593        /* find position of longest 0 run */
4594        for (i = 0; i < range; i++) {
4595                for (j = i; j < range; j++) {
4596                        if (in6.s6_addr16[j] != 0)
4597                                break;
4598                        zerolength[i]++;
4599                }
4600        }
4601        for (i = 0; i < range; i++) {
4602                if (zerolength[i] > longest) {
4603                        longest = zerolength[i];
4604                        colonpos = i;
4605                }
4606        }
4607        if (longest == 1)               /* don't compress a single 0 */
4608                colonpos = -1;
4609
4610        /* emit address */
4611        for (i = 0; i < range; i++) {
4612                if (i == colonpos) {
4613                        if (needcolon || i == 0)
4614                                trace_seq_printf(s, ":");
4615                        trace_seq_printf(s, ":");
4616                        needcolon = false;
4617                        i += longest - 1;
4618                        continue;
4619                }
4620                if (needcolon) {
4621                        trace_seq_printf(s, ":");
4622                        needcolon = false;
4623                }
4624                /* hex u16 without leading 0s */
4625                word = ntohs(in6.s6_addr16[i]);
4626                hi = word >> 8;
4627                lo = word & 0xff;
4628                if (hi)
4629                        trace_seq_printf(s, "%x%02x", hi, lo);
4630                else
4631                        trace_seq_printf(s, "%x", lo);
4632
4633                needcolon = true;
4634        }
4635
4636        if (useIPv4) {
4637                if (needcolon)
4638                        trace_seq_printf(s, ":");
4639                print_ip4_addr(s, 'I', &in6.s6_addr[12]);
4640        }
4641
4642        return;
4643}
4644
4645static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4646{
4647        int j;
4648
4649        for (j = 0; j < 16; j += 2) {
4650                trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4651                if (i == 'I' && j < 14)
4652                        trace_seq_printf(s, ":");
4653        }
4654}
4655
4656/*
4657 * %pi4   print an IPv4 address with leading zeros
4658 * %pI4   print an IPv4 address without leading zeros
4659 * %pi6   print an IPv6 address without colons
4660 * %pI6   print an IPv6 address with colons
4661 * %pI6c  print an IPv6 address in compressed form with colons
4662 * %pISpc print an IP address based on sockaddr; p adds port.
4663 */
4664static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4665                          void *data, int size, struct tep_event *event,
4666                          struct tep_print_arg *arg)
4667{
4668        unsigned char *buf;
4669
4670        if (arg->type == TEP_PRINT_FUNC) {
4671                process_defined_func(s, data, size, event, arg);
4672                return 0;
4673        }
4674
4675        if (arg->type != TEP_PRINT_FIELD) {
4676                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4677                return 0;
4678        }
4679
4680        if (!arg->field.field) {
4681                arg->field.field =
4682                        tep_find_any_field(event, arg->field.name);
4683                if (!arg->field.field) {
4684                        do_warning("%s: field %s not found",
4685                                   __func__, arg->field.name);
4686                        return 0;
4687                }
4688        }
4689
4690        buf = data + arg->field.field->offset;
4691
4692        if (arg->field.field->size != 4) {
4693                trace_seq_printf(s, "INVALIDIPv4");
4694                return 0;
4695        }
4696        print_ip4_addr(s, i, buf);
4697
4698        return 0;
4699}
4700
4701static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4702                          void *data, int size, struct tep_event *event,
4703                          struct tep_print_arg *arg)
4704{
4705        char have_c = 0;
4706        unsigned char *buf;
4707        int rc = 0;
4708
4709        /* pI6c */
4710        if (i == 'I' && *ptr == 'c') {
4711                have_c = 1;
4712                ptr++;
4713                rc++;
4714        }
4715
4716        if (arg->type == TEP_PRINT_FUNC) {
4717                process_defined_func(s, data, size, event, arg);
4718                return rc;
4719        }
4720
4721        if (arg->type != TEP_PRINT_FIELD) {
4722                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4723                return rc;
4724        }
4725
4726        if (!arg->field.field) {
4727                arg->field.field =
4728                        tep_find_any_field(event, arg->field.name);
4729                if (!arg->field.field) {
4730                        do_warning("%s: field %s not found",
4731                                   __func__, arg->field.name);
4732                        return rc;
4733                }
4734        }
4735
4736        buf = data + arg->field.field->offset;
4737
4738        if (arg->field.field->size != 16) {
4739                trace_seq_printf(s, "INVALIDIPv6");
4740                return rc;
4741        }
4742
4743        if (have_c)
4744                print_ip6c_addr(s, buf);
4745        else
4746                print_ip6_addr(s, i, buf);
4747
4748        return rc;
4749}
4750
4751static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4752                          void *data, int size, struct tep_event *event,
4753                          struct tep_print_arg *arg)
4754{
4755        char have_c = 0, have_p = 0;
4756        unsigned char *buf;
4757        struct sockaddr_storage *sa;
4758        int rc = 0;
4759
4760        /* pISpc */
4761        if (i == 'I') {
4762                if (*ptr == 'p') {
4763                        have_p = 1;
4764                        ptr++;
4765                        rc++;
4766                }
4767                if (*ptr == 'c') {
4768                        have_c = 1;
4769                        ptr++;
4770                        rc++;
4771                }
4772        }
4773
4774        if (arg->type == TEP_PRINT_FUNC) {
4775                process_defined_func(s, data, size, event, arg);
4776                return rc;
4777        }
4778
4779        if (arg->type != TEP_PRINT_FIELD) {
4780                trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4781                return rc;
4782        }
4783
4784        if (!arg->field.field) {
4785                arg->field.field =
4786                        tep_find_any_field(event, arg->field.name);
4787                if (!arg->field.field) {
4788                        do_warning("%s: field %s not found",
4789                                   __func__, arg->field.name);
4790                        return rc;
4791                }
4792        }
4793
4794        sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4795
4796        if (sa->ss_family == AF_INET) {
4797                struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4798
4799                if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4800                        trace_seq_printf(s, "INVALIDIPv4");
4801                        return rc;
4802                }
4803
4804                print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
4805                if (have_p)
4806                        trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4807
4808
4809        } else if (sa->ss_family == AF_INET6) {
4810                struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4811
4812                if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4813                        trace_seq_printf(s, "INVALIDIPv6");
4814                        return rc;
4815                }
4816
4817                if (have_p)
4818                        trace_seq_printf(s, "[");
4819
4820                buf = (unsigned char *) &sa6->sin6_addr;
4821                if (have_c)
4822                        print_ip6c_addr(s, buf);
4823                else
4824                        print_ip6_addr(s, i, buf);
4825
4826                if (have_p)
4827                        trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4828        }
4829
4830        return rc;
4831}
4832
4833static int print_ip_arg(struct trace_seq *s, const char *ptr,
4834                        void *data, int size, struct tep_event *event,
4835                        struct tep_print_arg *arg)
4836{
4837        char i = *ptr;  /* 'i' or 'I' */
4838        char ver;
4839        int rc = 0;
4840
4841        ptr++;
4842        rc++;
4843
4844        ver = *ptr;
4845        ptr++;
4846        rc++;
4847
4848        switch (ver) {
4849        case '4':
4850                rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
4851                break;
4852        case '6':
4853                rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
4854                break;
4855        case 'S':
4856                rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
4857                break;
4858        default:
4859                return 0;
4860        }
4861
4862        return rc;
4863}
4864
4865static int is_printable_array(char *p, unsigned int len)
4866{
4867        unsigned int i;
4868
4869        for (i = 0; i < len && p[i]; i++)
4870                if (!isprint(p[i]) && !isspace(p[i]))
4871                    return 0;
4872        return 1;
4873}
4874
4875void tep_print_field(struct trace_seq *s, void *data,
4876                     struct tep_format_field *field)
4877{
4878        unsigned long long val;
4879        unsigned int offset, len, i;
4880        struct tep_handle *tep = field->event->tep;
4881
4882        if (field->flags & TEP_FIELD_IS_ARRAY) {
4883                offset = field->offset;
4884                len = field->size;
4885                if (field->flags & TEP_FIELD_IS_DYNAMIC) {
4886                        val = tep_read_number(tep, data + offset, len);
4887                        offset = val;
4888                        len = offset >> 16;
4889                        offset &= 0xffff;
4890                }
4891                if (field->flags & TEP_FIELD_IS_STRING &&
4892                    is_printable_array(data + offset, len)) {
4893                        trace_seq_printf(s, "%s", (char *)data + offset);
4894                } else {
4895                        trace_seq_puts(s, "ARRAY[");
4896                        for (i = 0; i < len; i++) {
4897                                if (i)
4898                                        trace_seq_puts(s, ", ");
4899                                trace_seq_printf(s, "%02x",
4900                                                 *((unsigned char *)data + offset + i));
4901                        }
4902                        trace_seq_putc(s, ']');
4903                        field->flags &= ~TEP_FIELD_IS_STRING;
4904                }
4905        } else {
4906                val = tep_read_number(tep, data + field->offset,
4907                                      field->size);
4908                if (field->flags & TEP_FIELD_IS_POINTER) {
4909                        trace_seq_printf(s, "0x%llx", val);
4910                } else if (field->flags & TEP_FIELD_IS_SIGNED) {
4911                        switch (field->size) {
4912                        case 4:
4913                                /*
4914                                 * If field is long then print it in hex.
4915                                 * A long usually stores pointers.
4916                                 */
4917                                if (field->flags & TEP_FIELD_IS_LONG)
4918                                        trace_seq_printf(s, "0x%x", (int)val);
4919                                else
4920                                        trace_seq_printf(s, "%d", (int)val);
4921                                break;
4922                        case 2:
4923                                trace_seq_printf(s, "%2d", (short)val);
4924                                break;
4925                        case 1:
4926                                trace_seq_printf(s, "%1d", (char)val);
4927                                break;
4928                        default:
4929                                trace_seq_printf(s, "%lld", val);
4930                        }
4931                } else {
4932                        if (field->flags & TEP_FIELD_IS_LONG)
4933                                trace_seq_printf(s, "0x%llx", val);
4934                        else
4935                                trace_seq_printf(s, "%llu", val);
4936                }
4937        }
4938}
4939
4940void tep_print_fields(struct trace_seq *s, void *data,
4941                      int size __maybe_unused, struct tep_event *event)
4942{
4943        struct tep_format_field *field;
4944
4945        field = event->format.fields;
4946        while (field) {
4947                trace_seq_printf(s, " %s=", field->name);
4948                tep_print_field(s, data, field);
4949                field = field->next;
4950        }
4951}
4952
4953static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event *event)
4954{
4955        struct tep_handle *tep = event->tep;
4956        struct tep_print_fmt *print_fmt = &event->print_fmt;
4957        struct tep_print_arg *arg = print_fmt->args;
4958        struct tep_print_arg *args = NULL;
4959        const char *ptr = print_fmt->format;
4960        unsigned long long val;
4961        struct func_map *func;
4962        const char *saveptr;
4963        struct trace_seq p;
4964        char *bprint_fmt = NULL;
4965        char format[32];
4966        int show_func;
4967        int len_as_arg;
4968        int len_arg = 0;
4969        int len;
4970        int ls;
4971
4972        if (event->flags & TEP_EVENT_FL_FAILED) {
4973                trace_seq_printf(s, "[FAILED TO PARSE]");
4974                tep_print_fields(s, data, size, event);
4975                return;
4976        }
4977
4978        if (event->flags & TEP_EVENT_FL_ISBPRINT) {
4979                bprint_fmt = get_bprint_format(data, size, event);
4980                args = make_bprint_args(bprint_fmt, data, size, event);
4981                arg = args;
4982                ptr = bprint_fmt;
4983        }
4984
4985        for (; *ptr; ptr++) {
4986                ls = 0;
4987                if (*ptr == '\\') {
4988                        ptr++;
4989                        switch (*ptr) {
4990                        case 'n':
4991                                trace_seq_putc(s, '\n');
4992                                break;
4993                        case 't':
4994                                trace_seq_putc(s, '\t');
4995                                break;
4996                        case 'r':
4997                                trace_seq_putc(s, '\r');
4998                                break;
4999                        case '\\':
5000                                trace_seq_putc(s, '\\');
5001                                break;
5002                        default:
5003                                trace_seq_putc(s, *ptr);
5004                                break;
5005                        }
5006
5007                } else if (*ptr == '%') {
5008                        saveptr = ptr;
5009                        show_func = 0;
5010                        len_as_arg = 0;
5011 cont_process:
5012                        ptr++;
5013                        switch (*ptr) {
5014                        case '%':
5015                                trace_seq_putc(s, '%');
5016                                break;
5017                        case '#':
5018                                /* FIXME: need to handle properly */
5019                                goto cont_process;
5020                        case 'h':
5021                                ls--;
5022                                goto cont_process;
5023                        case 'l':
5024                                ls++;
5025                                goto cont_process;
5026                        case 'L':
5027                                ls = 2;
5028                                goto cont_process;
5029                        case '*':
5030                                /* The argument is the length. */
5031                                if (!arg) {
5032                                        do_warning_event(event, "no argument match");
5033                                        event->flags |= TEP_EVENT_FL_FAILED;
5034                                        goto out_failed;
5035                                }
5036                                len_arg = eval_num_arg(data, size, event, arg);
5037                                len_as_arg = 1;
5038                                arg = arg->next;
5039                                goto cont_process;
5040                        case '.':
5041                        case 'z':
5042                        case 'Z':
5043                        case '0' ... '9':
5044                        case '-':
5045                                goto cont_process;
5046                        case 'p':
5047                                if (tep->long_size == 4)
5048                                        ls = 1;
5049                                else
5050                                        ls = 2;
5051
5052                                if (isalnum(ptr[1]))
5053                                        ptr++;
5054
5055                                if (arg->type == TEP_PRINT_BSTRING) {
5056                                        trace_seq_puts(s, arg->string.string);
5057                                        arg = arg->next;
5058                                        break;
5059                                }
5060
5061                                if (*ptr == 'F' || *ptr == 'f' ||
5062                                    *ptr == 'S' || *ptr == 's') {
5063                                        show_func = *ptr;
5064                                } else if (*ptr == 'M' || *ptr == 'm') {
5065                                        print_mac_arg(s, *ptr, data, size, event, arg);
5066                                        arg = arg->next;
5067                                        break;
5068                                } else if (*ptr == 'I' || *ptr == 'i') {
5069                                        int n;
5070
5071                                        n = print_ip_arg(s, ptr, data, size, event, arg);
5072                                        if (n > 0) {
5073                                                ptr += n - 1;
5074                                                arg = arg->next;
5075                                                break;
5076                                        }
5077                                }
5078
5079                                /* fall through */
5080                        case 'd':
5081                        case 'i':
5082                        case 'x':
5083                        case 'X':
5084                        case 'u':
5085                                if (!arg) {
5086                                        do_warning_event(event, "no argument match");
5087                                        event->flags |= TEP_EVENT_FL_FAILED;
5088                                        goto out_failed;
5089                                }
5090
5091                                len = ((unsigned long)ptr + 1) -
5092                                        (unsigned long)saveptr;
5093
5094                                /* should never happen */
5095                                if (len > 31) {
5096                                        do_warning_event(event, "bad format!");
5097                                        event->flags |= TEP_EVENT_FL_FAILED;
5098                                        len = 31;
5099                                }
5100
5101                                memcpy(format, saveptr, len);
5102                                format[len] = 0;
5103
5104                                val = eval_num_arg(data, size, event, arg);
5105                                arg = arg->next;
5106
5107                                if (show_func) {
5108                                        func = find_func(tep, val);
5109                                        if (func) {
5110                                                trace_seq_puts(s, func->func);
5111                                                if (show_func == 'F')
5112                                                        trace_seq_printf(s,
5113                                                               "+0x%llx",
5114                                                               val - func->addr);
5115                                                break;
5116                                        }
5117                                }
5118                                if (tep->long_size == 8 && ls == 1 &&
5119                                    sizeof(long) != 8) {
5120                                        char *p;
5121
5122                                        /* make %l into %ll */
5123                                        if (ls == 1 && (p = strchr(format, 'l')))
5124                                                memmove(p+1, p, strlen(p)+1);
5125                                        else if (strcmp(format, "%p") == 0)
5126                                                strcpy(format, "0x%llx");
5127                                        ls = 2;
5128                                }
5129                                switch (ls) {
5130                                case -2:
5131                                        if (len_as_arg)
5132                                                trace_seq_printf(s, format, len_arg, (char)val);
5133                                        else
5134                                                trace_seq_printf(s, format, (char)val);
5135                                        break;
5136                                case -1:
5137                                        if (len_as_arg)
5138                                                trace_seq_printf(s, format, len_arg, (short)val);
5139                                        else
5140                                                trace_seq_printf(s, format, (short)val);
5141                                        break;
5142                                case 0:
5143                                        if (len_as_arg)
5144                                                trace_seq_printf(s, format, len_arg, (int)val);
5145                                        else
5146                                                trace_seq_printf(s, format, (int)val);
5147                                        break;
5148                                case 1:
5149                                        if (len_as_arg)
5150                                                trace_seq_printf(s, format, len_arg, (long)val);
5151                                        else
5152                                                trace_seq_printf(s, format, (long)val);
5153                                        break;
5154                                case 2:
5155                                        if (len_as_arg)
5156                                                trace_seq_printf(s, format, len_arg,
5157                                                                 (long long)val);
5158                                        else
5159                                                trace_seq_printf(s, format, (long long)val);
5160                                        break;
5161                                default:
5162                                        do_warning_event(event, "bad count (%d)", ls);
5163                                        event->flags |= TEP_EVENT_FL_FAILED;
5164                                }
5165                                break;
5166                        case 's':
5167                                if (!arg) {
5168                                        do_warning_event(event, "no matching argument");
5169                                        event->flags |= TEP_EVENT_FL_FAILED;
5170                                        goto out_failed;
5171                                }
5172
5173                                len = ((unsigned long)ptr + 1) -
5174                                        (unsigned long)saveptr;
5175
5176                                /* should never happen */
5177                                if (len > 31) {
5178                                        do_warning_event(event, "bad format!");
5179                                        event->flags |= TEP_EVENT_FL_FAILED;
5180                                        len = 31;
5181                                }
5182
5183                                memcpy(format, saveptr, len);
5184                                format[len] = 0;
5185                                if (!len_as_arg)
5186                                        len_arg = -1;
5187                                /* Use helper trace_seq */
5188                                trace_seq_init(&p);
5189                                print_str_arg(&p, data, size, event,
5190                                              format, len_arg, arg);
5191                                trace_seq_terminate(&p);
5192                                trace_seq_puts(s, p.buffer);
5193                                trace_seq_destroy(&p);
5194                                arg = arg->next;
5195                                break;
5196                        default:
5197                                trace_seq_printf(s, ">%c<", *ptr);
5198
5199                        }
5200                } else
5201                        trace_seq_putc(s, *ptr);
5202        }
5203
5204        if (event->flags & TEP_EVENT_FL_FAILED) {
5205out_failed:
5206                trace_seq_printf(s, "[FAILED TO PARSE]");
5207        }
5208
5209        if (args) {
5210                free_args(args);
5211                free(bprint_fmt);
5212        }
5213}
5214
5215/*
5216 * This parses out the Latency format (interrupts disabled,
5217 * need rescheduling, in hard/soft interrupt, preempt count
5218 * and lock depth) and places it into the trace_seq.
5219 */
5220static void data_latency_format(struct tep_handle *tep, struct trace_seq *s,
5221                                char *format, struct tep_record *record)
5222{
5223        static int check_lock_depth = 1;
5224        static int check_migrate_disable = 1;
5225        static int lock_depth_exists;
5226        static int migrate_disable_exists;
5227        unsigned int lat_flags;
5228        struct trace_seq sq;
5229        unsigned int pc;
5230        int lock_depth = 0;
5231        int migrate_disable = 0;
5232        int hardirq;
5233        int softirq;
5234        void *data = record->data;
5235
5236        trace_seq_init(&sq);
5237        lat_flags = parse_common_flags(tep, data);
5238        pc = parse_common_pc(tep, data);
5239        /* lock_depth may not always exist */
5240        if (lock_depth_exists)
5241                lock_depth = parse_common_lock_depth(tep, data);
5242        else if (check_lock_depth) {
5243                lock_depth = parse_common_lock_depth(tep, data);
5244                if (lock_depth < 0)
5245                        check_lock_depth = 0;
5246                else
5247                        lock_depth_exists = 1;
5248        }
5249
5250        /* migrate_disable may not always exist */
5251        if (migrate_disable_exists)
5252                migrate_disable = parse_common_migrate_disable(tep, data);
5253        else if (check_migrate_disable) {
5254                migrate_disable = parse_common_migrate_disable(tep, data);
5255                if (migrate_disable < 0)
5256                        check_migrate_disable = 0;
5257                else
5258                        migrate_disable_exists = 1;
5259        }
5260
5261        hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5262        softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5263
5264        trace_seq_printf(&sq, "%c%c%c",
5265               (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5266               (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5267               'X' : '.',
5268               (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5269               'N' : '.',
5270               (hardirq && softirq) ? 'H' :
5271               hardirq ? 'h' : softirq ? 's' : '.');
5272
5273        if (pc)
5274                trace_seq_printf(&sq, "%x", pc);
5275        else
5276                trace_seq_printf(&sq, ".");
5277
5278        if (migrate_disable_exists) {
5279                if (migrate_disable < 0)
5280                        trace_seq_printf(&sq, ".");
5281                else
5282                        trace_seq_printf(&sq, "%d", migrate_disable);
5283        }
5284
5285        if (lock_depth_exists) {
5286                if (lock_depth < 0)
5287                        trace_seq_printf(&sq, ".");
5288                else
5289                        trace_seq_printf(&sq, "%d", lock_depth);
5290        }
5291
5292        if (sq.state == TRACE_SEQ__MEM_ALLOC_FAILED) {
5293                s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
5294                return;
5295        }
5296
5297        trace_seq_terminate(&sq);
5298        trace_seq_puts(s, sq.buffer);
5299        trace_seq_destroy(&sq);
5300        trace_seq_terminate(s);
5301}
5302
5303/**
5304 * tep_data_type - parse out the given event type
5305 * @tep: a handle to the trace event parser context
5306 * @rec: the record to read from
5307 *
5308 * This returns the event id from the @rec.
5309 */
5310int tep_data_type(struct tep_handle *tep, struct tep_record *rec)
5311{
5312        return trace_parse_common_type(tep, rec->data);
5313}
5314
5315/**
5316 * tep_data_pid - parse the PID from record
5317 * @tep: a handle to the trace event parser context
5318 * @rec: the record to parse
5319 *
5320 * This returns the PID from a record.
5321 */
5322int tep_data_pid(struct tep_handle *tep, struct tep_record *rec)
5323{
5324        return parse_common_pid(tep, rec->data);
5325}
5326
5327/**
5328 * tep_data_preempt_count - parse the preempt count from the record
5329 * @tep: a handle to the trace event parser context
5330 * @rec: the record to parse
5331 *
5332 * This returns the preempt count from a record.
5333 */
5334int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec)
5335{
5336        return parse_common_pc(tep, rec->data);
5337}
5338
5339/**
5340 * tep_data_flags - parse the latency flags from the record
5341 * @tep: a handle to the trace event parser context
5342 * @rec: the record to parse
5343 *
5344 * This returns the latency flags from a record.
5345 *
5346 *  Use trace_flag_type enum for the flags (see event-parse.h).
5347 */
5348int tep_data_flags(struct tep_handle *tep, struct tep_record *rec)
5349{
5350        return parse_common_flags(tep, rec->data);
5351}
5352
5353/**
5354 * tep_data_comm_from_pid - return the command line from PID
5355 * @tep: a handle to the trace event parser context
5356 * @pid: the PID of the task to search for
5357 *
5358 * This returns a pointer to the command line that has the given
5359 * @pid.
5360 */
5361const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid)
5362{
5363        const char *comm;
5364
5365        comm = find_cmdline(tep, pid);
5366        return comm;
5367}
5368
5369static struct tep_cmdline *
5370pid_from_cmdlist(struct tep_handle *tep, const char *comm, struct tep_cmdline *next)
5371{
5372        struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5373
5374        if (cmdlist)
5375                cmdlist = cmdlist->next;
5376        else
5377                cmdlist = tep->cmdlist;
5378
5379        while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5380                cmdlist = cmdlist->next;
5381
5382        return (struct tep_cmdline *)cmdlist;
5383}
5384
5385/**
5386 * tep_data_pid_from_comm - return the pid from a given comm
5387 * @tep: a handle to the trace event parser context
5388 * @comm: the cmdline to find the pid from
5389 * @next: the cmdline structure to find the next comm
5390 *
5391 * This returns the cmdline structure that holds a pid for a given
5392 * comm, or NULL if none found. As there may be more than one pid for
5393 * a given comm, the result of this call can be passed back into
5394 * a recurring call in the @next parameter, and then it will find the
5395 * next pid.
5396 * Also, it does a linear search, so it may be slow.
5397 */
5398struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm,
5399                                           struct tep_cmdline *next)
5400{
5401        struct tep_cmdline *cmdline;
5402
5403        /*
5404         * If the cmdlines have not been converted yet, then use
5405         * the list.
5406         */
5407        if (!tep->cmdlines)
5408                return pid_from_cmdlist(tep, comm, next);
5409
5410        if (next) {
5411                /*
5412                 * The next pointer could have been still from
5413                 * a previous call before cmdlines were created
5414                 */
5415                if (next < tep->cmdlines ||
5416                    next >= tep->cmdlines + tep->cmdline_count)
5417                        next = NULL;
5418                else
5419                        cmdline  = next++;
5420        }
5421
5422        if (!next)
5423                cmdline = tep->cmdlines;
5424
5425        while (cmdline < tep->cmdlines + tep->cmdline_count) {
5426                if (strcmp(cmdline->comm, comm) == 0)