tools/lib/traceevent/event-parse.c

   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
  30 static const char *input_buf;
  31 static unsigned long long input_buf_ptr;
  32 static unsigned long long input_buf_siz;
  33
  34 static int is_flag_field;
  35 static int is_symbolic_field;
  36
  37 static 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 static void init_input_buf(const char *buf, unsigned long long size)
  58 {
  59         input_buf = buf;
  60         input_buf_siz = size;
  61         input_buf_ptr = 0;
  62 }
  63
  64 const char *tep_get_input_buf(void)
  65 {
  66         return input_buf;
  67 }
  68
  69 unsigned long long tep_get_input_buf_ptr(void)
  70 {
  71         return input_buf_ptr;
  72 }
  73
  74 struct event_handler {
  75         struct event_handler            *next;
  76         int                             id;
  77         const char                      *sys_name;
  78         const char                      *event_name;
  79         tep_event_handler_func          func;
  80         void                            *context;
  81 };
  82
  83 struct func_params {
  84         struct func_params      *next;
  85         enum tep_func_arg_type  type;
  86 };
  87
  88 struct tep_function_handler {
  89         struct tep_function_handler     *next;
  90         enum tep_func_arg_type          ret_type;
  91         char                            *name;
  92         tep_func_handler                func;
  93         struct func_params              *params;
  94         int                             nr_args;
  95 };
  96
  97 static unsigned long long
  98 process_defined_func(struct trace_seq *s, void *data, int size,
  99                      struct tep_event *event, struct tep_print_arg *arg);
 100
 101 static void free_func_handle(struct tep_function_handler *func);
 102
 103 /**
 104  * tep_buffer_init - init buffer for parsing
 105  * @buf: buffer to parse
 106  * @size: the size of the buffer
 107  *
 108  * For use with tep_read_token(), this initializes the internal
 109  * buffer that tep_read_token() will parse.
 110  */
 111 void tep_buffer_init(const char *buf, unsigned long long size)
 112 {
 113         init_input_buf(buf, size);
 114 }
 115
 116 void breakpoint(void)
 117 {
 118         static int x;
 119         x++;
 120 }
 121
 122 struct tep_print_arg *alloc_arg(void)
 123 {
 124         return calloc(1, sizeof(struct tep_print_arg));
 125 }
 126
 127 struct tep_cmdline {
 128         char *comm;
 129         int pid;
 130 };
 131
 132 static int cmdline_cmp(const void *a, const void *b)
 133 {
 134         const struct tep_cmdline *ca = a;
 135         const struct tep_cmdline *cb = b;
 136
 137         if (ca->pid < cb->pid)
 138                 return -1;
 139         if (ca->pid > cb->pid)
 140                 return 1;
 141
 142         return 0;
 143 }
 144
 145 /* Looking for where to place the key */
 146 static int cmdline_slot_cmp(const void *a, const void *b)
 147 {
 148         const struct tep_cmdline *ca = a;
 149         const struct tep_cmdline *cb = b;
 150         const struct tep_cmdline *cb1 = cb + 1;
 151
 152         if (ca->pid < cb->pid)
 153                 return -1;
 154
 155         if (ca->pid > cb->pid) {
 156                 if (ca->pid <= cb1->pid)
 157                         return 0;
 158                 return 1;
 159         }
 160
 161         return 0;
 162 }
 163
 164 struct cmdline_list {
 165         struct cmdline_list     *next;
 166         char                    *comm;
 167         int                     pid;
 168 };
 169
 170 static int cmdline_init(struct tep_handle *tep)
 171 {
 172         struct cmdline_list *cmdlist = tep->cmdlist;
 173         struct cmdline_list *item;
 174         struct tep_cmdline *cmdlines;
 175         int i;
 176
 177         cmdlines = malloc(sizeof(*cmdlines) * tep->cmdline_count);
 178         if (!cmdlines)
 179                 return -1;
 180
 181         i = 0;
 182         while (cmdlist) {
 183                 cmdlines[i].pid = cmdlist->pid;
 184                 cmdlines[i].comm = cmdlist->comm;
 185                 i++;
 186                 item = cmdlist;
 187                 cmdlist = cmdlist->next;
 188                 free(item);
 189         }
 190
 191         qsort(cmdlines, tep->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
 192
 193         tep->cmdlines = cmdlines;
 194         tep->cmdlist = NULL;
 195
 196         return 0;
 197 }
 198
 199 static const char *find_cmdline(struct tep_handle *tep, int pid)
 200 {
 201         const struct tep_cmdline *comm;
 202         struct tep_cmdline key;
 203
 204         if (!pid)
 205                 return "<idle>";
 206
 207         if (!tep->cmdlines && cmdline_init(tep))
 208                 return "<not enough memory for cmdlines!>";
 209
 210         key.pid = pid;
 211
 212         comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 213                        sizeof(*tep->cmdlines), cmdline_cmp);
 214
 215         if (comm)
 216                 return comm->comm;
 217         return "<...>";
 218 }
 219
 220 /**
 221  * tep_is_pid_registered - return if a pid has a cmdline registered
 222  * @tep: a handle to the trace event parser context
 223  * @pid: The pid to check if it has a cmdline registered with.
 224  *
 225  * Returns true if the pid has a cmdline mapped to it
 226  * false otherwise.
 227  */
 228 bool tep_is_pid_registered(struct tep_handle *tep, int pid)
 229 {
 230         const struct tep_cmdline *comm;
 231         struct tep_cmdline key;
 232
 233         if (!pid)
 234                 return true;
 235
 236         if (!tep->cmdlines && cmdline_init(tep))
 237                 return false;
 238
 239         key.pid = pid;
 240
 241         comm = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 242                        sizeof(*tep->cmdlines), cmdline_cmp);
 243
 244         if (comm)
 245                 return true;
 246         return false;
 247 }
 248
 249 /*
 250  * If the command lines have been converted to an array, then
 251  * we must add this pid. This is much slower than when cmdlines
 252  * are added before the array is initialized.
 253  */
 254 static int add_new_comm(struct tep_handle *tep,
 255                         const char *comm, int pid, bool override)
 256 {
 257         struct tep_cmdline *cmdlines = tep->cmdlines;
 258         struct tep_cmdline *cmdline;
 259         struct tep_cmdline key;
 260         char *new_comm;
 261         int cnt;
 262
 263         if (!pid)
 264                 return 0;
 265
 266         /* avoid duplicates */
 267         key.pid = pid;
 268
 269         cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count,
 270                           sizeof(*tep->cmdlines), cmdline_cmp);
 271         if (cmdline) {
 272                 if (!override) {
 273                         errno = EEXIST;
 274                         return -1;
 275                 }
 276                 new_comm = strdup(comm);
 277                 if (!new_comm) {
 278                         errno = ENOMEM;
 279                         return -1;
 280                 }
 281                 free(cmdline->comm);
 282                 cmdline->comm = new_comm;
 283
 284                 return 0;
 285         }
 286
 287         cmdlines = realloc(cmdlines, sizeof(*cmdlines) * (tep->cmdline_count + 1));
 288         if (!cmdlines) {
 289                 errno = ENOMEM;
 290                 return -1;
 291         }
 292         tep->cmdlines = cmdlines;
 293
 294         key.comm = strdup(comm);
 295         if (!key.comm) {
 296                 errno = ENOMEM;
 297                 return -1;
 298         }
 299
 300         if (!tep->cmdline_count) {
 301                 /* no entries yet */
 302                 tep->cmdlines[0] = key;
 303                 tep->cmdline_count++;
 304                 return 0;
 305         }
 306
 307         /* Now find where we want to store the new cmdline */
 308         cmdline = bsearch(&key, tep->cmdlines, tep->cmdline_count - 1,
 309                           sizeof(*tep->cmdlines), cmdline_slot_cmp);
 310
 311         cnt = tep->cmdline_count;
 312         if (cmdline) {
 313                 /* cmdline points to the one before the spot we want */
 314                 cmdline++;
 315                 cnt -= cmdline - tep->cmdlines;
 316
 317         } else {
 318                 /* The new entry is either before or after the list */
 319                 if (key.pid > tep->cmdlines[tep->cmdline_count - 1].pid) {
 320                         tep->cmdlines[tep->cmdline_count++] = key;
 321                         return 0;
 322                 }
 323                 cmdline = &tep->cmdlines[0];
 324         }
 325         memmove(cmdline + 1, cmdline, (cnt * sizeof(*cmdline)));
 326         *cmdline = key;
 327
 328         tep->cmdline_count++;
 329
 330         return 0;
 331 }
 332
 333 static int _tep_register_comm(struct tep_handle *tep,
 334                               const char *comm, int pid, bool override)
 335 {
 336         struct cmdline_list *item;
 337
 338         if (tep->cmdlines)
 339                 return add_new_comm(tep, comm, pid, override);
 340
 341         item = malloc(sizeof(*item));
 342         if (!item)
 343                 return -1;
 344
 345         if (comm)
 346                 item->comm = strdup(comm);
 347         else
 348                 item->comm = strdup("<...>");
 349         if (!item->comm) {
 350                 free(item);
 351                 return -1;
 352         }
 353         item->pid = pid;
 354         item->next = tep->cmdlist;
 355
 356         tep->cmdlist = item;
 357         tep->cmdline_count++;
 358
 359         return 0;
 360 }
 361
 362 /**
 363  * tep_register_comm - register a pid / comm mapping
 364  * @tep: a handle to the trace event parser context
 365  * @comm: the command line to register
 366  * @pid: the pid to map the command line to
 367  *
 368  * This adds a mapping to search for command line names with
 369  * a given pid. The comm is duplicated. If a command with the same pid
 370  * already exist, -1 is returned and errno is set to EEXIST
 371  */
 372 int tep_register_comm(struct tep_handle *tep, const char *comm, int pid)
 373 {
 374         return _tep_register_comm(tep, comm, pid, false);
 375 }
 376
 377 /**
 378  * tep_override_comm - register a pid / comm mapping
 379  * @tep: a handle to the trace event parser context
 380  * @comm: the command line to register
 381  * @pid: the pid to map the command line to
 382  *
 383  * This adds a mapping to search for command line names with
 384  * a given pid. The comm is duplicated. If a command with the same pid
 385  * already exist, the command string is udapted with the new one
 386  */
 387 int tep_override_comm(struct tep_handle *tep, const char *comm, int pid)
 388 {
 389         if (!tep->cmdlines && cmdline_init(tep)) {
 390                 errno = ENOMEM;
 391                 return -1;
 392         }
 393         return _tep_register_comm(tep, comm, pid, true);
 394 }
 395
 396 struct func_map {
 397         unsigned long long              addr;
 398         char                            *func;
 399         char                            *mod;
 400 };
 401
 402 struct func_list {
 403         struct func_list        *next;
 404         unsigned long long      addr;
 405         char                    *func;
 406         char                    *mod;
 407 };
 408
 409 static int func_cmp(const void *a, const void *b)
 410 {
 411         const struct func_map *fa = a;
 412         const struct func_map *fb = b;
 413
 414         if (fa->addr < fb->addr)
 415                 return -1;
 416         if (fa->addr > fb->addr)
 417                 return 1;
 418
 419         return 0;
 420 }
 421
 422 /*
 423  * We are searching for a record in between, not an exact
 424  * match.
 425  */
 426 static int func_bcmp(const void *a, const void *b)
 427 {
 428         const struct func_map *fa = a;
 429         const struct func_map *fb = b;
 430
 431         if ((fa->addr == fb->addr) ||
 432
 433             (fa->addr > fb->addr &&
 434              fa->addr < (fb+1)->addr))
 435                 return 0;
 436
 437         if (fa->addr < fb->addr)
 438                 return -1;
 439
 440         return 1;
 441 }
 442
 443 static int func_map_init(struct tep_handle *tep)
 444 {
 445         struct func_list *funclist;
 446         struct func_list *item;
 447         struct func_map *func_map;
 448         int i;
 449
 450         func_map = malloc(sizeof(*func_map) * (tep->func_count + 1));
 451         if (!func_map)
 452                 return -1;
 453
 454         funclist = tep->funclist;
 455
 456         i = 0;
 457         while (funclist) {
 458                 func_map[i].func = funclist->func;
 459                 func_map[i].addr = funclist->addr;
 460                 func_map[i].mod = funclist->mod;
 461                 i++;
 462                 item = funclist;
 463                 funclist = funclist->next;
 464                 free(item);
 465         }
 466
 467         qsort(func_map, tep->func_count, sizeof(*func_map), func_cmp);
 468
 469         /*
 470          * Add a special record at the end.
 471          */
 472         func_map[tep->func_count].func = NULL;
 473         func_map[tep->func_count].addr = 0;
 474         func_map[tep->func_count].mod = NULL;
 475
 476         tep->func_map = func_map;
 477         tep->funclist = NULL;
 478
 479         return 0;
 480 }
 481
 482 static struct func_map *
 483 __find_func(struct tep_handle *tep, unsigned long long addr)
 484 {
 485         struct func_map *func;
 486         struct func_map key;
 487
 488         if (!tep->func_map)
 489                 func_map_init(tep);
 490
 491         key.addr = addr;
 492
 493         func = bsearch(&key, tep->func_map, tep->func_count,
 494                        sizeof(*tep->func_map), func_bcmp);
 495
 496         return func;
 497 }
 498
 499 struct func_resolver {
 500         tep_func_resolver_t     *func;
 501         void                    *priv;
 502         struct func_map         map;
 503 };
 504
 505 /**
 506  * tep_set_function_resolver - set an alternative function resolver
 507  * @tep: a handle to the trace event parser context
 508  * @resolver: function to be used
 509  * @priv: resolver function private state.
 510  *
 511  * Some tools may have already a way to resolve kernel functions, allow them to
 512  * keep using it instead of duplicating all the entries inside tep->funclist.
 513  */
 514 int tep_set_function_resolver(struct tep_handle *tep,
 515                               tep_func_resolver_t *func, void *priv)
 516 {
 517         struct func_resolver *resolver = malloc(sizeof(*resolver));
 518
 519         if (resolver == NULL)
 520                 return -1;
 521
 522         resolver->func = func;
 523         resolver->priv = priv;
 524
 525         free(tep->func_resolver);
 526         tep->func_resolver = resolver;
 527
 528         return 0;
 529 }
 530
 531 /**
 532  * tep_reset_function_resolver - reset alternative function resolver
 533  * @tep: a handle to the trace event parser context
 534  *
 535  * Stop using whatever alternative resolver was set, use the default
 536  * one instead.
 537  */
 538 void tep_reset_function_resolver(struct tep_handle *tep)
 539 {
 540         free(tep->func_resolver);
 541         tep->func_resolver = NULL;
 542 }
 543
 544 static struct func_map *
 545 find_func(struct tep_handle *tep, unsigned long long addr)
 546 {
 547         struct func_map *map;
 548
 549         if (!tep->func_resolver)
 550                 return __find_func(tep, addr);
 551
 552         map = &tep->func_resolver->map;
 553         map->mod  = NULL;
 554         map->addr = addr;
 555         map->func = tep->func_resolver->func(tep->func_resolver->priv,
 556                                              &map->addr, &map->mod);
 557         if (map->func == NULL)
 558                 return NULL;
 559
 560         return map;
 561 }
 562
 563 /**
 564  * tep_find_function - find a function by a given address
 565  * @tep: a handle to the trace event parser context
 566  * @addr: the address to find the function with
 567  *
 568  * Returns a pointer to the function stored that has the given
 569  * address. Note, the address does not have to be exact, it
 570  * will select the function that would contain the address.
 571  */
 572 const char *tep_find_function(struct tep_handle *tep, unsigned long long addr)
 573 {
 574         struct func_map *map;
 575
 576         map = find_func(tep, addr);
 577         if (!map)
 578                 return NULL;
 579
 580         return map->func;
 581 }
 582
 583 /**
 584  * tep_find_function_address - find a function address by a given address
 585  * @tep: a handle to the trace event parser context
 586  * @addr: the address to find the function with
 587  *
 588  * Returns the address the function starts at. This can be used in
 589  * conjunction with tep_find_function to print both the function
 590  * name and the function offset.
 591  */
 592 unsigned long long
 593 tep_find_function_address(struct tep_handle *tep, unsigned long long addr)
 594 {
 595         struct func_map *map;
 596
 597         map = find_func(tep, addr);
 598         if (!map)
 599                 return 0;
 600
 601         return map->addr;
 602 }
 603
 604 /**
 605  * tep_register_function - register a function with a given address
 606  * @tep: a handle to the trace event parser context
 607  * @function: the function name to register
 608  * @addr: the address the function starts at
 609  * @mod: the kernel module the function may be in (NULL for none)
 610  *
 611  * This registers a function name with an address and module.
 612  * The @func passed in is duplicated.
 613  */
 614 int tep_register_function(struct tep_handle *tep, char *func,
 615                           unsigned long long addr, char *mod)
 616 {
 617         struct func_list *item = malloc(sizeof(*item));
 618
 619         if (!item)
 620                 return -1;
 621
 622         item->next = tep->funclist;
 623         item->func = strdup(func);
 624         if (!item->func)
 625                 goto out_free;
 626
 627         if (mod) {
 628                 item->mod = strdup(mod);
 629                 if (!item->mod)
 630                         goto out_free_func;
 631         } else
 632                 item->mod = NULL;
 633         item->addr = addr;
 634
 635         tep->funclist = item;
 636         tep->func_count++;
 637
 638         return 0;
 639
 640 out_free_func:
 641         free(item->func);
 642         item->func = NULL;
 643 out_free:
 644         free(item);
 645         errno = ENOMEM;
 646         return -1;
 647 }
 648
 649 /**
 650  * tep_print_funcs - print out the stored functions
 651  * @tep: a handle to the trace event parser context
 652  *
 653  * This prints out the stored functions.
 654  */
 655 void tep_print_funcs(struct tep_handle *tep)
 656 {
 657         int i;
 658
 659         if (!tep->func_map)
 660                 func_map_init(tep);
 661
 662         for (i = 0; i < (int)tep->func_count; i++) {
 663                 printf("%016llx %s",
 664                        tep->func_map[i].addr,
 665                        tep->func_map[i].func);
 666                 if (tep->func_map[i].mod)
 667                         printf(" [%s]\n", tep->func_map[i].mod);
 668                 else
 669                         printf("\n");
 670         }
 671 }
 672
 673 struct printk_map {
 674         unsigned long long              addr;
 675         char                            *printk;
 676 };
 677
 678 struct printk_list {
 679         struct printk_list      *next;
 680         unsigned long long      addr;
 681         char                    *printk;
 682 };
 683
 684 static int printk_cmp(const void *a, const void *b)
 685 {
 686         const struct printk_map *pa = a;
 687         const struct printk_map *pb = b;
 688
 689         if (pa->addr < pb->addr)
 690                 return -1;
 691         if (pa->addr > pb->addr)
 692                 return 1;
 693
 694         return 0;
 695 }
 696
 697 static int printk_map_init(struct tep_handle *tep)
 698 {
 699         struct printk_list *printklist;
 700         struct printk_list *item;
 701         struct printk_map *printk_map;
 702         int i;
 703
 704         printk_map = malloc(sizeof(*printk_map) * (tep->printk_count + 1));
 705         if (!printk_map)
 706                 return -1;
 707
 708         printklist = tep->printklist;
 709
 710         i = 0;
 711         while (printklist) {
 712                 printk_map[i].printk = printklist->printk;
 713                 printk_map[i].addr = printklist->addr;
 714                 i++;
 715                 item = printklist;
 716                 printklist = printklist->next;
 717                 free(item);
 718         }
 719
 720         qsort(printk_map, tep->printk_count, sizeof(*printk_map), printk_cmp);
 721
 722         tep->printk_map = printk_map;
 723         tep->printklist = NULL;
 724
 725         return 0;
 726 }
 727
 728 static struct printk_map *
 729 find_printk(struct tep_handle *tep, unsigned long long addr)
 730 {
 731         struct printk_map *printk;
 732         struct printk_map key;
 733
 734         if (!tep->printk_map && printk_map_init(tep))
 735                 return NULL;
 736
 737         key.addr = addr;
 738
 739         printk = bsearch(&key, tep->printk_map, tep->printk_count,
 740                          sizeof(*tep->printk_map), printk_cmp);
 741
 742         return printk;
 743 }
 744
 745 /**
 746  * tep_register_print_string - register a string by its address
 747  * @tep: a handle to the trace event parser context
 748  * @fmt: the string format to register
 749  * @addr: the address the string was located at
 750  *
 751  * This registers a string by the address it was stored in the kernel.
 752  * The @fmt passed in is duplicated.
 753  */
 754 int tep_register_print_string(struct tep_handle *tep, const char *fmt,
 755                               unsigned long long addr)
 756 {
 757         struct printk_list *item = malloc(sizeof(*item));
 758         char *p;
 759
 760         if (!item)
 761                 return -1;
 762
 763         item->next = tep->printklist;
 764         item->addr = addr;
 765
 766         /* Strip off quotes and '\n' from the end */
 767         if (fmt[0] == '"')
 768                 fmt++;
 769         item->printk = strdup(fmt);
 770         if (!item->printk)
 771                 goto out_free;
 772
 773         p = item->printk + strlen(item->printk) - 1;
 774         if (*p == '"')
 775                 *p = 0;
 776
 777         p -= 2;
 778         if (strcmp(p, "\\n") == 0)
 779                 *p = 0;
 780
 781         tep->printklist = item;
 782         tep->printk_count++;
 783
 784         return 0;
 785
 786 out_free:
 787         free(item);
 788         errno = ENOMEM;
 789         return -1;
 790 }
 791
 792 /**
 793  * tep_print_printk - print out the stored strings
 794  * @tep: a handle to the trace event parser context
 795  *
 796  * This prints the string formats that were stored.
 797  */
 798 void tep_print_printk(struct tep_handle *tep)
 799 {
 800         int i;
 801
 802         if (!tep->printk_map)
 803                 printk_map_init(tep);
 804
 805         for (i = 0; i < (int)tep->printk_count; i++) {
 806                 printf("%016llx %s\n",
 807                        tep->printk_map[i].addr,
 808                        tep->printk_map[i].printk);
 809         }
 810 }
 811
 812 static struct tep_event *alloc_event(void)
 813 {
 814         return calloc(1, sizeof(struct tep_event));
 815 }
 816
 817 static int add_event(struct tep_handle *tep, struct tep_event *event)
 818 {
 819         int i;
 820         struct tep_event **events = realloc(tep->events, sizeof(event) *
 821                                             (tep->nr_events + 1));
 822         if (!events)
 823                 return -1;
 824
 825         tep->events = events;
 826
 827         for (i = 0; i < tep->nr_events; i++) {
 828                 if (tep->events[i]->id > event->id)
 829                         break;
 830         }
 831         if (i < tep->nr_events)
 832                 memmove(&tep->events[i + 1],
 833                         &tep->events[i],
 834                         sizeof(event) * (tep->nr_events - i));
 835
 836         tep->events[i] = event;
 837         tep->nr_events++;
 838
 839         event->tep = tep;
 840
 841         return 0;
 842 }
 843
 844 static int event_item_type(enum tep_event_type type)
 845 {
 846         switch (type) {
 847         case TEP_EVENT_ITEM ... TEP_EVENT_SQUOTE:
 848                 return 1;
 849         case TEP_EVENT_ERROR ... TEP_EVENT_DELIM:
 850         default:
 851                 return 0;
 852         }
 853 }
 854
 855 static void free_flag_sym(struct tep_print_flag_sym *fsym)
 856 {
 857         struct tep_print_flag_sym *next;
 858
 859         while (fsym) {
 860                 next = fsym->next;
 861                 free(fsym->value);
 862                 free(fsym->str);
 863                 free(fsym);
 864                 fsym = next;
 865         }
 866 }
 867
 868 static void free_arg(struct tep_print_arg *arg)
 869 {
 870         struct tep_print_arg *farg;
 871
 872         if (!arg)
 873                 return;
 874
 875         switch (arg->type) {
 876         case TEP_PRINT_ATOM:
 877                 free(arg->atom.atom);
 878                 break;
 879         case TEP_PRINT_FIELD:
 880                 free(arg->field.name);
 881                 break;
 882         case TEP_PRINT_FLAGS:
 883                 free_arg(arg->flags.field);
 884                 free(arg->flags.delim);
 885                 free_flag_sym(arg->flags.flags);
 886                 break;
 887         case TEP_PRINT_SYMBOL:
 888                 free_arg(arg->symbol.field);
 889                 free_flag_sym(arg->symbol.symbols);
 890                 break;
 891         case TEP_PRINT_HEX:
 892         case TEP_PRINT_HEX_STR:
 893                 free_arg(arg->hex.field);
 894                 free_arg(arg->hex.size);
 895                 break;
 896         case TEP_PRINT_INT_ARRAY:
 897                 free_arg(arg->int_array.field);
 898                 free_arg(arg->int_array.count);
 899                 free_arg(arg->int_array.el_size);
 900                 break;
 901         case TEP_PRINT_TYPE:
 902                 free(arg->typecast.type);
 903                 free_arg(arg->typecast.item);
 904                 break;
 905         case TEP_PRINT_STRING:
 906         case TEP_PRINT_BSTRING:
 907                 free(arg->string.string);
 908                 break;
 909         case TEP_PRINT_BITMASK:
 910                 free(arg->bitmask.bitmask);
 911                 break;
 912         case TEP_PRINT_DYNAMIC_ARRAY:
 913         case TEP_PRINT_DYNAMIC_ARRAY_LEN:
 914                 free(arg->dynarray.index);
 915                 break;
 916         case TEP_PRINT_OP:
 917                 free(arg->op.op);
 918                 free_arg(arg->op.left);
 919                 free_arg(arg->op.right);
 920                 break;
 921         case TEP_PRINT_FUNC:
 922                 while (arg->func.args) {
 923                         farg = arg->func.args;
 924                         arg->func.args = farg->next;
 925                         free_arg(farg);
 926                 }
 927                 break;
 928
 929         case TEP_PRINT_NULL:
 930         default:
 931                 break;
 932         }
 933
 934         free(arg);
 935 }
 936
 937 static enum tep_event_type get_type(int ch)
 938 {
 939         if (ch == '\n')
 940                 return TEP_EVENT_NEWLINE;
 941         if (isspace(ch))
 942                 return TEP_EVENT_SPACE;
 943         if (isalnum(ch) || ch == '_')
 944                 return TEP_EVENT_ITEM;
 945         if (ch == '\'')
 946                 return TEP_EVENT_SQUOTE;
 947         if (ch == '"')
 948                 return TEP_EVENT_DQUOTE;
 949         if (!isprint(ch))
 950                 return TEP_EVENT_NONE;
 951         if (ch == '(' || ch == ')' || ch == ',')
 952                 return TEP_EVENT_DELIM;
 953
 954         return TEP_EVENT_OP;
 955 }
 956
 957 static int __read_char(void)
 958 {
 959         if (input_buf_ptr >= input_buf_siz)
 960                 return -1;
 961
 962         return input_buf[input_buf_ptr++];
 963 }
 964
 965 static int __peek_char(void)
 966 {
 967         if (input_buf_ptr >= input_buf_siz)
 968                 return -1;
 969
 970         return input_buf[input_buf_ptr];
 971 }
 972
 973 /**
 974  * tep_peek_char - peek at the next character that will be read
 975  *
 976  * Returns the next character read, or -1 if end of buffer.
 977  */
 978 int tep_peek_char(void)
 979 {
 980         return __peek_char();
 981 }
 982
 983 static int extend_token(char **tok, char *buf, int size)
 984 {
 985         char *newtok = realloc(*tok, size);
 986
 987         if (!newtok) {
 988                 free(*tok);
 989                 *tok = NULL;
 990                 return -1;
 991         }
 992
 993         if (!*tok)
 994                 strcpy(newtok, buf);
 995         else
 996                 strcat(newtok, buf);
 997         *tok = newtok;
 998
 999         return 0;
1000 }
1001
1002 static enum tep_event_type force_token(const char *str, char **tok);
1003
1004 static enum tep_event_type __read_token(char **tok)
1005 {
1006         char buf[BUFSIZ];
1007         int ch, last_ch, quote_ch, next_ch;
1008         int i = 0;
1009         int tok_size = 0;
1010         enum tep_event_type type;
1011
1012         *tok = NULL;
1013
1014
1015         ch = __read_char();
1016         if (ch < 0)
1017                 return TEP_EVENT_NONE;
1018
1019         type = get_type(ch);
1020         if (type == TEP_EVENT_NONE)
1021                 return type;
1022
1023         buf[i++] = ch;
1024
1025         switch (type) {
1026         case TEP_EVENT_NEWLINE:
1027         case TEP_EVENT_DELIM:
1028                 if (asprintf(tok, "%c", ch) < 0)
1029                         return TEP_EVENT_ERROR;
1030
1031                 return type;
1032
1033         case TEP_EVENT_OP:
1034                 switch (ch) {
1035                 case '-':
1036                         next_ch = __peek_char();
1037                         if (next_ch == '>') {
1038                                 buf[i++] = __read_char();
1039                                 break;
1040                         }
1041                         /* fall through */
1042                 case '+':
1043                 case '|':
1044                 case '&':
1045                 case '>':
1046                 case '<':
1047                         last_ch = ch;
1048                         ch = __peek_char();
1049                         if (ch != last_ch)
1050                                 goto test_equal;
1051                         buf[i++] = __read_char();
1052                         switch (last_ch) {
1053                         case '>':
1054                         case '<':
1055                                 goto test_equal;
1056                         default:
1057                                 break;
1058                         }
1059                         break;
1060                 case '!':
1061                 case '=':
1062                         goto test_equal;
1063                 default: /* what should we do instead? */
1064                         break;
1065                 }
1066                 buf[i] = 0;
1067                 *tok = strdup(buf);
1068                 return type;
1069
1070  test_equal:
1071                 ch = __peek_char();
1072                 if (ch == '=')
1073                         buf[i++] = __read_char();
1074                 goto out;
1075
1076         case TEP_EVENT_DQUOTE:
1077         case TEP_EVENT_SQUOTE:
1078                 /* don't keep quotes */
1079                 i--;
1080                 quote_ch = ch;
1081                 last_ch = 0;
1082  concat:
1083                 do {
1084                         if (i == (BUFSIZ - 1)) {
1085                                 buf[i] = 0;
1086                                 tok_size += BUFSIZ;
1087
1088                                 if (extend_token(tok, buf, tok_size) < 0)
1089                                         return TEP_EVENT_NONE;
1090                                 i = 0;
1091                         }
1092                         last_ch = ch;
1093                         ch = __read_char();
1094                         buf[i++] = ch;
1095                         /* the '\' '\' will cancel itself */
1096                         if (ch == '\\' && last_ch == '\\')
1097                                 last_ch = 0;
1098                 } while (ch != quote_ch || last_ch == '\\');
1099                 /* remove the last quote */
1100                 i--;
1101
1102                 /*
1103                  * For strings (double quotes) check the next token.
1104                  * If it is another string, concatinate the two.
1105                  */
1106                 if (type == TEP_EVENT_DQUOTE) {
1107                         unsigned long long save_input_buf_ptr = input_buf_ptr;
1108
1109                         do {
1110                                 ch = __read_char();
1111                         } while (isspace(ch));
1112                         if (ch == '"')
1113                                 goto concat;
1114                         input_buf_ptr = save_input_buf_ptr;
1115                 }
1116
1117                 goto out;
1118
1119         case TEP_EVENT_ERROR ... TEP_EVENT_SPACE:
1120         case TEP_EVENT_ITEM:
1121         default:
1122                 break;
1123         }
1124
1125         while (get_type(__peek_char()) == type) {
1126                 if (i == (BUFSIZ - 1)) {
1127                         buf[i] = 0;
1128                         tok_size += BUFSIZ;
1129
1130                         if (extend_token(tok, buf, tok_size) < 0)
1131                                 return TEP_EVENT_NONE;
1132                         i = 0;
1133                 }
1134                 ch = __read_char();
1135                 buf[i++] = ch;
1136         }
1137
1138  out:
1139         buf[i] = 0;
1140         if (extend_token(tok, buf, tok_size + i + 1) < 0)
1141                 return TEP_EVENT_NONE;
1142
1143         if (type == TEP_EVENT_ITEM) {
1144                 /*
1145                  * Older versions of the kernel has a bug that
1146                  * creates invalid symbols and will break the mac80211
1147                  * parsing. This is a work around to that bug.
1148                  *
1149                  * See Linux kernel commit:
1150                  *  811cb50baf63461ce0bdb234927046131fc7fa8b
1151                  */
1152                 if (strcmp(*tok, "LOCAL_PR_FMT") == 0) {
1153                         free(*tok);
1154                         *tok = NULL;
1155                         return force_token("\"%s\" ", tok);
1156                 } else if (strcmp(*tok, "STA_PR_FMT") == 0) {
1157                         free(*tok);
1158                         *tok = NULL;
1159                         return force_token("\" sta:%pM\" ", tok);
1160                 } else if (strcmp(*tok, "VIF_PR_FMT") == 0) {
1161                         free(*tok);
1162                         *tok = NULL;
1163                         return force_token("\" vif:%p(%d)\" ", tok);
1164                 }
1165         }
1166
1167         return type;
1168 }
1169
1170 static enum tep_event_type force_token(const char *str, char **tok)
1171 {
1172         const char *save_input_buf;
1173         unsigned long long save_input_buf_ptr;
1174         unsigned long long save_input_buf_siz;
1175         enum tep_event_type type;
1176
1177         /* save off the current input pointers */
1178         save_input_buf = input_buf;
1179         save_input_buf_ptr = input_buf_ptr;
1180         save_input_buf_siz = input_buf_siz;
1181
1182         init_input_buf(str, strlen(str));
1183
1184         type = __read_token(tok);
1185
1186         /* reset back to original token */
1187         input_buf = save_input_buf;
1188         input_buf_ptr = save_input_buf_ptr;
1189         input_buf_siz = save_input_buf_siz;
1190
1191         return type;
1192 }
1193
1194 static void free_token(char *tok)
1195 {
1196         if (tok)
1197                 free(tok);
1198 }
1199
1200 static enum tep_event_type read_token(char **tok)
1201 {
1202         enum tep_event_type type;
1203
1204         for (;;) {
1205                 type = __read_token(tok);
1206                 if (type != TEP_EVENT_SPACE)
1207                         return type;
1208
1209                 free_token(*tok);
1210         }
1211
1212         /* not reached */
1213         *tok = NULL;
1214         return TEP_EVENT_NONE;
1215 }
1216
1217 /**
1218  * tep_read_token - access to utilities to use the tep parser
1219  * @tok: The token to return
1220  *
1221  * This will parse tokens from the string given by
1222  * tep_init_data().
1223  *
1224  * Returns the token type.
1225  */
1226 enum tep_event_type tep_read_token(char **tok)
1227 {
1228         return read_token(tok);
1229 }
1230
1231 /**
1232  * tep_free_token - free a token returned by tep_read_token
1233  * @token: the token to free
1234  */
1235 void tep_free_token(char *token)
1236 {
1237         free_token(token);
1238 }
1239
1240 /* no newline */
1241 static enum tep_event_type read_token_item(char **tok)
1242 {
1243         enum tep_event_type type;
1244
1245         for (;;) {
1246                 type = __read_token(tok);
1247                 if (type != TEP_EVENT_SPACE && type != TEP_EVENT_NEWLINE)
1248                         return type;
1249                 free_token(*tok);
1250                 *tok = NULL;
1251         }
1252
1253         /* not reached */
1254         *tok = NULL;
1255         return TEP_EVENT_NONE;
1256 }
1257
1258 static int test_type(enum tep_event_type type, enum tep_event_type expect)
1259 {
1260         if (type != expect) {
1261                 do_warning("Error: expected type %d but read %d",
1262                     expect, type);
1263                 return -1;
1264         }
1265         return 0;
1266 }
1267
1268 static int test_type_token(enum tep_event_type type, const char *token,
1269                     enum tep_event_type expect, const char *expect_tok)
1270 {
1271         if (type != expect) {
1272                 do_warning("Error: expected type %d but read %d",
1273                     expect, type);
1274                 return -1;
1275         }
1276
1277         if (strcmp(token, expect_tok) != 0) {
1278                 do_warning("Error: expected '%s' but read '%s'",
1279                     expect_tok, token);
1280                 return -1;
1281         }
1282         return 0;
1283 }
1284
1285 static int __read_expect_type(enum tep_event_type expect, char **tok, int newline_ok)
1286 {
1287         enum tep_event_type type;
1288
1289         if (newline_ok)
1290                 type = read_token(tok);
1291         else
1292                 type = read_token_item(tok);
1293         return test_type(type, expect);
1294 }
1295
1296 static int read_expect_type(enum tep_event_type expect, char **tok)
1297 {
1298         return __read_expect_type(expect, tok, 1);
1299 }
1300
1301 static int __read_expected(enum tep_event_type expect, const char *str,
1302                            int newline_ok)
1303 {
1304         enum tep_event_type type;
1305         char *token;
1306         int ret;
1307
1308         if (newline_ok)
1309                 type = read_token(&token);
1310         else
1311                 type = read_token_item(&token);
1312
1313         ret = test_type_token(type, token, expect, str);
1314
1315         free_token(token);
1316
1317         return ret;
1318 }
1319
1320 static int read_expected(enum tep_event_type expect, const char *str)
1321 {
1322         return __read_expected(expect, str, 1);
1323 }
1324
1325 static int read_expected_item(enum tep_event_type expect, const char *str)
1326 {
1327         return __read_expected(expect, str, 0);
1328 }
1329
1330 static char *event_read_name(void)
1331 {
1332         char *token;
1333
1334         if (read_expected(TEP_EVENT_ITEM, "name") < 0)
1335                 return NULL;
1336
1337         if (read_expected(TEP_EVENT_OP, ":") < 0)
1338                 return NULL;
1339
1340         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1341                 goto fail;
1342
1343         return token;
1344
1345  fail:
1346         free_token(token);
1347         return NULL;
1348 }
1349
1350 static int event_read_id(void)
1351 {
1352         char *token;
1353         int id;
1354
1355         if (read_expected_item(TEP_EVENT_ITEM, "ID") < 0)
1356                 return -1;
1357
1358         if (read_expected(TEP_EVENT_OP, ":") < 0)
1359                 return -1;
1360
1361         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1362                 goto fail;
1363
1364         id = strtoul(token, NULL, 0);
1365         free_token(token);
1366         return id;
1367
1368  fail:
1369         free_token(token);
1370         return -1;
1371 }
1372
1373 static int field_is_string(struct tep_format_field *field)
1374 {
1375         if ((field->flags & TEP_FIELD_IS_ARRAY) &&
1376             (strstr(field->type, "char") || strstr(field->type, "u8") ||
1377              strstr(field->type, "s8")))
1378                 return 1;
1379
1380         return 0;
1381 }
1382
1383 static int field_is_dynamic(struct tep_format_field *field)
1384 {
1385         if (strncmp(field->type, "__data_loc", 10) == 0)
1386                 return 1;
1387
1388         return 0;
1389 }
1390
1391 static int field_is_long(struct tep_format_field *field)
1392 {
1393         /* includes long long */
1394         if (strstr(field->type, "long"))
1395                 return 1;
1396
1397         return 0;
1398 }
1399
1400 static unsigned int type_size(const char *name)
1401 {
1402         /* This covers all TEP_FIELD_IS_STRING types. */
1403         static struct {
1404                 const char *type;
1405                 unsigned int size;
1406         } table[] = {
1407                 { "u8",   1 },
1408                 { "u16",  2 },
1409                 { "u32",  4 },
1410                 { "u64",  8 },
1411                 { "s8",   1 },
1412                 { "s16",  2 },
1413                 { "s32",  4 },
1414                 { "s64",  8 },
1415                 { "char", 1 },
1416                 { },
1417         };
1418         int i;
1419
1420         for (i = 0; table[i].type; i++) {
1421                 if (!strcmp(table[i].type, name))
1422                         return table[i].size;
1423         }
1424
1425         return 0;
1426 }
1427
1428 static int append(char **buf, const char *delim, const char *str)
1429 {
1430         char *new_buf;
1431
1432         new_buf = realloc(*buf, strlen(*buf) + strlen(delim) + strlen(str) + 1);
1433         if (!new_buf)
1434                 return -1;
1435         strcat(new_buf, delim);
1436         strcat(new_buf, str);
1437         *buf = new_buf;
1438         return 0;
1439 }
1440
1441 static int event_read_fields(struct tep_event *event, struct tep_format_field **fields)
1442 {
1443         struct tep_format_field *field = NULL;
1444         enum tep_event_type type;
1445         char *token;
1446         char *last_token;
1447         char *delim = " ";
1448         int count = 0;
1449         int ret;
1450
1451         do {
1452                 unsigned int size_dynamic = 0;
1453
1454                 type = read_token(&token);
1455                 if (type == TEP_EVENT_NEWLINE) {
1456                         free_token(token);
1457                         return count;
1458                 }
1459
1460                 count++;
1461
1462                 if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
1463                         goto fail;
1464                 free_token(token);
1465
1466                 type = read_token(&token);
1467                 /*
1468                  * The ftrace fields may still use the "special" name.
1469                  * Just ignore it.
1470                  */
1471                 if (event->flags & TEP_EVENT_FL_ISFTRACE &&
1472                     type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
1473                         free_token(token);
1474                         type = read_token(&token);
1475                 }
1476
1477                 if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
1478                         goto fail;
1479
1480                 free_token(token);
1481                 if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1482                         goto fail;
1483
1484                 last_token = token;
1485
1486                 field = calloc(1, sizeof(*field));
1487                 if (!field)
1488                         goto fail;
1489
1490                 field->event = event;
1491
1492                 /* read the rest of the type */
1493                 for (;;) {
1494                         type = read_token(&token);
1495                         if (type == TEP_EVENT_ITEM ||
1496                             (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
1497                             /*
1498                              * Some of the ftrace fields are broken and have
1499                              * an illegal "." in them.
1500                              */
1501                             (event->flags & TEP_EVENT_FL_ISFTRACE &&
1502                              type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
1503
1504                                 if (strcmp(token, "*") == 0)
1505                                         field->flags |= TEP_FIELD_IS_POINTER;
1506
1507                                 if (field->type) {
1508                                         ret = append(&field->type, delim, last_token);
1509                                         free(last_token);
1510                                         if (ret < 0)
1511                                                 goto fail;
1512                                 } else
1513                                         field->type = last_token;
1514                                 last_token = token;
1515                                 delim = " ";
1516                                 continue;
1517                         }
1518
1519                         /* Handle __attribute__((user)) */
1520                         if ((type == TEP_EVENT_DELIM) &&
1521                             strcmp("__attribute__", last_token) == 0 &&
1522                             token[0] == '(') {
1523                                 int depth = 1;
1524                                 int ret;
1525
1526                                 ret = append(&field->type, " ", last_token);
1527                                 ret |= append(&field->type, "", "(");
1528                                 if (ret < 0)
1529                                         goto fail;
1530
1531                                 delim = " ";
1532                                 while ((type = read_token(&token)) != TEP_EVENT_NONE) {
1533                                         if (type == TEP_EVENT_DELIM) {
1534                                                 if (token[0] == '(')
1535                                                         depth++;
1536                                                 else if (token[0] == ')')
1537                                                         depth--;
1538                                                 if (!depth)
1539                                                         break;
1540                                                 ret = append(&field->type, "", token);
1541                                                 delim = "";
1542                                         } else {
1543                                                 ret = append(&field->type, delim, token);
1544                                                 delim = " ";
1545                                         }
1546                                         if (ret < 0)
1547                                                 goto fail;
1548                                         free(last_token);
1549                                         last_token = token;
1550                                 }
1551                                 continue;
1552                         }
1553                         break;
1554                 }
1555
1556                 if (!field->type) {
1557                         do_warning_event(event, "%s: no type found", __func__);
1558                         goto fail;
1559                 }
1560                 field->name = field->alias = last_token;
1561
1562                 if (test_type(type, TEP_EVENT_OP))
1563                         goto fail;
1564
1565                 if (strcmp(token, "[") == 0) {
1566                         enum tep_event_type last_type = type;
1567                         char *brackets = token;
1568
1569                         field->flags |= TEP_FIELD_IS_ARRAY;
1570
1571                         type = read_token(&token);
1572
1573                         if (type == TEP_EVENT_ITEM)
1574                                 field->arraylen = strtoul(token, NULL, 0);
1575                         else
1576                                 field->arraylen = 0;
1577
1578                         while (strcmp(token, "]") != 0) {
1579                                 const char *delim;
1580
1581                                 if (last_type == TEP_EVENT_ITEM &&
1582                                     type == TEP_EVENT_ITEM)
1583                                         delim = " ";
1584                                 else
1585                                         delim = "";
1586
1587                                 last_type = type;
1588
1589                                 ret = append(&brackets, delim, token);
1590                                 if (ret < 0) {
1591                                         free(brackets);
1592                                         goto fail;
1593                                 }
1594                                 /* We only care about the last token */
1595                                 field->arraylen = strtoul(token, NULL, 0);
1596                                 free_token(token);
1597                                 type = read_token(&token);
1598                                 if (type == TEP_EVENT_NONE) {
1599                                         free(brackets);
1600                                         do_warning_event(event, "failed to find token");
1601                                         goto fail;
1602                                 }
1603                         }
1604
1605                         free_token(token);
1606
1607                         ret = append(&brackets, "", "]");
1608                         if (ret < 0) {
1609                                 free(brackets);
1610                                 goto fail;
1611                         }
1612
1613                         /* add brackets to type */
1614
1615                         type = read_token(&token);
1616                         /*
1617                          * If the next token is not an OP, then it is of
1618                          * the format: type [] item;
1619                          */
1620                         if (type == TEP_EVENT_ITEM) {
1621                                 ret = append(&field->type, " ", field->name);
1622                                 if (ret < 0) {
1623                                         free(brackets);
1624                                         goto fail;
1625                                 }
1626                                 ret = append(&field->type, "", brackets);
1627
1628                                 size_dynamic = type_size(field->name);
1629                                 free_token(field->name);
1630                                 field->name = field->alias = token;
1631                                 type = read_token(&token);
1632                         } else {
1633                                 ret = append(&field->type, "", brackets);
1634                                 if (ret < 0) {
1635                                         free(brackets);
1636                                         goto fail;
1637                                 }
1638                         }
1639                         free(brackets);
1640                 }
1641
1642                 if (field_is_string(field))
1643                         field->flags |= TEP_FIELD_IS_STRING;
1644                 if (field_is_dynamic(field))
1645                         field->flags |= TEP_FIELD_IS_DYNAMIC;
1646                 if (field_is_long(field))
1647                         field->flags |= TEP_FIELD_IS_LONG;
1648
1649                 if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
1650                         goto fail;
1651                 free_token(token);
1652
1653                 if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
1654                         goto fail_expect;
1655
1656                 if (read_expected(TEP_EVENT_OP, ":") < 0)
1657                         goto fail_expect;
1658
1659                 if (read_expect_type(TEP_EVENT_ITEM, &token))
1660                         goto fail;
1661                 field->offset = strtoul(token, NULL, 0);
1662                 free_token(token);
1663
1664                 if (read_expected(TEP_EVENT_OP, ";") < 0)
1665                         goto fail_expect;
1666
1667                 if (read_expected(TEP_EVENT_ITEM, "size") < 0)
1668                         goto fail_expect;
1669
1670                 if (read_expected(TEP_EVENT_OP, ":") < 0)
1671                         goto fail_expect;
1672
1673                 if (read_expect_type(TEP_EVENT_ITEM, &token))
1674                         goto fail;
1675                 field->size = strtoul(token, NULL, 0);
1676                 free_token(token);
1677
1678                 if (read_expected(TEP_EVENT_OP, ";") < 0)
1679                         goto fail_expect;
1680
1681                 type = read_token(&token);
1682                 if (type != TEP_EVENT_NEWLINE) {
1683                         /* newer versions of the kernel have a "signed" type */
1684                         if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
1685                                 goto fail;
1686
1687                         free_token(token);
1688
1689                         if (read_expected(TEP_EVENT_OP, ":") < 0)
1690                                 goto fail_expect;
1691
1692                         if (read_expect_type(TEP_EVENT_ITEM, &token))
1693                                 goto fail;
1694
1695                         if (strtoul(token, NULL, 0))
1696                                 field->flags |= TEP_FIELD_IS_SIGNED;
1697
1698                         free_token(token);
1699                         if (read_expected(TEP_EVENT_OP, ";") < 0)
1700                                 goto fail_expect;
1701
1702                         if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1703                                 goto fail;
1704                 }
1705
1706                 free_token(token);
1707
1708                 if (field->flags & TEP_FIELD_IS_ARRAY) {
1709                         if (field->arraylen)
1710                                 field->elementsize = field->size / field->arraylen;
1711                         else if (field->flags & TEP_FIELD_IS_DYNAMIC)
1712                                 field->elementsize = size_dynamic;
1713                         else if (field->flags & TEP_FIELD_IS_STRING)
1714                                 field->elementsize = 1;
1715                         else if (field->flags & TEP_FIELD_IS_LONG)
1716                                 field->elementsize = event->tep ?
1717                                                      event->tep->long_size :
1718                                                      sizeof(long);
1719                 } else
1720                         field->elementsize = field->size;
1721
1722                 *fields = field;
1723                 fields = &field->next;
1724
1725         } while (1);
1726
1727         return 0;
1728
1729 fail:
1730         free_token(token);
1731 fail_expect:
1732         if (field) {
1733                 free(field->type);
1734                 free(field->name);
1735                 free(field);
1736         }
1737         return -1;
1738 }
1739
1740 static int event_read_format(struct tep_event *event)
1741 {
1742         char *token;
1743         int ret;
1744
1745         if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
1746                 return -1;
1747
1748         if (read_expected(TEP_EVENT_OP, ":") < 0)
1749                 return -1;
1750
1751         if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1752                 goto fail;
1753         free_token(token);
1754
1755         ret = event_read_fields(event, &event->format.common_fields);
1756         if (ret < 0)
1757                 return ret;
1758         event->format.nr_common = ret;
1759
1760         ret = event_read_fields(event, &event->format.fields);
1761         if (ret < 0)
1762                 return ret;
1763         event->format.nr_fields = ret;
1764
1765         return 0;
1766
1767  fail:
1768         free_token(token);
1769         return -1;
1770 }
1771
1772 static enum tep_event_type
1773 process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
1774                   char **tok, enum tep_event_type type);
1775
1776 static enum tep_event_type
1777 process_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1778 {
1779         enum tep_event_type type;
1780         char *token;
1781
1782         type = read_token(&token);
1783         *tok = token;
1784
1785         return process_arg_token(event, arg, tok, type);
1786 }
1787
1788 static enum tep_event_type
1789 process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok);
1790
1791 /*
1792  * For __print_symbolic() and __print_flags, we need to completely
1793  * evaluate the first argument, which defines what to print next.
1794  */
1795 static enum tep_event_type
1796 process_field_arg(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1797 {
1798         enum tep_event_type type;
1799
1800         type = process_arg(event, arg, tok);
1801
1802         while (type == TEP_EVENT_OP) {
1803                 type = process_op(event, arg, tok);
1804         }
1805
1806         return type;
1807 }
1808
1809 static enum tep_event_type
1810 process_cond(struct tep_event *event, struct tep_print_arg *top, char **tok)
1811 {
1812         struct tep_print_arg *arg, *left, *right;
1813         enum tep_event_type type;
1814         char *token = NULL;
1815
1816         arg = alloc_arg();
1817         left = alloc_arg();
1818         right = alloc_arg();
1819
1820         if (!arg || !left || !right) {
1821                 do_warning_event(event, "%s: not enough memory!", __func__);
1822                 /* arg will be freed at out_free */
1823                 free_arg(left);
1824                 free_arg(right);
1825                 goto out_free;
1826         }
1827
1828         arg->type = TEP_PRINT_OP;
1829         arg->op.left = left;
1830         arg->op.right = right;
1831
1832         *tok = NULL;
1833         type = process_arg(event, left, &token);
1834
1835  again:
1836         if (type == TEP_EVENT_ERROR)
1837                 goto out_free;
1838
1839         /* Handle other operations in the arguments */
1840         if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
1841                 type = process_op(event, left, &token);
1842                 goto again;
1843         }
1844
1845         if (test_type_token(type, token, TEP_EVENT_OP, ":"))
1846                 goto out_free;
1847
1848         arg->op.op = token;
1849
1850         type = process_arg(event, right, &token);
1851
1852         top->op.right = arg;
1853
1854         *tok = token;
1855         return type;
1856
1857 out_free:
1858         /* Top may point to itself */
1859         top->op.right = NULL;
1860         free_token(token);
1861         free_arg(arg);
1862         return TEP_EVENT_ERROR;
1863 }
1864
1865 static enum tep_event_type
1866 process_array(struct tep_event *event, struct tep_print_arg *top, char **tok)
1867 {
1868         struct tep_print_arg *arg;
1869         enum tep_event_type type;
1870         char *token = NULL;
1871
1872         arg = alloc_arg();
1873         if (!arg) {
1874                 do_warning_event(event, "%s: not enough memory!", __func__);
1875                 /* '*tok' is set to top->op.op.  No need to free. */
1876                 *tok = NULL;
1877                 return TEP_EVENT_ERROR;
1878         }
1879
1880         *tok = NULL;
1881         type = process_arg(event, arg, &token);
1882         if (test_type_token(type, token, TEP_EVENT_OP, "]"))
1883                 goto out_free;
1884
1885         top->op.right = arg;
1886
1887         free_token(token);
1888         type = read_token_item(&token);
1889         *tok = token;
1890
1891         return type;
1892
1893 out_free:
1894         free_token(token);
1895         free_arg(arg);
1896         return TEP_EVENT_ERROR;
1897 }
1898
1899 static int get_op_prio(char *op)
1900 {
1901         if (!op[1]) {
1902                 switch (op[0]) {
1903                 case '~':
1904                 case '!':
1905                         return 4;
1906                 case '*':
1907                 case '/':
1908                 case '%':
1909                         return 6;
1910                 case '+':
1911                 case '-':
1912                         return 7;
1913                         /* '>>' and '<<' are 8 */
1914                 case '<':
1915                 case '>':
1916                         return 9;
1917                         /* '==' and '!=' are 10 */
1918                 case '&':
1919                         return 11;
1920                 case '^':
1921                         return 12;
1922                 case '|':
1923                         return 13;
1924                 case '?':
1925                         return 16;
1926                 default:
1927                         do_warning("unknown op '%c'", op[0]);
1928                         return -1;
1929                 }
1930         } else {
1931                 if (strcmp(op, "++") == 0 ||
1932                     strcmp(op, "--") == 0) {
1933                         return 3;
1934                 } else if (strcmp(op, ">>") == 0 ||
1935                            strcmp(op, "<<") == 0) {
1936                         return 8;
1937                 } else if (strcmp(op, ">=") == 0 ||
1938                            strcmp(op, "<=") == 0) {
1939                         return 9;
1940                 } else if (strcmp(op, "==") == 0 ||
1941                            strcmp(op, "!=") == 0) {
1942                         return 10;
1943                 } else if (strcmp(op, "&&") == 0) {
1944                         return 14;
1945                 } else if (strcmp(op, "||") == 0) {
1946                         return 15;
1947                 } else {
1948                         do_warning("unknown op '%s'", op);
1949                         return -1;
1950                 }
1951         }
1952 }
1953
1954 static int set_op_prio(struct tep_print_arg *arg)
1955 {
1956
1957         /* single ops are the greatest */
1958         if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1959                 arg->op.prio = 0;
1960         else
1961                 arg->op.prio = get_op_prio(arg->op.op);
1962
1963         return arg->op.prio;
1964 }
1965
1966 /* Note, *tok does not get freed, but will most likely be saved */
1967 static enum tep_event_type
1968 process_op(struct tep_event *event, struct tep_print_arg *arg, char **tok)
1969 {
1970         struct tep_print_arg *left, *right = NULL;
1971         enum tep_event_type type;
1972         char *token;
1973
1974         /* the op is passed in via tok */
1975         token = *tok;
1976
1977         if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1978                 /* handle single op */
1979                 if (token[1]) {
1980                         do_warning_event(event, "bad op token %s", token);
1981                         goto out_free;
1982                 }
1983                 switch (token[0]) {
1984                 case '~':
1985                 case '!':
1986                 case '+':
1987                 case '-':
1988                         break;
1989                 default:
1990                         do_warning_event(event, "bad op token %s", token);
1991                         goto out_free;
1992
1993                 }
1994
1995                 /* make an empty left */
1996                 left = alloc_arg();
1997                 if (!left)
1998                         goto out_warn_free;
1999
2000                 left->type = TEP_PRINT_NULL;
2001                 arg->op.left = left;
2002
2003                 right = alloc_arg();
2004                 if (!right)
2005                         goto out_warn_free;
2006
2007                 arg->op.right = right;
2008
2009                 /* do not free the token, it belongs to an op */
2010                 *tok = NULL;
2011                 type = process_arg(event, right, tok);
2012
2013         } else if (strcmp(token, "?") == 0) {
2014
2015                 left = alloc_arg();
2016                 if (!left)
2017                         goto out_warn_free;
2018
2019                 /* copy the top arg to the left */
2020                 *left = *arg;
2021
2022                 arg->type = TEP_PRINT_OP;
2023                 arg->op.op = token;
2024                 arg->op.left = left;
2025                 arg->op.prio = 0;
2026
2027                 /* it will set arg->op.right */
2028                 type = process_cond(event, arg, tok);
2029
2030         } else if (strcmp(token, ">>") == 0 ||
2031                    strcmp(token, "<<") == 0 ||
2032                    strcmp(token, "&") == 0 ||
2033                    strcmp(token, "|") == 0 ||
2034                    strcmp(token, "&&") == 0 ||
2035                    strcmp(token, "||") == 0 ||
2036                    strcmp(token, "-") == 0 ||
2037                    strcmp(token, "+") == 0 ||
2038                    strcmp(token, "*") == 0 ||
2039                    strcmp(token, "^") == 0 ||
2040                    strcmp(token, "/") == 0 ||
2041                    strcmp(token, "%") == 0 ||
2042                    strcmp(token, "<") == 0 ||
2043                    strcmp(token, ">") == 0 ||
2044                    strcmp(token, "<=") == 0 ||
2045                    strcmp(token, ">=") == 0 ||
2046                    strcmp(token, "==") == 0 ||
2047                    strcmp(token, "!=") == 0) {
2048
2049                 left = alloc_arg();
2050                 if (!left)
2051                         goto out_warn_free;
2052
2053                 /* copy the top arg to the left */
2054                 *left = *arg;
2055
2056                 arg->type = TEP_PRINT_OP;
2057                 arg->op.op = token;
2058                 arg->op.left = left;
2059                 arg->op.right = NULL;
2060
2061                 if (set_op_prio(arg) == -1) {
2062                         event->flags |= TEP_EVENT_FL_FAILED;
2063                         /* arg->op.op (= token) will be freed at out_free */
2064                         arg->op.op = NULL;
2065                         goto out_free;
2066                 }
2067
2068                 type = read_token_item(&token);
2069                 *tok = token;
2070
2071                 /* could just be a type pointer */
2072                 if ((strcmp(arg->op.op, "*") == 0) &&
2073                     type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
2074                         int ret;
2075
2076                         if (left->type != TEP_PRINT_ATOM) {
2077                                 do_warning_event(event, "bad pointer type");
2078                                 goto out_free;
2079                         }
2080                         ret = append(&left->atom.atom, " ", "*");
2081                         if (ret < 0)
2082                                 goto out_warn_free;
2083
2084                         free(arg->op.op);
2085                         *arg = *left;
2086                         free(left);
2087
2088                         return type;
2089                 }
2090
2091                 right = alloc_arg();
2092                 if (!right)
2093                         goto out_warn_free;
2094
2095                 type = process_arg_token(event, right, tok, type);
2096                 if (type == TEP_EVENT_ERROR) {
2097                         free_arg(right);
2098                         /* token was freed in process_arg_token() via *tok */
2099                         token = NULL;
2100                         goto out_free;
2101                 }
2102
2103                 if (right->type == TEP_PRINT_OP &&
2104                     get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2105                         struct tep_print_arg tmp;
2106
2107                         /* rotate ops according to the priority */
2108                         arg->op.right = right->op.left;
2109
2110                         tmp = *arg;
2111                         *arg = *right;
2112                         *right = tmp;
2113
2114                         arg->op.left = right;
2115                 } else {
2116                         arg->op.right = right;
2117                 }
2118
2119         } else if (strcmp(token, "[") == 0) {
2120
2121                 left = alloc_arg();
2122                 if (!left)
2123                         goto out_warn_free;
2124
2125                 *left = *arg;
2126
2127                 arg->type = TEP_PRINT_OP;
2128                 arg->op.op = token;
2129                 arg->op.left = left;
2130
2131                 arg->op.prio = 0;
2132
2133                 /* it will set arg->op.right */
2134                 type = process_array(event, arg, tok);
2135
2136         } else {
2137                 do_warning_event(event, "unknown op '%s'", token);
2138                 event->flags |= TEP_EVENT_FL_FAILED;
2139                 /* the arg is now the left side */
2140                 goto out_free;
2141         }
2142
2143         if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
2144                 int prio;
2145
2146                 /* higher prios need to be closer to the root */
2147                 prio = get_op_prio(*tok);
2148
2149                 if (prio > arg->op.prio)
2150                         return process_op(event, arg, tok);
2151
2152                 return process_op(event, right, tok);
2153         }
2154
2155         return type;
2156
2157 out_warn_free:
2158         do_warning_event(event, "%s: not enough memory!", __func__);
2159 out_free:
2160         free_token(token);
2161         *tok = NULL;
2162         return TEP_EVENT_ERROR;
2163 }
2164
2165 static enum tep_event_type
2166 process_entry(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2167               char **tok)
2168 {
2169         enum tep_event_type type;
2170         char *field;
2171         char *token;
2172
2173         if (read_expected(TEP_EVENT_OP, "->") < 0)
2174                 goto out_err;
2175
2176         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2177                 goto out_free;
2178         field = token;
2179
2180         arg->type = TEP_PRINT_FIELD;
2181         arg->field.name = field;
2182
2183         if (is_flag_field) {
2184                 arg->field.field = tep_find_any_field(event, arg->field.name);
2185                 arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2186                 is_flag_field = 0;
2187         } else if (is_symbolic_field) {
2188                 arg->field.field = tep_find_any_field(event, arg->field.name);
2189                 arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2190                 is_symbolic_field = 0;
2191         }
2192
2193         type = read_token(&token);
2194         *tok = token;
2195
2196         return type;
2197
2198  out_free:
2199         free_token(token);
2200  out_err:
2201         *tok = NULL;
2202         return TEP_EVENT_ERROR;
2203 }
2204
2205 static int alloc_and_process_delim(struct tep_event *event, char *next_token,
2206                                    struct tep_print_arg **print_arg)
2207 {
2208         struct tep_print_arg *field;
2209         enum tep_event_type type;
2210         char *token;
2211         int ret = 0;
2212
2213         field = alloc_arg();
2214         if (!field) {
2215                 do_warning_event(event, "%s: not enough memory!", __func__);
2216                 errno = ENOMEM;
2217                 return -1;
2218         }
2219
2220         type = process_arg(event, field, &token);
2221
2222         if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
2223                 errno = EINVAL;
2224                 ret = -1;
2225                 free_arg(field);
2226                 goto out_free_token;
2227         }
2228
2229         *print_arg = field;
2230
2231 out_free_token:
2232         free_token(token);
2233
2234         return ret;
2235 }
2236
2237 static char *arg_eval (struct tep_print_arg *arg);
2238
2239 static unsigned long long
2240 eval_type_str(unsigned long long val, const char *type, int pointer)
2241 {
2242         int sign = 0;
2243         char *ref;
2244         int len;
2245
2246         len = strlen(type);
2247
2248         if (pointer) {
2249
2250                 if (type[len-1] != '*') {
2251                         do_warning("pointer expected with non pointer type");
2252                         return val;
2253                 }
2254
2255                 ref = malloc(len);
2256                 if (!ref) {
2257                         do_warning("%s: not enough memory!", __func__);
2258                         return val;
2259                 }
2260                 memcpy(ref, type, len);
2261
2262                 /* chop off the " *" */
2263                 ref[len - 2] = 0;
2264
2265                 val = eval_type_str(val, ref, 0);
2266                 free(ref);
2267                 return val;
2268         }
2269
2270         /* check if this is a pointer */
2271         if (type[len - 1] == '*')
2272                 return val;
2273
2274         /* Try to figure out the arg size*/
2275         if (strncmp(type, "struct", 6) == 0)
2276                 /* all bets off */
2277                 return val;
2278
2279         if (strcmp(type, "u8") == 0)
2280                 return val & 0xff;
2281
2282         if (strcmp(type, "u16") == 0)
2283                 return val & 0xffff;
2284
2285         if (strcmp(type, "u32") == 0)
2286                 return val & 0xffffffff;
2287
2288         if (strcmp(type, "u64") == 0 ||
2289             strcmp(type, "s64") == 0)
2290                 return val;
2291
2292         if (strcmp(type, "s8") == 0)
2293                 return (unsigned long long)(char)val & 0xff;
2294
2295         if (strcmp(type, "s16") == 0)
2296                 return (unsigned long long)(short)val & 0xffff;
2297
2298         if (strcmp(type, "s32") == 0)
2299                 return (unsigned long long)(int)val & 0xffffffff;
2300
2301         if (strncmp(type, "unsigned ", 9) == 0) {
2302                 sign = 0;
2303                 type += 9;
2304         }
2305
2306         if (strcmp(type, "char") == 0) {
2307                 if (sign)
2308                         return (unsigned long long)(char)val & 0xff;
2309                 else
2310                         return val & 0xff;
2311         }
2312
2313         if (strcmp(type, "short") == 0) {
2314                 if (sign)
2315                         return (unsigned long long)(short)val & 0xffff;
2316                 else
2317                         return val & 0xffff;
2318         }
2319
2320         if (strcmp(type, "int") == 0) {
2321                 if (sign)
2322                         return (unsigned long long)(int)val & 0xffffffff;
2323                 else
2324                         return val & 0xffffffff;
2325         }
2326
2327         return val;
2328 }
2329
2330 /*
2331  * Try to figure out the type.
2332  */
2333 static unsigned long long
2334 eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2335 {
2336         if (arg->type != TEP_PRINT_TYPE) {
2337                 do_warning("expected type argument");
2338                 return 0;
2339         }
2340
2341         return eval_type_str(val, arg->typecast.type, pointer);
2342 }
2343
2344 static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2345 {
2346         long long left, right;
2347         int ret = 1;
2348
2349         switch (arg->type) {
2350         case TEP_PRINT_ATOM:
2351                 *val = strtoll(arg->atom.atom, NULL, 0);
2352                 break;
2353         case TEP_PRINT_TYPE:
2354                 ret = arg_num_eval(arg->typecast.item, val);
2355                 if (!ret)
2356                         break;
2357                 *val = eval_type(*val, arg, 0);
2358                 break;
2359         case TEP_PRINT_OP:
2360                 switch (arg->op.op[0]) {
2361                 case '|':
2362                         ret = arg_num_eval(arg->op.left, &left);
2363                         if (!ret)
2364                                 break;
2365                         ret = arg_num_eval(arg->op.right, &right);
2366                         if (!ret)
2367                                 break;
2368                         if (arg->op.op[1])
2369                                 *val = left || right;
2370                         else
2371                                 *val = left | right;
2372                         break;
2373                 case '&':
2374                         ret = arg_num_eval(arg->op.left, &left);
2375                         if (!ret)
2376                                 break;
2377                         ret = arg_num_eval(arg->op.right, &right);
2378                         if (!ret)
2379                                 break;
2380                         if (arg->op.op[1])
2381                                 *val = left && right;
2382                         else
2383                                 *val = left & right;
2384                         break;
2385                 case '<':
2386                         ret = arg_num_eval(arg->op.left, &left);
2387                         if (!ret)
2388                                 break;
2389                         ret = arg_num_eval(arg->op.right, &right);
2390                         if (!ret)
2391                                 break;
2392                         switch (arg->op.op[1]) {
2393                         case 0:
2394                                 *val = left < right;
2395                                 break;
2396                         case '<':
2397                                 *val = left << right;
2398                                 break;
2399                         case '=':
2400                                 *val = left <= right;
2401                                 break;
2402                         default:
2403                                 do_warning("unknown op '%s'", arg->op.op);
2404                                 ret = 0;
2405                         }
2406                         break;
2407                 case '>':
2408                         ret = arg_num_eval(arg->op.left, &left);
2409                         if (!ret)
2410                                 break;
2411                         ret = arg_num_eval(arg->op.right, &right);
2412                         if (!ret)
2413                                 break;
2414                         switch (arg->op.op[1]) {
2415                         case 0:
2416                                 *val = left > right;
2417                                 break;
2418                         case '>':
2419                                 *val = left >> right;
2420                                 break;
2421                         case '=':
2422                                 *val = left >= right;
2423                                 break;
2424                         default:
2425                                 do_warning("unknown op '%s'", arg->op.op);
2426                                 ret = 0;
2427                         }
2428                         break;
2429                 case '=':
2430                         ret = arg_num_eval(arg->op.left, &left);
2431                         if (!ret)
2432                                 break;
2433                         ret = arg_num_eval(arg->op.right, &right);
2434                         if (!ret)
2435                                 break;
2436
2437                         if (arg->op.op[1] != '=') {
2438                                 do_warning("unknown op '%s'", arg->op.op);
2439                                 ret = 0;
2440                         } else
2441                                 *val = left == right;
2442                         break;
2443                 case '!':
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
2451                         switch (arg->op.op[1]) {
2452                         case '=':
2453                                 *val = left != right;
2454                                 break;
2455                         default:
2456                                 do_warning("unknown op '%s'", arg->op.op);
2457                                 ret = 0;
2458                         }
2459                         break;
2460                 case '-':
2461                         /* check for negative */
2462                         if (arg->op.left->type == TEP_PRINT_NULL)
2463                                 left = 0;
2464                         else
2465                                 ret = arg_num_eval(arg->op.left, &left);
2466                         if (!ret)
2467                                 break;
2468                         ret = arg_num_eval(arg->op.right, &right);
2469                         if (!ret)
2470                                 break;
2471                         *val = left - right;
2472                         break;
2473                 case '+':
2474                         if (arg->op.left->type == TEP_PRINT_NULL)
2475                                 left = 0;
2476                         else
2477                                 ret = arg_num_eval(arg->op.left, &left);
2478                         if (!ret)
2479                                 break;
2480                         ret = arg_num_eval(arg->op.right, &right);
2481                         if (!ret)
2482                                 break;
2483                         *val = left + right;
2484                         break;
2485                 case '~':
2486                         ret = arg_num_eval(arg->op.right, &right);
2487                         if (!ret)
2488                                 break;
2489                         *val = ~right;
2490                         break;
2491                 default:
2492                         do_warning("unknown op '%s'", arg->op.op);
2493                         ret = 0;
2494                 }
2495                 break;
2496
2497         case TEP_PRINT_NULL:
2498         case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2499         case TEP_PRINT_STRING:
2500         case TEP_PRINT_BSTRING:
2501         case TEP_PRINT_BITMASK:
2502         default:
2503                 do_warning("invalid eval type %d", arg->type);
2504                 ret = 0;
2505
2506         }
2507         return ret;
2508 }
2509
2510 static char *arg_eval (struct tep_print_arg *arg)
2511 {
2512         long long val;
2513         static char buf[24];
2514
2515         switch (arg->type) {
2516         case TEP_PRINT_ATOM:
2517                 return arg->atom.atom;
2518         case TEP_PRINT_TYPE:
2519                 return arg_eval(arg->typecast.item);
2520         case TEP_PRINT_OP:
2521                 if (!arg_num_eval(arg, &val))
2522                         break;
2523                 sprintf(buf, "%lld", val);
2524                 return buf;
2525
2526         case TEP_PRINT_NULL:
2527         case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2528         case TEP_PRINT_STRING:
2529         case TEP_PRINT_BSTRING:
2530         case TEP_PRINT_BITMASK:
2531         default:
2532                 do_warning("invalid eval type %d", arg->type);
2533                 break;
2534         }
2535
2536         return NULL;
2537 }
2538
2539 static enum tep_event_type
2540 process_fields(struct tep_event *event, struct tep_print_flag_sym **list, char **tok)
2541 {
2542         enum tep_event_type type;
2543         struct tep_print_arg *arg = NULL;
2544         struct tep_print_flag_sym *field;
2545         char *token = *tok;
2546         char *value;
2547
2548         do {
2549                 free_token(token);
2550                 type = read_token_item(&token);
2551                 if (test_type_token(type, token, TEP_EVENT_OP, "{"))
2552                         break;
2553
2554                 arg = alloc_arg();
2555                 if (!arg)
2556                         goto out_free;
2557
2558                 free_token(token);
2559                 type = process_arg(event, arg, &token);
2560
2561                 if (type == TEP_EVENT_OP)
2562                         type = process_op(event, arg, &token);
2563
2564                 if (type == TEP_EVENT_ERROR)
2565                         goto out_free;
2566
2567                 if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2568                         goto out_free;
2569
2570                 field = calloc(1, sizeof(*field));
2571                 if (!field)
2572                         goto out_free;
2573
2574                 value = arg_eval(arg);
2575                 if (value == NULL)
2576                         goto out_free_field;
2577                 field->value = strdup(value);
2578                 if (field->value == NULL)
2579                         goto out_free_field;
2580
2581                 free_arg(arg);
2582                 arg = alloc_arg();
2583                 if (!arg)
2584                         goto out_free;
2585
2586                 free_token(token);
2587                 type = process_arg(event, arg, &token);
2588                 if (test_type_token(type, token, TEP_EVENT_OP, "}"))
2589                         goto out_free_field;
2590
2591                 value = arg_eval(arg);
2592                 if (value == NULL)
2593                         goto out_free_field;
2594                 field->str = strdup(value);
2595                 if (field->str == NULL)
2596                         goto out_free_field;
2597                 free_arg(arg);
2598                 arg = NULL;
2599
2600                 *list = field;
2601                 list = &field->next;
2602
2603                 free_token(token);
2604                 type = read_token_item(&token);
2605         } while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
2606
2607         *tok = token;
2608         return type;
2609
2610 out_free_field:
2611         free_flag_sym(field);
2612 out_free:
2613         free_arg(arg);
2614         free_token(token);
2615         *tok = NULL;
2616
2617         return TEP_EVENT_ERROR;
2618 }
2619
2620 static enum tep_event_type
2621 process_flags(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2622 {
2623         struct tep_print_arg *field;
2624         enum tep_event_type type;
2625         char *token = NULL;
2626
2627         memset(arg, 0, sizeof(*arg));
2628         arg->type = TEP_PRINT_FLAGS;
2629
2630         field = alloc_arg();
2631         if (!field) {
2632                 do_warning_event(event, "%s: not enough memory!", __func__);
2633                 goto out_free;
2634         }
2635
2636         type = process_field_arg(event, field, &token);
2637
2638         /* Handle operations in the first argument */
2639         while (type == TEP_EVENT_OP)
2640                 type = process_op(event, field, &token);
2641
2642         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2643                 goto out_free_field;
2644         free_token(token);
2645
2646         arg->flags.field = field;
2647
2648         type = read_token_item(&token);
2649         if (event_item_type(type)) {
2650                 arg->flags.delim = token;
2651                 type = read_token_item(&token);
2652         }
2653
2654         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2655                 goto out_free;
2656
2657         type = process_fields(event, &arg->flags.flags, &token);
2658         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2659                 goto out_free;
2660
2661         free_token(token);
2662         type = read_token_item(tok);
2663         return type;
2664
2665 out_free_field:
2666         free_arg(field);
2667 out_free:
2668         free_token(token);
2669         *tok = NULL;
2670         return TEP_EVENT_ERROR;
2671 }
2672
2673 static enum tep_event_type
2674 process_symbols(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2675 {
2676         struct tep_print_arg *field;
2677         enum tep_event_type type;
2678         char *token = NULL;
2679
2680         memset(arg, 0, sizeof(*arg));
2681         arg->type = TEP_PRINT_SYMBOL;
2682
2683         field = alloc_arg();
2684         if (!field) {
2685                 do_warning_event(event, "%s: not enough memory!", __func__);
2686                 goto out_free;
2687         }
2688
2689         type = process_field_arg(event, field, &token);
2690
2691         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2692                 goto out_free_field;
2693
2694         arg->symbol.field = field;
2695
2696         type = process_fields(event, &arg->symbol.symbols, &token);
2697         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2698                 goto out_free;
2699
2700         free_token(token);
2701         type = read_token_item(tok);
2702         return type;
2703
2704 out_free_field:
2705         free_arg(field);
2706 out_free:
2707         free_token(token);
2708         *tok = NULL;
2709         return TEP_EVENT_ERROR;
2710 }
2711
2712 static enum tep_event_type
2713 process_hex_common(struct tep_event *event, struct tep_print_arg *arg,
2714                    char **tok, enum tep_print_arg_type type)
2715 {
2716         memset(arg, 0, sizeof(*arg));
2717         arg->type = type;
2718
2719         if (alloc_and_process_delim(event, ",", &arg->hex.field))
2720                 goto out;
2721
2722         if (alloc_and_process_delim(event, ")", &arg->hex.size))
2723                 goto free_field;
2724
2725         return read_token_item(tok);
2726
2727 free_field:
2728         free_arg(arg->hex.field);
2729         arg->hex.field = NULL;
2730 out:
2731         *tok = NULL;
2732         return TEP_EVENT_ERROR;
2733 }
2734
2735 static enum tep_event_type
2736 process_hex(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2737 {
2738         return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2739 }
2740
2741 static enum tep_event_type
2742 process_hex_str(struct tep_event *event, struct tep_print_arg *arg,
2743                 char **tok)
2744 {
2745         return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2746 }
2747
2748 static enum tep_event_type
2749 process_int_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2750 {
2751         memset(arg, 0, sizeof(*arg));
2752         arg->type = TEP_PRINT_INT_ARRAY;
2753
2754         if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2755                 goto out;
2756
2757         if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2758                 goto free_field;
2759
2760         if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2761                 goto free_size;
2762
2763         return read_token_item(tok);
2764
2765 free_size:
2766         free_arg(arg->int_array.count);
2767         arg->int_array.count = NULL;
2768 free_field:
2769         free_arg(arg->int_array.field);
2770         arg->int_array.field = NULL;
2771 out:
2772         *tok = NULL;
2773         return TEP_EVENT_ERROR;
2774 }
2775
2776 static enum tep_event_type
2777 process_dynamic_array(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2778 {
2779         struct tep_format_field *field;
2780         enum tep_event_type type;
2781         char *token;
2782
2783         memset(arg, 0, sizeof(*arg));
2784         arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2785
2786         /*
2787          * The item within the parenthesis is another field that holds
2788          * the index into where the array starts.
2789          */
2790         type = read_token(&token);
2791         *tok = token;
2792         if (type != TEP_EVENT_ITEM)
2793                 goto out_free;
2794
2795         /* Find the field */
2796
2797         field = tep_find_field(event, token);
2798         if (!field)
2799                 goto out_free;
2800
2801         arg->dynarray.field = field;
2802         arg->dynarray.index = 0;
2803
2804         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2805                 goto out_free;
2806
2807         free_token(token);
2808         type = read_token_item(&token);
2809         *tok = token;
2810         if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
2811                 return type;
2812
2813         free_token(token);
2814         arg = alloc_arg();
2815         if (!arg) {
2816                 do_warning_event(event, "%s: not enough memory!", __func__);
2817                 *tok = NULL;
2818                 return TEP_EVENT_ERROR;
2819         }
2820
2821         type = process_arg(event, arg, &token);
2822         if (type == TEP_EVENT_ERROR)
2823                 goto out_free_arg;
2824
2825         if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
2826                 goto out_free_arg;
2827
2828         free_token(token);
2829         type = read_token_item(tok);
2830         return type;
2831
2832  out_free_arg:
2833         free_arg(arg);
2834  out_free:
2835         free_token(token);
2836         *tok = NULL;
2837         return TEP_EVENT_ERROR;
2838 }
2839
2840 static enum tep_event_type
2841 process_dynamic_array_len(struct tep_event *event, struct tep_print_arg *arg,
2842                           char **tok)
2843 {
2844         struct tep_format_field *field;
2845         enum tep_event_type type;
2846         char *token;
2847
2848         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2849                 goto out_free;
2850
2851         arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2852
2853         /* Find the field */
2854         field = tep_find_field(event, token);
2855         if (!field)
2856                 goto out_free;
2857
2858         arg->dynarray.field = field;
2859         arg->dynarray.index = 0;
2860
2861         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2862                 goto out_err;
2863
2864         free_token(token);
2865         type = read_token(&token);
2866         *tok = token;
2867
2868         return type;
2869
2870  out_free:
2871         free_token(token);
2872  out_err:
2873         *tok = NULL;
2874         return TEP_EVENT_ERROR;
2875 }
2876
2877 static enum tep_event_type
2878 process_paren(struct tep_event *event, struct tep_print_arg *arg, char **tok)
2879 {
2880         struct tep_print_arg *item_arg;
2881         enum tep_event_type type;
2882         char *token;
2883
2884         type = process_arg(event, arg, &token);
2885
2886         if (type == TEP_EVENT_ERROR)
2887                 goto out_free;
2888
2889         if (type == TEP_EVENT_OP)
2890                 type = process_op(event, arg, &token);
2891
2892         if (type == TEP_EVENT_ERROR)
2893                 goto out_free;
2894
2895         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2896                 goto out_free;
2897
2898         free_token(token);
2899         type = read_token_item(&token);
2900
2901         /*
2902          * If the next token is an item or another open paren, then
2903          * this was a typecast.
2904          */
2905         if (event_item_type(type) ||
2906             (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
2907
2908                 /* make this a typecast and contine */
2909
2910                 /* prevous must be an atom */
2911                 if (arg->type != TEP_PRINT_ATOM) {
2912                         do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
2913                         goto out_free;
2914                 }
2915
2916                 item_arg = alloc_arg();
2917                 if (!item_arg) {
2918                         do_warning_event(event, "%s: not enough memory!",
2919                                          __func__);
2920                         goto out_free;
2921                 }
2922
2923                 arg->type = TEP_PRINT_TYPE;
2924                 arg->typecast.type = arg->atom.atom;
2925                 arg->typecast.item = item_arg;
2926                 type = process_arg_token(event, item_arg, &token, type);
2927
2928         }
2929
2930         *tok = token;
2931         return type;
2932
2933  out_free:
2934         free_token(token);
2935         *tok = NULL;
2936         return TEP_EVENT_ERROR;
2937 }
2938
2939
2940 static enum tep_event_type
2941 process_str(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2942             char **tok)
2943 {
2944         enum tep_event_type type;
2945         char *token;
2946
2947         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2948                 goto out_free;
2949
2950         arg->type = TEP_PRINT_STRING;
2951         arg->string.string = token;
2952         arg->string.offset = -1;
2953
2954         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2955                 goto out_err;
2956
2957         type = read_token(&token);
2958         *tok = token;
2959
2960         return type;
2961
2962  out_free:
2963         free_token(token);
2964  out_err:
2965         *tok = NULL;
2966         return TEP_EVENT_ERROR;
2967 }
2968
2969 static enum tep_event_type
2970 process_bitmask(struct tep_event *event __maybe_unused, struct tep_print_arg *arg,
2971                 char **tok)
2972 {
2973         enum tep_event_type type;
2974         char *token;
2975
2976         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2977                 goto out_free;
2978
2979         arg->type = TEP_PRINT_BITMASK;
2980         arg->bitmask.bitmask = token;
2981         arg->bitmask.offset = -1;
2982
2983         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2984                 goto out_err;
2985
2986         type = read_token(&token);
2987         *tok = token;
2988
2989         return type;
2990
2991  out_free:
2992         free_token(token);
2993  out_err:
2994         *tok = NULL;
2995         return TEP_EVENT_ERROR;
2996 }
2997
2998 static struct tep_function_handler *
2999 find_func_handler(struct tep_handle *tep, char *func_name)
3000 {
3001         struct tep_function_handler *func;
3002
3003         if (!tep)
3004                 return NULL;
3005
3006         for (func = tep->func_handlers; func; func = func->next) {
3007                 if (strcmp(func->name, func_name) == 0)
3008                         break;
3009         }
3010
3011         return func;
3012 }
3013
3014 static void remove_func_handler(struct tep_handle *tep, char *func_name)
3015 {
3016         struct tep_function_handler *func;
3017         struct tep_function_handler **next;
3018
3019         next = &tep->func_handlers;
3020         while ((func = *next)) {
3021                 if (strcmp(func->name, func_name) == 0) {
3022                         *next = func->next;
3023                         free_func_handle(func);
3024                         break;
3025                 }
3026                 next = &func->next;
3027         }
3028 }
3029
3030 static enum tep_event_type
3031 process_func_handler(struct tep_event *event, struct tep_function_handler *func,
3032                      struct tep_print_arg *arg, char **tok)
3033 {
3034         struct tep_print_arg **next_arg;
3035         struct tep_print_arg *farg;
3036         enum tep_event_type type;
3037         char *token;
3038         int i;
3039
3040         arg->type = TEP_PRINT_FUNC;
3041         arg->func.func = func;
3042
3043         *tok = NULL;
3044
3045         next_arg = &(arg->func.args);
3046         for (i = 0; i < func->nr_args; i++) {
3047                 farg = alloc_arg();
3048                 if (!farg) {
3049                         do_warning_event(event, "%s: not enough memory!",
3050                                          __func__);
3051                         return TEP_EVENT_ERROR;
3052                 }
3053
3054                 type = process_arg(event, farg, &token);
3055                 if (i < (func->nr_args - 1)) {
3056                         if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
3057                                 do_warning_event(event,
3058                                         "Error: function '%s()' expects %d arguments but event %s only uses %d",
3059                                         func->name, func->nr_args,
3060                                         event->name, i + 1);
3061                                 goto err;
3062                         }
3063                 } else {
3064                         if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
3065                                 do_warning_event(event,
3066                                         "Error: function '%s()' only expects %d arguments but event %s has more",
3067                                         func->name, func->nr_args, event->name);
3068                                 goto err;
3069                         }
3070                 }
3071
3072                 *next_arg = farg;
3073                 next_arg = &(farg->next);
3074                 free_token(token);
3075         }
3076
3077         type = read_token(&token);
3078         *tok = token;
3079
3080         return type;
3081
3082 err:
3083         free_arg(farg);
3084         free_token(token);
3085         return TEP_EVENT_ERROR;
3086 }
3087
3088 static enum tep_event_type
3089 process_builtin_expect(struct tep_event *event, struct tep_print_arg *arg, char **tok)
3090 {
3091         enum tep_event_type type;
3092         char *token = NULL;
3093
3094         /* Handle __builtin_expect( cond, #) */
3095         type = process_arg(event, arg, &token);
3096
3097         if (type != TEP_EVENT_DELIM || token[0] != ',')
3098                 goto out_free;
3099
3100         free_token(token);
3101
3102         /* We don't care what the second parameter is of the __builtin_expect() */
3103         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
3104                 goto out_free;
3105
3106         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
3107                 goto out_free;
3108
3109         free_token(token);
3110         type = read_token_item(tok);
3111         return type;
3112
3113 out_free:
3114         free_token(token);
3115         *tok = NULL;
3116         return TEP_EVENT_ERROR;
3117 }
3118
3119 static enum tep_event_type
3120 process_function(struct tep_event *event, struct tep_print_arg *arg,
3121                  char *token, char **tok)
3122 {
3123         struct tep_function_handler *func;
3124
3125         if (strcmp(token, "__print_flags") == 0) {
3126                 free_token(token);
3127                 is_flag_field = 1;
3128                 return process_flags(event, arg, tok);
3129         }
3130         if (strcmp(token, "__print_symbolic") == 0) {
3131                 free_token(token);
3132                 is_symbolic_field = 1;
3133                 return process_symbols(event, arg, tok);
3134         }
3135         if (strcmp(token, "__print_hex") == 0) {
3136                 free_token(token);
3137                 return process_hex(event, arg, tok);
3138         }
3139         if (strcmp(token, "__print_hex_str") == 0) {
3140                 free_token(token);
3141                 return process_hex_str(event, arg, tok);
3142         }
3143         if (strcmp(token, "__print_array") == 0) {
3144                 free_token(token);
3145                 return process_int_array(event, arg, tok);
3146         }
3147         if (strcmp(token, "__get_str") == 0) {
3148                 free_token(token);
3149                 return process_str(event, arg, tok);
3150         }
3151         if (strcmp(token, "__get_bitmask") == 0) {
3152                 free_token(token);
3153                 return process_bitmask(event, arg, tok);
3154         }
3155         if (strcmp(token, "__get_dynamic_array") == 0) {
3156                 free_token(token);
3157                 return process_dynamic_array(event, arg, tok);
3158         }
3159         if (strcmp(token, "__get_dynamic_array_len") == 0) {
3160                 free_token(token);
3161                 return process_dynamic_array_len(event, arg, tok);
3162         }
3163         if (strcmp(token, "__builtin_expect") == 0) {
3164                 free_token(token);
3165                 return process_builtin_expect(event, arg, tok);
3166         }
3167
3168         func = find_func_handler(event->tep, token);
3169         if (func) {
3170                 free_token(token);
3171                 return process_func_handler(event, func, arg, tok);
3172         }
3173
3174         do_warning_event(event, "function %s not defined", token);
3175         free_token(token);
3176         return TEP_EVENT_ERROR;
3177 }
3178
3179 static enum tep_event_type
3180 process_arg_token(struct tep_event *event, struct tep_print_arg *arg,
3181                   char **tok, enum tep_event_type type)
3182 {
3183         char *token;
3184         char *atom;
3185
3186         token = *tok;
3187
3188         switch (type) {
3189         case TEP_EVENT_ITEM:
3190                 if (strcmp(token, "REC") == 0) {
3191                         free_token(token);
3192                         type = process_entry(event, arg, &token);
3193                         break;
3194                 }
3195                 atom = token;
3196                 /* test the next token */
3197                 type = read_token_item(&token);
3198
3199                 /*
3200                  * If the next token is a parenthesis, then this
3201                  * is a function.
3202                  */
3203                 if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
3204                         free_token(token);
3205                         token = NULL;
3206                         /* this will free atom. */
3207                         type = process_function(event, arg, atom, &token);
3208                         break;
3209                 }
3210                 /* atoms can be more than one token long */
3211                 while (type == TEP_EVENT_ITEM) {
3212                         int ret;
3213
3214                         ret = append(&atom, " ", token);
3215                         if (ret < 0) {
3216                                 free(atom);
3217                                 *tok = NULL;
3218                                 free_token(token);
3219                                 return TEP_EVENT_ERROR;
3220                         }
3221                         free_token(token);
3222                         type = read_token_item(&token);
3223                 }
3224
3225                 arg->type = TEP_PRINT_ATOM;
3226                 arg->atom.atom = atom;
3227                 break;
3228
3229         case TEP_EVENT_DQUOTE:
3230         case TEP_EVENT_SQUOTE:
3231                 arg->type = TEP_PRINT_ATOM;
3232                 arg->atom.atom = token;
3233                 type = read_token_item(&token);
3234                 break;
3235         case TEP_EVENT_DELIM:
3236                 if (strcmp(token, "(") == 0) {
3237                         free_token(token);
3238                         type = process_paren(event, arg, &token);
3239                         break;
3240                 }
3241         case TEP_EVENT_OP:
3242                 /* handle single ops */
3243                 arg->type = TEP_PRINT_OP;
3244                 arg->op.op = token;
3245                 arg->op.left = NULL;
3246                 type = process_op(event, arg, &token);
3247
3248                 /* On error, the op is freed */
3249                 if (type == TEP_EVENT_ERROR)
3250                         arg->op.op = NULL;
3251
3252                 /* return error type if errored */
3253                 break;
3254
3255         case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
3256         default:
3257                 do_warning_event(event, "unexpected type %d", type);
3258                 return TEP_EVENT_ERROR;
3259         }
3260         *tok = token;
3261
3262         return type;
3263 }
3264
3265 static int event_read_print_args(struct tep_event *event, struct tep_print_arg **list)
3266 {
3267         enum tep_event_type type = TEP_EVENT_ERROR;
3268         struct tep_print_arg *arg;
3269         char *token;
3270         int args = 0;
3271
3272         do {
3273                 if (type == TEP_EVENT_NEWLINE) {
3274                         type = read_token_item(&token);
3275                         continue;
3276                 }
3277
3278                 arg = alloc_arg();
3279                 if (!arg) {
3280                         do_warning_event(event, "%s: not enough memory!",
3281                                          __func__);
3282                         return -1;
3283                 }
3284
3285                 type = process_arg(event, arg, &token);
3286
3287                 if (type == TEP_EVENT_ERROR) {
3288                         free_token(token);
3289                         free_arg(arg);
3290                         return -1;
3291                 }
3292
3293                 *list = arg;
3294                 args++;
3295
3296                 if (type == TEP_EVENT_OP) {
3297                         type = process_op(event, arg, &token);
3298                         free_token(token);
3299                         if (type == TEP_EVENT_ERROR) {
3300                                 *list = NULL;
3301                                 free_arg(arg);
3302                                 return -1;
3303                         }
3304                         list = &arg->next;
3305                         continue;
3306                 }
3307
3308                 if (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0) {
3309                         free_token(token);
3310                         *list = arg;
3311                         list = &arg->next;
3312                         continue;
3313                 }
3314                 break;
3315         } while (type != TEP_EVENT_NONE);
3316
3317         if (type != TEP_EVENT_NONE && type != TEP_EVENT_ERROR)
3318                 free_token(token);
3319
3320         return args;
3321 }
3322
3323 static int event_read_print(struct tep_event *event)
3324 {
3325         enum tep_event_type type;
3326         char *token;
3327         int ret;
3328
3329         if (read_expected_item(TEP_EVENT_ITEM, "print") < 0)
3330                 return -1;
3331
3332         if (read_expected(TEP_EVENT_ITEM, "fmt") < 0)
3333                 return -1;
3334
3335         if (read_expected(TEP_EVENT_OP, ":") < 0)
3336                 return -1;
3337
3338         if (read_expect_type(TEP_EVENT_DQUOTE, &token) < 0)
3339                 goto fail;
3340
3341  concat:
3342         event->print_fmt.format = token;
3343         event->print_fmt.args = NULL;
3344
3345         /* ok to have no arg */
3346         type = read_token_item(&token);
3347
3348         if (type == TEP_EVENT_NONE)
3349                 return 0;
3350
3351         /* Handle concatenation of print lines */
3352         if (type == TEP_EVENT_DQUOTE) {
3353                 char *cat;
3354
3355                 if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
3356                         goto fail;
3357                 free_token(token);
3358                 free_token(event->print_fmt.format);
3359                 event->print_fmt.format = NULL;
3360                 token = cat;
3361                 goto concat;
3362         }
3363
3364         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
3365                 goto fail;
3366
3367         free_token(token);
3368
3369         ret = event_read_print_args(event, &event->print_fmt.args);
3370         if (ret < 0)
3371                 return -1;
3372
3373         return ret;
3374
3375  fail:
3376         free_token(token);
3377         return -1;
3378 }
3379
3380 /**
3381  * tep_find_common_field - return a common field by event
3382  * @event: handle for the event
3383  * @name: the name of the common field to return
3384  *
3385  * Returns a common field from the event by the given @name.
3386  * This only searches the common fields and not all field.
3387  */
3388 struct tep_format_field *
3389 tep_find_common_field(struct tep_event *event, const char *name)
3390 {
3391         struct tep_format_field *format;
3392
3393         for (format = event->format.common_fields;
3394              format; format = format->next) {
3395                 if (strcmp(format->name, name) == 0)
3396                         break;
3397         }
3398
3399         return format;
3400 }
3401
3402 /**
3403  * tep_find_field - find a non-common field
3404  * @event: handle for the event
3405  * @name: the name of the non-common field
3406  *
3407  * Returns a non-common field by the given @name.
3408  * This does not search common fields.
3409  */
3410 struct tep_format_field *
3411 tep_find_field(struct tep_event *event, const char *name)
3412 {
3413         struct tep_format_field *format;
3414
3415         for (format = event->format.fields;
3416              format; format = format->next) {
3417                 if (strcmp(format->name, name) == 0)
3418                         break;
3419         }
3420
3421         return format;
3422 }
3423
3424 /**
3425  * tep_find_any_field - find any field by name
3426  * @event: handle for the event
3427  * @name: the name of the field
3428  *
3429  * Returns a field by the given @name.
3430  * This searches the common field names first, then
3431  * the non-common ones if a common one was not found.
3432  */
3433 struct tep_format_field *
3434 tep_find_any_field(struct tep_event *event, const char *name)
3435 {
3436         struct tep_format_field *format;
3437
3438         format = tep_find_common_field(event, name);
3439         if (format)
3440                 return format;
3441         return tep_find_field(event, name);
3442 }
3443
3444 /**
3445  * tep_read_number - read a number from data
3446  * @tep: a handle to the trace event parser context
3447  * @ptr: the raw data
3448  * @size: the size of the data that holds the number
3449  *
3450  * Returns the number (converted to host) from the
3451  * raw data.
3452  */
3453 unsigned long long tep_read_number(struct tep_handle *tep,
3454                                    const void *ptr, int size)
3455 {
3456         unsigned long long val;
3457
3458         switch (size) {
3459         case 1:
3460                 return *(unsigned char *)ptr;
3461         case 2:
3462                 return tep_data2host2(tep, *(unsigned short *)ptr);
3463         case 4:
3464                 return tep_data2host4(tep, *(unsigned int *)ptr);
3465         case 8:
3466                 memcpy(&val, (ptr), sizeof(unsigned long long));
3467                 return tep_data2host8(tep, val);
3468         default:
3469                 /* BUG! */
3470                 return 0;
3471         }
3472 }
3473
3474 /**
3475  * tep_read_number_field - read a number from data
3476  * @field: a handle to the field
3477  * @data: the raw data to read
3478  * @value: the value to place the number in
3479  *
3480  * Reads raw data according to a field offset and size,
3481  * and translates it into @value.
3482  *
3483  * Returns 0 on success, -1 otherwise.
3484  */
3485 int tep_read_number_field(struct tep_format_field *field, const void *data,
3486                           unsigned long long *value)
3487 {
3488         if (!field)
3489                 return -1;
3490         switch (field->size) {
3491         case 1:
3492         case 2:
3493         case 4:
3494         case 8:
3495                 *value = tep_read_number(field->event->tep,
3496                                          data + field->offset, field->size);
3497                 return 0;
3498         default:
3499                 return -1;
3500         }
3501 }
3502
3503 static int get_common_info(struct tep_handle *tep,
3504                            const char *type, int *offset, int *size)
3505 {
3506         struct tep_event *event;
3507         struct tep_format_field *field;
3508
3509         /*
3510          * All events should have the same common elements.
3511          * Pick any event to find where the type is;
3512          */
3513         if (!tep->events) {
3514                 do_warning("no event_list!");
3515                 return -1;
3516         }
3517
3518         event = tep->events[0];
3519         field = tep_find_common_field(event, type);
3520         if (!field)
3521                 return -1;
3522
3523         *offset = field->offset;
3524         *size = field->size;
3525
3526         return 0;
3527 }
3528
3529 static int __parse_common(struct tep_handle *tep, void *data,
3530                           int *size, int *offset, const char *name)
3531 {
3532         int ret;
3533
3534         if (!*size) {
3535                 ret = get_common_info(tep, name, offset, size);
3536                 if (ret < 0)
3537                         return ret;
3538         }
3539         return tep_read_number(tep, data + *offset, *size);
3540 }
3541
3542 static int trace_parse_common_type(struct tep_handle *tep, void *data)
3543 {
3544         return __parse_common(tep, data,
3545                               &tep->type_size, &tep->type_offset,
3546                               "common_type");
3547 }
3548
3549 static int parse_common_pid(struct tep_handle *tep, void *data)
3550 {
3551         return __parse_common(tep, data,
3552                               &tep->pid_size, &tep->pid_offset,
3553                               "common_pid");
3554 }
3555
3556 static int parse_common_pc(struct tep_handle *tep, void *data)
3557 {
3558         return __parse_common(tep, data,
3559                               &tep->pc_size, &tep->pc_offset,
3560                               "common_preempt_count");
3561 }
3562
3563 static int parse_common_flags(struct tep_handle *tep, void *data)
3564 {
3565         return __parse_common(tep, data,
3566                               &tep->flags_size, &tep->flags_offset,
3567                               "common_flags");
3568 }
3569
3570 static int parse_common_lock_depth(struct tep_handle *tep, void *data)
3571 {
3572         return __parse_common(tep, data,
3573                               &tep->ld_size, &tep->ld_offset,
3574                               "common_lock_depth");
3575 }
3576
3577 static int parse_common_migrate_disable(struct tep_handle *tep, void *data)
3578 {
3579         return __parse_common(tep, data,
3580                               &tep->ld_size, &tep->ld_offset,
3581                               "common_migrate_disable");
3582 }
3583
3584 static int events_id_cmp(const void *a, const void *b);
3585
3586 /**
3587  * tep_find_event - find an event by given id
3588  * @tep: a handle to the trace event parser context
3589  * @id: the id of the event
3590  *
3591  * Returns an event that has a given @id.
3592  */
3593 struct tep_event *tep_find_event(struct tep_handle *tep, int id)
3594 {
3595         struct tep_event **eventptr;
3596         struct tep_event key;
3597         struct tep_event *pkey = &key;
3598
3599         /* Check cache first */
3600         if (tep->last_event && tep->last_event->id == id)
3601                 return tep->last_event;
3602
3603         key.id = id;
3604
3605         eventptr = bsearch(&pkey, tep->events, tep->nr_events,
3606                            sizeof(*tep->events), events_id_cmp);
3607
3608         if (eventptr) {
3609                 tep->last_event = *eventptr;
3610                 return *eventptr;
3611         }
3612
3613         return NULL;
3614 }
3615
3616 /**
3617  * tep_find_event_by_name - find an event by given name
3618  * @tep: a handle to the trace event parser context
3619  * @sys: the system name to search for
3620  * @name: the name of the event to search for
3621  *
3622  * This returns an event with a given @name and under the system
3623  * @sys. If @sys is NULL the first event with @name is returned.
3624  */
3625 struct tep_event *
3626 tep_find_event_by_name(struct tep_handle *tep,
3627                        const char *sys, const char *name)
3628 {
3629         struct tep_event *event = NULL;
3630         int i;
3631
3632         if (tep->last_event &&
3633             strcmp(tep->last_event->name, name) == 0 &&
3634             (!sys || strcmp(tep->last_event->system, sys) == 0))
3635                 return tep->last_event;
3636
3637         for (i = 0; i < tep->nr_events; i++) {
3638                 event = tep->events[i];
3639                 if (strcmp(event->name, name) == 0) {
3640                         if (!sys)
3641                                 break;
3642                         if (strcmp(event->system, sys) == 0)
3643                                 break;
3644                 }
3645         }
3646         if (i == tep->nr_events)
3647                 event = NULL;
3648
3649         tep->last_event = event;
3650         return event;
3651 }
3652
3653 static unsigned long long
3654 eval_num_arg(void *data, int size, struct tep_event *event, struct tep_print_arg *arg)
3655 {
3656         struct tep_handle *tep = event->tep;
3657         unsigned long long val = 0;
3658         unsigned long long left, right;
3659         struct tep_print_arg *typearg = NULL;
3660         struct tep_print_arg *larg;
3661         unsigned long offset;
3662         unsigned int field_size;
3663
3664         switch (arg->type) {
3665         case TEP_PRINT_NULL:
3666                 /* ?? */
3667                 return 0;
3668         case TEP_PRINT_ATOM:
3669                 return strtoull(arg->atom.atom, NULL, 0);
3670         case TEP_PRINT_FIELD:
3671                 if (!arg->field.field) {
3672                         arg->field.field = tep_find_any_field(event, arg->field.name);
3673                         if (!arg->field.field)
3674                                 goto out_warning_field;
3675
3676                 }
3677                 /* must be a number */
3678                 val = tep_read_number(tep, data + arg->field.field->offset,
3679                                       arg->field.field->size);
3680                 break;
3681         case TEP_PRINT_FLAGS:
3682         case TEP_PRINT_SYMBOL:
3683         case TEP_PRINT_INT_ARRAY:
3684         case TEP_PRINT_HEX:
3685         case TEP_PRINT_HEX_STR:
3686                 break;
3687         case TEP_PRINT_TYPE:
3688                 val = eval_num_arg(data, size, event, arg->typecast.item);
3689                 return eval_type(val, arg, 0);
3690         case TEP_PRINT_STRING:
3691         case TEP_PRINT_BSTRING:
3692         case TEP_PRINT_BITMASK:
3693                 return 0;
3694         case TEP_PRINT_FUNC: {
3695                 struct trace_seq s;
3696                 trace_seq_init(&s);
3697                 val = process_defined_func(&s, data, size, event, arg);
3698                 trace_seq_destroy(&s);
3699                 return val;
3700         }
3701         case TEP_PRINT_OP:
3702                 if (strcmp(arg->op.op, "[") == 0) {
3703                         /*
3704                          * Arrays are special, since we don't want
3705                          * to read the arg as is.
3706                          */
3707                         right = eval_num_arg(data, size, event, arg->op.right);
3708
3709                         /* handle typecasts */
3710                         larg = arg->op.left;
3711                         while (larg->type == TEP_PRINT_TYPE) {
3712                                 if (!typearg)
3713                                         typearg = larg;
3714                                 larg = larg->typecast.item;
3715                         }
3716
3717                         /* Default to long size */
3718                         field_size = tep->long_size;
3719
3720                         switch (larg->type) {
3721                         case TEP_PRINT_DYNAMIC_ARRAY:
3722                                 offset = tep_read_number(tep,
3723                                                    data + larg->dynarray.field->offset,
3724                                                    larg->dynarray.field->size);
3725                                 if (larg->dynarray.field->elementsize)
3726                                         field_size = larg->dynarray.field->elementsize;
3727                                 /*
3728                                  * The actual length of the dynamic array is stored
3729                                  * in the top half of the field, and the offset
3730                                  * is in the bottom half of the 32 bit field.
3731                                  */
3732                                 offset &= 0xffff;
3733                                 offset += right;
3734                                 break;
3735                         case TEP_PRINT_FIELD:
3736                                 if (!larg->field.field) {
3737                                         larg->field.field =
3738                                                 tep_find_any_field(event, larg->field.name);
3739                                         if (!larg->field.field) {
3740                                                 arg = larg;
3741                                                 goto out_warning_field;
3742                                         }
3743                                 }
3744                                 field_size = larg->field.field->elementsize;
3745                                 offset = larg->field.field->offset +
3746                                         right * larg->field.field->elementsize;
3747                                 break;
3748                         default:
3749                                 goto default_op; /* oops, all bets off */
3750                         }
3751                         val = tep_read_number(tep,
3752                                               data + offset, field_size);
3753                         if (typearg)
3754                                 val = eval_type(val, typearg, 1);
3755                         break;
3756                 } else if (strcmp(arg->op.op, "?") == 0) {
3757                         left = eval_num_arg(data, size, event, arg->op.left);
3758                         arg = arg->op.right;
3759                         if (left)
3760                                 val = eval_num_arg(data, size, event, arg->op.left);
3761                         else
3762                                 val = eval_num_arg(data, size, event, arg->op.right);
3763                         break;
3764                 }
3765  default_op:
3766                 left = eval_num_arg(data, size, event, arg->op.left);
3767                 right = eval_num_arg(data, size, event, arg->op.right);
3768                 switch (arg->op.op[0]) {
3769                 case '!':
3770                         switch (arg->op.op[1]) {
3771                         case 0:
3772                                 val = !right;
3773                                 break;
3774                         case '=':
3775                                 val = left != right;
3776                                 break;
3777                         default:
3778                                 goto out_warning_op;
3779                         }
3780                         break;
3781                 case '~':
3782                         val = ~right;
3783                         break;
3784                 case '|':
3785                         if (arg->op.op[1])
3786                                 val = left || right;
3787                         else
3788                                 val = left | right;
3789                         break;
3790                 case '&':
3791                         if (arg->op.op[1])
3792                                 val = left && right;
3793                         else
3794                                 val = left & right;
3795                         break;
3796                 case '<':
3797                         switch (arg->op.op[1]) {
3798                         case 0:
3799                                 val = left < right;
3800                                 break;
3801                         case '<':
3802                                 val = left << right;
3803                                 break;
3804                         case '=':
3805                                 val = left <= right;
3806                                 break;
3807                         default:
3808                                 goto out_warning_op;
3809                         }
3810                         break;
3811                 case '>':
3812                         switch (arg->op.op[1]) {
3813                         case 0:
3814                                 val = left > right;
3815                                 break;
3816                         case '>':
3817                                 val = left >> right;
3818                                 break;
3819                         case '=':
3820                                 val = left >= right;
3821                                 break;
3822                         default:
3823                                 goto out_warning_op;
3824                         }
3825                         break;
3826                 case '=':
3827                         if (arg->op.op[1] != '=')
3828                                 goto out_warning_op;
3829
3830                         val = left == right;
3831                         break;
3832                 case '-':
3833                         val = left - right;
3834                         break;
3835                 case '+':
3836                         val = left + right;
3837                         break;
3838                 case '/':
3839                         val = left / right;
3840                         break;
3841                 case '%':
3842                         val = left % right;
3843                         break;
3844                 case '*':
3845                         val = left * right;
3846                         break;
3847                 default:
3848                         goto out_warning_op;
3849                 }
3850                 break;
3851         case TEP_PRINT_DYNAMIC_ARRAY_LEN:
3852                 offset = tep_read_number(tep,
3853                                          data + arg->dynarray.field->offset,
3854                                          arg->dynarray.field->size);
3855                 /*
3856                  * The total allocated length of the dynamic array is
3857                  * stored in the top half of the field, and the offset
3858                  * is in the bottom half of the 32 bit field.
3859                  */
3860                 val = (unsigned long long)(offset >> 16);
3861                 break;
3862         case TEP_PRINT_DYNAMIC_ARRAY:
3863                 /* Without [], we pass the address to the dynamic data */
3864                 offset = tep_read_number(tep,
3865                                          data + arg->dynarray.field->offset,
3866                                          arg->dynarray.field->size);
3867                 /*
3868                  * The total allocated length of the dynamic array is
3869                  * stored in the top half of the field, and the offset
3870                  * is in the bottom half of the 32 bit field.
3871                  */
3872                 offset &= 0xffff;
3873                 val = (unsigned long long)((unsigned long)data + offset);
3874                 break;
3875         default: /* not sure what to do there */
3876                 return 0;
3877         }
3878         return val;
3879
3880 out_warning_op:
3881         do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3882         return 0;
3883
3884 out_warning_field:
3885         do_warning_event(event, "%s: field %s not found",
3886                          __func__, arg->field.name);
3887         return 0;
3888 }
3889
3890 struct flag {
3891         const char *name;
3892         unsigned long long value;
3893 };
3894
3895 static const struct flag flags[] = {
3896         { "HI_SOFTIRQ", 0 },
3897         { "TIMER_SOFTIRQ", 1 },
3898         { "NET_TX_SOFTIRQ", 2 },
3899         { "NET_RX_SOFTIRQ", 3 },
3900         { "BLOCK_SOFTIRQ", 4 },
3901         { "IRQ_POLL_SOFTIRQ", 5 },
3902         { "TASKLET_SOFTIRQ", 6 },
3903         { "SCHED_SOFTIRQ", 7 },
3904         { "HRTIMER_SOFTIRQ", 8 },
3905         { "RCU_SOFTIRQ", 9 },
3906
3907         { "HRTIMER_NORESTART", 0 },
3908         { "HRTIMER_RESTART", 1 },
3909 };
3910
3911 static long long eval_flag(const char *flag)
3912 {
3913         int i;
3914
3915         /*
3916          * Some flags in the format files do not get converted.
3917          * If the flag is not numeric, see if it is something that
3918          * we already know about.
3919          */
3920         if (isdigit(flag[0]))
3921                 return strtoull(flag, NULL, 0);
3922
3923         for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
3924                 if (strcmp(flags[i].name, flag) == 0)
3925                         return flags[i].value;
3926
3927         return -1LL;
3928 }
3929
3930 static void print_str_to_seq(struct trace_seq *s, const char *format,
3931                              int len_arg, const char *str)
3932 {
3933         if (len_arg >= 0)
3934                 trace_seq_printf(s, format, len_arg, str);
3935         else
3936                 trace_seq_printf(s, format, str);
3937 }
3938
3939 static void print_bitmask_to_seq(struct tep_handle *tep,
3940                                  struct trace_seq *s, const char *format,
3941                                  int len_arg, const void *data, int size)
3942 {
3943         int nr_bits = size * 8;
3944         int str_size = (nr_bits + 3) / 4;
3945         int len = 0;
3946         char buf[3];
3947         char *str;
3948         int index;
3949         int i;
3950
3951         /*
3952          * The kernel likes to put in commas every 32 bits, we
3953          * can do the same.
3954          */
3955         str_size += (nr_bits - 1) / 32;
3956
3957         str = malloc(str_size + 1);
3958         if (!str) {
3959                 do_warning("%s: not enough memory!", __func__);
3960                 return;
3961         }
3962         str[str_size] = 0;
3963
3964         /* Start out with -2 for the two chars per byte */
3965         for (i = str_size - 2; i >= 0; i -= 2) {
3966                 /*
3967                  * data points to a bit mask of size bytes.
3968                  * In the kernel, this is an array of long words, thus
3969                  * endianness is very important.
3970                  */
3971                 if (tep->file_bigendian)
3972                         index = size - (len + 1);
3973                 else
3974                         index = len;
3975
3976                 snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
3977                 memcpy(str + i, buf, 2);
3978                 len++;
3979                 if (!(len & 3) && i > 0) {
3980                         i--;
3981                         str[i] = ',';
3982                 }
3983         }
3984
3985         if (len_arg >= 0)
3986                 trace_seq_printf(s, format, len_arg, str);
3987         else
3988                 trace_seq_printf(s, format, str);
3989
3990         free(str);
3991 }
3992
3993 static void print_str_arg(struct trace_seq *s, void *data, int size,
3994                           struct tep_event *event, const char *format,
3995                           int len_arg, struct tep_print_arg *arg)
3996 {
3997         struct tep_handle *tep = event->tep;
3998         struct tep_print_flag_sym *flag;
3999         struct tep_format_field *field;
4000         struct printk_map *printk;
4001         long long val, fval;
4002         unsigned long long addr;
4003         char *str;
4004         unsigned char *hex;
4005         int print;
4006         int i, len;
4007
4008         switch (arg->type) {
4009         case TEP_PRINT_NULL:
4010                 /* ?? */
4011                 return;
4012         case TEP_PRINT_ATOM:
4013                 print_str_to_seq(s, format, len_arg, arg->atom.atom);
4014                 return;
4015         case TEP_PRINT_FIELD:
4016                 field = arg->field.field;
4017                 if (!field) {
4018                         field = tep_find_any_field(event, arg->field.name);
4019                         if (!field) {
4020                                 str = arg->field.name;
4021                                 goto out_warning_field;
4022                         }
4023                         arg->field.field = field;
4024                 }
4025                 /* Zero sized fields, mean the rest of the data */
4026                 len = field->size ? : size - field->offset;
4027
4028                 /*
4029                  * Some events pass in pointers. If this is not an array
4030                  * and the size is the same as long_size, assume that it
4031                  * is a pointer.
4032                  */
4033                 if (!(field->flags & TEP_FIELD_IS_ARRAY) &&
4034                     field->size == tep->long_size) {
4035
4036                         /* Handle heterogeneous recording and processing
4037                          * architectures
4038                          *
4039                          * CASE I:
4040                          * Traces recorded on 32-bit devices (32-bit
4041                          * addressing) and processed on 64-bit devices:
4042                          * In this case, only 32 bits should be read.
4043                          *
4044                          * CASE II:
4045                          * Traces recorded on 64 bit devices and processed
4046                          * on 32-bit devices:
4047                          * In this case, 64 bits must be read.
4048                          */
4049                         addr = (tep->long_size == 8) ?
4050                                 *(unsigned long long *)(data + field->offset) :
4051                                 (unsigned long long)*(unsigned int *)(data + field->offset);
4052
4053                         /* Check if it matches a print format */
4054                         printk = find_printk(tep, addr);
4055                         if (printk)
4056                                 trace_seq_puts(s, printk->printk);
4057                         else
4058                                 trace_seq_printf(s, "%llx", addr);
4059                         break;
4060                 }
4061                 str = malloc(len + 1);
4062                 if (!str) {
4063                         do_warning_event(event, "%s: not enough memory!",
4064                                          __func__);
4065                         return;
4066                 }
4067                 memcpy(str, data + field->offset, len);
4068                 str[len] = 0;
4069                 print_str_to_seq(s, format, len_arg, str);
4070                 free(str);
4071                 break;
4072         case TEP_PRINT_FLAGS:
4073                 val = eval_num_arg(data, size, event, arg->flags.field);
4074                 print = 0;
4075                 for (flag = arg->flags.flags; flag; flag = flag->next) {
4076                         fval = eval_flag(flag->value);
4077                         if (!val && fval < 0) {
4078                                 print_str_to_seq(s, format, len_arg, flag->str);
4079                                 break;
4080                         }
4081                         if (fval > 0 && (val & fval) == fval) {
4082                                 if (print && arg->flags.delim)
4083                                         trace_seq_puts(s, arg->flags.delim);
4084                                 print_str_to_seq(s, format, len_arg, flag->str);
4085                                 print = 1;
4086                                 val &= ~fval;
4087                         }
4088                 }
4089                 if (val) {
4090                         if (print && arg->flags.delim)
4091                                 trace_seq_puts(s, arg->flags.delim);
4092                         trace_seq_printf(s, "0x%llx", val);
4093                 }
4094                 break;
4095         case TEP_PRINT_SYMBOL:
4096                 val = eval_num_arg(data, size, event, arg->symbol.field);
4097                 for (flag = arg->symbol.symbols; flag; flag = flag->next) {
4098                         fval = eval_flag(flag->value);
4099                         if (val == fval) {
4100                                 print_str_to_seq(s, format, len_arg, flag->str);
4101                                 break;
4102                         }
4103                 }
4104                 if (!flag)
4105                         trace_seq_printf(s, "0x%llx", val);
4106                 break;
4107         case TEP_PRINT_HEX:
4108         case TEP_PRINT_HEX_STR:
4109                 if (arg->hex.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4110                         unsigned long offset;
4111                         offset = tep_read_number(tep,
4112                                 data + arg->hex.field->dynarray.field->offset,
4113                                 arg->hex.field->dynarray.field->size);
4114                         hex = data + (offset & 0xffff);
4115                 } else {
4116                         field = arg->hex.field->field.field;
4117                         if (!field) {
4118                                 str = arg->hex.field->field.name;
4119                                 field = tep_find_any_field(event, str);
4120                                 if (!field)
4121                                         goto out_warning_field;
4122                                 arg->hex.field->field.field = field;
4123                         }
4124                         hex = data + field->offset;
4125                 }
4126                 len = eval_num_arg(data, size, event, arg->hex.size);
4127                 for (i = 0; i < len; i++) {
4128                         if (i && arg->type == TEP_PRINT_HEX)
4129                                 trace_seq_putc(s, ' ');
4130                         trace_seq_printf(s, "%02x", hex[i]);
4131                 }
4132                 break;
4133
4134         case TEP_PRINT_INT_ARRAY: {
4135                 void *num;
4136                 int el_size;
4137
4138                 if (arg->int_array.field->type == TEP_PRINT_DYNAMIC_ARRAY) {
4139                         unsigned long offset;
4140                         struct tep_format_field *field =
4141                                 arg->int_array.field->dynarray.field;
4142                         offset = tep_read_number(tep,
4143                                                  data + field->offset,
4144                                                  field->size);
4145                         num = data + (offset & 0xffff);
4146                 } else {
4147                         field = arg->int_array.field->field.field;
4148                         if (!field) {
4149                                 str = arg->int_array.field->field.name;
4150                                 field = tep_find_any_field(event, str);
4151                                 if (!field)
4152                                         goto out_warning_field;
4153                                 arg->int_array.field->field.field = field;
4154                         }
4155                         num = data + field->offset;
4156                 }
4157                 len = eval_num_arg(data, size, event, arg->int_array.count);
4158                 el_size = eval_num_arg(data, size, event,
4159                                        arg->int_array.el_size);
4160                 for (i = 0; i < len; i++) {
4161                         if (i)
4162                                 trace_seq_putc(s, ' ');
4163
4164                         if (el_size == 1) {
4165                                 trace_seq_printf(s, "%u", *(uint8_t *)num);
4166                         } else if (el_size == 2) {
4167                                 trace_seq_printf(s, "%u", *(uint16_t *)num);
4168                         } else if (el_size == 4) {
4169                                 trace_seq_printf(s, "%u", *(uint32_t *)num);
4170                         } else if (el_size == 8) {
4171                                 trace_seq_printf(s, "%"PRIu64, *(uint64_t *)num);
4172                         } else {
4173                                 trace_seq_printf(s, "BAD SIZE:%d 0x%x",
4174                                                  el_size, *(uint8_t *)num);
4175                                 el_size = 1;
4176                         }
4177
4178                         num += el_size;
4179                 }
4180                 break;
4181         }
4182         case TEP_PRINT_TYPE:
4183                 break;
4184         case TEP_PRINT_STRING: {
4185                 int str_offset;
4186
4187                 if (arg->string.offset == -1) {
4188                         struct tep_format_field *f;
4189
4190                         f = tep_find_any_field(event, arg->string.string);
4191                         arg->string.offset = f->offset;
4192                 }
4193                 str_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->string.offset));
4194                 str_offset &= 0xffff;
4195                 print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
4196                 break;
4197         }
4198         case TEP_PRINT_BSTRING:
4199                 print_str_to_seq(s, format, len_arg, arg->string.string);
4200                 break;
4201         case TEP_PRINT_BITMASK: {
4202                 int bitmask_offset;
4203                 int bitmask_size;
4204
4205                 if (arg->bitmask.offset == -1) {
4206                         struct tep_format_field *f;
4207
4208                         f = tep_find_any_field(event, arg->bitmask.bitmask);
4209                         arg->bitmask.offset = f->offset;
4210                 }
4211                 bitmask_offset = tep_data2host4(tep, *(unsigned int *)(data + arg->bitmask.offset));
4212                 bitmask_size = bitmask_offset >> 16;
4213                 bitmask_offset &= 0xffff;
4214                 print_bitmask_to_seq(tep, s, format, len_arg,
4215                                      data + bitmask_offset, bitmask_size);
4216                 break;
4217         }
4218         case TEP_PRINT_OP:
4219                 /*
4220                  * The only op for string should be ? :
4221                  */
4222                 if (arg->op.op[0] != '?')
4223                         return;
4224                 val = eval_num_arg(data, size, event, arg->op.left);
4225                 if (val)
4226                         print_str_arg(s, data, size, event,
4227                                       format, len_arg, arg->op.right->op.left);
4228                 else
4229                         print_str_arg(s, data, size, event,
4230                                       format, len_arg, arg->op.right->op.right);
4231                 break;
4232         case TEP_PRINT_FUNC:
4233                 process_defined_func(s, data, size, event, arg);
4234                 break;
4235         default:
4236                 /* well... */
4237                 break;
4238         }
4239
4240         return;
4241
4242 out_warning_field:
4243         do_warning_event(event, "%s: field %s not found",
4244                          __func__, arg->field.name);
4245 }
4246
4247 static unsigned long long
4248 process_defined_func(struct trace_seq *s, void *data, int size,
4249                      struct tep_event *event, struct tep_print_arg *arg)
4250 {
4251         struct tep_function_handler *func_handle = arg->func.func;
4252         struct func_params *param;
4253         unsigned long long *args;
4254         unsigned long long ret;
4255         struct tep_print_arg *farg;
4256         struct trace_seq str;
4257         struct save_str {
4258                 struct save_str *next;
4259                 char *str;
4260         } *strings = NULL, *string;
4261         int i;
4262
4263         if (!func_handle->nr_args) {
4264                 ret = (*func_handle->func)(s, NULL);
4265                 goto out;
4266         }
4267
4268         farg = arg->func.args;
4269         param = func_handle->params;
4270
4271         ret = ULLONG_MAX;
4272         args = malloc(sizeof(*args) * func_handle->nr_args);
4273         if (!args)
4274                 goto out;
4275
4276         for (i = 0; i < func_handle->nr_args; i++) {
4277                 switch (param->type) {
4278                 case TEP_FUNC_ARG_INT:
4279                 case TEP_FUNC_ARG_LONG:
4280                 case TEP_FUNC_ARG_PTR:
4281                         args[i] = eval_num_arg(data, size, event, farg);
4282                         break;
4283                 case TEP_FUNC_ARG_STRING:
4284                         trace_seq_init(&str);
4285                         print_str_arg(&str, data, size, event, "%s", -1, farg);
4286                         trace_seq_terminate(&str);
4287                         string = malloc(sizeof(*string));
4288                         if (!string) {
4289                                 do_warning_event(event, "%s(%d): malloc str",
4290                                                  __func__, __LINE__);
4291                                 goto out_free;
4292                         }
4293                         string->next = strings;
4294                         string->str = strdup(str.buffer);
4295                         if (!string->str) {
4296                                 free(string);
4297                                 do_warning_event(event, "%s(%d): malloc str",
4298                                                  __func__, __LINE__);
4299                                 goto out_free;
4300                         }
4301                         args[i] = (uintptr_t)string->str;
4302                         strings = string;
4303                         trace_seq_destroy(&str);
4304                         break;
4305                 default:
4306                         /*
4307                          * Something went totally wrong, this is not
4308                          * an input error, something in this code broke.
4309                          */
4310                         do_warning_event(event, "Unexpected end of arguments\n");
4311                         goto out_free;
4312                 }
4313                 farg = farg->next;
4314                 param = param->next;
4315         }
4316
4317         ret = (*func_handle->func)(s, args);
4318 out_free:
4319         free(args);
4320         while (strings) {
4321                 string = strings;
4322                 strings = string->next;
4323                 free(string->str);
4324                 free(string);
4325         }
4326
4327  out:
4328         /* TBD : handle return type here */
4329         return ret;
4330 }
4331
4332 static void free_args(struct tep_print_arg *args)
4333 {
4334         struct tep_print_arg *next;
4335
4336         while (args) {
4337                 next = args->next;
4338
4339                 free_arg(args);
4340                 args = next;
4341         }
4342 }
4343
4344 static struct tep_print_arg *make_bprint_args(char *fmt, void *data, int size, struct tep_event *event)
4345 {
4346         struct tep_handle *tep = event->tep;
4347         struct tep_format_field *field, *ip_field;
4348         struct tep_print_arg *args, *arg, **next;
4349         unsigned long long ip, val;
4350         char *ptr;
4351         void *bptr;
4352         int vsize = 0;
4353
4354         field = tep->bprint_buf_field;
4355         ip_field = tep->bprint_ip_field;
4356
4357         if (!field) {
4358                 field = tep_find_field(event, "buf");
4359                 if (!field) {
4360                         do_warning_event(event, "can't find buffer field for binary printk");
4361                         return NULL;
4362                 }
4363                 ip_field = tep_find_field(event, "ip");
4364                 if (!ip_field) {
4365                         do_warning_event(event, "can't find ip field for binary printk");
4366                         return NULL;
4367                 }
4368                 tep->bprint_buf_field = field;
4369                 tep->bprint_ip_field = ip_field;
4370         }
4371
4372         ip = tep_read_number(tep, data + ip_field->offset, ip_field->size);
4373
4374         /*
4375          * The first arg is the IP pointer.
4376          */
4377         args = alloc_arg();
4378         if (!args) {
4379                 do_warning_event(event, "%s(%d): not enough memory!",
4380                                  __func__, __LINE__);
4381                 return NULL;
4382         }
4383         arg = args;
4384         arg->next = NULL;
4385         next = &arg->next;
4386
4387         arg->type = TEP_PRINT_ATOM;
4388
4389         if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4390                 goto out_free;
4391
4392         /* skip the first "%ps: " */
4393         for (ptr = fmt + 5, bptr = data + field->offset;
4394              bptr < data + size && *ptr; ptr++) {
4395                 int ls = 0;
4396
4397                 if (*ptr == '%') {
4398  process_again:
4399                         ptr++;
4400                         switch (*ptr) {
4401                         case '%':
4402                                 break;
4403                         case 'l':
4404                                 ls++;
4405                                 goto process_again;
4406                         case 'L':
4407                                 ls = 2;
4408                                 goto process_again;
4409                         case '0' ... '9':
4410                                 goto process_again;
4411                         case '.':
4412                                 goto process_again;
4413                         case 'z':
4414                         case 'Z':
4415                                 ls = 1;
4416                                 goto process_again;
4417                         case 'p':
4418                                 ls = 1;
4419                                 if (isalnum(ptr[1])) {
4420                                         ptr++;
4421                                         /* Check for special pointers */
4422                                         switch (*ptr) {
4423                                         case 's':
4424                                         case 'S':
4425                                         case 'x':
4426                                                 break;
4427                                         case 'f':
4428                                         case 'F':
4429                                                 /*
4430                                                  * Pre-5.5 kernels use %pf and
4431                                                  * %pF for printing symbols
4432                                                  * while kernels since 5.5 use
4433                                                  * %pfw for fwnodes. So check
4434                                                  * %p[fF] isn't followed by 'w'.
4435                                                  */
4436                                                 if (ptr[1] != 'w')
4437                                                         break;
4438                                                 /* fall through */
4439                                         default:
4440                                                 /*
4441                                                  * Older kernels do not process
4442                                                  * dereferenced pointers.
4443                                                  * Only process if the pointer
4444                                                  * value is a printable.
4445                                                  */
4446                                                 if (isprint(*(char *)bptr))
4447                                                         goto process_string;
4448                                         }
4449                                 }
4450                                 /* fall through */
4451                         case 'd':
4452                         case 'u':
4453                         case 'i':
4454                         case 'x':
4455                         case 'X':
4456                         case 'o':
4457                                 switch (ls) {
4458                                 case 0:
4459                                         vsize = 4;
4460                                         break;
4461                                 case 1:
4462                                         vsize = tep->long_size;
4463                                         break;
4464                                 case 2:
4465                                         vsize = 8;
4466                                         break;
4467                                 default:
4468                                         vsize = ls; /* ? */
4469                                         break;
4470                                 }
4471                         /* fall through */
4472                         case '*':
4473                                 if (*ptr == '*')
4474                                         vsize = 4;
4475
4476                                 /* the pointers are always 4 bytes aligned */
4477                                 bptr = (void *)(((unsigned long)bptr + 3) &
4478                                                 ~3);
4479                                 val = tep_read_number(tep, bptr, vsize);
4480                                 bptr += vsize;
4481                                 arg = alloc_arg();
4482                                 if (!arg) {
4483                                         do_warning_event(event, "%s(%d): not enough memory!",
4484                                                    __func__, __LINE__);
4485                                         goto out_free;
4486                                 }
4487                                 arg->next = NULL;
4488                                 arg->type = TEP_PRINT_ATOM;
4489                                 if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4490                                         free(arg);
4491                                         goto out_free;
4492                                 }
4493                                 *next = arg;
4494                                 next = &arg->next;
4495                                 /*
4496                                  * The '*' case means that an arg is used as the length.
4497                                  * We need to continue to figure out for what.
4498                                  */
4499                                 if (*ptr == '*')
4500                                         goto process_again;
4501
4502                                 break;
4503                         case 's':
4504  process_string:
4505                                 arg = alloc_arg();
4506                                 if (!arg) {
4507                                         do_warning_event(event, "%s(%d): not enough memory!",
4508                                                    __func__, __LINE__);
4509                                         goto out_free;
4510                                 }
4511                                 arg->next = NULL;
4512                                 arg->type = TEP_PRINT_BSTRING;
4513                                 arg->string.string = strdup(bptr);
4514                                 if (!arg->string.string)
4515                                         goto out_free;
4516                                 bptr += strlen(bptr) + 1;
4517                                 *next = arg;
4518                                 next = &arg->next;
4519                         default:
4520                                 break;
4521                         }
4522                 }
4523         }
4524
4525         return args;
4526
4527 out_free:
4528         free_args(args);
4529         return NULL;
4530 }
4531
4532 static char *
4533 get_bprint_format(void *data, int size __maybe_unused,
4534                   struct tep_event *event)
4535 {
4536         struct tep_handle *tep = event->tep;
4537         unsigned long long addr;
4538         struct tep_format_field *field;
4539         struct printk_map *printk;
4540         char *format;
4541
4542         field = tep->bprint_fmt_field;
4543
4544         if (!field) {
4545                 field = tep_find_field(event, "fmt");
4546                 if (!field) {
4547                         do_warning_event(event, "can't find format field for binary printk");
4548                         return NULL;
4549                 }
4550                 tep->bprint_fmt_field = field;
4551         }
4552
4553         addr = tep_read_number(tep, data + field->offset, field->size);
4554
4555         printk = find_printk(tep, addr);
4556         if (!printk) {
4557                 if (asprintf(&format, "%%ps: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4558                         return NULL;
4559                 return format;
4560         }
4561
4562         if (asprintf(&format, "%s: %s", "%ps", printk->printk) < 0)
4563                 return NULL;
4564
4565         return format;
4566 }
4567
4568 static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
4569                           struct tep_event *event, struct tep_print_arg *arg)
4570 {
4571         unsigned char *buf;
4572         const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4573
4574         if (arg->type == TEP_PRINT_FUNC) {
4575                 process_defined_func(s, data, size, event, arg);
4576                 return;
4577         }
4578
4579         if (arg->type != TEP_PRINT_FIELD) {
4580                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4581                                  arg->type);
4582                 return;
4583         }
4584
4585         if (mac == 'm')
4586                 fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4587         if (!arg->field.field) {
4588                 arg->field.field =
4589                         tep_find_any_field(event, arg->field.name);
4590                 if (!arg->field.field) {
4591                         do_warning_event(event, "%s: field %s not found",
4592                                          __func__, arg->field.name);
4593                         return;
4594                 }
4595         }
4596         if (arg->field.field->size != 6) {
4597                 trace_seq_printf(s, "INVALIDMAC");
4598                 return;
4599         }
4600         buf = data + arg->field.field->offset;
4601         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4602 }
4603
4604 static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
4605 {
4606         const char *fmt;
4607
4608         if (i == 'i')
4609                 fmt = "%03d.%03d.%03d.%03d";
4610         else
4611                 fmt = "%d.%d.%d.%d";
4612
4613         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4614 }
4615
4616 static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4617 {
4618         return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4619                 (unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4620 }
4621
4622 static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4623 {
4624         return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4625 }
4626
4627 static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4628 {
4629         int i, j, range;
4630         unsigned char zerolength[8];
4631         int longest = 1;
4632         int colonpos = -1;
4633         uint16_t word;
4634         uint8_t hi, lo;
4635         bool needcolon = false;
4636         bool useIPv4;
4637         struct in6_addr in6;
4638
4639         memcpy(&in6, addr, sizeof(struct in6_addr));
4640
4641         useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4642
4643         memset(zerolength, 0, sizeof(zerolength));
4644
4645         if (useIPv4)
4646                 range = 6;
4647         else
4648                 range = 8;
4649
4650         /* find position of longest 0 run */
4651         for (i = 0; i < range; i++) {
4652                 for (j = i; j < range; j++) {
4653                         if (in6.s6_addr16[j] != 0)
4654                                 break;
4655                         zerolength[i]++;
4656                 }
4657         }
4658         for (i = 0; i < range; i++) {
4659                 if (zerolength[i] > longest) {
4660                         longest = zerolength[i];
4661                         colonpos = i;
4662                 }
4663         }
4664         if (longest == 1)               /* don't compress a single 0 */
4665                 colonpos = -1;
4666
4667         /* emit address */
4668         for (i = 0; i < range; i++) {
4669                 if (i == colonpos) {
4670                         if (needcolon || i == 0)
4671                                 trace_seq_printf(s, ":");
4672                         trace_seq_printf(s, ":");
4673                         needcolon = false;
4674                         i += longest - 1;
4675                         continue;
4676                 }
4677                 if (needcolon) {
4678                         trace_seq_printf(s, ":");
4679                         needcolon = false;
4680                 }
4681                 /* hex u16 without leading 0s */
4682                 word = ntohs(in6.s6_addr16[i]);
4683                 hi = word >> 8;
4684                 lo = word & 0xff;
4685                 if (hi)
4686                         trace_seq_printf(s, "%x%02x", hi, lo);
4687                 else
4688                         trace_seq_printf(s, "%x", lo);
4689
4690                 needcolon = true;
4691         }
4692
4693         if (useIPv4) {
4694                 if (needcolon)
4695                         trace_seq_printf(s, ":");
4696                 print_ip4_addr(s, 'I', &in6.s6_addr[12]);
4697         }
4698
4699         return;
4700 }
4701
4702 static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4703 {
4704         int j;
4705
4706         for (j = 0; j < 16; j += 2) {
4707                 trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4708                 if (i == 'I' && j < 14)
4709                         trace_seq_printf(s, ":");
4710         }
4711 }
4712
4713 /*
4714  * %pi4   print an IPv4 address with leading zeros
4715  * %pI4   print an IPv4 address without leading zeros
4716  * %pi6   print an IPv6 address without colons
4717  * %pI6   print an IPv6 address with colons
4718  * %pI6c  print an IPv6 address in compressed form with colons
4719  * %pISpc print an IP address based on sockaddr; p adds port.
4720  */
4721 static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4722                           void *data, int size, struct tep_event *event,
4723                           struct tep_print_arg *arg)
4724 {
4725         unsigned char *buf;
4726
4727         if (arg->type == TEP_PRINT_FUNC) {
4728                 process_defined_func(s, data, size, event, arg);
4729                 return 0;
4730         }
4731
4732         if (arg->type != TEP_PRINT_FIELD) {
4733                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4734                 return 0;
4735         }
4736
4737         if (!arg->field.field) {
4738                 arg->field.field =
4739                         tep_find_any_field(event, arg->field.name);
4740                 if (!arg->field.field) {
4741                         do_warning("%s: field %s not found",
4742                                    __func__, arg->field.name);
4743                         return 0;
4744                 }
4745         }
4746
4747         buf = data + arg->field.field->offset;
4748
4749         if (arg->field.field->size != 4) {
4750                 trace_seq_printf(s, "INVALIDIPv4");
4751                 return 0;
4752         }
4753         print_ip4_addr(s, i, buf);
4754
4755         return 0;
4756 }
4757
4758 static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4759                           void *data, int size, struct tep_event *event,
4760                           struct tep_print_arg *arg)
4761 {
4762         char have_c = 0;
4763         unsigned char *buf;
4764         int rc = 0;
4765
4766         /* pI6c */
4767         if (i == 'I' && *ptr == 'c') {
4768                 have_c = 1;
4769                 ptr++;
4770                 rc++;
4771         }
4772
4773         if (arg->type == TEP_PRINT_FUNC) {
4774                 process_defined_func(s, data, size, event, arg);
4775                 return rc;
4776         }
4777
4778         if (arg->type != TEP_PRINT_FIELD) {
4779                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4780                 return rc;
4781         }
4782
4783         if (!arg->field.field) {
4784                 arg->field.field =
4785                         tep_find_any_field(event, arg->field.name);
4786                 if (!arg->field.field) {
4787                         do_warning("%s: field %s not found",
4788                                    __func__, arg->field.name);
4789                         return rc;
4790                 }
4791         }
4792
4793         buf = data + arg->field.field->offset;
4794
4795         if (arg->field.field->size != 16) {
4796                 trace_seq_printf(s, "INVALIDIPv6");
4797                 return rc;
4798         }
4799
4800         if (have_c)
4801                 print_ip6c_addr(s, buf);
4802         else
4803                 print_ip6_addr(s, i, buf);
4804
4805         return rc;
4806 }
4807
4808 static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4809                           void *data, int size, struct tep_event *event,
4810                           struct tep_print_arg *arg)
4811 {
4812         char have_c = 0, have_p = 0;
4813         unsigned char *buf;
4814         struct sockaddr_storage *sa;
4815         int rc = 0;
4816
4817         /* pISpc */
4818         if (i == 'I') {
4819                 if (*ptr == 'p') {
4820                         have_p = 1;
4821                         ptr++;
4822                         rc++;
4823                 }
4824                 if (*ptr == 'c') {
4825                         have_c = 1;
4826                         ptr++;
4827                         rc++;
4828                 }
4829         }
4830
4831         if (arg->type == TEP_PRINT_FUNC) {
4832                 process_defined_func(s, data, size, event, arg);
4833                 return rc;
4834         }
4835
4836         if (arg->type != TEP_PRINT_FIELD) {
4837                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4838                 return rc;
4839         }
4840
4841         if (!arg->field.field) {
4842                 arg->field.field =
4843                         tep_find_any_field(event, arg->field.name);
4844                 if (!arg->field.field) {
4845                         do_warning("%s: field %s not found",
4846                                    __func__, arg->field.name);
4847                         return rc;
4848                 }
4849         }
4850
4851         sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4852
4853         if (sa->ss_family == AF_INET) {
4854                 struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4855
4856                 if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4857                         trace_seq_printf(s, "INVALIDIPv4");
4858                         return rc;
4859                 }
4860
4861                 print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
4862                 if (have_p)
4863                         trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4864
4865
4866         } else if (sa->ss_family == AF_INET6) {
4867                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4868
4869                 if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4870                         trace_seq_printf(s, "INVALIDIPv6");
4871                         return rc;
4872                 }
4873
4874                 if (have_p)
4875                         trace_seq_printf(s, "[");
4876
4877                 buf = (unsigned char *) &sa6->sin6_addr;
4878                 if (have_c)
4879                         print_ip6c_addr(s, buf);
4880                 else
4881                         print_ip6_addr(s, i, buf);
4882
4883                 if (have_p)
4884                         trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4885         }
4886
4887         return rc;
4888 }
4889
4890 static int print_ip_arg(struct trace_seq *s, const char *ptr,
4891                         void *data, int size, struct tep_event *event,
4892                         struct tep_print_arg *arg)
4893 {
4894         char i = *ptr;  /* 'i' or 'I' */
4895         char ver;
4896         int rc = 0;
4897
4898         ptr++;
4899         rc++;
4900
4901         ver = *ptr;
4902         ptr++;
4903         rc++;
4904
4905         switch (ver) {
4906         case '4':
4907                 rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
4908                 break;
4909         case '6':
4910                 rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
4911                 break;
4912         case 'S':
4913                 rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
4914                 break;
4915         default:
4916                 return 0;
4917         }
4918
4919         return rc;
4920 }
4921
4922 static int is_printable_array(char *p, unsigned int len)
4923 {
4924         unsigned int i;
4925
4926         for (i = 0; i < len && p[i]; i++)
4927                 if (!isprint(p[i]) && !isspace(p[i]))
4928                     return 0;
4929         return 1;
4930 }
4931
4932 void tep_print_field(struct trace_seq *s, void *data,
4933                      struct tep_format_field *field)
4934 {
4935         unsigned long long val;
4936         unsigned int offset, len, i;
4937         struct tep_handle *tep = field->event->tep;
4938
4939         if (field->flags & TEP_FIELD_IS_ARRAY) {
4940                 offset = field->offset;
4941                 len = field->size;
4942                 if (field->flags & TEP_FIELD_IS_DYNAMIC) {
4943                         val = tep_read_number(tep, data + offset, len);
4944                         offset = val;
4945                         len = offset >> 16;
4946                         offset &= 0xffff;
4947                 }
4948                 if (field->flags & TEP_FIELD_IS_STRING &&
4949                     is_printable_array(data + offset, len)) {
4950                         trace_seq_printf(s, "%s", (char *)data + offset);
4951                 } else {
4952                         trace_seq_puts(s, "ARRAY[");
4953                         for (i = 0; i < len; i++) {
4954                                 if (i)
4955                                         trace_seq_puts(s, ", ");
4956                                 trace_seq_printf(s, "%02x",
4957                                                  *((unsigned char *)data + offset + i));
4958                         }
4959                         trace_seq_putc(s, ']');
4960                         field->flags &= ~TEP_FIELD_IS_STRING;
4961                 }
4962         } else {
4963                 val = tep_read_number(tep, data + field->offset,
4964                                       field->size);
4965                 if (field->flags & TEP_FIELD_IS_POINTER) {
4966                         trace_seq_printf(s, "0x%llx", val);
4967                 } else if (field->flags & TEP_FIELD_IS_SIGNED) {
4968                         switch (field->size) {
4969                         case 4:
4970                                 /*
4971                                  * If field is long then print it in hex.
4972                                  * A long usually stores pointers.
4973                                  */
4974                                 if (field->flags & TEP_FIELD_IS_LONG)
4975                                         trace_seq_printf(s, "0x%x", (int)val);
4976                                 else
4977                                         trace_seq_printf(s, "%d", (int)val);
4978                                 break;
4979                         case 2:
4980                                 trace_seq_printf(s, "%2d", (short)val);
4981                                 break;
4982                         case 1:
4983                                 trace_seq_printf(s, "%1d", (char)val);
4984                                 break;
4985                         default:
4986                                 trace_seq_printf(s, "%lld", val);
4987                         }
4988                 } else {
4989                         if (field->flags & TEP_FIELD_IS_LONG)
4990                                 trace_seq_printf(s, "0x%llx", val);
4991                         else
4992                                 trace_seq_printf(s, "%llu", val);
4993                 }
4994         }
4995 }
4996
4997 void tep_print_fields(struct trace_seq *s, void *data,
4998                       int size __maybe_unused, struct tep_event *event)
4999 {
5000         struct tep_format_field *field;
5001
5002         field = event->format.fields;
5003         while (field) {
5004                 trace_seq_printf(s, " %s=", field->name);
5005                 tep_print_field(s, data, field);
5006                 field = field->next;
5007         }
5008 }
5009
5010 static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event *event)
5011 {
5012         struct tep_handle *tep = event->tep;
5013         struct tep_print_fmt *print_fmt = &event->print_fmt;
5014         struct tep_print_arg *arg = print_fmt->args;
5015         struct tep_print_arg *args = NULL;
5016         const char *ptr = print_fmt->format;
5017         unsigned long long val;
5018         struct func_map *func;
5019         const char *saveptr;
5020         struct trace_seq p;
5021         char *bprint_fmt = NULL;
5022         char format[32];
5023         int show_func;
5024         int len_as_arg;
5025         int len_arg = 0;
5026         int len;
5027         int ls;
5028
5029         if (event->flags & TEP_EVENT_FL_FAILED) {
5030                 trace_seq_printf(s, "[FAILED TO PARSE]");
5031                 tep_print_fields(s, data, size, event);
5032                 return;
5033         }
5034
5035         if (event->flags & TEP_EVENT_FL_ISBPRINT) {
5036                 bprint_fmt = get_bprint_format(data, size, event);
5037                 args = make_bprint_args(bprint_fmt, data, size, event);
5038                 arg = args;
5039                 ptr = bprint_fmt;
5040         }
5041
5042         for (; *ptr; ptr++) {
5043                 ls = 0;
5044                 if (*ptr == '\\') {
5045                         ptr++;
5046                         switch (*ptr) {
5047                         case 'n':
5048                                 trace_seq_putc(s, '\n');
5049                                 break;
5050                         case 't':
5051                                 trace_seq_putc(s, '\t');
5052                                 break;
5053                         case 'r':
5054                                 trace_seq_putc(s, '\r');
5055                                 break;
5056                         case '\\':
5057                                 trace_seq_putc(s, '\\');
5058                                 break;
5059                         default:
5060                                 trace_seq_putc(s, *ptr);
5061                                 break;
5062                         }
5063
5064                 } else if (*ptr == '%') {
5065                         saveptr = ptr;
5066                         show_func = 0;
5067                         len_as_arg = 0;
5068  cont_process:
5069                         ptr++;
5070                         switch (*ptr) {
5071                         case '%':
5072                                 trace_seq_putc(s, '%');
5073                                 break;
5074                         case '#':
5075                                 /* FIXME: need to handle properly */
5076                                 goto cont_process;
5077                         case 'h':
5078                                 ls--;
5079                                 goto cont_process;
5080                         case 'l':
5081                                 ls++;
5082                                 goto cont_process;
5083                         case 'L':
5084                                 ls = 2;
5085                                 goto cont_process;
5086                         case '*':
5087                                 /* The argument is the length. */
5088                                 if (!arg) {
5089                                         do_warning_event(event, "no argument match");
5090                                         event->flags |= TEP_EVENT_FL_FAILED;
5091                                         goto out_failed;
5092                                 }
5093                                 len_arg = eval_num_arg(data, size, event, arg);
5094                                 len_as_arg = 1;
5095                                 arg = arg->next;
5096                                 goto cont_process;
5097                         case '.':
5098                         case 'z':
5099                         case 'Z':
5100                         case '0' ... '9':
5101                         case '-':
5102                                 goto cont_process;
5103                         case 'p':
5104                                 if (tep->long_size == 4)
5105                                         ls = 1;
5106                                 else
5107                                         ls = 2;
5108
5109                                 if (isalnum(ptr[1]))
5110                                         ptr++;
5111
5112                                 if (arg->type == TEP_PRINT_BSTRING) {
5113                                         trace_seq_puts(s, arg->string.string);
5114                                         arg = arg->next;
5115                                         break;
5116                                 }
5117
5118                                 if (*ptr == 'F' || *ptr == 'f' ||
5119                                     *ptr == 'S' || *ptr == 's') {
5120                                         show_func = *ptr;
5121                                 } else if (*ptr == 'M' || *ptr == 'm') {
5122                                         print_mac_arg(s, *ptr, data, size, event, arg);
5123                                         arg = arg->next;
5124                                         break;
5125                                 } else if (*ptr == 'I' || *ptr == 'i') {
5126                                         int n;
5127
5128                                         n = print_ip_arg(s, ptr, data, size, event, arg);
5129                                         if (n > 0) {
5130                                                 ptr += n - 1;
5131                                                 arg = arg->next;
5132                                                 break;
5133                                         }
5134                                 }
5135
5136                                 /* fall through */
5137                         case 'd':
5138                         case 'u':
5139                         case 'i':
5140                         case 'x':
5141                         case 'X':
5142                         case 'o':
5143                                 if (!arg) {
5144                                         do_warning_event(event, "no argument match");
5145                                         event->flags |= TEP_EVENT_FL_FAILED;
5146                                         goto out_failed;
5147                                 }
5148
5149                                 len = ((unsigned long)ptr + 1) -
5150                                         (unsigned long)saveptr;
5151
5152                                 /* should never happen */
5153                                 if (len > 31) {
5154                                         do_warning_event(event, "bad format!");
5155                                         event->flags |= TEP_EVENT_FL_FAILED;
5156                                         len = 31;
5157                                 }
5158
5159                                 memcpy(format, saveptr, len);
5160                                 format[len] = 0;
5161
5162                                 val = eval_num_arg(data, size, event, arg);
5163                                 arg = arg->next;
5164
5165                                 if (show_func) {
5166                                         func = find_func(tep, val);
5167                                         if (func) {
5168                                                 trace_seq_puts(s, func->func);
5169                                                 if (show_func == 'F')
5170                                                         trace_seq_printf(s,
5171                                                                "+0x%llx",
5172                                                                val - func->addr);
5173                                                 break;
5174                                         }
5175                                 }
5176                                 if (tep->long_size == 8 && ls == 1 &&
5177                                     sizeof(long) != 8) {
5178                                         char *p;
5179
5180                                         /* make %l into %ll */
5181                                         if (ls == 1 && (p = strchr(format, 'l')))
5182                                                 memmove(p+1, p, strlen(p)+1);
5183                                         else if (strcmp(format, "%p") == 0)
5184                                                 strcpy(format, "0x%llx");
5185                                         ls = 2;
5186                                 }
5187                                 switch (ls) {
5188                                 case -2:
5189                                         if (len_as_arg)
5190                                                 trace_seq_printf(s, format, len_arg, (char)val);
5191                                         else
5192                                                 trace_seq_printf(s, format, (char)val);
5193                                         break;
5194                                 case -1:
5195                                         if (len_as_arg)
5196                                                 trace_seq_printf(s, format, len_arg, (short)val);
5197                                         else
5198                                                 trace_seq_printf(s, format, (short)val);
5199                                         break;
5200                                 case 0:
5201                                         if (len_as_arg)
5202                                                 trace_seq_printf(s, format, len_arg, (int)val);
5203                                         else
5204                                                 trace_seq_printf(s, format, (int)val);
5205                                         break;
5206                                 case 1:
5207                                         if (len_as_arg)
5208                                                 trace_seq_printf(s, format, len_arg, (long)val);
5209                                         else
5210                                                 trace_seq_printf(s, format, (long)val);
5211                                         break;
5212                                 case 2:
5213                                         if (len_as_arg)
5214                                                 trace_seq_printf(s, format, len_arg,
5215                                                                  (long long)val);
5216                                         else
5217                                                 trace_seq_printf(s, format, (long long)val);
5218                                         break;
5219                                 default:
5220                                         do_warning_event(event, "bad count (%d)", ls);
5221                                         event->flags |= TEP_EVENT_FL_FAILED;
5222                                 }
5223                                 break;
5224                         case 's':
5225                                 if (!arg) {
5226                                         do_warning_event(event, "no matching argument");
5227                                         event->flags |= TEP_EVENT_FL_FAILED;
5228                                         goto out_failed;
5229                                 }
5230
5231                                 len = ((unsigned long)ptr + 1) -
5232                                         (unsigned long)saveptr;
5233
5234                                 /* should never happen */
5235                                 if (len > 31) {
5236                                         do_warning_event(event, "bad format!");
5237                                         event->flags |= TEP_EVENT_FL_FAILED;
5238                                         len = 31;
5239                                 }
5240
5241                                 memcpy(format, saveptr, len);
5242                                 format[len] = 0;
5243                                 if (!len_as_arg)
5244                                         len_arg = -1;
5245                                 /* Use helper trace_seq */
5246                                 trace_seq_init(&p);
5247                                 print_str_arg(&p, data, size, event,
5248                                               format, len_arg, arg);
5249                                 trace_seq_terminate(&p);
5250                                 trace_seq_puts(s, p.buffer);
5251                                 trace_seq_destroy(&p);
5252                                 arg = arg->next;
5253                                 break;
5254                         default:
5255                                 trace_seq_printf(s, ">%c<", *ptr);
5256
5257                         }
5258                 } else
5259                         trace_seq_putc(s, *ptr);
5260         }
5261
5262         if (event->flags & TEP_EVENT_FL_FAILED) {
5263 out_failed:
5264                 trace_seq_printf(s, "[FAILED TO PARSE]");
5265         }
5266
5267         if (args) {
5268                 free_args(args);
5269                 free(bprint_fmt);
5270         }
5271 }
5272
5273 /*
5274  * This parses out the Latency format (interrupts disabled,
5275  * need rescheduling, in hard/soft interrupt, preempt count
5276  * and lock depth) and places it into the trace_seq.
5277  */
5278 static void data_latency_format(struct tep_handle *tep, struct trace_seq *s,
5279                                 char *format, struct tep_record *record)
5280 {
5281         static int check_lock_depth = 1;
5282         static int check_migrate_disable = 1;
5283         static int lock_depth_exists;
5284         static int migrate_disable_exists;
5285         unsigned int lat_flags;
5286         struct trace_seq sq;
5287         unsigned int pc;
5288         int lock_depth = 0;
5289         int migrate_disable = 0;
5290         int hardirq;
5291         int softirq;
5292         void *data = record->data;
5293
5294         trace_seq_init(&sq);
5295         lat_flags = parse_common_flags(tep, data);
5296         pc = parse_common_pc(tep, data);
5297         /* lock_depth may not always exist */
5298         if (lock_depth_exists)
5299                 lock_depth = parse_common_lock_depth(tep, data);
5300         else if (check_lock_depth) {
5301                 lock_depth = parse_common_lock_depth(tep, data);
5302                 if (lock_depth < 0)
5303                         check_lock_depth = 0;
5304                 else
5305                         lock_depth_exists = 1;
5306         }
5307
5308         /* migrate_disable may not always exist */
5309         if (migrate_disable_exists)
5310                 migrate_disable = parse_common_migrate_disable(tep, data);
5311         else if (check_migrate_disable) {
5312                 migrate_disable = parse_common_migrate_disable(tep, data);
5313                 if (migrate_disable < 0)
5314                         check_migrate_disable = 0;
5315                 else
5316                         migrate_disable_exists = 1;
5317         }
5318
5319         hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5320         softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5321
5322         trace_seq_printf(&sq, "%c%c%c",
5323                (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5324                (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5325                'X' : '.',
5326                (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5327                'N' : '.',
5328                (hardirq && softirq) ? 'H' :
5329                hardirq ? 'h' : softirq ? 's' : '.');
5330
5331         if (pc)
5332                 trace_seq_printf(&sq, "%x", pc);
5333         else
5334                 trace_seq_printf(&sq, ".");
5335
5336         if (migrate_disable_exists) {
5337                 if (migrate_disable < 0)
5338                         trace_seq_printf(&sq, ".");
5339                 else
5340                         trace_seq_printf(&sq, "%d", migrate_disable);
5341         }
5342
5343         if (lock_depth_exists) {
5344                 if (lock_depth < 0)
5345                         trace_seq_printf(&sq, ".");
5346                 else
5347                         trace_seq_printf(&sq, "%d", lock_depth);
5348         }
5349
5350         if (sq.state == TRACE_SEQ__MEM_ALLOC_FAILED) {
5351                 s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
5352                 return;
5353         }
5354
5355         trace_seq_terminate(&sq);
5356         trace_seq_puts(s, sq.buffer);
5357         trace_seq_destroy(&sq);
5358         trace_seq_terminate(s);
5359 }
5360
5361 /**
5362  * tep_data_type - parse out the given event type
5363  * @tep: a handle to the trace event parser context
5364  * @rec: the record to read from
5365  *
5366  * This returns the event id from the @rec.
5367  */
5368 int tep_data_type(struct tep_handle *tep, struct tep_record *rec)
5369 {
5370         return trace_parse_common_type(tep, rec->data);
5371 }
5372
5373 /**
5374  * tep_data_pid - parse the PID from record
5375  * @tep: a handle to the trace event parser context
5376  * @rec: the record to parse
5377  *
5378  * This returns the PID from a record.
5379  */
5380 int tep_data_pid(struct tep_handle *tep, struct tep_record *rec)
5381 {
5382         return parse_common_pid(tep, rec->data);
5383 }
5384
5385 /**
5386  * tep_data_preempt_count - parse the preempt count from the record
5387  * @tep: a handle to the trace event parser context
5388  * @rec: the record to parse
5389  *
5390  * This returns the preempt count from a record.
5391  */
5392 int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec)
5393 {
5394         return parse_common_pc(tep, rec->data);
5395 }
5396
5397 /**
5398  * tep_data_flags - parse the latency flags from the record
5399  * @tep: a handle to the trace event parser context
5400  * @rec: the record to parse
5401  *
5402  * This returns the latency flags from a record.
5403  *
5404  *  Use trace_flag_type enum for the flags (see event-parse.h).
5405  */
5406 int tep_data_flags(struct tep_handle *tep, struct tep_record *rec)
5407 {
5408         return parse_common_flags(tep, rec->data);
5409 }
5410
5411 /**
5412  * tep_data_comm_from_pid - return the command line from PID
5413  * @tep: a handle to the trace event parser context
5414  * @pid: the PID of the task to search for
5415  *
5416  * This returns a pointer to the command line that has the given
5417  * @pid.
5418  */
5419 const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid)
5420 {
5421         const char *comm;
5422
5423         comm = find_cmdline(tep, pid);
5424         return comm;
5425 }
5426
5427 static struct tep_cmdline *
5428 pid_from_cmdlist(struct tep_handle *tep, const char *comm, struct tep_cmdline *next)
5429 {
5430         struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5431
5432         if (cmdlist)
5433                 cmdlist = cmdlist->next;
5434         else
5435                 cmdlist = tep->cmdlist;
5436
5437         while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5438                 cmdlist = cmdlist->next;
5439
5440         return (struct tep_cmdline *)cmdlist;
5441 }
5442
5443 /**
5444  * tep_data_pid_from_comm - return the pid from a given comm
5445  * @tep: a handle to the trace event parser context
5446  * @comm: the cmdline to find the pid from
5447  * @next: the cmdline structure to find the next comm
5448  *
5449  * This returns the cmdline structure that holds a pid for a given
5450  * comm, or NULL if none found. As there may be more than one pid for
5451  * a given comm, the result of this call can be passed back into
5452  * a recurring call in the @next parameter, and then it will find the
5453  * next pid.
5454  * Also, it does a linear search, so it may be slow.
5455  */
5456 struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm,
5457                                            struct tep_cmdline *next)
5458 {
5459         struct tep_cmdline *cmdline;
5460
5461         /*
5462          * If the cmdlines have not been converted yet, then use
5463          * the list.
5464          */
5465         if (!tep->cmdlines)
5466                 return pid_from_cmdlist(tep, comm, next);
5467
5468         if (next) {
5469                 /*
5470                  * The next pointer could have been still from
5471                  * a previous call before cmdlines were created
5472                  */
5473                 if (next < tep->cmdlines ||
5474                     next >= tep->cmdlines + tep->cmdline_count)
5475                         next = NULL;
5476                 else
5477                         cmdline  = next++;
5478         }
5479
5480         if (!next)
5481                 cmdline = tep->cmdlines;
5482
5483         while (cmdline < tep->cmdlines + tep->cmdline_count) {
5484                 if (strcmp(cmdline->comm, comm) == 0)
5485                         return cmdline;
5486                 cmdline++;
5487         }
5488         return NULL;
5489 }
5490
5491 /**
5492  * tep_cmdline_pid - return the pid associated to a given cmdline
5493  * @tep: a handle to the trace event parser context
5494  * @cmdline: The cmdline structure to get the pid from
5495  *
5496  * Returns the pid for a give cmdline. If @cmdline is NULL, then
5497  * -1 is returned.
5498  */
5499 int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline)
5500 {
5501         struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
5502
5503         if (!cmdline)
5504                 return -1;
5505
5506         /*
5507          * If cmdlines have not been created yet, or cmdline is
5508          * not part of the array, then treat it as a cmdlist instead.
5509          */
5510         if (!tep->cmdlines ||
5511             cmdline < tep->cmdlines ||
5512             cmdline >= tep->cmdlines + tep->cmdline_count)
5513                 return cmdlist->pid;
5514
5515         return cmdline->pid;
5516 }
5517
5518 /*
5519  * This parses the raw @data using the given @event information and
5520  * writes the print format into the trace_seq.
5521  */
5522 static void print_event_info(struct trace_seq *s, char *format, bool raw,
5523                              struct tep_event *event, struct tep_record *record)
5524 {
5525         int print_pretty = 1;
5526
5527         if (raw || (event->flags & TEP_EVENT_FL_PRINTRAW))
5528                 tep_print_fields(s, record->data, record->size, event);
5529         else {
5530
5531                 if (event->handler && !(event->flags & TEP_EVENT_FL_NOHANDLE))
5532                         print_pretty = event->handler(s, record, event,
5533                                                       event->context);
5534
5535                 if (print_pretty)
5536                         pretty_print(s, record->data, record->size, event);
5537         }
5538
5539         trace_seq_terminate(s);
5540 }
5541
5542 /**
5543  * tep_find_event_by_record - return the event from a given record
5544  * @tep: a handle to the trace event parser context
5545  * @record: The record to get the event from
5546  *
5547  * Returns the associated event for a given record, or NULL if non is
5548  * is found.
5549  */
5550 struct tep_event *
5551 tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record)
5552 {
5553         int type;
5554
5555         if (record->size < 0) {
5556                 do_warning("ug! negative record size %d", record->size);
5557                 return NULL;
5558         }
5559
5560         type = trace_parse_common_type(tep, record->data);
5561
5562         return tep_find_event(tep, type);
5563 }
5564
5565 /*
5566  * Writes the timestamp of the record into @s. Time divisor and precision can be
5567  * specified as part of printf @format string. Example:
5568  *      "%3.1000d" - divide the time by 1000 and print the first 3 digits
5569  *      before the dot. Thus, the timestamp "123456000" will be printed as
5570  *      "123.456"
5571  */
5572 static void print_event_time(struct tep_handle *tep, struct trace_seq *s,
5573                                  char *format, struct tep_event *event,
5574                                  struct tep_record *record)
5575 {
5576         unsigned long long time;
5577         char *divstr;
5578         int prec = 0, pr;
5579         int div = 0;
5580         int p10 = 1;
5581
5582         if (isdigit(*(format + 1)))
5583                 prec = atoi(format + 1);
5584         divstr = strchr(format, '.');
5585         if (divstr && isdigit(*(divstr + 1)))
5586                 div = atoi(divstr + 1);
5587         time = record->ts;
5588         if (div) {
5589                 time += div / 2;
5590                 time /= div;
5591         }
5592         pr = prec;
5593         while (pr--)
5594                 p10 *= 10;
5595
5596         if (p10 > 1 && p10 < time)
5597                 trace_seq_printf(s, "%5llu.%0*llu", time / p10, prec, time % p10);
5598         else
5599                 trace_seq_printf(s, "%12llu", time);
5600 }
5601
5602 struct print_event_type {
5603         enum {
5604                 EVENT_TYPE_INT = 1,
5605                 EVENT_TYPE_STRING,
5606                 EVENT_TYPE_UNKNOWN,
5607         } type;
5608         char format[32];
5609 };
5610
5611 static void print_string(struct tep_handle *tep, struct trace_seq *s,
5612                          struct tep_record *record, struct tep_event *event,
5613                          const char *arg, struct print_event_type *type)
5614 {
5615         const char *comm;
5616         int pid;
5617
5618         if (strncmp(arg, TEP_PRINT_LATENCY, strlen(TEP_PRINT_LATENCY)) == 0) {
5619                 data_latency_format(tep, s, type->format, record);
5620         } else if (strncmp(arg, TEP_PRINT_COMM, strlen(TEP_PRINT_COMM)) == 0) {
5621                 pid = parse_common_pid(tep, record->data);
5622                 comm = find_cmdline(tep, pid);
5623                 trace_seq_printf(s, type->format, comm);
5624         } else if (strncmp(arg, TEP_PRINT_INFO_RAW, strlen(TEP_PRINT_INFO_RAW)) == 0) {
5625                 print_event_info(s, type->format, true, event, record);
5626         } else if (strncmp(arg, TEP_PRINT_INFO, strlen(TEP_PRINT_INFO)) == 0) {
5627                 print_event_info(s, type->format, false, event, record);
5628         } else if  (strncmp(arg, TEP_PRINT_NAME, strlen(TEP_PRINT_NAME)) == 0) {
5629                 trace_seq_printf(s, type->format, event->name);
5630         } else {
5631                 trace_seq_printf(s, "[UNKNOWN TEP TYPE %s]", arg);
5632         }
5633
5634 }
5635
5636 static void print_int(struct tep_handle *tep, struct trace_seq *s,
5637                       struct tep_record *record, struct tep_event *event,
5638                       int arg, struct print_event_type *type)
5639 {
5640         int param;
5641
5642         switch (arg) {
5643         case TEP_PRINT_CPU:
5644                 param = record->cpu;
5645                 break;
5646         case TEP_PRINT_PID:
5647                 param = parse_common_pid(tep, record->data);
5648                 break;
5649         case TEP_PRINT_TIME:
5650                 return print_event_time(tep, s, type->format, event, record);
5651         default:
5652                 return;
5653         }
5654         trace_seq_printf(s, type->format, param);
5655 }
5656
5657 static int tep_print_event_param_type(char *format,
5658                                       struct print_event_type *type)
5659 {
5660         char *str = format + 1;
5661         int i = 1;
5662
5663         type->type = EVENT_TYPE_UNKNOWN;
5664         while (*str) {
5665                 switch (*str) {
5666                 case 'd':
5667                 case 'u':
5668                 case 'i':
5669                 case 'x':
5670                 case 'X':
5671                 case 'o':
5672                         type->type = EVENT_TYPE_INT;
5673                         break;
5674                 case 's':
5675                         type->type = EVENT_TYPE_STRING;
5676                         break;
5677                 }
5678                 str++;
5679                 i++;
5680                 if (type->type != EVENT_TYPE_UNKNOWN)
5681                         break;
5682         }
5683         memset(type->format, 0, 32);
5684         memcpy(type->format, format, i < 32 ? i : 31);
5685         return i;
5686 }
5687
5688 /**
5689  * tep_print_event - Write various event information
5690  * @tep: a handle to the trace event parser context
5691  * @s: the trace_seq to write to
5692  * @record: The record to get the event from
5693  * @format: a printf format string. Supported event fileds:
5694  *      TEP_PRINT_PID, "%d" - event PID
5695  *      TEP_PRINT_CPU, "%d" - event CPU
5696  *      TEP_PRINT_COMM, "%s" - event command string
5697  *      TEP_PRINT_NAME, "%s" - event name
5698  *      TEP_PRINT_LATENCY, "%s" - event latency
5699  *      TEP_PRINT_TIME, %d - event time stamp. A divisor and precision
5700  *                      can be specified as part of this format string:
5701  *                      "%precision.divisord". Example:
5702  *                      "%3.1000d" - divide the time by 1000 and print the first
5703  *                      3 digits before the dot. Thus, the time stamp
5704  *                      "123456000" will be printed as "123.456"
5705  *      TEP_PRINT_INFO, "%s" - event information. If any width is specified in
5706  *                      the format string, the event information will be printed
5707  *                      in raw format.
5708  * Writes the specified event information into @s.
5709  */
5710 void tep_print_event(struct tep_handle *tep, struct trace_seq *s,
5711                      struct tep_record *record, const char *fmt, ...)
5712 {
5713         struct print_event_type type;
5714         char *format = strdup(fmt);
5715         char *current = format;
5716         char *str = format;
5717         int offset;
5718         va_list args;
5719         struct tep_event *event;
5720
5721         if (!format)
5722                 return;
5723
5724         event = tep_find_event_by_record(tep, record);
5725         va_start(args, fmt);
5726         while (*current) {
5727                 current = strchr(str, '%');
5728                 if (!current) {
5729                         trace_seq_puts(s, str);
5730                         break;
5731                 }
5732                 memset(&type, 0, sizeof(type));
5733                 offset = tep_print_event_param_type(current, &type);
5734                 *current = '\0';
5735                 trace_seq_puts(s, str);
5736                 current += offset;
5737                 switch (type.type) {
5738                 case EVENT_TYPE_STRING:
5739                         print_string(tep, s, record, event,
5740                                      va_arg(args, char*), &type);
5741                         break;
5742                 case EVENT_TYPE_INT:
5743                         print_int(tep, s, record, event,
5744                                   va_arg(args, int), &type);
5745                         break;
5746                 case EVENT_TYPE_UNKNOWN:
5747                 default:
5748                         trace_seq_printf(s, "[UNKNOWN TYPE]");
5749                         break;
5750                 }
5751                 str = current;
5752
5753         }
5754         va_end(args);
5755         free(format);
5756 }
5757
5758 static int events_id_cmp(const void *a, const void *b)
5759 {
5760         struct tep_event * const * ea = a;
5761         struct tep_event * const * eb = b;
5762
5763         if ((*ea)->id < (*eb)->id)
5764                 return -1;
5765
5766         if ((*ea)->id > (*eb)->id)
5767                 return 1;
5768
5769         return 0;
5770 }
5771
5772 static int events_name_cmp(const void *a, const void *b)
5773 {
5774         struct tep_event * const * ea = a;
5775         struct tep_event * const * eb = b;
5776         int res;
5777
5778         res = strcmp((*ea)->name, (*eb)->name);
5779         if (res)
5780                 return res;
5781
5782         res = strcmp((*ea)->system, (*eb)->system);
5783         if (res)
5784                 return res;
5785
5786         return events_id_cmp(a, b);
5787 }
5788
5789 static int events_system_cmp(const void *a, const void *b)
5790 {
5791         struct tep_event * const * ea = a;
5792         struct tep_event * const * eb = b;
5793         int res;
5794
5795         res = strcmp((*ea)->system, (*eb)->system);
5796         if (res)
5797                 return res;
5798
5799         res = strcmp((*ea)->name, (*eb)->name);
5800         if (res)
5801                 return res;
5802
5803         return events_id_cmp(a, b);
5804 }
5805
5806 static struct tep_event **list_events_copy(struct tep_handle *tep)
5807 {
5808         struct tep_event **events;
5809
5810         if (!tep)
5811                 return NULL;
5812
5813         events = malloc(sizeof(*events) * (tep->nr_events + 1));
5814         if (!events)
5815                 return NULL;
5816
5817         memcpy(events, tep->events, sizeof(*events) * tep->nr_events);
5818         events[tep->nr_events] = NULL;
5819         return events;
5820 }
5821
5822 static void list_events_sort(struct tep_event **events, int nr_events,
5823                              enum tep_event_sort_type sort_type)
5824 {
5825         int (*sort)(const void *a, const void *b);
5826
5827         switch (sort_type) {
5828         case TEP_EVENT_SORT_ID:
5829                 sort = events_id_cmp;
5830                 break;
5831         case TEP_EVENT_SORT_NAME:
5832                 sort = events_name_cmp;
5833                 break;
5834         case TEP_EVENT_SORT_SYSTEM:
5835                 sort = events_system_cmp;
5836                 break;
5837         default:
5838                 sort = NULL;
5839         }
5840
5841         if (sort)
5842                 qsort(events, nr_events, sizeof(*events), sort);
5843 }
5844
5845 /**
5846  * tep_list_events - Get events, sorted by given criteria.
5847  * @tep: a handle to the tep context
5848  * @sort_type: desired sort order of the events in the array
5849  *
5850  * Returns an array of pointers to all events, sorted by the given
5851  * @sort_type criteria. The last element of the array is NULL. The returned
5852  * memory must not be freed, it is managed by the library.
5853  * The function is not thread safe.
5854  */
5855 struct tep_event **tep_list_events(struct tep_handle *tep,
5856                                    enum tep_event_sort_type sort_type)
5857 {
5858         struct tep_event **events;
5859
5860         if (!tep)
5861                 return NULL;
5862
5863         events = tep->sort_events;
5864         if (events && tep->last_type == sort_type)
5865                 return events;
5866
5867         if (!events) {
5868                 events = list_events_copy(tep);
5869                 if (!events)
5870                         return NULL;
5871
5872                 tep->sort_events = events;
5873
5874                 /* the internal events are sorted by id */
5875                 if (sort_type == TEP_EVENT_SORT_ID) {
5876                         tep->last_type = sort_type;
5877                         return events;
5878                 }
5879         }
5880
5881         list_events_sort(events, tep->nr_events, sort_type);
5882         tep->last_type = sort_type;
5883
5884         return events;
5885 }
5886
5887
5888 /**
5889  * tep_list_events_copy - Thread safe version of tep_list_events()
5890  * @tep: a handle to the tep context
5891  * @sort_type: desired sort order of the events in the array
5892  *
5893  * Returns an array of pointers to all events, sorted by the given
5894  * @sort_type criteria. The last element of the array is NULL. The returned
5895  * array is newly allocated inside the function and must be freed by the caller
5896  */
5897 struct tep_event **tep_list_events_copy(struct tep_handle *tep,
5898                                         enum tep_event_sort_type sort_type)
5899 {
5900         struct tep_event **events;
5901
5902         if (!tep)
5903                 return NULL;
5904
5905         events = list_events_copy(tep);
5906         if (!events)
5907                 return NULL;
5908
5909         /* the internal events are sorted by id */
5910         if (sort_type == TEP_EVENT_SORT_ID)
5911                 return events;
5912
5913         list_events_sort(events, tep->nr_events, sort_type);
5914
5915         return events;
5916 }
5917
5918 static struct tep_format_field **
5919 get_event_fields(const char *type, const char *name,
5920                  int count, struct tep_format_field *list)
5921 {
5922         struct tep_format_field **fields;
5923         struct tep_format_field *field;
5924         int i = 0;
5925
5926         fields = malloc(sizeof(*fields) * (count + 1));
5927         if (!fields)
5928                 return NULL;
5929
5930         for (field = list; field; field = field->next) {
5931                 fields[i++] = field;
5932                 if (i == count + 1) {
5933                         do_warning("event %s has more %s fields than specified",
5934                                 name, type);
5935                         i--;
5936                         break;
5937                 }
5938         }
5939
5940         if (i != count)
5941                 do_warning("event %s has less %s fields than specified",
5942                         name, type);
5943
5944         fields[i] = NULL;
5945
5946         return fields;
5947 }
5948
5949 /**
5950  * tep_event_common_fields - return a list of common fields for an event
5951  * @event: the event to return the common fields of.
5952  *
5953  * Returns an allocated array of fields. The last item in the array is NULL.
5954  * The array must be freed with free().
5955  */
5956 struct tep_format_field **tep_event_common_fields(struct tep_event *event)
5957 {
5958         return get_event_fields("common", event->name,
5959                                 event->format.nr_common,
5960                                 event->format.common_fields);
5961 }
5962
5963 /**
5964  * tep_event_fields - return a list of event specific fields for an event
5965  * @event: the event to return the fields of.
5966  *
5967  * Returns an allocated array of fields. The last item in the array is NULL.
5968  * The array must be freed with free().
5969  */
5970 struct tep_format_field **tep_event_fields(struct tep_event *event)
5971 {
5972         return get_event_fields("event", event->name,
5973                                 event->format.nr_fields,
5974                                 event->format.fields);
5975 }
5976
5977 static void print_fields(struct trace_seq *s, struct tep_print_flag_sym *field)
5978 {
5979         trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
5980         if (field->next) {
5981                 trace_seq_puts(s, ", ");
5982                 print_fields(s, field->next);
5983         }
5984 }
5985
5986 /* for debugging */
5987 static void print_args(struct tep_print_arg *args)
5988 {
5989         int print_paren = 1;
5990         struct trace_seq s;
5991
5992         switch (args->type) {
5993         case TEP_PRINT_NULL:
5994                 printf("null");
5995                 break;
5996         case TEP_PRINT_ATOM:
5997                 printf("%s", args->atom.atom);
5998                 break;
5999         case TEP_PRINT_FIELD:
6000                 printf("REC->%s", args->field.name);
6001                 break;
6002         case TEP_PRINT_FLAGS:
6003                 printf("__print_flags(");
6004                 print_args(args->flags.field);
6005                 printf(", %s, ", args->flags.delim);
6006                 trace_seq_init(&s);
6007                 print_fields(&s, args->flags.flags);
6008                 trace_seq_do_printf(&s);
6009                 trace_seq_destroy(&s);
6010                 printf(")");
6011                 break;
6012         case TEP_PRINT_SYMBOL:
6013                 printf("__print_symbolic(");
6014                 print_args(args->symbol.field);
6015                 printf(", ");
6016                 trace_seq_init(&s);
6017                 print_fields(&s, args->symbol.symbols);
6018                 trace_seq_do_printf(&s);
6019                 trace_seq_destroy(&s);
6020                 printf(")");
6021                 break;
6022         case TEP_PRINT_HEX:
6023                 printf("__print_hex(");
6024                 print_args(args->hex.field);
6025                 printf(", ");
6026                 print_args(args->hex.size);
6027                 printf(")");
6028                 break;
6029         case TEP_PRINT_HEX_STR:
6030                 printf("__print_hex_str(");
6031                 print_args(args->hex.field);
6032                 printf(", ");
6033                 print_args(args->hex.size);
6034                 printf(")");
6035                 break;
6036         case TEP_PRINT_INT_ARRAY:
6037                 printf("__print_array(");
6038                 print_args(args->int_array.field);
6039                 printf(", ");
6040                 print_args(args->int_array.count);
6041                 printf(", ");
6042                 print_args(args->int_array.el_size);
6043                 printf(")");
6044                 break;
6045         case TEP_PRINT_STRING:
6046         case TEP_PRINT_BSTRING:
6047                 printf("__get_str(%s)", args->string.string);
6048                 break;
6049         case TEP_PRINT_BITMASK:
6050                 printf("__get_bitmask(%s)", args->bitmask.bitmask);
6051                 break;
6052         case TEP_PRINT_TYPE:
6053                 printf("(%s)", args->typecast.type);
6054                 print_args(args->typecast.item);
6055                 break;
6056         case TEP_PRINT_OP:
6057                 if (strcmp(args->op.op, ":") == 0)
6058                         print_paren = 0;
6059                 if (print_paren)
6060                         printf("(");
6061                 print_args(args->op.left);
6062                 printf(" %s ", args->op.op);
6063                 print_args(args->op.right);
6064                 if (print_paren)
6065                         printf(")");
6066                 break;
6067         default:
6068                 /* we should warn... */
6069                 return;
6070         }
6071         if (args->next) {
6072                 printf("\n");
6073                 print_args(args->next);
6074         }
6075 }
6076
6077 static void parse_header_field(const char *field,
6078                                int *offset, int *size, int mandatory)
6079 {
6080         unsigned long long save_input_buf_ptr;
6081         unsigned long long save_input_buf_siz;
6082         char *token;
6083         int type;
6084
6085         save_input_buf_ptr = input_buf_ptr;
6086         save_input_buf_siz = input_buf_siz;
6087
6088         if (read_expected(TEP_EVENT_ITEM, "field") < 0)
6089                 return;
6090         if (read_expected(TEP_EVENT_OP, ":") < 0)
6091                 return;
6092
6093         /* type */
6094         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6095                 goto fail;
6096         free_token(token);
6097
6098         /*
6099          * If this is not a mandatory field, then test it first.
6100          */
6101         if (mandatory) {
6102                 if (read_expected(TEP_EVENT_ITEM, field) < 0)
6103                         return;
6104         } else {
6105                 if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6106                         goto fail;
6107                 if (strcmp(token, field) != 0)
6108                         goto discard;
6109                 free_token(token);
6110         }
6111
6112         if (read_expected(TEP_EVENT_OP, ";") < 0)
6113                 return;
6114         if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
6115                 return;
6116         if (read_expected(TEP_EVENT_OP, ":") < 0)
6117                 return;
6118         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6119                 goto fail;
6120         *offset = atoi(token);
6121         free_token(token);
6122         if (read_expected(TEP_EVENT_OP, ";") < 0)
6123                 return;
6124         if (read_expected(TEP_EVENT_ITEM, "size") < 0)
6125                 return;
6126         if (read_expected(TEP_EVENT_OP, ":") < 0)
6127                 return;
6128         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6129                 goto fail;
6130         *size = atoi(token);
6131         free_token(token);
6132         if (read_expected(TEP_EVENT_OP, ";") < 0)
6133                 return;
6134         type = read_token(&token);
6135         if (type != TEP_EVENT_NEWLINE) {
6136                 /* newer versions of the kernel have a "signed" type */
6137                 if (type != TEP_EVENT_ITEM)
6138                         goto fail;
6139
6140                 if (strcmp(token, "signed") != 0)
6141                         goto fail;
6142
6143                 free_token(token);
6144
6145                 if (read_expected(TEP_EVENT_OP, ":") < 0)
6146                         return;
6147
6148                 if (read_expect_type(TEP_EVENT_ITEM, &token))
6149                         goto fail;
6150
6151                 free_token(token);
6152                 if (read_expected(TEP_EVENT_OP, ";") < 0)
6153                         return;
6154
6155                 if (read_expect_type(TEP_EVENT_NEWLINE, &token))
6156                         goto fail;
6157         }
6158  fail:
6159         free_token(token);
6160         return;
6161
6162  discard:
6163         input_buf_ptr = save_input_buf_ptr;
6164         input_buf_siz = save_input_buf_siz;
6165         *offset = 0;
6166         *size = 0;
6167         free_token(token);
6168 }
6169
6170 /**
6171  * tep_parse_header_page - parse the data stored in the header page
6172  * @tep: a handle to the trace event parser context
6173  * @buf: the buffer storing the header page format string
6174  * @size: the size of @buf
6175  * @long_size: the long size to use if there is no header
6176  *
6177  * This parses the header page format for information on the
6178  * ring buffer used. The @buf should be copied from
6179  *
6180  * /sys/kernel/debug/tracing/events/header_page
6181  */
6182 int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size,
6183                           int long_size)
6184 {
6185         int ignore;
6186
6187         if (!size) {
6188                 /*
6189                  * Old kernels did not have header page info.
6190                  * Sorry but we just use what we find here in user space.
6191                  */
6192                 tep->header_page_ts_size = sizeof(long long);
6193                 tep->header_page_size_size = long_size;
6194                 tep->header_page_data_offset = sizeof(long long) + long_size;
6195                 tep->old_format = 1;
6196                 return -1;
6197         }
6198         init_input_buf(buf, size);
6199
6200         parse_header_field("timestamp", &tep->header_page_ts_offset,
6201                            &tep->header_page_ts_size, 1);
6202         parse_header_field("commit", &tep->header_page_size_offset,
6203                            &tep->header_page_size_size, 1);
6204         parse_header_field("overwrite", &tep->header_page_overwrite,
6205                            &ignore, 0);
6206         parse_header_field("data", &tep->header_page_data_offset,
6207                            &tep->header_page_data_size, 1);
6208
6209         return 0;
6210 }
6211
6212 static int event_matches(struct tep_event *event,
6213                          int id, const char *sys_name,
6214                          const char *event_name)
6215 {
6216         if (id >= 0 && id != event->id)
6217                 return 0;
6218
6219         if (event_name && (strcmp(event_name, event->name) != 0))
6220                 return 0;
6221
6222         if (sys_name && (strcmp(sys_name, event->system) != 0))
6223                 return 0;
6224
6225         return 1;
6226 }
6227
6228 static void free_handler(struct event_handler *handle)
6229 {
6230         free((void *)handle->sys_name);
6231         free((void *)handle->event_name);
6232         free(handle);
6233 }
6234
6235 static int find_event_handle(struct tep_handle *tep, struct tep_event *event)
6236 {
6237         struct event_handler *handle, **next;
6238
6239         for (next = &tep->handlers; *next;
6240              next = &(*next)->next) {
6241                 handle = *next;
6242                 if (event_matches(event, handle->id,
6243                                   handle->sys_name,
6244                                   handle->event_name))
6245                         break;
6246         }
6247
6248         if (!(*next))
6249                 return 0;
6250
6251         pr_stat("overriding event (%d) %s:%s with new print handler",
6252                 event->id, event->system, event->name);
6253
6254         event->handler = handle->func;
6255         event->context = handle->context;
6256
6257         *next = handle->next;
6258         free_handler(handle);
6259
6260         return 1;
6261 }
6262
6263 /**
6264  * __tep_parse_format - parse the event format
6265  * @buf: the buffer storing the event format string
6266  * @size: the size of @buf
6267  * @sys: the system the event belongs to
6268  *
6269  * This parses the event format and creates an event structure
6270  * to quickly parse raw data for a given event.
6271  *
6272  * These files currently come from:
6273  *
6274  * /sys/kernel/debug/tracing/events/.../.../format
6275  */
6276 enum tep_errno __tep_parse_format(struct tep_event **eventp,
6277                                   struct tep_handle *tep, const char *buf,
6278                                   unsigned long size, const char *sys)
6279 {
6280         struct tep_event *event;
6281         int ret;
6282
6283         init_input_buf(buf, size);
6284
6285         *eventp = event = alloc_event();
6286         if (!event)
6287                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6288
6289         event->name = event_read_name();
6290         if (!event->name) {
6291                 /* Bad event? */
6292                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6293                 goto event_alloc_failed;
6294         }
6295
6296         if (strcmp(sys, "ftrace") == 0) {
6297                 event->flags |= TEP_EVENT_FL_ISFTRACE;
6298
6299                 if (strcmp(event->name, "bprint") == 0)
6300                         event->flags |= TEP_EVENT_FL_ISBPRINT;
6301         }
6302
6303         event->id = event_read_id();
6304         if (event->id < 0) {
6305                 ret = TEP_ERRNO__READ_ID_FAILED;
6306                 /*
6307                  * This isn't an allocation error actually.
6308                  * But as the ID is critical, just bail out.
6309                  */
6310                 goto event_alloc_failed;
6311         }
6312
6313         event->system = strdup(sys);
6314         if (!event->system) {
6315                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6316                 goto event_alloc_failed;
6317         }
6318
6319         /* Add tep to event so that it can be referenced */
6320         event->tep = tep;
6321
6322         ret = event_read_format(event);
6323         if (ret < 0) {
6324                 ret = TEP_ERRNO__READ_FORMAT_FAILED;
6325                 goto event_parse_failed;
6326         }
6327
6328         /*
6329          * If the event has an override, don't print warnings if the event
6330          * print format fails to parse.
6331          */
6332         if (tep && find_event_handle(tep, event))
6333                 show_warning = 0;
6334
6335         ret = event_read_print(event);
6336         show_warning = 1;
6337
6338         if (ret < 0) {
6339                 ret = TEP_ERRNO__READ_PRINT_FAILED;
6340                 goto event_parse_failed;
6341         }
6342
6343         if (!ret && (event->flags & TEP_EVENT_FL_ISFTRACE)) {
6344                 struct tep_format_field *field;
6345                 struct tep_print_arg *arg, **list;
6346
6347                 /* old ftrace had no args */
6348                 list = &event->print_fmt.args;
6349                 for (field = event->format.fields; field; field = field->next) {
6350                         arg = alloc_arg();
6351                         if (!arg) {
6352                                 event->flags |= TEP_EVENT_FL_FAILED;
6353                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6354                         }
6355                         arg->type = TEP_PRINT_FIELD;
6356                         arg->field.name = strdup(field->name);
6357                         if (!arg->field.name) {
6358                                 event->flags |= TEP_EVENT_FL_FAILED;
6359                                 free_arg(arg);
6360                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6361                         }
6362                         arg->field.field = field;
6363                         *list = arg;
6364                         list = &arg->next;
6365                 }
6366                 return 0;
6367         }
6368
6369         return 0;
6370
6371  event_parse_failed:
6372         event->flags |= TEP_EVENT_FL_FAILED;
6373         return ret;
6374
6375  event_alloc_failed:
6376         free(event->system);
6377         free(event->name);
6378         free(event);
6379         *eventp = NULL;
6380         return ret;
6381 }
6382
6383 static enum tep_errno
6384 __parse_event(struct tep_handle *tep,
6385               struct tep_event **eventp,
6386               const char *buf, unsigned long size,
6387               const char *sys)
6388 {
6389         int ret = __tep_parse_format(eventp, tep, buf, size, sys);
6390         struct tep_event *event = *eventp;
6391
6392         if (event == NULL)
6393                 return ret;
6394
6395         if (tep && add_event(tep, event)) {
6396                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6397                 goto event_add_failed;
6398         }
6399
6400 #define PRINT_ARGS 0
6401         if (PRINT_ARGS && event->print_fmt.args)
6402                 print_args(event->print_fmt.args);
6403
6404         return 0;
6405
6406 event_add_failed:
6407         tep_free_event(event);
6408         return ret;
6409 }
6410
6411 /**
6412  * tep_parse_format - parse the event format
6413  * @tep: a handle to the trace event parser context
6414  * @eventp: returned format
6415  * @buf: the buffer storing the event format string
6416  * @size: the size of @buf
6417  * @sys: the system the event belongs to
6418  *
6419  * This parses the event format and creates an event structure
6420  * to quickly parse raw data for a given event.
6421  *
6422  * These files currently come from:
6423  *
6424  * /sys/kernel/debug/tracing/events/.../.../format
6425  */
6426 enum tep_errno tep_parse_format(struct tep_handle *tep,
6427                                 struct tep_event **eventp,
6428                                 const char *buf,
6429                                 unsigned long size, const char *sys)
6430 {
6431         return __parse_event(tep, eventp, buf, size, sys);
6432 }
6433
6434 /**
6435  * tep_parse_event - parse the event format
6436  * @tep: a handle to the trace event parser context
6437  * @buf: the buffer storing the event format string
6438  * @size: the size of @buf
6439  * @sys: the system the event belongs to
6440  *
6441  * This parses the event format and creates an event structure
6442  * to quickly parse raw data for a given event.
6443  *
6444  * These files currently come from:
6445  *
6446  * /sys/kernel/debug/tracing/events/.../.../format
6447  */
6448 enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf,
6449                                unsigned long size, const char *sys)
6450 {
6451         struct tep_event *event = NULL;
6452         return __parse_event(tep, &event, buf, size, sys);
6453 }
6454
6455 int get_field_val(struct trace_seq *s, struct tep_format_field *field,
6456                   const char *name, struct tep_record *record,
6457                   unsigned long long *val, int err)
6458 {
6459         if (!field) {
6460                 if (err)
6461                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6462                 return -1;
6463         }
6464
6465         if (tep_read_number_field(field, record->data, val)) {
6466                 if (err)
6467                         trace_seq_printf(s, " %s=INVALID", name);
6468                 return -1;
6469         }
6470
6471         return 0;
6472 }
6473
6474 /**
6475  * tep_get_field_raw - return the raw pointer into the data field
6476  * @s: The seq to print to on error
6477  * @event: the event that the field is for
6478  * @name: The name of the field
6479  * @record: The record with the field name.
6480  * @len: place to store the field length.
6481  * @err: print default error if failed.
6482  *
6483  * Returns a pointer into record->data of the field and places
6484  * the length of the field in @len.
6485  *
6486  * On failure, it returns NULL.
6487  */
6488 void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event,
6489                         const char *name, struct tep_record *record,
6490                         int *len, int err)
6491 {
6492         struct tep_format_field *field;
6493         void *data = record->data;
6494         unsigned offset;
6495         int dummy;
6496
6497         if (!event)
6498                 return NULL;
6499
6500         field = tep_find_field(event, name);
6501
6502         if (!field) {
6503                 if (err)
6504                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6505                 return NULL;
6506         }
6507
6508         /* Allow @len to be NULL */
6509         if (!len)
6510                 len = &dummy;
6511
6512         offset = field->offset;
6513         if (field->flags & TEP_FIELD_IS_DYNAMIC) {
6514                 offset = tep_read_number(event->tep,
6515                                          data + offset, field->size);
6516                 *len = offset >> 16;
6517                 offset &= 0xffff;
6518         } else
6519                 *len = field->size;
6520
6521         return data + offset;
6522 }
6523
6524 /**
6525  * tep_get_field_val - find a field and return its value
6526  * @s: The seq to print to on error
6527  * @event: the event that the field is for
6528  * @name: The name of the field
6529  * @record: The record with the field name.
6530  * @val: place to store the value of the field.
6531  * @err: print default error if failed.
6532  *
6533  * Returns 0 on success -1 on field not found.
6534  */
6535 int tep_get_field_val(struct trace_seq *s, struct tep_event *event,
6536                       const char *name, struct tep_record *record,
6537                       unsigned long long *val, int err)
6538 {
6539         struct tep_format_field *field;
6540
6541         if (!event)
6542                 return -1;
6543
6544         field = tep_find_field(event, name);
6545
6546         return get_field_val(s, field, name, record, val, err);
6547 }
6548
6549 /**
6550  * tep_get_common_field_val - find a common field and return its value
6551  * @s: The seq to print to on error
6552  * @event: the event that the field is for
6553  * @name: The name of the field
6554  * @record: The record with the field name.
6555  * @val: place to store the value of the field.
6556  * @err: print default error if failed.
6557  *
6558  * Returns 0 on success -1 on field not found.
6559  */
6560 int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event,
6561                              const char *name, struct tep_record *record,
6562                              unsigned long long *val, int err)
6563 {
6564         struct tep_format_field *field;
6565
6566         if (!event)
6567                 return -1;
6568
6569         field = tep_find_common_field(event, name);
6570
6571         return get_field_val(s, field, name, record, val, err);
6572 }
6573
6574 /**
6575  * tep_get_any_field_val - find a any field and return its value
6576  * @s: The seq to print to on error
6577  * @event: the event that the field is for
6578  * @name: The name of the field
6579  * @record: The record with the field name.
6580  * @val: place to store the value of the field.
6581  * @err: print default error if failed.
6582  *
6583  * Returns 0 on success -1 on field not found.
6584  */
6585 int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event,
6586                           const char *name, struct tep_record *record,
6587                           unsigned long long *val, int err)
6588 {
6589         struct tep_format_field *field;
6590
6591         if (!event)
6592                 return -1;
6593
6594         field = tep_find_any_field(event, name);
6595
6596         return get_field_val(s, field, name, record, val, err);
6597 }
6598
6599 /**
6600  * tep_print_num_field - print a field and a format
6601  * @s: The seq to print to
6602  * @fmt: The printf format to print the field with.
6603  * @event: the event that the field is for
6604  * @name: The name of the field
6605  * @record: The record with the field name.
6606  * @err: print default error if failed.
6607  *
6608  * Returns positive value on success, negative in case of an error,
6609  * or 0 if buffer is full.
6610  */
6611 int tep_print_num_field(struct trace_seq *s, const char *fmt,
6612                         struct tep_event *event, const char *name,
6613                         struct tep_record *record, int err)
6614 {
6615         struct tep_format_field *field = tep_find_field(event, name);
6616         unsigned long long val;
6617
6618         if (!field)
6619                 goto failed;
6620
6621         if (tep_read_number_field(field, record->data, &val))
6622                 goto failed;
6623
6624         return trace_seq_printf(s, fmt, val);
6625
6626  failed:
6627         if (err)
6628                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6629         return -1;
6630 }
6631
6632 /**
6633  * tep_print_func_field - print a field and a format for function pointers
6634  * @s: The seq to print to
6635  * @fmt: The printf format to print the field with.
6636  * @event: the event that the field is for
6637  * @name: The name of the field
6638  * @record: The record with the field name.
6639  * @err: print default error if failed.
6640  *
6641  * Returns positive value on success, negative in case of an error,
6642  * or 0 if buffer is full.
6643  */
6644 int tep_print_func_field(struct trace_seq *s, const char *fmt,
6645                          struct tep_event *event, const char *name,
6646                          struct tep_record *record, int err)
6647 {
6648         struct tep_format_field *field = tep_find_field(event, name);
6649         struct tep_handle *tep = event->tep;
6650         unsigned long long val;
6651         struct func_map *func;
6652         char tmp[128];
6653
6654         if (!field)
6655                 goto failed;
6656
6657         if (tep_read_number_field(field, record->data, &val))
6658                 goto failed;
6659
6660         func = find_func(tep, val);
6661
6662         if (func)
6663                 snprintf(tmp, 128, "%s/0x%llx", func->func, func->addr - val);
6664         else
6665                 sprintf(tmp, "0x%08llx", val);
6666
6667         return trace_seq_printf(s, fmt, tmp);
6668
6669  failed:
6670         if (err)
6671                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6672         return -1;
6673 }
6674
6675 static void free_func_handle(struct tep_function_handler *func)
6676 {
6677         struct func_params *params;
6678
6679         free(func->name);
6680
6681         while (func->params) {
6682                 params = func->params;
6683                 func->params = params->next;
6684                 free(params);
6685         }
6686
6687         free(func);
6688 }
6689
6690 /**
6691  * tep_register_print_function - register a helper function
6692  * @tep: a handle to the trace event parser context
6693  * @func: the function to process the helper function
6694  * @ret_type: the return type of the helper function
6695  * @name: the name of the helper function
6696  * @parameters: A list of enum tep_func_arg_type
6697  *
6698  * Some events may have helper functions in the print format arguments.
6699  * This allows a plugin to dynamically create a way to process one
6700  * of these functions.
6701  *
6702  * The @parameters is a variable list of tep_func_arg_type enums that
6703  * must end with TEP_FUNC_ARG_VOID.
6704  */
6705 int tep_register_print_function(struct tep_handle *tep,
6706                                 tep_func_handler func,
6707                                 enum tep_func_arg_type ret_type,
6708                                 char *name, ...)
6709 {
6710         struct tep_function_handler *func_handle;
6711         struct func_params **next_param;
6712         struct func_params *param;
6713         enum tep_func_arg_type type;
6714         va_list ap;
6715         int ret;
6716
6717         func_handle = find_func_handler(tep, name);
6718         if (func_handle) {
6719                 /*
6720                  * This is most like caused by the users own
6721                  * plugins updating the function. This overrides the
6722                  * system defaults.
6723                  */
6724                 pr_stat("override of function helper '%s'", name);
6725                 remove_func_handler(tep, name);
6726         }
6727
6728         func_handle = calloc(1, sizeof(*func_handle));
6729         if (!func_handle) {
6730                 do_warning("Failed to allocate function handler");
6731                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6732         }
6733
6734         func_handle->ret_type = ret_type;
6735         func_handle->name = strdup(name);
6736         func_handle->func = func;
6737         if (!func_handle->name) {
6738                 do_warning("Failed to allocate function name");
6739                 free(func_handle);
6740                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6741         }
6742
6743         next_param = &(func_handle->params);
6744         va_start(ap, name);
6745         for (;;) {
6746                 type = va_arg(ap, enum tep_func_arg_type);
6747                 if (type == TEP_FUNC_ARG_VOID)
6748                         break;
6749
6750                 if (type >= TEP_FUNC_ARG_MAX_TYPES) {
6751                         do_warning("Invalid argument type %d", type);
6752                         ret = TEP_ERRNO__INVALID_ARG_TYPE;
6753                         goto out_free;
6754                 }
6755
6756                 param = malloc(sizeof(*param));
6757                 if (!param) {
6758                         do_warning("Failed to allocate function param");
6759                         ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6760                         goto out_free;
6761                 }
6762                 param->type = type;
6763                 param->next = NULL;
6764
6765                 *next_param = param;
6766                 next_param = &(param->next);
6767
6768                 func_handle->nr_args++;
6769         }
6770         va_end(ap);
6771
6772         func_handle->next = tep->func_handlers;
6773         tep->func_handlers = func_handle;
6774
6775         return 0;
6776  out_free:
6777         va_end(ap);
6778         free_func_handle(func_handle);
6779         return ret;
6780 }
6781
6782 /**
6783  * tep_unregister_print_function - unregister a helper function
6784  * @tep: a handle to the trace event parser context
6785  * @func: the function to process the helper function
6786  * @name: the name of the helper function
6787  *
6788  * This function removes existing print handler for function @name.
6789  *
6790  * Returns 0 if the handler was removed successully, -1 otherwise.
6791  */
6792 int tep_unregister_print_function(struct tep_handle *tep,
6793                                   tep_func_handler func, char *name)
6794 {
6795         struct tep_function_handler *func_handle;
6796
6797         func_handle = find_func_handler(tep, name);
6798         if (func_handle && func_handle->func == func) {
6799                 remove_func_handler(tep, name);
6800                 return 0;
6801         }
6802         return -1;
6803 }
6804
6805 static struct tep_event *search_event(struct tep_handle *tep, int id,
6806                                       const char *sys_name,
6807                                       const char *event_name)
6808 {
6809         struct tep_event *event;
6810
6811         if (id >= 0) {
6812                 /* search by id */
6813                 event = tep_find_event(tep, id);
6814                 if (!event)
6815                         return NULL;
6816                 if (event_name && (strcmp(event_name, event->name) != 0))
6817                         return NULL;
6818                 if (sys_name && (strcmp(sys_name, event->system) != 0))
6819                         return NULL;
6820         } else {
6821                 event = tep_find_event_by_name(tep, sys_name, event_name);
6822                 if (!event)
6823                         return NULL;
6824         }
6825         return event;
6826 }
6827
6828 /**
6829  * tep_register_event_handler - register a way to parse an event
6830  * @tep: a handle to the trace event parser context
6831  * @id: the id of the event to register
6832  * @sys_name: the system name the event belongs to
6833  * @event_name: the name of the event
6834  * @func: the function to call to parse the event information
6835  * @context: the data to be passed to @func
6836  *
6837  * This function allows a developer to override the parsing of
6838  * a given event. If for some reason the default print format
6839  * is not sufficient, this function will register a function
6840  * for an event to be used to parse the data instead.
6841  *
6842  * If @id is >= 0, then it is used to find the event.
6843  * else @sys_name and @event_name are used.
6844  *
6845  * Returns:
6846  *  TEP_REGISTER_SUCCESS_OVERWRITE if an existing handler is overwritten
6847  *  TEP_REGISTER_SUCCESS if a new handler is registered successfully
6848  *  negative TEP_ERRNO_... in case of an error
6849  *
6850  */
6851 int tep_register_event_handler(struct tep_handle *tep, int id,
6852                                const char *sys_name, const char *event_name,
6853                                tep_event_handler_func func, void *context)
6854 {
6855         struct tep_event *event;
6856         struct event_handler *handle;
6857
6858         event = search_event(tep, id, sys_name, event_name);
6859         if (event == NULL)
6860                 goto not_found;
6861
6862         pr_stat("overriding event (%d) %s:%s with new print handler",
6863                 event->id, event->system, event->name);
6864
6865         event->handler = func;
6866         event->context = context;
6867         return TEP_REGISTER_SUCCESS_OVERWRITE;
6868
6869  not_found:
6870         /* Save for later use. */
6871         handle = calloc(1, sizeof(*handle));
6872         if (!handle) {
6873                 do_warning("Failed to allocate event handler");
6874                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6875         }
6876
6877         handle->id = id;
6878         if (event_name)
6879                 handle->event_name = strdup(event_name);
6880         if (sys_name)
6881                 handle->sys_name = strdup(sys_name);
6882
6883         if ((event_name && !handle->event_name) ||
6884             (sys_name && !handle->sys_name)) {
6885                 do_warning("Failed to allocate event/sys name");
6886                 free((void *)handle->event_name);
6887                 free((void *)handle->sys_name);
6888                 free(handle);
6889                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6890         }
6891
6892         handle->func = func;
6893         handle->next = tep->handlers;
6894         tep->handlers = handle;
6895         handle->context = context;
6896
6897         return TEP_REGISTER_SUCCESS;
6898 }
6899
6900 static int handle_matches(struct event_handler *handler, int id,
6901                           const char *sys_name, const char *event_name,
6902                           tep_event_handler_func func, void *context)
6903 {
6904         if (id >= 0 && id != handler->id)
6905                 return 0;
6906
6907         if (event_name && (strcmp(event_name, handler->event_name) != 0))
6908                 return 0;
6909
6910         if (sys_name && (strcmp(sys_name, handler->sys_name) != 0))
6911                 return 0;
6912
6913         if (func != handler->func || context != handler->context)
6914                 return 0;
6915
6916         return 1;
6917 }
6918
6919 /**
6920  * tep_unregister_event_handler - unregister an existing event handler
6921  * @tep: a handle to the trace event parser context
6922  * @id: the id of the event to unregister
6923  * @sys_name: the system name the handler belongs to
6924  * @event_name: the name of the event handler
6925  * @func: the function to call to parse the event information
6926  * @context: the data to be passed to @func
6927  *
6928  * This function removes existing event handler (parser).
6929  *
6930  * If @id is >= 0, then it is used to find the event.
6931  * else @sys_name and @event_name are used.
6932  *
6933  * Returns 0 if handler was removed successfully, -1 if event was not found.
6934  */
6935 int tep_unregister_event_handler(struct tep_handle *tep, int id,
6936                                  const char *sys_name, const char *event_name,
6937                                  tep_event_handler_func func, void *context)
6938 {
6939         struct tep_event *event;
6940         struct event_handler *handle;
6941         struct event_handler **next;
6942
6943         event = search_event(tep, id, sys_name, event_name);
6944         if (event == NULL)
6945                 goto not_found;
6946
6947         if (event->handler == func && event->context == context) {
6948                 pr_stat("removing override handler for event (%d) %s:%s. Going back to default handler.",
6949                         event->id, event->system, event->name);
6950
6951                 event->handler = NULL;
6952                 event->context = NULL;
6953                 return 0;
6954         }
6955
6956 not_found:
6957         for (next = &tep->handlers; *next; next = &(*next)->next) {
6958                 handle = *next;
6959                 if (handle_matches(handle, id, sys_name, event_name,
6960                                    func, context))
6961                         break;
6962         }
6963
6964         if (!(*next))
6965                 return -1;
6966
6967         *next = handle->next;
6968         free_handler(handle);
6969
6970         return 0;
6971 }
6972
6973 /**
6974  * tep_alloc - create a tep handle
6975  */
6976 struct tep_handle *tep_alloc(void)
6977 {
6978         struct tep_handle *tep = calloc(1, sizeof(*tep));
6979
6980         if (tep) {
6981                 tep->ref_count = 1;
6982                 tep->host_bigendian = tep_is_bigendian();
6983         }
6984
6985         return tep;
6986 }
6987
6988 void tep_ref(struct tep_handle *tep)
6989 {
6990         tep->ref_count++;
6991 }
6992
6993 int tep_get_ref(struct tep_handle *tep)
6994 {
6995         if (tep)
6996                 return tep->ref_count;
6997         return 0;
6998 }
6999
7000 void tep_free_format_field(struct tep_format_field *field)
7001 {
7002         free(field->type);
7003         if (field->alias != field->name)
7004                 free(field->alias);
7005         free(field->name);
7006         free(field);
7007 }
7008
7009 static void free_format_fields(struct tep_format_field *field)
7010 {
7011         struct tep_format_field *next;
7012
7013         while (field) {
7014                 next = field->next;
7015                 tep_free_format_field(field);
7016                 field = next;
7017         }
7018 }
7019
7020 static void free_formats(struct tep_format *format)
7021 {
7022         free_format_fields(format->common_fields);
7023         free_format_fields(format->fields);
7024 }
7025
7026 void tep_free_event(struct tep_event *event)
7027 {
7028         free(event->name);
7029         free(event->system);
7030
7031         free_formats(&event->format);
7032
7033         free(event->print_fmt.format);
7034         free_args(event->print_fmt.args);
7035
7036         free(event);
7037 }
7038
7039 /**
7040  * tep_free - free a tep handle
7041  * @tep: the tep handle to free
7042  */
7043 void tep_free(struct tep_handle *tep)
7044 {
7045         struct cmdline_list *cmdlist, *cmdnext;
7046         struct func_list *funclist, *funcnext;
7047         struct printk_list *printklist, *printknext;
7048         struct tep_function_handler *func_handler;
7049         struct event_handler *handle;
7050         int i;
7051
7052         if (!tep)
7053                 return;
7054
7055         cmdlist = tep->cmdlist;
7056         funclist = tep->funclist;
7057         printklist = tep->printklist;
7058
7059         tep->ref_count--;
7060         if (tep->ref_count)
7061                 return;
7062
7063         if (tep->cmdlines) {
7064                 for (i = 0; i < tep->cmdline_count; i++)
7065                         free(tep->cmdlines[i].comm);
7066                 free(tep->cmdlines);
7067         }
7068
7069         while (cmdlist) {
7070                 cmdnext = cmdlist->next;
7071                 free(cmdlist->comm);
7072                 free(cmdlist);
7073                 cmdlist = cmdnext;
7074         }
7075
7076         if (tep->func_map) {
7077                 for (i = 0; i < (int)tep->func_count; i++) {
7078                         free(tep->func_map[i].func);
7079                         free(tep->func_map[i].mod);
7080                 }
7081                 free(tep->func_map);
7082         }
7083
7084         while (funclist) {
7085                 funcnext = funclist->next;
7086                 free(funclist->func);
7087                 free(funclist->mod);
7088                 free(funclist);
7089                 funclist = funcnext;
7090         }
7091
7092         while (tep->func_handlers) {
7093                 func_handler = tep->func_handlers;
7094                 tep->func_handlers = func_handler->next;
7095                 free_func_handle(func_handler);
7096         }
7097
7098         if (tep->printk_map) {
7099                 for (i = 0; i < (int)tep->printk_count; i++)
7100                         free(tep->printk_map[i].printk);
7101                 free(tep->printk_map);
7102         }
7103
7104         while (printklist) {
7105                 printknext = printklist->next;
7106                 free(printklist->printk);
7107                 free(printklist);
7108                 printklist = printknext;
7109         }
7110
7111         for (i = 0; i < tep->nr_events; i++)
7112                 tep_free_event(tep->events[i]);
7113
7114         while (tep->handlers) {
7115                 handle = tep->handlers;
7116                 tep->handlers = handle->next;
7117                 free_handler(handle);
7118         }
7119
7120         free(tep->events);
7121         free(tep->sort_events);
7122         free(tep->func_resolver);
7123
7124         free(tep);
7125 }
7126
7127 void tep_unref(struct tep_handle *tep)
7128 {
7129         tep_free(tep);
7130 }