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