tools/lib/traceevent/event-parse.c

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