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 'x':
4371                                                 break;
4372                                         case 'f':
4373                                         case 'F':
4374                                                 /*
4375                                                  * Pre-5.5 kernels use %pf and
4376                                                  * %pF for printing symbols
4377                                                  * while kernels since 5.5 use
4378                                                  * %pfw for fwnodes. So check
4379                                                  * %p[fF] isn't followed by 'w'.
4380                                                  */
4381                                                 if (ptr[1] != 'w')
4382                                                         break;
4383                                                 /* fall through */
4384                                         default:
4385                                                 /*
4386                                                  * Older kernels do not process
4387                                                  * dereferenced pointers.
4388                                                  * Only process if the pointer
4389                                                  * value is a printable.
4390                                                  */
4391                                                 if (isprint(*(char *)bptr))
4392                                                         goto process_string;
4393                                         }
4394                                 }
4395                                 /* fall through */
4396                         case 'd':
4397                         case 'u':
4398                         case 'i':
4399                         case 'x':
4400                         case 'X':
4401                         case 'o':
4402                                 switch (ls) {
4403                                 case 0:
4404                                         vsize = 4;
4405                                         break;
4406                                 case 1:
4407                                         vsize = tep->long_size;
4408                                         break;
4409                                 case 2:
4410                                         vsize = 8;
4411                                         break;
4412                                 default:
4413                                         vsize = ls; /* ? */
4414                                         break;
4415                                 }
4416                         /* fall through */
4417                         case '*':
4418                                 if (*ptr == '*')
4419                                         vsize = 4;
4420
4421                                 /* the pointers are always 4 bytes aligned */
4422                                 bptr = (void *)(((unsigned long)bptr + 3) &
4423                                                 ~3);
4424                                 val = tep_read_number(tep, bptr, vsize);
4425                                 bptr += vsize;
4426                                 arg = alloc_arg();
4427                                 if (!arg) {
4428                                         do_warning_event(event, "%s(%d): not enough memory!",
4429                                                    __func__, __LINE__);
4430                                         goto out_free;
4431                                 }
4432                                 arg->next = NULL;
4433                                 arg->type = TEP_PRINT_ATOM;
4434                                 if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4435                                         free(arg);
4436                                         goto out_free;
4437                                 }
4438                                 *next = arg;
4439                                 next = &arg->next;
4440                                 /*
4441                                  * The '*' case means that an arg is used as the length.
4442                                  * We need to continue to figure out for what.
4443                                  */
4444                                 if (*ptr == '*')
4445                                         goto process_again;
4446
4447                                 break;
4448                         case 's':
4449  process_string:
4450                                 arg = alloc_arg();
4451                                 if (!arg) {
4452                                         do_warning_event(event, "%s(%d): not enough memory!",
4453                                                    __func__, __LINE__);
4454                                         goto out_free;
4455                                 }
4456                                 arg->next = NULL;
4457                                 arg->type = TEP_PRINT_BSTRING;
4458                                 arg->string.string = strdup(bptr);
4459                                 if (!arg->string.string)
4460                                         goto out_free;
4461                                 bptr += strlen(bptr) + 1;
4462                                 *next = arg;
4463                                 next = &arg->next;
4464                         default:
4465                                 break;
4466                         }
4467                 }
4468         }
4469
4470         return args;
4471
4472 out_free:
4473         free_args(args);
4474         return NULL;
4475 }
4476
4477 static char *
4478 get_bprint_format(void *data, int size __maybe_unused,
4479                   struct tep_event *event)
4480 {
4481         struct tep_handle *tep = event->tep;
4482         unsigned long long addr;
4483         struct tep_format_field *field;
4484         struct printk_map *printk;
4485         char *format;
4486
4487         field = tep->bprint_fmt_field;
4488
4489         if (!field) {
4490                 field = tep_find_field(event, "fmt");
4491                 if (!field) {
4492                         do_warning_event(event, "can't find format field for binary printk");
4493                         return NULL;
4494                 }
4495                 tep->bprint_fmt_field = field;
4496         }
4497
4498         addr = tep_read_number(tep, data + field->offset, field->size);
4499
4500         printk = find_printk(tep, addr);
4501         if (!printk) {
4502                 if (asprintf(&format, "%%ps: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4503                         return NULL;
4504                 return format;
4505         }
4506
4507         if (asprintf(&format, "%s: %s", "%ps", printk->printk) < 0)
4508                 return NULL;
4509
4510         return format;
4511 }
4512
4513 static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
4514                           struct tep_event *event, struct tep_print_arg *arg)
4515 {
4516         unsigned char *buf;
4517         const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4518
4519         if (arg->type == TEP_PRINT_FUNC) {
4520                 process_defined_func(s, data, size, event, arg);
4521                 return;
4522         }
4523
4524         if (arg->type != TEP_PRINT_FIELD) {
4525                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4526                                  arg->type);
4527                 return;
4528         }
4529
4530         if (mac == 'm')
4531                 fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4532         if (!arg->field.field) {
4533                 arg->field.field =
4534                         tep_find_any_field(event, arg->field.name);
4535                 if (!arg->field.field) {
4536                         do_warning_event(event, "%s: field %s not found",
4537                                          __func__, arg->field.name);
4538                         return;
4539                 }
4540         }
4541         if (arg->field.field->size != 6) {
4542                 trace_seq_printf(s, "INVALIDMAC");
4543                 return;
4544         }
4545         buf = data + arg->field.field->offset;
4546         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4547 }
4548
4549 static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
4550 {
4551         const char *fmt;
4552
4553         if (i == 'i')
4554                 fmt = "%03d.%03d.%03d.%03d";
4555         else
4556                 fmt = "%d.%d.%d.%d";
4557
4558         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4559 }
4560
4561 static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4562 {
4563         return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4564                 (unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4565 }
4566
4567 static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4568 {
4569         return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4570 }
4571
4572 static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4573 {
4574         int i, j, range;
4575         unsigned char zerolength[8];
4576         int longest = 1;
4577         int colonpos = -1;
4578         uint16_t word;
4579         uint8_t hi, lo;
4580         bool needcolon = false;
4581         bool useIPv4;
4582         struct in6_addr in6;
4583
4584         memcpy(&in6, addr, sizeof(struct in6_addr));
4585
4586         useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4587
4588         memset(zerolength, 0, sizeof(zerolength));
4589
4590         if (useIPv4)
4591                 range = 6;
4592         else
4593                 range = 8;
4594
4595         /* find position of longest 0 run */
4596         for (i = 0; i < range; i++) {
4597                 for (j = i; j < range; j++) {
4598                         if (in6.s6_addr16[j] != 0)
4599                                 break;
4600                         zerolength[i]++;
4601                 }
4602         }
4603         for (i = 0; i < range; i++) {
4604                 if (zerolength[i] > longest) {
4605                         longest = zerolength[i];
4606                         colonpos = i;
4607                 }
4608         }
4609         if (longest == 1)               /* don't compress a single 0 */
4610                 colonpos = -1;
4611
4612         /* emit address */
4613         for (i = 0; i < range; i++) {
4614                 if (i == colonpos) {
4615                         if (needcolon || i == 0)
4616                                 trace_seq_printf(s, ":");
4617                         trace_seq_printf(s, ":");
4618                         needcolon = false;
4619                         i += longest - 1;
4620                         continue;
4621                 }
4622                 if (needcolon) {
4623                         trace_seq_printf(s, ":");
4624                         needcolon = false;
4625                 }
4626                 /* hex u16 without leading 0s */
4627                 word = ntohs(in6.s6_addr16[i]);
4628                 hi = word >> 8;
4629                 lo = word & 0xff;
4630                 if (hi)
4631                         trace_seq_printf(s, "%x%02x", hi, lo);
4632                 else
4633                         trace_seq_printf(s, "%x", lo);
4634
4635                 needcolon = true;
4636         }
4637
4638         if (useIPv4) {
4639                 if (needcolon)
4640                         trace_seq_printf(s, ":");
4641                 print_ip4_addr(s, 'I', &in6.s6_addr[12]);
4642         }
4643
4644         return;
4645 }
4646
4647 static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4648 {
4649         int j;
4650
4651         for (j = 0; j < 16; j += 2) {
4652                 trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4653                 if (i == 'I' && j < 14)
4654                         trace_seq_printf(s, ":");
4655         }
4656 }
4657
4658 /*
4659  * %pi4   print an IPv4 address with leading zeros
4660  * %pI4   print an IPv4 address without leading zeros
4661  * %pi6   print an IPv6 address without colons
4662  * %pI6   print an IPv6 address with colons
4663  * %pI6c  print an IPv6 address in compressed form with colons
4664  * %pISpc print an IP address based on sockaddr; p adds port.
4665  */
4666 static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4667                           void *data, int size, struct tep_event *event,
4668                           struct tep_print_arg *arg)
4669 {
4670         unsigned char *buf;
4671
4672         if (arg->type == TEP_PRINT_FUNC) {
4673                 process_defined_func(s, data, size, event, arg);
4674                 return 0;
4675         }
4676
4677         if (arg->type != TEP_PRINT_FIELD) {
4678                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4679                 return 0;
4680         }
4681
4682         if (!arg->field.field) {
4683                 arg->field.field =
4684                         tep_find_any_field(event, arg->field.name);
4685                 if (!arg->field.field) {
4686                         do_warning("%s: field %s not found",
4687                                    __func__, arg->field.name);
4688                         return 0;
4689                 }
4690         }
4691
4692         buf = data + arg->field.field->offset;
4693
4694         if (arg->field.field->size != 4) {
4695                 trace_seq_printf(s, "INVALIDIPv4");
4696                 return 0;
4697         }
4698         print_ip4_addr(s, i, buf);
4699
4700         return 0;
4701 }
4702
4703 static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4704                           void *data, int size, struct tep_event *event,
4705                           struct tep_print_arg *arg)
4706 {
4707         char have_c = 0;
4708         unsigned char *buf;
4709         int rc = 0;
4710
4711         /* pI6c */
4712         if (i == 'I' && *ptr == 'c') {
4713                 have_c = 1;
4714                 ptr++;
4715                 rc++;
4716         }
4717
4718         if (arg->type == TEP_PRINT_FUNC) {
4719                 process_defined_func(s, data, size, event, arg);
4720                 return rc;
4721         }
4722
4723         if (arg->type != TEP_PRINT_FIELD) {
4724                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4725                 return rc;
4726         }
4727
4728         if (!arg->field.field) {
4729                 arg->field.field =
4730                         tep_find_any_field(event, arg->field.name);
4731                 if (!arg->field.field) {
4732                         do_warning("%s: field %s not found",
4733                                    __func__, arg->field.name);
4734                         return rc;
4735                 }
4736         }
4737
4738         buf = data + arg->field.field->offset;
4739
4740         if (arg->field.field->size != 16) {
4741                 trace_seq_printf(s, "INVALIDIPv6");
4742                 return rc;
4743         }
4744
4745         if (have_c)
4746                 print_ip6c_addr(s, buf);
4747         else
4748                 print_ip6_addr(s, i, buf);
4749
4750         return rc;
4751 }
4752
4753 static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4754                           void *data, int size, struct tep_event *event,
4755                           struct tep_print_arg *arg)
4756 {
4757         char have_c = 0, have_p = 0;
4758         unsigned char *buf;
4759         struct sockaddr_storage *sa;
4760         int rc = 0;
4761
4762         /* pISpc */
4763         if (i == 'I') {
4764                 if (*ptr == 'p') {
4765                         have_p = 1;
4766                         ptr++;
4767                         rc++;
4768                 }
4769                 if (*ptr == 'c') {
4770                         have_c = 1;
4771                         ptr++;
4772                         rc++;
4773                 }
4774         }
4775
4776         if (arg->type == TEP_PRINT_FUNC) {
4777                 process_defined_func(s, data, size, event, arg);
4778                 return rc;
4779         }
4780
4781         if (arg->type != TEP_PRINT_FIELD) {
4782                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4783                 return rc;
4784         }
4785
4786         if (!arg->field.field) {
4787                 arg->field.field =
4788                         tep_find_any_field(event, arg->field.name);
4789                 if (!arg->field.field) {
4790                         do_warning("%s: field %s not found",
4791                                    __func__, arg->field.name);
4792                         return rc;
4793                 }
4794         }
4795
4796         sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4797
4798         if (sa->ss_family == AF_INET) {
4799                 struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4800
4801                 if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4802                         trace_seq_printf(s, "INVALIDIPv4");
4803                         return rc;
4804                 }
4805
4806                 print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
4807                 if (have_p)
4808                         trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4809
4810
4811         } else if (sa->ss_family == AF_INET6) {
4812                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4813
4814                 if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4815                         trace_seq_printf(s, "INVALIDIPv6");
4816                         return rc;
4817                 }
4818
4819                 if (have_p)
4820                         trace_seq_printf(s, "[");
4821
4822                 buf = (unsigned char *) &sa6->sin6_addr;
4823                 if (have_c)
4824                         print_ip6c_addr(s, buf);
4825                 else
4826                         print_ip6_addr(s, i, buf);
4827
4828                 if (have_p)
4829                         trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4830         }
4831
4832         return rc;
4833 }
4834
4835 static int print_ip_arg(struct trace_seq *s, const char *ptr,
4836                         void *data, int size, struct tep_event *event,
4837                         struct tep_print_arg *arg)
4838 {
4839         char i = *ptr;  /* 'i' or 'I' */
4840         char ver;
4841         int rc = 0;
4842
4843         ptr++;
4844         rc++;
4845
4846         ver = *ptr;
4847         ptr++;
4848         rc++;
4849
4850         switch (ver) {
4851         case '4':
4852                 rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
4853                 break;
4854         case '6':
4855                 rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
4856                 break;
4857         case 'S':
4858                 rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
4859                 break;
4860         default:
4861                 return 0;
4862         }
4863
4864         return rc;
4865 }
4866
4867 static int is_printable_array(char *p, unsigned int len)
4868 {
4869         unsigned int i;
4870
4871         for (i = 0; i < len && p[i]; i++)
4872                 if (!isprint(p[i]) && !isspace(p[i]))
4873                     return 0;
4874         return 1;
4875 }
4876
4877 void tep_print_field(struct trace_seq *s, void *data,
4878                      struct tep_format_field *field)
4879 {
4880         unsigned long long val;
4881         unsigned int offset, len, i;
4882         struct tep_handle *tep = field->event->tep;
4883
4884         if (field->flags & TEP_FIELD_IS_ARRAY) {
4885                 offset = field->offset;
4886                 len = field->size;
4887                 if (field->flags & TEP_FIELD_IS_DYNAMIC) {
4888                         val = tep_read_number(tep, data + offset, len);
4889                         offset = val;
4890                         len = offset >> 16;
4891                         offset &= 0xffff;
4892                 }
4893                 if (field->flags & TEP_FIELD_IS_STRING &&
4894                     is_printable_array(data + offset, len)) {
4895                         trace_seq_printf(s, "%s", (char *)data + offset);
4896                 } else {
4897                         trace_seq_puts(s, "ARRAY[");
4898                         for (i = 0; i < len; i++) {
4899                                 if (i)
4900                                         trace_seq_puts(s, ", ");
4901                                 trace_seq_printf(s, "%02x",
4902                                                  *((unsigned char *)data + offset + i));
4903                         }
4904                         trace_seq_putc(s, ']');
4905                         field->flags &= ~TEP_FIELD_IS_STRING;
4906                 }
4907         } else {
4908                 val = tep_read_number(tep, data + field->offset,
4909                                       field->size);
4910                 if (field->flags & TEP_FIELD_IS_POINTER) {
4911                         trace_seq_printf(s, "0x%llx", val);
4912                 } else if (field->flags & TEP_FIELD_IS_SIGNED) {
4913                         switch (field->size) {
4914                         case 4:
4915                                 /*
4916                                  * If field is long then print it in hex.
4917                                  * A long usually stores pointers.
4918                                  */
4919                                 if (field->flags & TEP_FIELD_IS_LONG)
4920                                         trace_seq_printf(s, "0x%x", (int)val);
4921                                 else
4922                                         trace_seq_printf(s, "%d", (int)val);
4923                                 break;
4924                         case 2:
4925                                 trace_seq_printf(s, "%2d", (short)val);
4926                                 break;
4927                         case 1:
4928                                 trace_seq_printf(s, "%1d", (char)val);
4929                                 break;
4930                         default:
4931                                 trace_seq_printf(s, "%lld", val);
4932                         }
4933                 } else {
4934                         if (field->flags & TEP_FIELD_IS_LONG)
4935                                 trace_seq_printf(s, "0x%llx", val);
4936                         else
4937                                 trace_seq_printf(s, "%llu", val);
4938                 }
4939         }
4940 }
4941
4942 void tep_print_fields(struct trace_seq *s, void *data,
4943                       int size __maybe_unused, struct tep_event *event)
4944 {
4945         struct tep_format_field *field;
4946
4947         field = event->format.fields;
4948         while (field) {
4949                 trace_seq_printf(s, " %s=", field->name);
4950                 tep_print_field(s, data, field);
4951                 field = field->next;
4952         }
4953 }
4954
4955 static void pretty_print(struct trace_seq *s, void *data, int size, struct tep_event *event)
4956 {
4957         struct tep_handle *tep = event->tep;
4958         struct tep_print_fmt *print_fmt = &event->print_fmt;
4959         struct tep_print_arg *arg = print_fmt->args;
4960         struct tep_print_arg *args = NULL;
4961         const char *ptr = print_fmt->format;
4962         unsigned long long val;
4963         struct func_map *func;
4964         const char *saveptr;
4965         struct trace_seq p;
4966         char *bprint_fmt = NULL;
4967         char format[32];
4968         int show_func;
4969         int len_as_arg;
4970         int len_arg = 0;
4971         int len;
4972         int ls;
4973
4974         if (event->flags & TEP_EVENT_FL_FAILED) {
4975                 trace_seq_printf(s, "[FAILED TO PARSE]");
4976                 tep_print_fields(s, data, size, event);
4977                 return;
4978         }
4979
4980         if (event->flags & TEP_EVENT_FL_ISBPRINT) {
4981                 bprint_fmt = get_bprint_format(data, size, event);
4982                 args = make_bprint_args(bprint_fmt, data, size, event);
4983                 arg = args;
4984                 ptr = bprint_fmt;
4985         }
4986
4987         for (; *ptr; ptr++) {
4988                 ls = 0;
4989                 if (*ptr == '\\') {
4990                         ptr++;
4991                         switch (*ptr) {
4992                         case 'n':
4993                                 trace_seq_putc(s, '\n');
4994                                 break;
4995                         case 't':
4996                                 trace_seq_putc(s, '\t');
4997                                 break;
4998                         case 'r':
4999                                 trace_seq_putc(s, '\r');
5000                                 break;
5001                         case '\\':
5002                                 trace_seq_putc(s, '\\');
5003                                 break;
5004                         default:
5005                                 trace_seq_putc(s, *ptr);
5006                                 break;
5007                         }
5008
5009                 } else if (*ptr == '%') {
5010                         saveptr = ptr;
5011                         show_func = 0;
5012                         len_as_arg = 0;
5013  cont_process:
5014                         ptr++;
5015                         switch (*ptr) {
5016                         case '%':
5017                                 trace_seq_putc(s, '%');
5018                                 break;
5019                         case '#':
5020                                 /* FIXME: need to handle properly */
5021                                 goto cont_process;
5022                         case 'h':
5023                                 ls--;
5024                                 goto cont_process;
5025                         case 'l':
5026                                 ls++;
5027                                 goto cont_process;
5028                         case 'L':
5029                                 ls = 2;
5030                                 goto cont_process;
5031                         case '*':
5032                                 /* The argument is the length. */
5033                                 if (!arg) {
5034                                         do_warning_event(event, "no argument match");
5035                                         event->flags |= TEP_EVENT_FL_FAILED;
5036                                         goto out_failed;
5037                                 }
5038                                 len_arg = eval_num_arg(data, size, event, arg);
5039                                 len_as_arg = 1;
5040                                 arg = arg->next;
5041                                 goto cont_process;
5042                         case '.':
5043                         case 'z':
5044                         case 'Z':
5045                         case '0' ... '9':
5046                         case '-':
5047                                 goto cont_process;
5048                         case 'p':
5049                                 if (tep->long_size == 4)
5050                                         ls = 1;
5051                                 else
5052                                         ls = 2;
5053
5054                                 if (isalnum(ptr[1]))
5055                                         ptr++;
5056
5057                                 if (arg->type == TEP_PRINT_BSTRING) {
5058                                         trace_seq_puts(s, arg->string.string);
5059                                         arg = arg->next;
5060                                         break;
5061                                 }
5062
5063                                 if (*ptr == 'F' || *ptr == 'f' ||
5064                                     *ptr == 'S' || *ptr == 's') {
5065                                         show_func = *ptr;
5066                                 } else if (*ptr == 'M' || *ptr == 'm') {
5067                                         print_mac_arg(s, *ptr, data, size, event, arg);
5068                                         arg = arg->next;
5069                                         break;
5070                                 } else if (*ptr == 'I' || *ptr == 'i') {
5071                                         int n;
5072
5073                                         n = print_ip_arg(s, ptr, data, size, event, arg);
5074                                         if (n > 0) {
5075                                                 ptr += n - 1;
5076                                                 arg = arg->next;
5077                                                 break;
5078                                         }
5079                                 }
5080
5081                                 /* fall through */
5082                         case 'd':
5083                         case 'u':
5084                         case 'i':
5085                         case 'x':
5086                         case 'X':
5087                         case 'o':
5088                                 if (!arg) {
5089                                         do_warning_event(event, "no argument match");
5090                                         event->flags |= TEP_EVENT_FL_FAILED;
5091                                         goto out_failed;
5092                                 }
5093
5094                                 len = ((unsigned long)ptr + 1) -
5095                                         (unsigned long)saveptr;
5096
5097                                 /* should never happen */
5098                                 if (len > 31) {
5099                                         do_warning_event(event, "bad format!");
5100                                         event->flags |= TEP_EVENT_FL_FAILED;
5101                                         len = 31;
5102                                 }
5103
5104                                 memcpy(format, saveptr, len);
5105                                 format[len] = 0;
5106
5107                                 val = eval_num_arg(data, size, event, arg);
5108                                 arg = arg->next;
5109
5110                                 if (show_func) {
5111                                         func = find_func(tep, val);
5112                                         if (func) {
5113                                                 trace_seq_puts(s, func->func);
5114                                                 if (show_func == 'F')
5115                                                         trace_seq_printf(s,
5116                                                                "+0x%llx",
5117                                                                val - func->addr);
5118                                                 break;
5119                                         }
5120                                 }
5121                                 if (tep->long_size == 8 && ls == 1 &&
5122                                     sizeof(long) != 8) {
5123                                         char *p;
5124
5125                                         /* make %l into %ll */
5126                                         if (ls == 1 && (p = strchr(format, 'l')))
5127                                                 memmove(p+1, p, strlen(p)+1);
5128                                         else if (strcmp(format, "%p") == 0)
5129                                                 strcpy(format, "0x%llx");
5130                                         ls = 2;
5131                                 }
5132                                 switch (ls) {
5133                                 case -2:
5134                                         if (len_as_arg)
5135                                                 trace_seq_printf(s, format, len_arg, (char)val);
5136                                         else
5137                                                 trace_seq_printf(s, format, (char)val);
5138                                         break;
5139                                 case -1:
5140                                         if (len_as_arg)
5141                                                 trace_seq_printf(s, format, len_arg, (short)val);
5142                                         else
5143                                                 trace_seq_printf(s, format, (short)val);
5144                                         break;
5145                                 case 0:
5146                                         if (len_as_arg)
5147                                                 trace_seq_printf(s, format, len_arg, (int)val);
5148                                         else
5149                                                 trace_seq_printf(s, format, (int)val);
5150                                         break;
5151                                 case 1:
5152                                         if (len_as_arg)
5153                                                 trace_seq_printf(s, format, len_arg, (long)val);
5154                                         else
5155                                                 trace_seq_printf(s, format, (long)val);
5156                                         break;
5157                                 case 2:
5158                                         if (len_as_arg)
5159                                                 trace_seq_printf(s, format, len_arg,
5160                                                                  (long long)val);
5161                                         else
5162                                                 trace_seq_printf(s, format, (long long)val);
5163                                         break;
5164                                 default:
5165                                         do_warning_event(event, "bad count (%d)", ls);
5166                                         event->flags |= TEP_EVENT_FL_FAILED;
5167                                 }
5168                                 break;
5169                         case 's':
5170                                 if (!arg) {
5171                                         do_warning_event(event, "no matching argument");
5172                                         event->flags |= TEP_EVENT_FL_FAILED;
5173                                         goto out_failed;
5174                                 }
5175
5176                                 len = ((unsigned long)ptr + 1) -
5177                                         (unsigned long)saveptr;
5178
5179                                 /* should never happen */
5180                                 if (len > 31) {
5181                                         do_warning_event(event, "bad format!");
5182                                         event->flags |= TEP_EVENT_FL_FAILED;
5183                                         len = 31;
5184                                 }
5185
5186                                 memcpy(format, saveptr, len);
5187                                 format[len] = 0;
5188                                 if (!len_as_arg)
5189                                         len_arg = -1;
5190                                 /* Use helper trace_seq */
5191                                 trace_seq_init(&p);
5192                                 print_str_arg(&p, data, size, event,
5193                                               format, len_arg, arg);
5194                                 trace_seq_terminate(&p);
5195                                 trace_seq_puts(s, p.buffer);
5196                                 trace_seq_destroy(&p);
5197                                 arg = arg->next;
5198                                 break;
5199                         default:
5200                                 trace_seq_printf(s, ">%c<", *ptr);
5201
5202                         }
5203                 } else
5204                         trace_seq_putc(s, *ptr);
5205         }
5206
5207         if (event->flags & TEP_EVENT_FL_FAILED) {
5208 out_failed:
5209                 trace_seq_printf(s, "[FAILED TO PARSE]");
5210         }
5211
5212         if (args) {
5213                 free_args(args);
5214                 free(bprint_fmt);
5215         }
5216 }
5217
5218 /*
5219  * This parses out the Latency format (interrupts disabled,
5220  * need rescheduling, in hard/soft interrupt, preempt count
5221  * and lock depth) and places it into the trace_seq.
5222  */
5223 static void data_latency_format(struct tep_handle *tep, struct trace_seq *s,
5224                                 char *format, struct tep_record *record)
5225 {
5226         static int check_lock_depth = 1;
5227         static int check_migrate_disable = 1;
5228         static int lock_depth_exists;
5229         static int migrate_disable_exists;
5230         unsigned int lat_flags;
5231         struct trace_seq sq;
5232         unsigned int pc;
5233         int lock_depth = 0;
5234         int migrate_disable = 0;
5235         int hardirq;
5236         int softirq;
5237         void *data = record->data;
5238
5239         trace_seq_init(&sq);
5240         lat_flags = parse_common_flags(tep, data);
5241         pc = parse_common_pc(tep, data);
5242         /* lock_depth may not always exist */
5243         if (lock_depth_exists)
5244                 lock_depth = parse_common_lock_depth(tep, data);
5245         else if (check_lock_depth) {
5246                 lock_depth = parse_common_lock_depth(tep, data);
5247                 if (lock_depth < 0)
5248                         check_lock_depth = 0;
5249                 else
5250                         lock_depth_exists = 1;
5251         }
5252
5253         /* migrate_disable may not always exist */
5254         if (migrate_disable_exists)
5255                 migrate_disable = parse_common_migrate_disable(tep, data);
5256         else if (check_migrate_disable) {
5257                 migrate_disable = parse_common_migrate_disable(tep, data);
5258                 if (migrate_disable < 0)
5259                         check_migrate_disable = 0;
5260                 else
5261                         migrate_disable_exists = 1;
5262         }
5263
5264         hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5265         softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5266
5267         trace_seq_printf(&sq, "%c%c%c",
5268                (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5269                (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5270                'X' : '.',
5271                (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5272                'N' : '.',
5273                (hardirq && softirq) ? 'H' :
5274                hardirq ? 'h' : softirq ? 's' : '.');
5275
5276         if (pc)
5277                 trace_seq_printf(&sq, "%x", pc);
5278         else
5279                 trace_seq_printf(&sq, ".");
5280
5281         if (migrate_disable_exists) {
5282                 if (migrate_disable < 0)
5283                         trace_seq_printf(&sq, ".");
5284                 else
5285                         trace_seq_printf(&sq, "%d", migrate_disable);
5286         }
5287
5288         if (lock_depth_exists) {
5289                 if (lock_depth < 0)
5290                         trace_seq_printf(&sq, ".");
5291                 else
5292                         trace_seq_printf(&sq, "%d", lock_depth);
5293         }
5294
5295         if (sq.state == TRACE_SEQ__MEM_ALLOC_FAILED) {
5296                 s->state = TRACE_SEQ__MEM_ALLOC_FAILED;
5297                 return;
5298         }
5299
5300         trace_seq_terminate(&sq);
5301         trace_seq_puts(s, sq.buffer);
5302         trace_seq_destroy(&sq);
5303         trace_seq_terminate(s);
5304 }
5305
5306 /**
5307  * tep_data_type - parse out the given event type
5308  * @tep: a handle to the trace event parser context
5309  * @rec: the record to read from
5310  *
5311  * This returns the event id from the @rec.
5312  */
5313 int tep_data_type(struct tep_handle *tep, struct tep_record *rec)
5314 {
5315         return trace_parse_common_type(tep, rec->data);
5316 }
5317
5318 /**
5319  * tep_data_pid - parse the PID from record
5320  * @tep: a handle to the trace event parser context
5321  * @rec: the record to parse
5322  *
5323  * This returns the PID from a record.
5324  */
5325 int tep_data_pid(struct tep_handle *tep, struct tep_record *rec)
5326 {
5327         return parse_common_pid(tep, rec->data);
5328 }
5329
5330 /**
5331  * tep_data_preempt_count - parse the preempt count from the record
5332  * @tep: a handle to the trace event parser context
5333  * @rec: the record to parse
5334  *
5335  * This returns the preempt count from a record.
5336  */
5337 int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec)
5338 {
5339         return parse_common_pc(tep, rec->data);
5340 }
5341
5342 /**
5343  * tep_data_flags - parse the latency flags from the record
5344  * @tep: a handle to the trace event parser context
5345  * @rec: the record to parse
5346  *
5347  * This returns the latency flags from a record.
5348  *
5349  *  Use trace_flag_type enum for the flags (see event-parse.h).
5350  */
5351 int tep_data_flags(struct tep_handle *tep, struct tep_record *rec)
5352 {
5353         return parse_common_flags(tep, rec->data);
5354 }
5355
5356 /**
5357  * tep_data_comm_from_pid - return the command line from PID
5358  * @tep: a handle to the trace event parser context
5359  * @pid: the PID of the task to search for
5360  *
5361  * This returns a pointer to the command line that has the given
5362  * @pid.
5363  */
5364 const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid)
5365 {
5366         const char *comm;
5367
5368         comm = find_cmdline(tep, pid);
5369         return comm;
5370 }
5371
5372 static struct tep_cmdline *
5373 pid_from_cmdlist(struct tep_handle *tep, const char *comm, struct tep_cmdline *next)
5374 {
5375         struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5376
5377         if (cmdlist)
5378                 cmdlist = cmdlist->next;
5379         else
5380                 cmdlist = tep->cmdlist;
5381
5382         while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5383                 cmdlist = cmdlist->next;
5384
5385         return (struct tep_cmdline *)cmdlist;
5386 }
5387
5388 /**
5389  * tep_data_pid_from_comm - return the pid from a given comm
5390  * @tep: a handle to the trace event parser context
5391  * @comm: the cmdline to find the pid from
5392  * @next: the cmdline structure to find the next comm
5393  *
5394  * This returns the cmdline structure that holds a pid for a given
5395  * comm, or NULL if none found. As there may be more than one pid for
5396  * a given comm, the result of this call can be passed back into
5397  * a recurring call in the @next parameter, and then it will find the
5398  * next pid.
5399  * Also, it does a linear search, so it may be slow.
5400  */
5401 struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm,
5402                                            struct tep_cmdline *next)
5403 {
5404         struct tep_cmdline *cmdline;
5405
5406         /*
5407          * If the cmdlines have not been converted yet, then use
5408          * the list.
5409          */
5410         if (!tep->cmdlines)
5411                 return pid_from_cmdlist(tep, comm, next);
5412
5413         if (next) {
5414                 /*
5415                  * The next pointer could have been still from
5416                  * a previous call before cmdlines were created
5417                  */
5418                 if (next < tep->cmdlines ||
5419                     next >= tep->cmdlines + tep->cmdline_count)
5420                         next = NULL;
5421                 else
5422                         cmdline  = next++;
5423         }
5424
5425         if (!next)
5426                 cmdline = tep->cmdlines;
5427
5428         while (cmdline < tep->cmdlines + tep->cmdline_count) {
5429                 if (strcmp(cmdline->comm, comm) == 0)
5430                         return cmdline;
5431                 cmdline++;
5432         }
5433         return NULL;
5434 }
5435
5436 /**
5437  * tep_cmdline_pid - return the pid associated to a given cmdline
5438  * @tep: a handle to the trace event parser context
5439  * @cmdline: The cmdline structure to get the pid from
5440  *
5441  * Returns the pid for a give cmdline. If @cmdline is NULL, then
5442  * -1 is returned.
5443  */
5444 int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline)
5445 {
5446         struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
5447
5448         if (!cmdline)
5449                 return -1;
5450
5451         /*
5452          * If cmdlines have not been created yet, or cmdline is
5453          * not part of the array, then treat it as a cmdlist instead.
5454          */
5455         if (!tep->cmdlines ||
5456             cmdline < tep->cmdlines ||
5457             cmdline >= tep->cmdlines + tep->cmdline_count)
5458                 return cmdlist->pid;
5459
5460         return cmdline->pid;
5461 }
5462
5463 /*
5464  * This parses the raw @data using the given @event information and
5465  * writes the print format into the trace_seq.
5466  */
5467 static void print_event_info(struct trace_seq *s, char *format, bool raw,
5468                              struct tep_event *event, struct tep_record *record)
5469 {
5470         int print_pretty = 1;
5471
5472         if (raw || (event->flags & TEP_EVENT_FL_PRINTRAW))
5473                 tep_print_fields(s, record->data, record->size, event);
5474         else {
5475
5476                 if (event->handler && !(event->flags & TEP_EVENT_FL_NOHANDLE))
5477                         print_pretty = event->handler(s, record, event,
5478                                                       event->context);
5479
5480                 if (print_pretty)
5481                         pretty_print(s, record->data, record->size, event);
5482         }
5483
5484         trace_seq_terminate(s);
5485 }
5486
5487 /**
5488  * tep_find_event_by_record - return the event from a given record
5489  * @tep: a handle to the trace event parser context
5490  * @record: The record to get the event from
5491  *
5492  * Returns the associated event for a given record, or NULL if non is
5493  * is found.
5494  */
5495 struct tep_event *
5496 tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record)
5497 {
5498         int type;
5499
5500         if (record->size < 0) {
5501                 do_warning("ug! negative record size %d", record->size);
5502                 return NULL;
5503         }
5504
5505         type = trace_parse_common_type(tep, record->data);
5506
5507         return tep_find_event(tep, type);
5508 }
5509
5510 /*
5511  * Writes the timestamp of the record into @s. Time divisor and precision can be
5512  * specified as part of printf @format string. Example:
5513  *      "%3.1000d" - divide the time by 1000 and print the first 3 digits
5514  *      before the dot. Thus, the timestamp "123456000" will be printed as
5515  *      "123.456"
5516  */
5517 static void print_event_time(struct tep_handle *tep, struct trace_seq *s,
5518                                  char *format, struct tep_event *event,
5519                                  struct tep_record *record)
5520 {
5521         unsigned long long time;
5522         char *divstr;
5523         int prec = 0, pr;
5524         int div = 0;
5525         int p10 = 1;
5526
5527         if (isdigit(*(format + 1)))
5528                 prec = atoi(format + 1);
5529         divstr = strchr(format, '.');
5530         if (divstr && isdigit(*(divstr + 1)))
5531                 div = atoi(divstr + 1);
5532         time = record->ts;
5533         if (div) {
5534                 time += div / 2;
5535                 time /= div;
5536         }
5537         pr = prec;
5538         while (pr--)
5539                 p10 *= 10;
5540
5541         if (p10 > 1 && p10 < time)
5542                 trace_seq_printf(s, "%5llu.%0*llu", time / p10, prec, time % p10);
5543         else
5544                 trace_seq_printf(s, "%12llu", time);
5545 }
5546
5547 struct print_event_type {
5548         enum {
5549                 EVENT_TYPE_INT = 1,
5550                 EVENT_TYPE_STRING,
5551                 EVENT_TYPE_UNKNOWN,
5552         } type;
5553         char format[32];
5554 };
5555
5556 static void print_string(struct tep_handle *tep, struct trace_seq *s,
5557                          struct tep_record *record, struct tep_event *event,
5558                          const char *arg, struct print_event_type *type)
5559 {
5560         const char *comm;
5561         int pid;
5562
5563         if (strncmp(arg, TEP_PRINT_LATENCY, strlen(TEP_PRINT_LATENCY)) == 0) {
5564                 data_latency_format(tep, s, type->format, record);
5565         } else if (strncmp(arg, TEP_PRINT_COMM, strlen(TEP_PRINT_COMM)) == 0) {
5566                 pid = parse_common_pid(tep, record->data);
5567                 comm = find_cmdline(tep, pid);
5568                 trace_seq_printf(s, type->format, comm);
5569         } else if (strncmp(arg, TEP_PRINT_INFO_RAW, strlen(TEP_PRINT_INFO_RAW)) == 0) {
5570                 print_event_info(s, type->format, true, event, record);
5571         } else if (strncmp(arg, TEP_PRINT_INFO, strlen(TEP_PRINT_INFO)) == 0) {
5572                 print_event_info(s, type->format, false, event, record);
5573         } else if  (strncmp(arg, TEP_PRINT_NAME, strlen(TEP_PRINT_NAME)) == 0) {
5574                 trace_seq_printf(s, type->format, event->name);
5575         } else {
5576                 trace_seq_printf(s, "[UNKNOWN TEP TYPE %s]", arg);
5577         }
5578
5579 }
5580
5581 static void print_int(struct tep_handle *tep, struct trace_seq *s,
5582                       struct tep_record *record, struct tep_event *event,
5583                       int arg, struct print_event_type *type)
5584 {
5585         int param;
5586
5587         switch (arg) {
5588         case TEP_PRINT_CPU:
5589                 param = record->cpu;
5590                 break;
5591         case TEP_PRINT_PID:
5592                 param = parse_common_pid(tep, record->data);
5593                 break;
5594         case TEP_PRINT_TIME:
5595                 return print_event_time(tep, s, type->format, event, record);
5596         default:
5597                 return;
5598         }
5599         trace_seq_printf(s, type->format, param);
5600 }
5601
5602 static int tep_print_event_param_type(char *format,
5603                                       struct print_event_type *type)
5604 {
5605         char *str = format + 1;
5606         int i = 1;
5607
5608         type->type = EVENT_TYPE_UNKNOWN;
5609         while (*str) {
5610                 switch (*str) {
5611                 case 'd':
5612                 case 'u':
5613                 case 'i':
5614                 case 'x':
5615                 case 'X':
5616                 case 'o':
5617                         type->type = EVENT_TYPE_INT;
5618                         break;
5619                 case 's':
5620                         type->type = EVENT_TYPE_STRING;
5621                         break;
5622                 }
5623                 str++;
5624                 i++;
5625                 if (type->type != EVENT_TYPE_UNKNOWN)
5626                         break;
5627         }
5628         memset(type->format, 0, 32);
5629         memcpy(type->format, format, i < 32 ? i : 31);
5630         return i;
5631 }
5632
5633 /**
5634  * tep_print_event - Write various event information
5635  * @tep: a handle to the trace event parser context
5636  * @s: the trace_seq to write to
5637  * @record: The record to get the event from
5638  * @format: a printf format string. Supported event fileds:
5639  *      TEP_PRINT_PID, "%d" - event PID
5640  *      TEP_PRINT_CPU, "%d" - event CPU
5641  *      TEP_PRINT_COMM, "%s" - event command string
5642  *      TEP_PRINT_NAME, "%s" - event name
5643  *      TEP_PRINT_LATENCY, "%s" - event latency
5644  *      TEP_PRINT_TIME, %d - event time stamp. A divisor and precision
5645  *                      can be specified as part of this format string:
5646  *                      "%precision.divisord". Example:
5647  *                      "%3.1000d" - divide the time by 1000 and print the first
5648  *                      3 digits before the dot. Thus, the time stamp
5649  *                      "123456000" will be printed as "123.456"
5650  *      TEP_PRINT_INFO, "%s" - event information. If any width is specified in
5651  *                      the format string, the event information will be printed
5652  *                      in raw format.
5653  * Writes the specified event information into @s.
5654  */
5655 void tep_print_event(struct tep_handle *tep, struct trace_seq *s,
5656                      struct tep_record *record, const char *fmt, ...)
5657 {
5658         struct print_event_type type;
5659         char *format = strdup(fmt);
5660         char *current = format;
5661         char *str = format;
5662         int offset;
5663         va_list args;
5664         struct tep_event *event;
5665
5666         if (!format)
5667                 return;
5668
5669         event = tep_find_event_by_record(tep, record);
5670         va_start(args, fmt);
5671         while (*current) {
5672                 current = strchr(str, '%');
5673                 if (!current) {
5674                         trace_seq_puts(s, str);
5675                         break;
5676                 }
5677                 memset(&type, 0, sizeof(type));
5678                 offset = tep_print_event_param_type(current, &type);
5679                 *current = '\0';
5680                 trace_seq_puts(s, str);
5681                 current += offset;
5682                 switch (type.type) {
5683                 case EVENT_TYPE_STRING:
5684                         print_string(tep, s, record, event,
5685                                      va_arg(args, char*), &type);
5686                         break;
5687                 case EVENT_TYPE_INT:
5688                         print_int(tep, s, record, event,
5689                                   va_arg(args, int), &type);
5690                         break;
5691                 case EVENT_TYPE_UNKNOWN:
5692                 default:
5693                         trace_seq_printf(s, "[UNKNOWN TYPE]");
5694                         break;
5695                 }
5696                 str = current;
5697
5698         }
5699         va_end(args);
5700         free(format);
5701 }
5702
5703 static int events_id_cmp(const void *a, const void *b)
5704 {
5705         struct tep_event * const * ea = a;
5706         struct tep_event * const * eb = b;
5707
5708         if ((*ea)->id < (*eb)->id)
5709                 return -1;
5710
5711         if ((*ea)->id > (*eb)->id)
5712                 return 1;
5713
5714         return 0;
5715 }
5716
5717 static int events_name_cmp(const void *a, const void *b)
5718 {
5719         struct tep_event * const * ea = a;
5720         struct tep_event * const * eb = b;
5721         int res;
5722
5723         res = strcmp((*ea)->name, (*eb)->name);
5724         if (res)
5725                 return res;
5726
5727         res = strcmp((*ea)->system, (*eb)->system);
5728         if (res)
5729                 return res;
5730
5731         return events_id_cmp(a, b);
5732 }
5733
5734 static int events_system_cmp(const void *a, const void *b)
5735 {
5736         struct tep_event * const * ea = a;
5737         struct tep_event * const * eb = b;
5738         int res;
5739
5740         res = strcmp((*ea)->system, (*eb)->system);
5741         if (res)
5742                 return res;
5743
5744         res = strcmp((*ea)->name, (*eb)->name);
5745         if (res)
5746                 return res;
5747
5748         return events_id_cmp(a, b);
5749 }
5750
5751 static struct tep_event **list_events_copy(struct tep_handle *tep)
5752 {
5753         struct tep_event **events;
5754
5755         if (!tep)
5756                 return NULL;
5757
5758         events = malloc(sizeof(*events) * (tep->nr_events + 1));
5759         if (!events)
5760                 return NULL;
5761
5762         memcpy(events, tep->events, sizeof(*events) * tep->nr_events);
5763         events[tep->nr_events] = NULL;
5764         return events;
5765 }
5766
5767 static void list_events_sort(struct tep_event **events, int nr_events,
5768                              enum tep_event_sort_type sort_type)
5769 {
5770         int (*sort)(const void *a, const void *b);
5771
5772         switch (sort_type) {
5773         case TEP_EVENT_SORT_ID:
5774                 sort = events_id_cmp;
5775                 break;
5776         case TEP_EVENT_SORT_NAME:
5777                 sort = events_name_cmp;
5778                 break;
5779         case TEP_EVENT_SORT_SYSTEM:
5780                 sort = events_system_cmp;
5781                 break;
5782         default:
5783                 sort = NULL;
5784         }
5785
5786         if (sort)
5787                 qsort(events, nr_events, sizeof(*events), sort);
5788 }
5789
5790 /**
5791  * tep_list_events - Get events, sorted by given criteria.
5792  * @tep: a handle to the tep context
5793  * @sort_type: desired sort order of the events in the array
5794  *
5795  * Returns an array of pointers to all events, sorted by the given
5796  * @sort_type criteria. The last element of the array is NULL. The returned
5797  * memory must not be freed, it is managed by the library.
5798  * The function is not thread safe.
5799  */
5800 struct tep_event **tep_list_events(struct tep_handle *tep,
5801                                    enum tep_event_sort_type sort_type)
5802 {
5803         struct tep_event **events;
5804
5805         if (!tep)
5806                 return NULL;
5807
5808         events = tep->sort_events;
5809         if (events && tep->last_type == sort_type)
5810                 return events;
5811
5812         if (!events) {
5813                 events = list_events_copy(tep);
5814                 if (!events)
5815                         return NULL;
5816
5817                 tep->sort_events = events;
5818
5819                 /* the internal events are sorted by id */
5820                 if (sort_type == TEP_EVENT_SORT_ID) {
5821                         tep->last_type = sort_type;
5822                         return events;
5823                 }
5824         }
5825
5826         list_events_sort(events, tep->nr_events, sort_type);
5827         tep->last_type = sort_type;
5828
5829         return events;
5830 }
5831
5832
5833 /**
5834  * tep_list_events_copy - Thread safe version of tep_list_events()
5835  * @tep: a handle to the tep context
5836  * @sort_type: desired sort order of the events in the array
5837  *
5838  * Returns an array of pointers to all events, sorted by the given
5839  * @sort_type criteria. The last element of the array is NULL. The returned
5840  * array is newly allocated inside the function and must be freed by the caller
5841  */
5842 struct tep_event **tep_list_events_copy(struct tep_handle *tep,
5843                                         enum tep_event_sort_type sort_type)
5844 {
5845         struct tep_event **events;
5846
5847         if (!tep)
5848                 return NULL;
5849
5850         events = list_events_copy(tep);
5851         if (!events)
5852                 return NULL;
5853
5854         /* the internal events are sorted by id */
5855         if (sort_type == TEP_EVENT_SORT_ID)
5856                 return events;
5857
5858         list_events_sort(events, tep->nr_events, sort_type);
5859
5860         return events;
5861 }
5862
5863 static struct tep_format_field **
5864 get_event_fields(const char *type, const char *name,
5865                  int count, struct tep_format_field *list)
5866 {
5867         struct tep_format_field **fields;
5868         struct tep_format_field *field;
5869         int i = 0;
5870
5871         fields = malloc(sizeof(*fields) * (count + 1));
5872         if (!fields)
5873                 return NULL;
5874
5875         for (field = list; field; field = field->next) {
5876                 fields[i++] = field;
5877                 if (i == count + 1) {
5878                         do_warning("event %s has more %s fields than specified",
5879                                 name, type);
5880                         i--;
5881                         break;
5882                 }
5883         }
5884
5885         if (i != count)
5886                 do_warning("event %s has less %s fields than specified",
5887                         name, type);
5888
5889         fields[i] = NULL;
5890
5891         return fields;
5892 }
5893
5894 /**
5895  * tep_event_common_fields - return a list of common fields for an event
5896  * @event: the event to return the common fields of.
5897  *
5898  * Returns an allocated array of fields. The last item in the array is NULL.
5899  * The array must be freed with free().
5900  */
5901 struct tep_format_field **tep_event_common_fields(struct tep_event *event)
5902 {
5903         return get_event_fields("common", event->name,
5904                                 event->format.nr_common,
5905                                 event->format.common_fields);
5906 }
5907
5908 /**
5909  * tep_event_fields - return a list of event specific fields for an event
5910  * @event: the event to return the fields of.
5911  *
5912  * Returns an allocated array of fields. The last item in the array is NULL.
5913  * The array must be freed with free().
5914  */
5915 struct tep_format_field **tep_event_fields(struct tep_event *event)
5916 {
5917         return get_event_fields("event", event->name,
5918                                 event->format.nr_fields,
5919                                 event->format.fields);
5920 }
5921
5922 static void print_fields(struct trace_seq *s, struct tep_print_flag_sym *field)
5923 {
5924         trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
5925         if (field->next) {
5926                 trace_seq_puts(s, ", ");
5927                 print_fields(s, field->next);
5928         }
5929 }
5930
5931 /* for debugging */
5932 static void print_args(struct tep_print_arg *args)
5933 {
5934         int print_paren = 1;
5935         struct trace_seq s;
5936
5937         switch (args->type) {
5938         case TEP_PRINT_NULL:
5939                 printf("null");
5940                 break;
5941         case TEP_PRINT_ATOM:
5942                 printf("%s", args->atom.atom);
5943                 break;
5944         case TEP_PRINT_FIELD:
5945                 printf("REC->%s", args->field.name);
5946                 break;
5947         case TEP_PRINT_FLAGS:
5948                 printf("__print_flags(");
5949                 print_args(args->flags.field);
5950                 printf(", %s, ", args->flags.delim);
5951                 trace_seq_init(&s);
5952                 print_fields(&s, args->flags.flags);
5953                 trace_seq_do_printf(&s);
5954                 trace_seq_destroy(&s);
5955                 printf(")");
5956                 break;
5957         case TEP_PRINT_SYMBOL:
5958                 printf("__print_symbolic(");
5959                 print_args(args->symbol.field);
5960                 printf(", ");
5961                 trace_seq_init(&s);
5962                 print_fields(&s, args->symbol.symbols);
5963                 trace_seq_do_printf(&s);
5964                 trace_seq_destroy(&s);
5965                 printf(")");
5966                 break;
5967         case TEP_PRINT_HEX:
5968                 printf("__print_hex(");
5969                 print_args(args->hex.field);
5970                 printf(", ");
5971                 print_args(args->hex.size);
5972                 printf(")");
5973                 break;
5974         case TEP_PRINT_HEX_STR:
5975                 printf("__print_hex_str(");
5976                 print_args(args->hex.field);
5977                 printf(", ");
5978                 print_args(args->hex.size);
5979                 printf(")");
5980                 break;
5981         case TEP_PRINT_INT_ARRAY:
5982                 printf("__print_array(");
5983                 print_args(args->int_array.field);
5984                 printf(", ");
5985                 print_args(args->int_array.count);
5986                 printf(", ");
5987                 print_args(args->int_array.el_size);
5988                 printf(")");
5989                 break;
5990         case TEP_PRINT_STRING:
5991         case TEP_PRINT_BSTRING:
5992                 printf("__get_str(%s)", args->string.string);
5993                 break;
5994         case TEP_PRINT_BITMASK:
5995                 printf("__get_bitmask(%s)", args->bitmask.bitmask);
5996                 break;
5997         case TEP_PRINT_TYPE:
5998                 printf("(%s)", args->typecast.type);
5999                 print_args(args->typecast.item);
6000                 break;
6001         case TEP_PRINT_OP:
6002                 if (strcmp(args->op.op, ":") == 0)
6003                         print_paren = 0;
6004                 if (print_paren)
6005                         printf("(");
6006                 print_args(args->op.left);
6007                 printf(" %s ", args->op.op);
6008                 print_args(args->op.right);
6009                 if (print_paren)
6010                         printf(")");
6011                 break;
6012         default:
6013                 /* we should warn... */
6014                 return;
6015         }
6016         if (args->next) {
6017                 printf("\n");
6018                 print_args(args->next);
6019         }
6020 }
6021
6022 static void parse_header_field(const char *field,
6023                                int *offset, int *size, int mandatory)
6024 {
6025         unsigned long long save_input_buf_ptr;
6026         unsigned long long save_input_buf_siz;
6027         char *token;
6028         int type;
6029
6030         save_input_buf_ptr = input_buf_ptr;
6031         save_input_buf_siz = input_buf_siz;
6032
6033         if (read_expected(TEP_EVENT_ITEM, "field") < 0)
6034                 return;
6035         if (read_expected(TEP_EVENT_OP, ":") < 0)
6036                 return;
6037
6038         /* type */
6039         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6040                 goto fail;
6041         free_token(token);
6042
6043         /*
6044          * If this is not a mandatory field, then test it first.
6045          */
6046         if (mandatory) {
6047                 if (read_expected(TEP_EVENT_ITEM, field) < 0)
6048                         return;
6049         } else {
6050                 if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6051                         goto fail;
6052                 if (strcmp(token, field) != 0)
6053                         goto discard;
6054                 free_token(token);
6055         }
6056
6057         if (read_expected(TEP_EVENT_OP, ";") < 0)
6058                 return;
6059         if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
6060                 return;
6061         if (read_expected(TEP_EVENT_OP, ":") < 0)
6062                 return;
6063         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6064                 goto fail;
6065         *offset = atoi(token);
6066         free_token(token);
6067         if (read_expected(TEP_EVENT_OP, ";") < 0)
6068                 return;
6069         if (read_expected(TEP_EVENT_ITEM, "size") < 0)
6070                 return;
6071         if (read_expected(TEP_EVENT_OP, ":") < 0)
6072                 return;
6073         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
6074                 goto fail;
6075         *size = atoi(token);
6076         free_token(token);
6077         if (read_expected(TEP_EVENT_OP, ";") < 0)
6078                 return;
6079         type = read_token(&token);
6080         if (type != TEP_EVENT_NEWLINE) {
6081                 /* newer versions of the kernel have a "signed" type */
6082                 if (type != TEP_EVENT_ITEM)
6083                         goto fail;
6084
6085                 if (strcmp(token, "signed") != 0)
6086                         goto fail;
6087
6088                 free_token(token);
6089
6090                 if (read_expected(TEP_EVENT_OP, ":") < 0)
6091                         return;
6092
6093                 if (read_expect_type(TEP_EVENT_ITEM, &token))
6094                         goto fail;
6095
6096                 free_token(token);
6097                 if (read_expected(TEP_EVENT_OP, ";") < 0)
6098                         return;
6099
6100                 if (read_expect_type(TEP_EVENT_NEWLINE, &token))
6101                         goto fail;
6102         }
6103  fail:
6104         free_token(token);
6105         return;
6106
6107  discard:
6108         input_buf_ptr = save_input_buf_ptr;
6109         input_buf_siz = save_input_buf_siz;
6110         *offset = 0;
6111         *size = 0;
6112         free_token(token);
6113 }
6114
6115 /**
6116  * tep_parse_header_page - parse the data stored in the header page
6117  * @tep: a handle to the trace event parser context
6118  * @buf: the buffer storing the header page format string
6119  * @size: the size of @buf
6120  * @long_size: the long size to use if there is no header
6121  *
6122  * This parses the header page format for information on the
6123  * ring buffer used. The @buf should be copied from
6124  *
6125  * /sys/kernel/debug/tracing/events/header_page
6126  */
6127 int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size,
6128                           int long_size)
6129 {
6130         int ignore;
6131
6132         if (!size) {
6133                 /*
6134                  * Old kernels did not have header page info.
6135                  * Sorry but we just use what we find here in user space.
6136                  */
6137                 tep->header_page_ts_size = sizeof(long long);
6138                 tep->header_page_size_size = long_size;
6139                 tep->header_page_data_offset = sizeof(long long) + long_size;
6140                 tep->old_format = 1;
6141                 return -1;
6142         }
6143         init_input_buf(buf, size);
6144
6145         parse_header_field("timestamp", &tep->header_page_ts_offset,
6146                            &tep->header_page_ts_size, 1);
6147         parse_header_field("commit", &tep->header_page_size_offset,
6148                            &tep->header_page_size_size, 1);
6149         parse_header_field("overwrite", &tep->header_page_overwrite,
6150                            &ignore, 0);
6151         parse_header_field("data", &tep->header_page_data_offset,
6152                            &tep->header_page_data_size, 1);
6153
6154         return 0;
6155 }
6156
6157 static int event_matches(struct tep_event *event,
6158                          int id, const char *sys_name,
6159                          const char *event_name)
6160 {
6161         if (id >= 0 && id != event->id)
6162                 return 0;
6163
6164         if (event_name && (strcmp(event_name, event->name) != 0))
6165                 return 0;
6166
6167         if (sys_name && (strcmp(sys_name, event->system) != 0))
6168                 return 0;
6169
6170         return 1;
6171 }
6172
6173 static void free_handler(struct event_handler *handle)
6174 {
6175         free((void *)handle->sys_name);
6176         free((void *)handle->event_name);
6177         free(handle);
6178 }
6179
6180 static int find_event_handle(struct tep_handle *tep, struct tep_event *event)
6181 {
6182         struct event_handler *handle, **next;
6183
6184         for (next = &tep->handlers; *next;
6185              next = &(*next)->next) {
6186                 handle = *next;
6187                 if (event_matches(event, handle->id,
6188                                   handle->sys_name,
6189                                   handle->event_name))
6190                         break;
6191         }
6192
6193         if (!(*next))
6194                 return 0;
6195
6196         pr_stat("overriding event (%d) %s:%s with new print handler",
6197                 event->id, event->system, event->name);
6198
6199         event->handler = handle->func;
6200         event->context = handle->context;
6201
6202         *next = handle->next;
6203         free_handler(handle);
6204
6205         return 1;
6206 }
6207
6208 /**
6209  * __tep_parse_format - parse the event format
6210  * @buf: the buffer storing the event format string
6211  * @size: the size of @buf
6212  * @sys: the system the event belongs to
6213  *
6214  * This parses the event format and creates an event structure
6215  * to quickly parse raw data for a given event.
6216  *
6217  * These files currently come from:
6218  *
6219  * /sys/kernel/debug/tracing/events/.../.../format
6220  */
6221 enum tep_errno __tep_parse_format(struct tep_event **eventp,
6222                                   struct tep_handle *tep, const char *buf,
6223                                   unsigned long size, const char *sys)
6224 {
6225         struct tep_event *event;
6226         int ret;
6227
6228         init_input_buf(buf, size);
6229
6230         *eventp = event = alloc_event();
6231         if (!event)
6232                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6233
6234         event->name = event_read_name();
6235         if (!event->name) {
6236                 /* Bad event? */
6237                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6238                 goto event_alloc_failed;
6239         }
6240
6241         if (strcmp(sys, "ftrace") == 0) {
6242                 event->flags |= TEP_EVENT_FL_ISFTRACE;
6243
6244                 if (strcmp(event->name, "bprint") == 0)
6245                         event->flags |= TEP_EVENT_FL_ISBPRINT;
6246         }
6247
6248         event->id = event_read_id();
6249         if (event->id < 0) {
6250                 ret = TEP_ERRNO__READ_ID_FAILED;
6251                 /*
6252                  * This isn't an allocation error actually.
6253                  * But as the ID is critical, just bail out.
6254                  */
6255                 goto event_alloc_failed;
6256         }
6257
6258         event->system = strdup(sys);
6259         if (!event->system) {
6260                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6261                 goto event_alloc_failed;
6262         }
6263
6264         /* Add tep to event so that it can be referenced */
6265         event->tep = tep;
6266
6267         ret = event_read_format(event);
6268         if (ret < 0) {
6269                 ret = TEP_ERRNO__READ_FORMAT_FAILED;
6270                 goto event_parse_failed;
6271         }
6272
6273         /*
6274          * If the event has an override, don't print warnings if the event
6275          * print format fails to parse.
6276          */
6277         if (tep && find_event_handle(tep, event))
6278                 show_warning = 0;
6279
6280         ret = event_read_print(event);
6281         show_warning = 1;
6282
6283         if (ret < 0) {
6284                 ret = TEP_ERRNO__READ_PRINT_FAILED;
6285                 goto event_parse_failed;
6286         }
6287
6288         if (!ret && (event->flags & TEP_EVENT_FL_ISFTRACE)) {
6289                 struct tep_format_field *field;
6290                 struct tep_print_arg *arg, **list;
6291
6292                 /* old ftrace had no args */
6293                 list = &event->print_fmt.args;
6294                 for (field = event->format.fields; field; field = field->next) {
6295                         arg = alloc_arg();
6296                         if (!arg) {
6297                                 event->flags |= TEP_EVENT_FL_FAILED;
6298                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6299                         }
6300                         arg->type = TEP_PRINT_FIELD;
6301                         arg->field.name = strdup(field->name);
6302                         if (!arg->field.name) {
6303                                 event->flags |= TEP_EVENT_FL_FAILED;
6304                                 free_arg(arg);
6305                                 return TEP_ERRNO__OLD_FTRACE_ARG_FAILED;
6306                         }
6307                         arg->field.field = field;
6308                         *list = arg;
6309                         list = &arg->next;
6310                 }
6311                 return 0;
6312         }
6313
6314         return 0;
6315
6316  event_parse_failed:
6317         event->flags |= TEP_EVENT_FL_FAILED;
6318         return ret;
6319
6320  event_alloc_failed:
6321         free(event->system);
6322         free(event->name);
6323         free(event);
6324         *eventp = NULL;
6325         return ret;
6326 }
6327
6328 static enum tep_errno
6329 __parse_event(struct tep_handle *tep,
6330               struct tep_event **eventp,
6331               const char *buf, unsigned long size,
6332               const char *sys)
6333 {
6334         int ret = __tep_parse_format(eventp, tep, buf, size, sys);
6335         struct tep_event *event = *eventp;
6336
6337         if (event == NULL)
6338                 return ret;
6339
6340         if (tep && add_event(tep, event)) {
6341                 ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6342                 goto event_add_failed;
6343         }
6344
6345 #define PRINT_ARGS 0
6346         if (PRINT_ARGS && event->print_fmt.args)
6347                 print_args(event->print_fmt.args);
6348
6349         return 0;
6350
6351 event_add_failed:
6352         tep_free_event(event);
6353         return ret;
6354 }
6355
6356 /**
6357  * tep_parse_format - parse the event format
6358  * @tep: a handle to the trace event parser context
6359  * @eventp: returned format
6360  * @buf: the buffer storing the event format string
6361  * @size: the size of @buf
6362  * @sys: the system the event belongs to
6363  *
6364  * This parses the event format and creates an event structure
6365  * to quickly parse raw data for a given event.
6366  *
6367  * These files currently come from:
6368  *
6369  * /sys/kernel/debug/tracing/events/.../.../format
6370  */
6371 enum tep_errno tep_parse_format(struct tep_handle *tep,
6372                                 struct tep_event **eventp,
6373                                 const char *buf,
6374                                 unsigned long size, const char *sys)
6375 {
6376         return __parse_event(tep, eventp, buf, size, sys);
6377 }
6378
6379 /**
6380  * tep_parse_event - parse the event format
6381  * @tep: a handle to the trace event parser context
6382  * @buf: the buffer storing the event format string
6383  * @size: the size of @buf
6384  * @sys: the system the event belongs to
6385  *
6386  * This parses the event format and creates an event structure
6387  * to quickly parse raw data for a given event.
6388  *
6389  * These files currently come from:
6390  *
6391  * /sys/kernel/debug/tracing/events/.../.../format
6392  */
6393 enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf,
6394                                unsigned long size, const char *sys)
6395 {
6396         struct tep_event *event = NULL;
6397         return __parse_event(tep, &event, buf, size, sys);
6398 }
6399
6400 int get_field_val(struct trace_seq *s, struct tep_format_field *field,
6401                   const char *name, struct tep_record *record,
6402                   unsigned long long *val, int err)
6403 {
6404         if (!field) {
6405                 if (err)
6406                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6407                 return -1;
6408         }
6409
6410         if (tep_read_number_field(field, record->data, val)) {
6411                 if (err)
6412                         trace_seq_printf(s, " %s=INVALID", name);
6413                 return -1;
6414         }
6415
6416         return 0;
6417 }
6418
6419 /**
6420  * tep_get_field_raw - return the raw pointer into the data field
6421  * @s: The seq to print to on error
6422  * @event: the event that the field is for
6423  * @name: The name of the field
6424  * @record: The record with the field name.
6425  * @len: place to store the field length.
6426  * @err: print default error if failed.
6427  *
6428  * Returns a pointer into record->data of the field and places
6429  * the length of the field in @len.
6430  *
6431  * On failure, it returns NULL.
6432  */
6433 void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event,
6434                         const char *name, struct tep_record *record,
6435                         int *len, int err)
6436 {
6437         struct tep_format_field *field;
6438         void *data = record->data;
6439         unsigned offset;
6440         int dummy;
6441
6442         if (!event)
6443                 return NULL;
6444
6445         field = tep_find_field(event, name);
6446
6447         if (!field) {
6448                 if (err)
6449                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6450                 return NULL;
6451         }
6452
6453         /* Allow @len to be NULL */
6454         if (!len)
6455                 len = &dummy;
6456
6457         offset = field->offset;
6458         if (field->flags & TEP_FIELD_IS_DYNAMIC) {
6459                 offset = tep_read_number(event->tep,
6460                                          data + offset, field->size);
6461                 *len = offset >> 16;
6462                 offset &= 0xffff;
6463         } else
6464                 *len = field->size;
6465
6466         return data + offset;
6467 }
6468
6469 /**
6470  * tep_get_field_val - find a field and return its value
6471  * @s: The seq to print to on error
6472  * @event: the event that the field is for
6473  * @name: The name of the field
6474  * @record: The record with the field name.
6475  * @val: place to store the value of the field.
6476  * @err: print default error if failed.
6477  *
6478  * Returns 0 on success -1 on field not found.
6479  */
6480 int tep_get_field_val(struct trace_seq *s, struct tep_event *event,
6481                       const char *name, struct tep_record *record,
6482                       unsigned long long *val, int err)
6483 {
6484         struct tep_format_field *field;
6485
6486         if (!event)
6487                 return -1;
6488
6489         field = tep_find_field(event, name);
6490
6491         return get_field_val(s, field, name, record, val, err);
6492 }
6493
6494 /**
6495  * tep_get_common_field_val - find a common field and return its value
6496  * @s: The seq to print to on error
6497  * @event: the event that the field is for
6498  * @name: The name of the field
6499  * @record: The record with the field name.
6500  * @val: place to store the value of the field.
6501  * @err: print default error if failed.
6502  *
6503  * Returns 0 on success -1 on field not found.
6504  */
6505 int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event,
6506                              const char *name, struct tep_record *record,
6507                              unsigned long long *val, int err)
6508 {
6509         struct tep_format_field *field;
6510
6511         if (!event)
6512                 return -1;
6513
6514         field = tep_find_common_field(event, name);
6515
6516         return get_field_val(s, field, name, record, val, err);
6517 }
6518
6519 /**
6520  * tep_get_any_field_val - find a any field and return its value
6521  * @s: The seq to print to on error
6522  * @event: the event that the field is for
6523  * @name: The name of the field
6524  * @record: The record with the field name.
6525  * @val: place to store the value of the field.
6526  * @err: print default error if failed.
6527  *
6528  * Returns 0 on success -1 on field not found.
6529  */
6530 int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event,
6531                           const char *name, struct tep_record *record,
6532                           unsigned long long *val, int err)
6533 {
6534         struct tep_format_field *field;
6535
6536         if (!event)
6537                 return -1;
6538
6539         field = tep_find_any_field(event, name);
6540
6541         return get_field_val(s, field, name, record, val, err);
6542 }
6543
6544 /**
6545  * tep_print_num_field - print a field and a format
6546  * @s: The seq to print to
6547  * @fmt: The printf format to print the field with.
6548  * @event: the event that the field is for
6549  * @name: The name of the field
6550  * @record: The record with the field name.
6551  * @err: print default error if failed.
6552  *
6553  * Returns positive value on success, negative in case of an error,
6554  * or 0 if buffer is full.
6555  */
6556 int tep_print_num_field(struct trace_seq *s, const char *fmt,
6557                         struct tep_event *event, const char *name,
6558                         struct tep_record *record, int err)
6559 {
6560         struct tep_format_field *field = tep_find_field(event, name);
6561         unsigned long long val;
6562
6563         if (!field)
6564                 goto failed;
6565
6566         if (tep_read_number_field(field, record->data, &val))
6567                 goto failed;
6568
6569         return trace_seq_printf(s, fmt, val);
6570
6571  failed:
6572         if (err)
6573                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6574         return -1;
6575 }
6576
6577 /**
6578  * tep_print_func_field - print a field and a format for function pointers
6579  * @s: The seq to print to
6580  * @fmt: The printf format to print the field with.
6581  * @event: the event that the field is for
6582  * @name: The name of the field
6583  * @record: The record with the field name.
6584  * @err: print default error if failed.
6585  *
6586  * Returns positive value on success, negative in case of an error,
6587  * or 0 if buffer is full.
6588  */
6589 int tep_print_func_field(struct trace_seq *s, const char *fmt,
6590                          struct tep_event *event, const char *name,
6591                          struct tep_record *record, int err)
6592 {
6593         struct tep_format_field *field = tep_find_field(event, name);
6594         struct tep_handle *tep = event->tep;
6595         unsigned long long val;
6596         struct func_map *func;
6597         char tmp[128];
6598
6599         if (!field)
6600                 goto failed;
6601
6602         if (tep_read_number_field(field, record->data, &val))
6603                 goto failed;
6604
6605         func = find_func(tep, val);
6606
6607         if (func)
6608                 snprintf(tmp, 128, "%s/0x%llx", func->func, func->addr - val);
6609         else
6610                 sprintf(tmp, "0x%08llx", val);
6611
6612         return trace_seq_printf(s, fmt, tmp);
6613
6614  failed:
6615         if (err)
6616                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6617         return -1;
6618 }
6619
6620 static void free_func_handle(struct tep_function_handler *func)
6621 {
6622         struct func_params *params;
6623
6624         free(func->name);
6625
6626         while (func->params) {
6627                 params = func->params;
6628                 func->params = params->next;
6629                 free(params);
6630         }
6631
6632         free(func);
6633 }
6634
6635 /**
6636  * tep_register_print_function - register a helper function
6637  * @tep: a handle to the trace event parser context
6638  * @func: the function to process the helper function
6639  * @ret_type: the return type of the helper function
6640  * @name: the name of the helper function
6641  * @parameters: A list of enum tep_func_arg_type
6642  *
6643  * Some events may have helper functions in the print format arguments.
6644  * This allows a plugin to dynamically create a way to process one
6645  * of these functions.
6646  *
6647  * The @parameters is a variable list of tep_func_arg_type enums that
6648  * must end with TEP_FUNC_ARG_VOID.
6649  */
6650 int tep_register_print_function(struct tep_handle *tep,
6651                                 tep_func_handler func,
6652                                 enum tep_func_arg_type ret_type,
6653                                 char *name, ...)
6654 {
6655         struct tep_function_handler *func_handle;
6656         struct func_params **next_param;
6657         struct func_params *param;
6658         enum tep_func_arg_type type;
6659         va_list ap;
6660         int ret;
6661
6662         func_handle = find_func_handler(tep, name);
6663         if (func_handle) {
6664                 /*
6665                  * This is most like caused by the users own
6666                  * plugins updating the function. This overrides the
6667                  * system defaults.
6668                  */
6669                 pr_stat("override of function helper '%s'", name);
6670                 remove_func_handler(tep, name);
6671         }
6672
6673         func_handle = calloc(1, sizeof(*func_handle));
6674         if (!func_handle) {
6675                 do_warning("Failed to allocate function handler");
6676                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6677         }
6678
6679         func_handle->ret_type = ret_type;
6680         func_handle->name = strdup(name);
6681         func_handle->func = func;
6682         if (!func_handle->name) {
6683                 do_warning("Failed to allocate function name");
6684                 free(func_handle);
6685                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6686         }
6687
6688         next_param = &(func_handle->params);
6689         va_start(ap, name);
6690         for (;;) {
6691                 type = va_arg(ap, enum tep_func_arg_type);
6692                 if (type == TEP_FUNC_ARG_VOID)
6693                         break;
6694
6695                 if (type >= TEP_FUNC_ARG_MAX_TYPES) {
6696                         do_warning("Invalid argument type %d", type);
6697                         ret = TEP_ERRNO__INVALID_ARG_TYPE;
6698                         goto out_free;
6699                 }
6700
6701                 param = malloc(sizeof(*param));
6702                 if (!param) {
6703                         do_warning("Failed to allocate function param");
6704                         ret = TEP_ERRNO__MEM_ALLOC_FAILED;
6705                         goto out_free;
6706                 }
6707                 param->type = type;
6708                 param->next = NULL;
6709
6710                 *next_param = param;
6711                 next_param = &(param->next);
6712
6713                 func_handle->nr_args++;
6714         }
6715         va_end(ap);
6716
6717         func_handle->next = tep->func_handlers;
6718         tep->func_handlers = func_handle;
6719
6720         return 0;
6721  out_free:
6722         va_end(ap);
6723         free_func_handle(func_handle);
6724         return ret;
6725 }
6726
6727 /**
6728  * tep_unregister_print_function - unregister a helper function
6729  * @tep: a handle to the trace event parser context
6730  * @func: the function to process the helper function
6731  * @name: the name of the helper function
6732  *
6733  * This function removes existing print handler for function @name.
6734  *
6735  * Returns 0 if the handler was removed successully, -1 otherwise.
6736  */
6737 int tep_unregister_print_function(struct tep_handle *tep,
6738                                   tep_func_handler func, char *name)
6739 {
6740         struct tep_function_handler *func_handle;
6741
6742         func_handle = find_func_handler(tep, name);
6743         if (func_handle && func_handle->func == func) {
6744                 remove_func_handler(tep, name);
6745                 return 0;
6746         }
6747         return -1;
6748 }
6749
6750 static struct tep_event *search_event(struct tep_handle *tep, int id,
6751                                       const char *sys_name,
6752                                       const char *event_name)
6753 {
6754         struct tep_event *event;
6755
6756         if (id >= 0) {
6757                 /* search by id */
6758                 event = tep_find_event(tep, id);
6759                 if (!event)
6760                         return NULL;
6761                 if (event_name && (strcmp(event_name, event->name) != 0))
6762                         return NULL;
6763                 if (sys_name && (strcmp(sys_name, event->system) != 0))
6764                         return NULL;
6765         } else {
6766                 event = tep_find_event_by_name(tep, sys_name, event_name);
6767                 if (!event)
6768                         return NULL;
6769         }
6770         return event;
6771 }
6772
6773 /**
6774  * tep_register_event_handler - register a way to parse an event
6775  * @tep: a handle to the trace event parser context
6776  * @id: the id of the event to register
6777  * @sys_name: the system name the event belongs to
6778  * @event_name: the name of the event
6779  * @func: the function to call to parse the event information
6780  * @context: the data to be passed to @func
6781  *
6782  * This function allows a developer to override the parsing of
6783  * a given event. If for some reason the default print format
6784  * is not sufficient, this function will register a function
6785  * for an event to be used to parse the data instead.
6786  *
6787  * If @id is >= 0, then it is used to find the event.
6788  * else @sys_name and @event_name are used.
6789  *
6790  * Returns:
6791  *  TEP_REGISTER_SUCCESS_OVERWRITE if an existing handler is overwritten
6792  *  TEP_REGISTER_SUCCESS if a new handler is registered successfully
6793  *  negative TEP_ERRNO_... in case of an error
6794  *
6795  */
6796 int tep_register_event_handler(struct tep_handle *tep, int id,
6797                                const char *sys_name, const char *event_name,
6798                                tep_event_handler_func func, void *context)
6799 {
6800         struct tep_event *event;
6801         struct event_handler *handle;
6802
6803         event = search_event(tep, id, sys_name, event_name);
6804         if (event == NULL)
6805                 goto not_found;
6806
6807         pr_stat("overriding event (%d) %s:%s with new print handler",
6808                 event->id, event->system, event->name);
6809
6810         event->handler = func;
6811         event->context = context;
6812         return TEP_REGISTER_SUCCESS_OVERWRITE;
6813
6814  not_found:
6815         /* Save for later use. */
6816         handle = calloc(1, sizeof(*handle));
6817         if (!handle) {
6818                 do_warning("Failed to allocate event handler");
6819                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6820         }
6821
6822         handle->id = id;
6823         if (event_name)
6824                 handle->event_name = strdup(event_name);
6825         if (sys_name)
6826                 handle->sys_name = strdup(sys_name);
6827
6828         if ((event_name && !handle->event_name) ||
6829             (sys_name && !handle->sys_name)) {
6830                 do_warning("Failed to allocate event/sys name");
6831                 free((void *)handle->event_name);
6832                 free((void *)handle->sys_name);
6833                 free(handle);
6834                 return TEP_ERRNO__MEM_ALLOC_FAILED;
6835         }
6836
6837         handle->func = func;
6838         handle->next = tep->handlers;
6839         tep->handlers = handle;
6840         handle->context = context;
6841
6842         return TEP_REGISTER_SUCCESS;
6843 }
6844
6845 static int handle_matches(struct event_handler *handler, int id,
6846                           const char *sys_name, const char *event_name,
6847                           tep_event_handler_func func, void *context)
6848 {
6849         if (id >= 0 && id != handler->id)
6850                 return 0;
6851
6852         if (event_name && (strcmp(event_name, handler->event_name) != 0))
6853                 return 0;
6854
6855         if (sys_name && (strcmp(sys_name, handler->sys_name) != 0))
6856                 return 0;
6857
6858         if (func != handler->func || context != handler->context)
6859                 return 0;
6860
6861         return 1;
6862 }
6863
6864 /**
6865  * tep_unregister_event_handler - unregister an existing event handler
6866  * @tep: a handle to the trace event parser context
6867  * @id: the id of the event to unregister
6868  * @sys_name: the system name the handler belongs to
6869  * @event_name: the name of the event handler
6870  * @func: the function to call to parse the event information
6871  * @context: the data to be passed to @func
6872  *
6873  * This function removes existing event handler (parser).
6874  *
6875  * If @id is >= 0, then it is used to find the event.
6876  * else @sys_name and @event_name are used.
6877  *
6878  * Returns 0 if handler was removed successfully, -1 if event was not found.
6879  */
6880 int tep_unregister_event_handler(struct tep_handle *tep, int id,
6881                                  const char *sys_name, const char *event_name,
6882                                  tep_event_handler_func func, void *context)
6883 {
6884         struct tep_event *event;
6885         struct event_handler *handle;
6886         struct event_handler **next;
6887
6888         event = search_event(tep, id, sys_name, event_name);
6889         if (event == NULL)
6890                 goto not_found;
6891
6892         if (event->handler == func && event->context == context) {
6893                 pr_stat("removing override handler for event (%d) %s:%s. Going back to default handler.",
6894                         event->id, event->system, event->name);
6895
6896                 event->handler = NULL;
6897                 event->context = NULL;
6898                 return 0;
6899         }
6900
6901 not_found:
6902         for (next = &tep->handlers; *next; next = &(*next)->next) {
6903                 handle = *next;
6904                 if (handle_matches(handle, id, sys_name, event_name,
6905                                    func, context))
6906                         break;
6907         }
6908
6909         if (!(*next))
6910                 return -1;
6911
6912         *next = handle->next;
6913         free_handler(handle);
6914
6915         return 0;
6916 }
6917
6918 /**
6919  * tep_alloc - create a tep handle
6920  */
6921 struct tep_handle *tep_alloc(void)
6922 {
6923         struct tep_handle *tep = calloc(1, sizeof(*tep));
6924
6925         if (tep) {
6926                 tep->ref_count = 1;
6927                 tep->host_bigendian = tep_is_bigendian();
6928         }
6929
6930         return tep;
6931 }
6932
6933 void tep_ref(struct tep_handle *tep)
6934 {
6935         tep->ref_count++;
6936 }
6937
6938 int tep_get_ref(struct tep_handle *tep)
6939 {
6940         if (tep)
6941                 return tep->ref_count;
6942         return 0;
6943 }
6944
6945 void tep_free_format_field(struct tep_format_field *field)
6946 {
6947         free(field->type);
6948         if (field->alias != field->name)
6949                 free(field->alias);
6950         free(field->name);
6951         free(field);
6952 }
6953
6954 static void free_format_fields(struct tep_format_field *field)
6955 {
6956         struct tep_format_field *next;
6957
6958         while (field) {
6959                 next = field->next;
6960                 tep_free_format_field(field);
6961                 field = next;
6962         }
6963 }
6964
6965 static void free_formats(struct tep_format *format)
6966 {
6967         free_format_fields(format->common_fields);
6968         free_format_fields(format->fields);
6969 }
6970
6971 void tep_free_event(struct tep_event *event)
6972 {
6973         free(event->name);
6974         free(event->system);
6975
6976         free_formats(&event->format);
6977
6978         free(event->print_fmt.format);
6979         free_args(event->print_fmt.args);
6980
6981         free(event);
6982 }
6983
6984 /**
6985  * tep_free - free a tep handle
6986  * @tep: the tep handle to free
6987  */
6988 void tep_free(struct tep_handle *tep)
6989 {
6990         struct cmdline_list *cmdlist, *cmdnext;
6991         struct func_list *funclist, *funcnext;
6992         struct printk_list *printklist, *printknext;
6993         struct tep_function_handler *func_handler;
6994         struct event_handler *handle;
6995         int i;
6996
6997         if (!tep)
6998                 return;
6999
7000         cmdlist = tep->cmdlist;
7001         funclist = tep->funclist;
7002         printklist = tep->printklist;
7003
7004         tep->ref_count--;
7005         if (tep->ref_count)
7006                 return;
7007
7008         if (tep->cmdlines) {
7009                 for (i = 0; i < tep->cmdline_count; i++)
7010                         free(tep->cmdlines[i].comm);
7011                 free(tep->cmdlines);
7012         }
7013
7014         while (cmdlist) {
7015                 cmdnext = cmdlist->next;
7016                 free(cmdlist->comm);
7017                 free(cmdlist);
7018                 cmdlist = cmdnext;
7019         }
7020
7021         if (tep->func_map) {
7022                 for (i = 0; i < (int)tep->func_count; i++) {
7023                         free(tep->func_map[i].func);
7024                         free(tep->func_map[i].mod);
7025                 }
7026                 free(tep->func_map);
7027         }
7028
7029         while (funclist) {
7030                 funcnext = funclist->next;
7031                 free(funclist->func);
7032                 free(funclist->mod);
7033                 free(funclist);
7034                 funclist = funcnext;
7035         }
7036
7037         while (tep->func_handlers) {
7038                 func_handler = tep->func_handlers;
7039                 tep->func_handlers = func_handler->next;
7040                 free_func_handle(func_handler);
7041         }
7042
7043         if (tep->printk_map) {
7044                 for (i = 0; i < (int)tep->printk_count; i++)
7045                         free(tep->printk_map[i].printk);
7046                 free(tep->printk_map);
7047         }
7048
7049         while (printklist) {
7050                 printknext = printklist->next;
7051                 free(printklist->printk);
7052                 free(printklist);
7053                 printklist = printknext;
7054         }
7055
7056         for (i = 0; i < tep->nr_events; i++)
7057                 tep_free_event(tep->events[i]);
7058
7059         while (tep->handlers) {
7060                 handle = tep->handlers;
7061                 tep->handlers = handle->next;
7062                 free_handler(handle);
7063         }
7064
7065         free(tep->events);
7066         free(tep->sort_events);
7067         free(tep->func_resolver);
7068
7069         free(tep);
7070 }
7071
7072 void tep_unref(struct tep_handle *tep)
7073 {
7074         tep_free(tep);
7075 }