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