tools/lib/traceevent/event-parse.c

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