tools/lib/traceevent/event-parse.c

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