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
 269         cmdlines[pevent->cmdline_count].comm = strdup(comm);
 270         if (!cmdlines[pevent->cmdline_count].comm) {
 271                 free(cmdlines);
 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         pevent->cmdlines = cmdlines;
 283
 284         return 0;
 285 }
 286
 287 /**
 288  * pevent_register_comm - register a pid / comm mapping
 289  * @pevent: handle for the pevent
 290  * @comm: the command line to register
 291  * @pid: the pid to map the command line to
 292  *
 293  * This adds a mapping to search for command line names with
 294  * a given pid. The comm is duplicated.
 295  */
 296 int pevent_register_comm(struct pevent *pevent, const char *comm, int pid)
 297 {
 298         struct cmdline_list *item;
 299
 300         if (pevent->cmdlines)
 301                 return add_new_comm(pevent, comm, pid);
 302
 303         item = malloc(sizeof(*item));
 304         if (!item)
 305                 return -1;
 306
 307         if (comm)
 308                 item->comm = strdup(comm);
 309         else
 310                 item->comm = strdup("<...>");
 311         if (!item->comm) {
 312                 free(item);
 313                 return -1;
 314         }
 315         item->pid = pid;
 316         item->next = pevent->cmdlist;
 317
 318         pevent->cmdlist = item;
 319         pevent->cmdline_count++;
 320
 321         return 0;
 322 }
 323
 324 int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock)
 325 {
 326         pevent->trace_clock = strdup(trace_clock);
 327         if (!pevent->trace_clock) {
 328                 errno = ENOMEM;
 329                 return -1;
 330         }
 331         return 0;
 332 }
 333
 334 struct func_map {
 335         unsigned long long              addr;
 336         char                            *func;
 337         char                            *mod;
 338 };
 339
 340 struct func_list {
 341         struct func_list        *next;
 342         unsigned long long      addr;
 343         char                    *func;
 344         char                    *mod;
 345 };
 346
 347 static int func_cmp(const void *a, const void *b)
 348 {
 349         const struct func_map *fa = a;
 350         const struct func_map *fb = b;
 351
 352         if (fa->addr < fb->addr)
 353                 return -1;
 354         if (fa->addr > fb->addr)
 355                 return 1;
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * We are searching for a record in between, not an exact
 362  * match.
 363  */
 364 static int func_bcmp(const void *a, const void *b)
 365 {
 366         const struct func_map *fa = a;
 367         const struct func_map *fb = b;
 368
 369         if ((fa->addr == fb->addr) ||
 370
 371             (fa->addr > fb->addr &&
 372              fa->addr < (fb+1)->addr))
 373                 return 0;
 374
 375         if (fa->addr < fb->addr)
 376                 return -1;
 377
 378         return 1;
 379 }
 380
 381 static int func_map_init(struct pevent *pevent)
 382 {
 383         struct func_list *funclist;
 384         struct func_list *item;
 385         struct func_map *func_map;
 386         int i;
 387
 388         func_map = malloc(sizeof(*func_map) * (pevent->func_count + 1));
 389         if (!func_map)
 390                 return -1;
 391
 392         funclist = pevent->funclist;
 393
 394         i = 0;
 395         while (funclist) {
 396                 func_map[i].func = funclist->func;
 397                 func_map[i].addr = funclist->addr;
 398                 func_map[i].mod = funclist->mod;
 399                 i++;
 400                 item = funclist;
 401                 funclist = funclist->next;
 402                 free(item);
 403         }
 404
 405         qsort(func_map, pevent->func_count, sizeof(*func_map), func_cmp);
 406
 407         /*
 408          * Add a special record at the end.
 409          */
 410         func_map[pevent->func_count].func = NULL;
 411         func_map[pevent->func_count].addr = 0;
 412         func_map[pevent->func_count].mod = NULL;
 413
 414         pevent->func_map = func_map;
 415         pevent->funclist = NULL;
 416
 417         return 0;
 418 }
 419
 420 static struct func_map *
 421 __find_func(struct pevent *pevent, unsigned long long addr)
 422 {
 423         struct func_map *func;
 424         struct func_map key;
 425
 426         if (!pevent->func_map)
 427                 func_map_init(pevent);
 428
 429         key.addr = addr;
 430
 431         func = bsearch(&key, pevent->func_map, pevent->func_count,
 432                        sizeof(*pevent->func_map), func_bcmp);
 433
 434         return func;
 435 }
 436
 437 struct func_resolver {
 438         pevent_func_resolver_t *func;
 439         void                   *priv;
 440         struct func_map        map;
 441 };
 442
 443 /**
 444  * pevent_set_function_resolver - set an alternative function resolver
 445  * @pevent: handle for the pevent
 446  * @resolver: function to be used
 447  * @priv: resolver function private state.
 448  *
 449  * Some tools may have already a way to resolve kernel functions, allow them to
 450  * keep using it instead of duplicating all the entries inside
 451  * pevent->funclist.
 452  */
 453 int pevent_set_function_resolver(struct pevent *pevent,
 454                                  pevent_func_resolver_t *func, void *priv)
 455 {
 456         struct func_resolver *resolver = malloc(sizeof(*resolver));
 457
 458         if (resolver == NULL)
 459                 return -1;
 460
 461         resolver->func = func;
 462         resolver->priv = priv;
 463
 464         free(pevent->func_resolver);
 465         pevent->func_resolver = resolver;
 466
 467         return 0;
 468 }
 469
 470 /**
 471  * pevent_reset_function_resolver - reset alternative function resolver
 472  * @pevent: handle for the pevent
 473  *
 474  * Stop using whatever alternative resolver was set, use the default
 475  * one instead.
 476  */
 477 void pevent_reset_function_resolver(struct pevent *pevent)
 478 {
 479         free(pevent->func_resolver);
 480         pevent->func_resolver = NULL;
 481 }
 482
 483 static struct func_map *
 484 find_func(struct pevent *pevent, unsigned long long addr)
 485 {
 486         struct func_map *map;
 487
 488         if (!pevent->func_resolver)
 489                 return __find_func(pevent, addr);
 490
 491         map = &pevent->func_resolver->map;
 492         map->mod  = NULL;
 493         map->addr = addr;
 494         map->func = pevent->func_resolver->func(pevent->func_resolver->priv,
 495                                                 &map->addr, &map->mod);
 496         if (map->func == NULL)
 497                 return NULL;
 498
 499         return map;
 500 }
 501
 502 /**
 503  * pevent_find_function - find a function by a given address
 504  * @pevent: handle for the pevent
 505  * @addr: the address to find the function with
 506  *
 507  * Returns a pointer to the function stored that has the given
 508  * address. Note, the address does not have to be exact, it
 509  * will select the function that would contain the address.
 510  */
 511 const char *pevent_find_function(struct pevent *pevent, unsigned long long addr)
 512 {
 513         struct func_map *map;
 514
 515         map = find_func(pevent, addr);
 516         if (!map)
 517                 return NULL;
 518
 519         return map->func;
 520 }
 521
 522 /**
 523  * pevent_find_function_address - find a function address by a given address
 524  * @pevent: handle for the pevent
 525  * @addr: the address to find the function with
 526  *
 527  * Returns the address the function starts at. This can be used in
 528  * conjunction with pevent_find_function to print both the function
 529  * name and the function offset.
 530  */
 531 unsigned long long
 532 pevent_find_function_address(struct pevent *pevent, unsigned long long addr)
 533 {
 534         struct func_map *map;
 535
 536         map = find_func(pevent, addr);
 537         if (!map)
 538                 return 0;
 539
 540         return map->addr;
 541 }
 542
 543 /**
 544  * pevent_register_function - register a function with a given address
 545  * @pevent: handle for the pevent
 546  * @function: the function name to register
 547  * @addr: the address the function starts at
 548  * @mod: the kernel module the function may be in (NULL for none)
 549  *
 550  * This registers a function name with an address and module.
 551  * The @func passed in is duplicated.
 552  */
 553 int pevent_register_function(struct pevent *pevent, char *func,
 554                              unsigned long long addr, char *mod)
 555 {
 556         struct func_list *item = malloc(sizeof(*item));
 557
 558         if (!item)
 559                 return -1;
 560
 561         item->next = pevent->funclist;
 562         item->func = strdup(func);
 563         if (!item->func)
 564                 goto out_free;
 565
 566         if (mod) {
 567                 item->mod = strdup(mod);
 568                 if (!item->mod)
 569                         goto out_free_func;
 570         } else
 571                 item->mod = NULL;
 572         item->addr = addr;
 573
 574         pevent->funclist = item;
 575         pevent->func_count++;
 576
 577         return 0;
 578
 579 out_free_func:
 580         free(item->func);
 581         item->func = NULL;
 582 out_free:
 583         free(item);
 584         errno = ENOMEM;
 585         return -1;
 586 }
 587
 588 /**
 589  * pevent_print_funcs - print out the stored functions
 590  * @pevent: handle for the pevent
 591  *
 592  * This prints out the stored functions.
 593  */
 594 void pevent_print_funcs(struct pevent *pevent)
 595 {
 596         int i;
 597
 598         if (!pevent->func_map)
 599                 func_map_init(pevent);
 600
 601         for (i = 0; i < (int)pevent->func_count; i++) {
 602                 printf("%016llx %s",
 603                        pevent->func_map[i].addr,
 604                        pevent->func_map[i].func);
 605                 if (pevent->func_map[i].mod)
 606                         printf(" [%s]\n", pevent->func_map[i].mod);
 607                 else
 608                         printf("\n");
 609         }
 610 }
 611
 612 struct printk_map {
 613         unsigned long long              addr;
 614         char                            *printk;
 615 };
 616
 617 struct printk_list {
 618         struct printk_list      *next;
 619         unsigned long long      addr;
 620         char                    *printk;
 621 };
 622
 623 static int printk_cmp(const void *a, const void *b)
 624 {
 625         const struct printk_map *pa = a;
 626         const struct printk_map *pb = b;
 627
 628         if (pa->addr < pb->addr)
 629                 return -1;
 630         if (pa->addr > pb->addr)
 631                 return 1;
 632
 633         return 0;
 634 }
 635
 636 static int printk_map_init(struct pevent *pevent)
 637 {
 638         struct printk_list *printklist;
 639         struct printk_list *item;
 640         struct printk_map *printk_map;
 641         int i;
 642
 643         printk_map = malloc(sizeof(*printk_map) * (pevent->printk_count + 1));
 644         if (!printk_map)
 645                 return -1;
 646
 647         printklist = pevent->printklist;
 648
 649         i = 0;
 650         while (printklist) {
 651                 printk_map[i].printk = printklist->printk;
 652                 printk_map[i].addr = printklist->addr;
 653                 i++;
 654                 item = printklist;
 655                 printklist = printklist->next;
 656                 free(item);
 657         }
 658
 659         qsort(printk_map, pevent->printk_count, sizeof(*printk_map), printk_cmp);
 660
 661         pevent->printk_map = printk_map;
 662         pevent->printklist = NULL;
 663
 664         return 0;
 665 }
 666
 667 static struct printk_map *
 668 find_printk(struct pevent *pevent, unsigned long long addr)
 669 {
 670         struct printk_map *printk;
 671         struct printk_map key;
 672
 673         if (!pevent->printk_map && printk_map_init(pevent))
 674                 return NULL;
 675
 676         key.addr = addr;
 677
 678         printk = bsearch(&key, pevent->printk_map, pevent->printk_count,
 679                          sizeof(*pevent->printk_map), printk_cmp);
 680
 681         return printk;
 682 }
 683
 684 /**
 685  * pevent_register_print_string - register a string by its address
 686  * @pevent: handle for the pevent
 687  * @fmt: the string format to register
 688  * @addr: the address the string was located at
 689  *
 690  * This registers a string by the address it was stored in the kernel.
 691  * The @fmt passed in is duplicated.
 692  */
 693 int pevent_register_print_string(struct pevent *pevent, const char *fmt,
 694                                  unsigned long long addr)
 695 {
 696         struct printk_list *item = malloc(sizeof(*item));
 697         char *p;
 698
 699         if (!item)
 700                 return -1;
 701
 702         item->next = pevent->printklist;
 703         item->addr = addr;
 704
 705         /* Strip off quotes and '\n' from the end */
 706         if (fmt[0] == '"')
 707                 fmt++;
 708         item->printk = strdup(fmt);
 709         if (!item->printk)
 710                 goto out_free;
 711
 712         p = item->printk + strlen(item->printk) - 1;
 713         if (*p == '"')
 714                 *p = 0;
 715
 716         p -= 2;
 717         if (strcmp(p, "\\n") == 0)
 718                 *p = 0;
 719
 720         pevent->printklist = item;
 721         pevent->printk_count++;
 722
 723         return 0;
 724
 725 out_free:
 726         free(item);
 727         errno = ENOMEM;
 728         return -1;
 729 }
 730
 731 /**
 732  * pevent_print_printk - print out the stored strings
 733  * @pevent: handle for the pevent
 734  *
 735  * This prints the string formats that were stored.
 736  */
 737 void pevent_print_printk(struct pevent *pevent)
 738 {
 739         int i;
 740
 741         if (!pevent->printk_map)
 742                 printk_map_init(pevent);
 743
 744         for (i = 0; i < (int)pevent->printk_count; i++) {
 745                 printf("%016llx %s\n",
 746                        pevent->printk_map[i].addr,
 747                        pevent->printk_map[i].printk);
 748         }
 749 }
 750
 751 static struct event_format *alloc_event(void)
 752 {
 753         return calloc(1, sizeof(struct event_format));
 754 }
 755
 756 static int add_event(struct pevent *pevent, struct event_format *event)
 757 {
 758         int i;
 759         struct event_format **events = realloc(pevent->events, sizeof(event) *
 760                                                (pevent->nr_events + 1));
 761         if (!events)
 762                 return -1;
 763
 764         pevent->events = events;
 765
 766         for (i = 0; i < pevent->nr_events; i++) {
 767                 if (pevent->events[i]->id > event->id)
 768                         break;
 769         }
 770         if (i < pevent->nr_events)
 771                 memmove(&pevent->events[i + 1],
 772                         &pevent->events[i],
 773                         sizeof(event) * (pevent->nr_events - i));
 774
 775         pevent->events[i] = event;
 776         pevent->nr_events++;
 777
 778         event->pevent = pevent;
 779
 780         return 0;
 781 }
 782
 783 static int event_item_type(enum event_type type)
 784 {
 785         switch (type) {
 786         case EVENT_ITEM ... EVENT_SQUOTE:
 787                 return 1;
 788         case EVENT_ERROR ... EVENT_DELIM:
 789         default:
 790                 return 0;
 791         }
 792 }
 793
 794 static void free_flag_sym(struct print_flag_sym *fsym)
 795 {
 796         struct print_flag_sym *next;
 797
 798         while (fsym) {
 799                 next = fsym->next;
 800                 free(fsym->value);
 801                 free(fsym->str);
 802                 free(fsym);
 803                 fsym = next;
 804         }
 805 }
 806
 807 static void free_arg(struct print_arg *arg)
 808 {
 809         struct print_arg *farg;
 810
 811         if (!arg)
 812                 return;
 813
 814         switch (arg->type) {
 815         case PRINT_ATOM:
 816                 free(arg->atom.atom);
 817                 break;
 818         case PRINT_FIELD:
 819                 free(arg->field.name);
 820                 break;
 821         case PRINT_FLAGS:
 822                 free_arg(arg->flags.field);
 823                 free(arg->flags.delim);
 824                 free_flag_sym(arg->flags.flags);
 825                 break;
 826         case PRINT_SYMBOL:
 827                 free_arg(arg->symbol.field);
 828                 free_flag_sym(arg->symbol.symbols);
 829                 break;
 830         case PRINT_HEX:
 831                 free_arg(arg->hex.field);
 832                 free_arg(arg->hex.size);
 833                 break;
 834         case PRINT_INT_ARRAY:
 835                 free_arg(arg->int_array.field);
 836                 free_arg(arg->int_array.count);
 837                 free_arg(arg->int_array.el_size);
 838                 break;
 839         case PRINT_TYPE:
 840                 free(arg->typecast.type);
 841                 free_arg(arg->typecast.item);
 842                 break;
 843         case PRINT_STRING:
 844         case PRINT_BSTRING:
 845                 free(arg->string.string);
 846                 break;
 847         case PRINT_BITMASK:
 848                 free(arg->bitmask.bitmask);
 849                 break;
 850         case PRINT_DYNAMIC_ARRAY:
 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"))
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[20];
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_paren(struct event_format *event, struct print_arg *arg, char **tok)
2733 {
2734         struct print_arg *item_arg;
2735         enum event_type type;
2736         char *token;
2737
2738         type = process_arg(event, arg, &token);
2739
2740         if (type == EVENT_ERROR)
2741                 goto out_free;
2742
2743         if (type == EVENT_OP)
2744                 type = process_op(event, arg, &token);
2745
2746         if (type == EVENT_ERROR)
2747                 goto out_free;
2748
2749         if (test_type_token(type, token, EVENT_DELIM, ")"))
2750                 goto out_free;
2751
2752         free_token(token);
2753         type = read_token_item(&token);
2754
2755         /*
2756          * If the next token is an item or another open paren, then
2757          * this was a typecast.
2758          */
2759         if (event_item_type(type) ||
2760             (type == EVENT_DELIM && strcmp(token, "(") == 0)) {
2761
2762                 /* make this a typecast and contine */
2763
2764                 /* prevous must be an atom */
2765                 if (arg->type != PRINT_ATOM) {
2766                         do_warning_event(event, "previous needed to be PRINT_ATOM");
2767                         goto out_free;
2768                 }
2769
2770                 item_arg = alloc_arg();
2771                 if (!item_arg) {
2772                         do_warning_event(event, "%s: not enough memory!",
2773                                          __func__);
2774                         goto out_free;
2775                 }
2776
2777                 arg->type = PRINT_TYPE;
2778                 arg->typecast.type = arg->atom.atom;
2779                 arg->typecast.item = item_arg;
2780                 type = process_arg_token(event, item_arg, &token, type);
2781
2782         }
2783
2784         *tok = token;
2785         return type;
2786
2787  out_free:
2788         free_token(token);
2789         *tok = NULL;
2790         return EVENT_ERROR;
2791 }
2792
2793
2794 static enum event_type
2795 process_str(struct event_format *event __maybe_unused, struct print_arg *arg,
2796             char **tok)
2797 {
2798         enum event_type type;
2799         char *token;
2800
2801         if (read_expect_type(EVENT_ITEM, &token) < 0)
2802                 goto out_free;
2803
2804         arg->type = PRINT_STRING;
2805         arg->string.string = token;
2806         arg->string.offset = -1;
2807
2808         if (read_expected(EVENT_DELIM, ")") < 0)
2809                 goto out_err;
2810
2811         type = read_token(&token);
2812         *tok = token;
2813
2814         return type;
2815
2816  out_free:
2817         free_token(token);
2818  out_err:
2819         *tok = NULL;
2820         return EVENT_ERROR;
2821 }
2822
2823 static enum event_type
2824 process_bitmask(struct event_format *event __maybe_unused, struct print_arg *arg,
2825             char **tok)
2826 {
2827         enum event_type type;
2828         char *token;
2829
2830         if (read_expect_type(EVENT_ITEM, &token) < 0)
2831                 goto out_free;
2832
2833         arg->type = PRINT_BITMASK;
2834         arg->bitmask.bitmask = token;
2835         arg->bitmask.offset = -1;
2836
2837         if (read_expected(EVENT_DELIM, ")") < 0)
2838                 goto out_err;
2839
2840         type = read_token(&token);
2841         *tok = token;
2842
2843         return type;
2844
2845  out_free:
2846         free_token(token);
2847  out_err:
2848         *tok = NULL;
2849         return EVENT_ERROR;
2850 }
2851
2852 static struct pevent_function_handler *
2853 find_func_handler(struct pevent *pevent, char *func_name)
2854 {
2855         struct pevent_function_handler *func;
2856
2857         if (!pevent)
2858                 return NULL;
2859
2860         for (func = pevent->func_handlers; func; func = func->next) {
2861                 if (strcmp(func->name, func_name) == 0)
2862                         break;
2863         }
2864
2865         return func;
2866 }
2867
2868 static void remove_func_handler(struct pevent *pevent, char *func_name)
2869 {
2870         struct pevent_function_handler *func;
2871         struct pevent_function_handler **next;
2872
2873         next = &pevent->func_handlers;
2874         while ((func = *next)) {
2875                 if (strcmp(func->name, func_name) == 0) {
2876                         *next = func->next;
2877                         free_func_handle(func);
2878                         break;
2879                 }
2880                 next = &func->next;
2881         }
2882 }
2883
2884 static enum event_type
2885 process_func_handler(struct event_format *event, struct pevent_function_handler *func,
2886                      struct print_arg *arg, char **tok)
2887 {
2888         struct print_arg **next_arg;
2889         struct print_arg *farg;
2890         enum event_type type;
2891         char *token;
2892         int i;
2893
2894         arg->type = PRINT_FUNC;
2895         arg->func.func = func;
2896
2897         *tok = NULL;
2898
2899         next_arg = &(arg->func.args);
2900         for (i = 0; i < func->nr_args; i++) {
2901                 farg = alloc_arg();
2902                 if (!farg) {
2903                         do_warning_event(event, "%s: not enough memory!",
2904                                          __func__);
2905                         return EVENT_ERROR;
2906                 }
2907
2908                 type = process_arg(event, farg, &token);
2909                 if (i < (func->nr_args - 1)) {
2910                         if (type != EVENT_DELIM || strcmp(token, ",") != 0) {
2911                                 do_warning_event(event,
2912                                         "Error: function '%s()' expects %d arguments but event %s only uses %d",
2913                                         func->name, func->nr_args,
2914                                         event->name, i + 1);
2915                                 goto err;
2916                         }
2917                 } else {
2918                         if (type != EVENT_DELIM || strcmp(token, ")") != 0) {
2919                                 do_warning_event(event,
2920                                         "Error: function '%s()' only expects %d arguments but event %s has more",
2921                                         func->name, func->nr_args, event->name);
2922                                 goto err;
2923                         }
2924                 }
2925
2926                 *next_arg = farg;
2927                 next_arg = &(farg->next);
2928                 free_token(token);
2929         }
2930
2931         type = read_token(&token);
2932         *tok = token;
2933
2934         return type;
2935
2936 err:
2937         free_arg(farg);
2938         free_token(token);
2939         return EVENT_ERROR;
2940 }
2941
2942 static enum event_type
2943 process_function(struct event_format *event, struct print_arg *arg,
2944                  char *token, char **tok)
2945 {
2946         struct pevent_function_handler *func;
2947
2948         if (strcmp(token, "__print_flags") == 0) {
2949                 free_token(token);
2950                 is_flag_field = 1;
2951                 return process_flags(event, arg, tok);
2952         }
2953         if (strcmp(token, "__print_symbolic") == 0) {
2954                 free_token(token);
2955                 is_symbolic_field = 1;
2956                 return process_symbols(event, arg, tok);
2957         }
2958         if (strcmp(token, "__print_hex") == 0) {
2959                 free_token(token);
2960                 return process_hex(event, arg, tok);
2961         }
2962         if (strcmp(token, "__print_array") == 0) {
2963                 free_token(token);
2964                 return process_int_array(event, arg, tok);
2965         }
2966         if (strcmp(token, "__get_str") == 0) {
2967                 free_token(token);
2968                 return process_str(event, arg, tok);
2969         }
2970         if (strcmp(token, "__get_bitmask") == 0) {
2971                 free_token(token);
2972                 return process_bitmask(event, arg, tok);
2973         }
2974         if (strcmp(token, "__get_dynamic_array") == 0) {
2975                 free_token(token);
2976                 return process_dynamic_array(event, arg, tok);
2977         }
2978
2979         func = find_func_handler(event->pevent, token);
2980         if (func) {
2981                 free_token(token);
2982                 return process_func_handler(event, func, arg, tok);
2983         }
2984
2985         do_warning_event(event, "function %s not defined", token);
2986         free_token(token);
2987         return EVENT_ERROR;
2988 }
2989
2990 static enum event_type
2991 process_arg_token(struct event_format *event, struct print_arg *arg,
2992                   char **tok, enum event_type type)
2993 {
2994         char *token;
2995         char *atom;
2996
2997         token = *tok;
2998
2999         switch (type) {
3000         case EVENT_ITEM:
3001                 if (strcmp(token, "REC") == 0) {
3002                         free_token(token);
3003                         type = process_entry(event, arg, &token);
3004                         break;
3005                 }
3006                 atom = token;
3007                 /* test the next token */
3008                 type = read_token_item(&token);
3009
3010                 /*
3011                  * If the next token is a parenthesis, then this
3012                  * is a function.
3013                  */
3014                 if (type == EVENT_DELIM && strcmp(token, "(") == 0) {
3015                         free_token(token);
3016                         token = NULL;
3017                         /* this will free atom. */
3018                         type = process_function(event, arg, atom, &token);
3019                         break;
3020                 }
3021                 /* atoms can be more than one token long */
3022                 while (type == EVENT_ITEM) {
3023                         char *new_atom;
3024                         new_atom = realloc(atom,
3025                                            strlen(atom) + strlen(token) + 2);
3026                         if (!new_atom) {
3027                                 free(atom);
3028                                 *tok = NULL;
3029                                 free_token(token);
3030                                 return EVENT_ERROR;
3031                         }
3032                         atom = new_atom;
3033                         strcat(atom, " ");
3034                         strcat(atom, token);
3035                         free_token(token);
3036                         type = read_token_item(&token);
3037                 }
3038
3039                 arg->type = PRINT_ATOM;
3040                 arg->atom.atom = atom;
3041                 break;
3042
3043         case EVENT_DQUOTE:
3044         case EVENT_SQUOTE:
3045                 arg->type = PRINT_ATOM;
3046                 arg->atom.atom = token;
3047                 type = read_token_item(&token);
3048                 break;
3049         case EVENT_DELIM:
3050                 if (strcmp(token, "(") == 0) {
3051                         free_token(token);
3052                         type = process_paren(event, arg, &token);
3053                         break;
3054                 }
3055         case EVENT_OP:
3056                 /* handle single ops */
3057                 arg->type = PRINT_OP;
3058                 arg->op.op = token;
3059                 arg->op.left = NULL;
3060                 type = process_op(event, arg, &token);
3061
3062                 /* On error, the op is freed */
3063                 if (type == EVENT_ERROR)
3064                         arg->op.op = NULL;
3065
3066                 /* return error type if errored */
3067                 break;
3068
3069         case EVENT_ERROR ... EVENT_NEWLINE:
3070         default:
3071                 do_warning_event(event, "unexpected type %d", type);
3072                 return EVENT_ERROR;
3073         }
3074         *tok = token;
3075
3076         return type;
3077 }
3078
3079 static int event_read_print_args(struct event_format *event, struct print_arg **list)
3080 {
3081         enum event_type type = EVENT_ERROR;
3082         struct print_arg *arg;
3083         char *token;
3084         int args = 0;
3085
3086         do {
3087                 if (type == EVENT_NEWLINE) {
3088                         type = read_token_item(&token);
3089                         continue;
3090                 }
3091
3092                 arg = alloc_arg();
3093                 if (!arg) {
3094                         do_warning_event(event, "%s: not enough memory!",
3095                                          __func__);
3096                         return -1;
3097                 }
3098
3099                 type = process_arg(event, arg, &token);
3100
3101                 if (type == EVENT_ERROR) {
3102                         free_token(token);
3103                         free_arg(arg);
3104                         return -1;
3105                 }
3106
3107                 *list = arg;
3108                 args++;
3109
3110                 if (type == EVENT_OP) {
3111                         type = process_op(event, arg, &token);
3112                         free_token(token);
3113                         if (type == EVENT_ERROR) {
3114                                 *list = NULL;
3115                                 free_arg(arg);
3116                                 return -1;
3117                         }
3118                         list = &arg->next;
3119                         continue;
3120                 }
3121
3122                 if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
3123                         free_token(token);
3124                         *list = arg;
3125                         list = &arg->next;
3126                         continue;
3127                 }
3128                 break;
3129         } while (type != EVENT_NONE);
3130
3131         if (type != EVENT_NONE && type != EVENT_ERROR)
3132                 free_token(token);
3133
3134         return args;
3135 }
3136
3137 static int event_read_print(struct event_format *event)
3138 {
3139         enum event_type type;
3140         char *token;
3141         int ret;
3142
3143         if (read_expected_item(EVENT_ITEM, "print") < 0)
3144                 return -1;
3145
3146         if (read_expected(EVENT_ITEM, "fmt") < 0)
3147                 return -1;
3148
3149         if (read_expected(EVENT_OP, ":") < 0)
3150                 return -1;
3151
3152         if (read_expect_type(EVENT_DQUOTE, &token) < 0)
3153                 goto fail;
3154
3155  concat:
3156         event->print_fmt.format = token;
3157         event->print_fmt.args = NULL;
3158
3159         /* ok to have no arg */
3160         type = read_token_item(&token);
3161
3162         if (type == EVENT_NONE)
3163                 return 0;
3164
3165         /* Handle concatenation of print lines */
3166         if (type == EVENT_DQUOTE) {
3167                 char *cat;
3168
3169                 if (asprintf(&cat, "%s%s", event->print_fmt.format, token) < 0)
3170                         goto fail;
3171                 free_token(token);
3172                 free_token(event->print_fmt.format);
3173                 event->print_fmt.format = NULL;
3174                 token = cat;
3175                 goto concat;
3176         }
3177
3178         if (test_type_token(type, token, EVENT_DELIM, ","))
3179                 goto fail;
3180
3181         free_token(token);
3182
3183         ret = event_read_print_args(event, &event->print_fmt.args);
3184         if (ret < 0)
3185                 return -1;
3186
3187         return ret;
3188
3189  fail:
3190         free_token(token);
3191         return -1;
3192 }
3193
3194 /**
3195  * pevent_find_common_field - return a common field by event
3196  * @event: handle for the event
3197  * @name: the name of the common field to return
3198  *
3199  * Returns a common field from the event by the given @name.
3200  * This only searchs the common fields and not all field.
3201  */
3202 struct format_field *
3203 pevent_find_common_field(struct event_format *event, const char *name)
3204 {
3205         struct format_field *format;
3206
3207         for (format = event->format.common_fields;
3208              format; format = format->next) {
3209                 if (strcmp(format->name, name) == 0)
3210                         break;
3211         }
3212
3213         return format;
3214 }
3215
3216 /**
3217  * pevent_find_field - find a non-common field
3218  * @event: handle for the event
3219  * @name: the name of the non-common field
3220  *
3221  * Returns a non-common field by the given @name.
3222  * This does not search common fields.
3223  */
3224 struct format_field *
3225 pevent_find_field(struct event_format *event, const char *name)
3226 {
3227         struct format_field *format;
3228
3229         for (format = event->format.fields;
3230              format; format = format->next) {
3231                 if (strcmp(format->name, name) == 0)
3232                         break;
3233         }
3234
3235         return format;
3236 }
3237
3238 /**
3239  * pevent_find_any_field - find any field by name
3240  * @event: handle for the event
3241  * @name: the name of the field
3242  *
3243  * Returns a field by the given @name.
3244  * This searchs the common field names first, then
3245  * the non-common ones if a common one was not found.
3246  */
3247 struct format_field *
3248 pevent_find_any_field(struct event_format *event, const char *name)
3249 {
3250         struct format_field *format;
3251
3252         format = pevent_find_common_field(event, name);
3253         if (format)
3254                 return format;
3255         return pevent_find_field(event, name);
3256 }
3257
3258 /**
3259  * pevent_read_number - read a number from data
3260  * @pevent: handle for the pevent
3261  * @ptr: the raw data
3262  * @size: the size of the data that holds the number
3263  *
3264  * Returns the number (converted to host) from the
3265  * raw data.
3266  */
3267 unsigned long long pevent_read_number(struct pevent *pevent,
3268                                       const void *ptr, int size)
3269 {
3270         switch (size) {
3271         case 1:
3272                 return *(unsigned char *)ptr;
3273         case 2:
3274                 return data2host2(pevent, ptr);
3275         case 4:
3276                 return data2host4(pevent, ptr);
3277         case 8:
3278                 return data2host8(pevent, ptr);
3279         default:
3280                 /* BUG! */
3281                 return 0;
3282         }
3283 }
3284
3285 /**
3286  * pevent_read_number_field - read a number from data
3287  * @field: a handle to the field
3288  * @data: the raw data to read
3289  * @value: the value to place the number in
3290  *
3291  * Reads raw data according to a field offset and size,
3292  * and translates it into @value.
3293  *
3294  * Returns 0 on success, -1 otherwise.
3295  */
3296 int pevent_read_number_field(struct format_field *field, const void *data,
3297                              unsigned long long *value)
3298 {
3299         if (!field)
3300                 return -1;
3301         switch (field->size) {
3302         case 1:
3303         case 2:
3304         case 4:
3305         case 8:
3306                 *value = pevent_read_number(field->event->pevent,
3307                                             data + field->offset, field->size);
3308                 return 0;
3309         default:
3310                 return -1;
3311         }
3312 }
3313
3314 static int get_common_info(struct pevent *pevent,
3315                            const char *type, int *offset, int *size)
3316 {
3317         struct event_format *event;
3318         struct format_field *field;
3319
3320         /*
3321          * All events should have the same common elements.
3322          * Pick any event to find where the type is;
3323          */
3324         if (!pevent->events) {
3325                 do_warning("no event_list!");
3326                 return -1;
3327         }
3328
3329         event = pevent->events[0];
3330         field = pevent_find_common_field(event, type);
3331         if (!field)
3332                 return -1;
3333
3334         *offset = field->offset;
3335         *size = field->size;
3336
3337         return 0;
3338 }
3339
3340 static int __parse_common(struct pevent *pevent, void *data,
3341                           int *size, int *offset, const char *name)
3342 {
3343         int ret;
3344
3345         if (!*size) {
3346                 ret = get_common_info(pevent, name, offset, size);
3347                 if (ret < 0)
3348                         return ret;
3349         }
3350         return pevent_read_number(pevent, data + *offset, *size);
3351 }
3352
3353 static int trace_parse_common_type(struct pevent *pevent, void *data)
3354 {
3355         return __parse_common(pevent, data,
3356                               &pevent->type_size, &pevent->type_offset,
3357                               "common_type");
3358 }
3359
3360 static int parse_common_pid(struct pevent *pevent, void *data)
3361 {
3362         return __parse_common(pevent, data,
3363                               &pevent->pid_size, &pevent->pid_offset,
3364                               "common_pid");
3365 }
3366
3367 static int parse_common_pc(struct pevent *pevent, void *data)
3368 {
3369         return __parse_common(pevent, data,
3370                               &pevent->pc_size, &pevent->pc_offset,
3371                               "common_preempt_count");
3372 }
3373
3374 static int parse_common_flags(struct pevent *pevent, void *data)
3375 {
3376         return __parse_common(pevent, data,
3377                               &pevent->flags_size, &pevent->flags_offset,
3378                               "common_flags");
3379 }
3380
3381 static int parse_common_lock_depth(struct pevent *pevent, void *data)
3382 {
3383         return __parse_common(pevent, data,
3384                               &pevent->ld_size, &pevent->ld_offset,
3385                               "common_lock_depth");
3386 }
3387
3388 static int parse_common_migrate_disable(struct pevent *pevent, void *data)
3389 {
3390         return __parse_common(pevent, data,
3391                               &pevent->ld_size, &pevent->ld_offset,
3392                               "common_migrate_disable");
3393 }
3394
3395 static int events_id_cmp(const void *a, const void *b);
3396
3397 /**
3398  * pevent_find_event - find an event by given id
3399  * @pevent: a handle to the pevent
3400  * @id: the id of the event
3401  *
3402  * Returns an event that has a given @id.
3403  */
3404 struct event_format *pevent_find_event(struct pevent *pevent, int id)
3405 {
3406         struct event_format **eventptr;
3407         struct event_format key;
3408         struct event_format *pkey = &key;
3409
3410         /* Check cache first */
3411         if (pevent->last_event && pevent->last_event->id == id)
3412                 return pevent->last_event;
3413
3414         key.id = id;
3415
3416         eventptr = bsearch(&pkey, pevent->events, pevent->nr_events,
3417                            sizeof(*pevent->events), events_id_cmp);
3418
3419         if (eventptr) {
3420                 pevent->last_event = *eventptr;
3421                 return *eventptr;
3422         }
3423
3424         return NULL;
3425 }
3426
3427 /**
3428  * pevent_find_event_by_name - find an event by given name
3429  * @pevent: a handle to the pevent
3430  * @sys: the system name to search for
3431  * @name: the name of the event to search for
3432  *
3433  * This returns an event with a given @name and under the system
3434  * @sys. If @sys is NULL the first event with @name is returned.
3435  */
3436 struct event_format *
3437 pevent_find_event_by_name(struct pevent *pevent,
3438                           const char *sys, const char *name)
3439 {
3440         struct event_format *event;
3441         int i;
3442
3443         if (pevent->last_event &&
3444             strcmp(pevent->last_event->name, name) == 0 &&
3445             (!sys || strcmp(pevent->last_event->system, sys) == 0))
3446                 return pevent->last_event;
3447
3448         for (i = 0; i < pevent->nr_events; i++) {
3449                 event = pevent->events[i];
3450                 if (strcmp(event->name, name) == 0) {
3451                         if (!sys)
3452                                 break;
3453                         if (strcmp(event->system, sys) == 0)
3454                                 break;
3455                 }
3456         }
3457         if (i == pevent->nr_events)
3458                 event = NULL;
3459
3460         pevent->last_event = event;
3461         return event;
3462 }
3463
3464 static unsigned long long
3465 eval_num_arg(void *data, int size, struct event_format *event, struct print_arg *arg)
3466 {
3467         struct pevent *pevent = event->pevent;
3468         unsigned long long val = 0;
3469         unsigned long long left, right;
3470         struct print_arg *typearg = NULL;
3471         struct print_arg *larg;
3472         unsigned long offset;
3473         unsigned int field_size;
3474
3475         switch (arg->type) {
3476         case PRINT_NULL:
3477                 /* ?? */
3478                 return 0;
3479         case PRINT_ATOM:
3480                 return strtoull(arg->atom.atom, NULL, 0);
3481         case PRINT_FIELD:
3482                 if (!arg->field.field) {
3483                         arg->field.field = pevent_find_any_field(event, arg->field.name);
3484                         if (!arg->field.field)
3485                                 goto out_warning_field;
3486
3487                 }
3488                 /* must be a number */
3489                 val = pevent_read_number(pevent, data + arg->field.field->offset,
3490                                 arg->field.field->size);
3491                 break;
3492         case PRINT_FLAGS:
3493         case PRINT_SYMBOL:
3494         case PRINT_INT_ARRAY:
3495         case PRINT_HEX:
3496                 break;
3497         case PRINT_TYPE:
3498                 val = eval_num_arg(data, size, event, arg->typecast.item);
3499                 return eval_type(val, arg, 0);
3500         case PRINT_STRING:
3501         case PRINT_BSTRING:
3502         case PRINT_BITMASK:
3503                 return 0;
3504         case PRINT_FUNC: {
3505                 struct trace_seq s;
3506                 trace_seq_init(&s);
3507                 val = process_defined_func(&s, data, size, event, arg);
3508                 trace_seq_destroy(&s);
3509                 return val;
3510         }
3511         case PRINT_OP:
3512                 if (strcmp(arg->op.op, "[") == 0) {
3513                         /*
3514                          * Arrays are special, since we don't want
3515                          * to read the arg as is.
3516                          */
3517                         right = eval_num_arg(data, size, event, arg->op.right);
3518
3519                         /* handle typecasts */
3520                         larg = arg->op.left;
3521                         while (larg->type == PRINT_TYPE) {
3522                                 if (!typearg)
3523                                         typearg = larg;
3524                                 larg = larg->typecast.item;
3525                         }
3526
3527                         /* Default to long size */
3528                         field_size = pevent->long_size;
3529
3530                         switch (larg->type) {
3531                         case PRINT_DYNAMIC_ARRAY:
3532                                 offset = pevent_read_number(pevent,
3533                                                    data + larg->dynarray.field->offset,
3534                                                    larg->dynarray.field->size);
3535                                 if (larg->dynarray.field->elementsize)
3536                                         field_size = larg->dynarray.field->elementsize;
3537                                 /*
3538                                  * The actual length of the dynamic array is stored
3539                                  * in the top half of the field, and the offset
3540                                  * is in the bottom half of the 32 bit field.
3541                                  */
3542                                 offset &= 0xffff;
3543                                 offset += right;
3544                                 break;
3545                         case PRINT_FIELD:
3546                                 if (!larg->field.field) {
3547                                         larg->field.field =
3548                                                 pevent_find_any_field(event, larg->field.name);
3549                                         if (!larg->field.field) {
3550                                                 arg = larg;
3551                                                 goto out_warning_field;
3552                                         }
3553                                 }
3554                                 field_size = larg->field.field->elementsize;
3555                                 offset = larg->field.field->offset +
3556                                         right * larg->field.field->elementsize;
3557                                 break;
3558                         default:
3559                                 goto default_op; /* oops, all bets off */
3560                         }
3561                         val = pevent_read_number(pevent,
3562                                                  data + offset, field_size);
3563                         if (typearg)
3564                                 val = eval_type(val, typearg, 1);
3565                         break;
3566                 } else if (strcmp(arg->op.op, "?") == 0) {
3567                         left = eval_num_arg(data, size, event, arg->op.left);
3568                         arg = arg->op.right;
3569                         if (left)
3570                                 val = eval_num_arg(data, size, event, arg->op.left);
3571                         else
3572                                 val = eval_num_arg(data, size, event, arg->op.right);
3573                         break;
3574                 }
3575  default_op:
3576                 left = eval_num_arg(data, size, event, arg->op.left);
3577                 right = eval_num_arg(data, size, event, arg->op.right);
3578                 switch (arg->op.op[0]) {
3579                 case '!':
3580                         switch (arg->op.op[1]) {
3581                         case 0:
3582                                 val = !right;
3583                                 break;
3584                         case '=':
3585                                 val = left != right;
3586                                 break;
3587                         default:
3588                                 goto out_warning_op;
3589                         }
3590                         break;
3591                 case '~':
3592                         val = ~right;
3593                         break;
3594                 case '|':
3595                         if (arg->op.op[1])
3596                                 val = left || right;
3597                         else
3598                                 val = left | right;
3599                         break;
3600                 case '&':
3601                         if (arg->op.op[1])
3602                                 val = left && right;
3603                         else
3604                                 val = left & right;
3605                         break;
3606                 case '<':
3607                         switch (arg->op.op[1]) {
3608                         case 0:
3609                                 val = left < right;
3610                                 break;
3611                         case '<':
3612                                 val = left << right;
3613                                 break;
3614                         case '=':
3615                                 val = left <= right;
3616                                 break;
3617                         default:
3618                                 goto out_warning_op;
3619                         }
3620                         break;
3621                 case '>':
3622                         switch (arg->op.op[1]) {
3623                         case 0:
3624                                 val = left > right;
3625                                 break;
3626                         case '>':
3627                                 val = left >> right;
3628                                 break;
3629                         case '=':
3630                                 val = left >= right;
3631                                 break;
3632                         default:
3633                                 goto out_warning_op;
3634                         }
3635                         break;
3636                 case '=':
3637                         if (arg->op.op[1] != '=')
3638                                 goto out_warning_op;
3639
3640                         val = left == right;
3641                         break;
3642                 case '-':
3643                         val = left - right;
3644                         break;
3645                 case '+':
3646                         val = left + right;
3647                         break;
3648                 case '/':
3649                         val = left / right;
3650                         break;
3651                 case '*':
3652                         val = left * right;
3653                         break;
3654                 default:
3655                         goto out_warning_op;
3656                 }
3657                 break;
3658         case PRINT_DYNAMIC_ARRAY:
3659                 /* Without [], we pass the address to the dynamic data */
3660                 offset = pevent_read_number(pevent,
3661                                             data + arg->dynarray.field->offset,
3662                                             arg->dynarray.field->size);
3663                 /*
3664                  * The actual length of the dynamic array is stored
3665                  * in the top half of the field, and the offset
3666                  * is in the bottom half of the 32 bit field.
3667                  */
3668                 offset &= 0xffff;
3669                 val = (unsigned long long)((unsigned long)data + offset);
3670                 break;
3671         default: /* not sure what to do there */
3672                 return 0;
3673         }
3674         return val;
3675
3676 out_warning_op:
3677         do_warning_event(event, "%s: unknown op '%s'", __func__, arg->op.op);
3678         return 0;
3679
3680 out_warning_field:
3681         do_warning_event(event, "%s: field %s not found",
3682                          __func__, arg->field.name);
3683         return 0;
3684 }
3685
3686 struct flag {
3687         const char *name;
3688         unsigned long long value;
3689 };
3690
3691 static const struct flag flags[] = {
3692         { "HI_SOFTIRQ", 0 },
3693         { "TIMER_SOFTIRQ", 1 },
3694         { "NET_TX_SOFTIRQ", 2 },
3695         { "NET_RX_SOFTIRQ", 3 },
3696         { "BLOCK_SOFTIRQ", 4 },
3697         { "BLOCK_IOPOLL_SOFTIRQ", 5 },
3698         { "TASKLET_SOFTIRQ", 6 },
3699         { "SCHED_SOFTIRQ", 7 },
3700         { "HRTIMER_SOFTIRQ", 8 },
3701         { "RCU_SOFTIRQ", 9 },
3702
3703         { "HRTIMER_NORESTART", 0 },
3704         { "HRTIMER_RESTART", 1 },
3705 };
3706
3707 static long long eval_flag(const char *flag)
3708 {
3709         int i;
3710
3711         /*
3712          * Some flags in the format files do not get converted.
3713          * If the flag is not numeric, see if it is something that
3714          * we already know about.
3715          */
3716         if (isdigit(flag[0]))
3717                 return strtoull(flag, NULL, 0);
3718
3719         for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
3720                 if (strcmp(flags[i].name, flag) == 0)
3721                         return flags[i].value;
3722
3723         return -1LL;
3724 }
3725
3726 static void print_str_to_seq(struct trace_seq *s, const char *format,
3727                              int len_arg, const char *str)
3728 {
3729         if (len_arg >= 0)
3730                 trace_seq_printf(s, format, len_arg, str);
3731         else
3732                 trace_seq_printf(s, format, str);
3733 }
3734
3735 static void print_bitmask_to_seq(struct pevent *pevent,
3736                                  struct trace_seq *s, const char *format,
3737                                  int len_arg, const void *data, int size)
3738 {
3739         int nr_bits = size * 8;
3740         int str_size = (nr_bits + 3) / 4;
3741         int len = 0;
3742         char buf[3];
3743         char *str;
3744         int index;
3745         int i;
3746
3747         /*
3748          * The kernel likes to put in commas every 32 bits, we
3749          * can do the same.
3750          */
3751         str_size += (nr_bits - 1) / 32;
3752
3753         str = malloc(str_size + 1);
3754         if (!str) {
3755                 do_warning("%s: not enough memory!", __func__);
3756                 return;
3757         }
3758         str[str_size] = 0;
3759
3760         /* Start out with -2 for the two chars per byte */
3761         for (i = str_size - 2; i >= 0; i -= 2) {
3762                 /*
3763                  * data points to a bit mask of size bytes.
3764                  * In the kernel, this is an array of long words, thus
3765                  * endianess is very important.
3766                  */
3767                 if (pevent->file_bigendian)
3768                         index = size - (len + 1);
3769                 else
3770                         index = len;
3771
3772                 snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
3773                 memcpy(str + i, buf, 2);
3774                 len++;
3775                 if (!(len & 3) && i > 0) {
3776                         i--;
3777                         str[i] = ',';
3778                 }
3779         }
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         free(str);
3787 }
3788
3789 static void print_str_arg(struct trace_seq *s, void *data, int size,
3790                           struct event_format *event, const char *format,
3791                           int len_arg, struct print_arg *arg)
3792 {
3793         struct pevent *pevent = event->pevent;
3794         struct print_flag_sym *flag;
3795         struct format_field *field;
3796         struct printk_map *printk;
3797         long long val, fval;
3798         unsigned long long addr;
3799         char *str;
3800         unsigned char *hex;
3801         int print;
3802         int i, len;
3803
3804         switch (arg->type) {
3805         case PRINT_NULL:
3806                 /* ?? */
3807                 return;
3808         case PRINT_ATOM:
3809                 print_str_to_seq(s, format, len_arg, arg->atom.atom);
3810                 return;
3811         case PRINT_FIELD:
3812                 field = arg->field.field;
3813                 if (!field) {
3814                         field = pevent_find_any_field(event, arg->field.name);
3815                         if (!field) {
3816                                 str = arg->field.name;
3817                                 goto out_warning_field;
3818                         }
3819                         arg->field.field = field;
3820                 }
3821                 /* Zero sized fields, mean the rest of the data */
3822                 len = field->size ? : size - field->offset;
3823
3824                 /*
3825                  * Some events pass in pointers. If this is not an array
3826                  * and the size is the same as long_size, assume that it
3827                  * is a pointer.
3828                  */
3829                 if (!(field->flags & FIELD_IS_ARRAY) &&
3830                     field->size == pevent->long_size) {
3831
3832                         /* Handle heterogeneous recording and processing
3833                          * architectures
3834                          *
3835                          * CASE I:
3836                          * Traces recorded on 32-bit devices (32-bit
3837                          * addressing) and processed on 64-bit devices:
3838                          * In this case, only 32 bits should be read.
3839                          *
3840                          * CASE II:
3841                          * Traces recorded on 64 bit devices and processed
3842                          * on 32-bit devices:
3843                          * In this case, 64 bits must be read.
3844                          */
3845                         addr = (pevent->long_size == 8) ?
3846                                 *(unsigned long long *)(data + field->offset) :
3847                                 (unsigned long long)*(unsigned int *)(data + field->offset);
3848
3849                         /* Check if it matches a print format */
3850                         printk = find_printk(pevent, addr);
3851                         if (printk)
3852                                 trace_seq_puts(s, printk->printk);
3853                         else
3854                                 trace_seq_printf(s, "%llx", addr);
3855                         break;
3856                 }
3857                 str = malloc(len + 1);
3858                 if (!str) {
3859                         do_warning_event(event, "%s: not enough memory!",
3860                                          __func__);
3861                         return;
3862                 }
3863                 memcpy(str, data + field->offset, len);
3864                 str[len] = 0;
3865                 print_str_to_seq(s, format, len_arg, str);
3866                 free(str);
3867                 break;
3868         case PRINT_FLAGS:
3869                 val = eval_num_arg(data, size, event, arg->flags.field);
3870                 print = 0;
3871                 for (flag = arg->flags.flags; flag; flag = flag->next) {
3872                         fval = eval_flag(flag->value);
3873                         if (!val && fval < 0) {
3874                                 print_str_to_seq(s, format, len_arg, flag->str);
3875                                 break;
3876                         }
3877                         if (fval > 0 && (val & fval) == fval) {
3878                                 if (print && arg->flags.delim)
3879                                         trace_seq_puts(s, arg->flags.delim);
3880                                 print_str_to_seq(s, format, len_arg, flag->str);
3881                                 print = 1;
3882                                 val &= ~fval;
3883                         }
3884                 }
3885                 break;
3886         case PRINT_SYMBOL:
3887                 val = eval_num_arg(data, size, event, arg->symbol.field);
3888                 for (flag = arg->symbol.symbols; flag; flag = flag->next) {
3889                         fval = eval_flag(flag->value);
3890                         if (val == fval) {
3891                                 print_str_to_seq(s, format, len_arg, flag->str);
3892                                 break;
3893                         }
3894                 }
3895                 break;
3896         case PRINT_HEX:
3897                 if (arg->hex.field->type == PRINT_DYNAMIC_ARRAY) {
3898                         unsigned long offset;
3899                         offset = pevent_read_number(pevent,
3900                                 data + arg->hex.field->dynarray.field->offset,
3901                                 arg->hex.field->dynarray.field->size);
3902                         hex = data + (offset & 0xffff);
3903                 } else {
3904                         field = arg->hex.field->field.field;
3905                         if (!field) {
3906                                 str = arg->hex.field->field.name;
3907                                 field = pevent_find_any_field(event, str);
3908                                 if (!field)
3909                                         goto out_warning_field;
3910                                 arg->hex.field->field.field = field;
3911                         }
3912                         hex = data + field->offset;
3913                 }
3914                 len = eval_num_arg(data, size, event, arg->hex.size);
3915                 for (i = 0; i < len; i++) {
3916                         if (i)
3917                                 trace_seq_putc(s, ' ');
3918                         trace_seq_printf(s, "%02x", hex[i]);
3919                 }
3920                 break;
3921
3922         case PRINT_INT_ARRAY: {
3923                 void *num;
3924                 int el_size;
3925
3926                 if (arg->int_array.field->type == PRINT_DYNAMIC_ARRAY) {
3927                         unsigned long offset;
3928                         struct format_field *field =
3929                                 arg->int_array.field->dynarray.field;
3930                         offset = pevent_read_number(pevent,
3931                                                     data + field->offset,
3932                                                     field->size);
3933                         num = data + (offset & 0xffff);
3934                 } else {
3935                         field = arg->int_array.field->field.field;
3936                         if (!field) {
3937                                 str = arg->int_array.field->field.name;
3938                                 field = pevent_find_any_field(event, str);
3939                                 if (!field)
3940                                         goto out_warning_field;
3941                                 arg->int_array.field->field.field = field;
3942                         }
3943                         num = data + field->offset;
3944                 }
3945                 len = eval_num_arg(data, size, event, arg->int_array.count);
3946                 el_size = eval_num_arg(data, size, event,
3947                                        arg->int_array.el_size);
3948                 for (i = 0; i < len; i++) {
3949                         if (i)
3950                                 trace_seq_putc(s, ' ');
3951
3952                         if (el_size == 1) {
3953                                 trace_seq_printf(s, "%u", *(uint8_t *)num);
3954                         } else if (el_size == 2) {
3955                                 trace_seq_printf(s, "%u", *(uint16_t *)num);
3956                         } else if (el_size == 4) {
3957                                 trace_seq_printf(s, "%u", *(uint32_t *)num);
3958                         } else if (el_size == 8) {
3959                                 trace_seq_printf(s, "%"PRIu64, *(uint64_t *)num);
3960                         } else {
3961                                 trace_seq_printf(s, "BAD SIZE:%d 0x%x",
3962                                                  el_size, *(uint8_t *)num);
3963                                 el_size = 1;
3964                         }
3965
3966                         num += el_size;
3967                 }
3968                 break;
3969         }
3970         case PRINT_TYPE:
3971                 break;
3972         case PRINT_STRING: {
3973                 int str_offset;
3974
3975                 if (arg->string.offset == -1) {
3976                         struct format_field *f;
3977
3978                         f = pevent_find_any_field(event, arg->string.string);
3979                         arg->string.offset = f->offset;
3980                 }
3981                 str_offset = data2host4(pevent, data + arg->string.offset);
3982                 str_offset &= 0xffff;
3983                 print_str_to_seq(s, format, len_arg, ((char *)data) + str_offset);
3984                 break;
3985         }
3986         case PRINT_BSTRING:
3987                 print_str_to_seq(s, format, len_arg, arg->string.string);
3988                 break;
3989         case PRINT_BITMASK: {
3990                 int bitmask_offset;
3991                 int bitmask_size;
3992
3993                 if (arg->bitmask.offset == -1) {
3994                         struct format_field *f;
3995
3996                         f = pevent_find_any_field(event, arg->bitmask.bitmask);
3997                         arg->bitmask.offset = f->offset;
3998                 }
3999                 bitmask_offset = data2host4(pevent, data + arg->bitmask.offset);
4000                 bitmask_size = bitmask_offset >> 16;
4001                 bitmask_offset &= 0xffff;
4002                 print_bitmask_to_seq(pevent, s, format, len_arg,
4003                                      data + bitmask_offset, bitmask_size);
4004                 break;
4005         }
4006         case PRINT_OP:
4007                 /*
4008                  * The only op for string should be ? :
4009                  */
4010                 if (arg->op.op[0] != '?')
4011                         return;
4012                 val = eval_num_arg(data, size, event, arg->op.left);
4013                 if (val)
4014                         print_str_arg(s, data, size, event,
4015                                       format, len_arg, arg->op.right->op.left);
4016                 else
4017                         print_str_arg(s, data, size, event,
4018                                       format, len_arg, arg->op.right->op.right);
4019                 break;
4020         case PRINT_FUNC:
4021                 process_defined_func(s, data, size, event, arg);
4022                 break;
4023         default:
4024                 /* well... */
4025                 break;
4026         }
4027
4028         return;
4029
4030 out_warning_field:
4031         do_warning_event(event, "%s: field %s not found",
4032                          __func__, arg->field.name);
4033 }
4034
4035 static unsigned long long
4036 process_defined_func(struct trace_seq *s, void *data, int size,
4037                      struct event_format *event, struct print_arg *arg)
4038 {
4039         struct pevent_function_handler *func_handle = arg->func.func;
4040         struct pevent_func_params *param;
4041         unsigned long long *args;
4042         unsigned long long ret;
4043         struct print_arg *farg;
4044         struct trace_seq str;
4045         struct save_str {
4046                 struct save_str *next;
4047                 char *str;
4048         } *strings = NULL, *string;
4049         int i;
4050
4051         if (!func_handle->nr_args) {
4052                 ret = (*func_handle->func)(s, NULL);
4053                 goto out;
4054         }
4055
4056         farg = arg->func.args;
4057         param = func_handle->params;
4058
4059         ret = ULLONG_MAX;
4060         args = malloc(sizeof(*args) * func_handle->nr_args);
4061         if (!args)
4062                 goto out;
4063
4064         for (i = 0; i < func_handle->nr_args; i++) {
4065                 switch (param->type) {
4066                 case PEVENT_FUNC_ARG_INT:
4067                 case PEVENT_FUNC_ARG_LONG:
4068                 case PEVENT_FUNC_ARG_PTR:
4069                         args[i] = eval_num_arg(data, size, event, farg);
4070                         break;
4071                 case PEVENT_FUNC_ARG_STRING:
4072                         trace_seq_init(&str);
4073                         print_str_arg(&str, data, size, event, "%s", -1, farg);
4074                         trace_seq_terminate(&str);
4075                         string = malloc(sizeof(*string));
4076                         if (!string) {
4077                                 do_warning_event(event, "%s(%d): malloc str",
4078                                                  __func__, __LINE__);
4079                                 goto out_free;
4080                         }
4081                         string->next = strings;
4082                         string->str = strdup(str.buffer);
4083                         if (!string->str) {
4084                                 free(string);
4085                                 do_warning_event(event, "%s(%d): malloc str",
4086                                                  __func__, __LINE__);
4087                                 goto out_free;
4088                         }
4089                         args[i] = (uintptr_t)string->str;
4090                         strings = string;
4091                         trace_seq_destroy(&str);
4092                         break;
4093                 default:
4094                         /*
4095                          * Something went totally wrong, this is not
4096                          * an input error, something in this code broke.
4097                          */
4098                         do_warning_event(event, "Unexpected end of arguments\n");
4099                         goto out_free;
4100                 }
4101                 farg = farg->next;
4102                 param = param->next;
4103         }
4104
4105         ret = (*func_handle->func)(s, args);
4106 out_free:
4107         free(args);
4108         while (strings) {
4109                 string = strings;
4110                 strings = string->next;
4111                 free(string->str);
4112                 free(string);
4113         }
4114
4115  out:
4116         /* TBD : handle return type here */
4117         return ret;
4118 }
4119
4120 static void free_args(struct print_arg *args)
4121 {
4122         struct print_arg *next;
4123
4124         while (args) {
4125                 next = args->next;
4126
4127                 free_arg(args);
4128                 args = next;
4129         }
4130 }
4131
4132 static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event_format *event)
4133 {
4134         struct pevent *pevent = event->pevent;
4135         struct format_field *field, *ip_field;
4136         struct print_arg *args, *arg, **next;
4137         unsigned long long ip, val;
4138         char *ptr;
4139         void *bptr;
4140         int vsize;
4141
4142         field = pevent->bprint_buf_field;
4143         ip_field = pevent->bprint_ip_field;
4144
4145         if (!field) {
4146                 field = pevent_find_field(event, "buf");
4147                 if (!field) {
4148                         do_warning_event(event, "can't find buffer field for binary printk");
4149                         return NULL;
4150                 }
4151                 ip_field = pevent_find_field(event, "ip");
4152                 if (!ip_field) {
4153                         do_warning_event(event, "can't find ip field for binary printk");
4154                         return NULL;
4155                 }
4156                 pevent->bprint_buf_field = field;
4157                 pevent->bprint_ip_field = ip_field;
4158         }
4159
4160         ip = pevent_read_number(pevent, data + ip_field->offset, ip_field->size);
4161
4162         /*
4163          * The first arg is the IP pointer.
4164          */
4165         args = alloc_arg();
4166         if (!args) {
4167                 do_warning_event(event, "%s(%d): not enough memory!",
4168                                  __func__, __LINE__);
4169                 return NULL;
4170         }
4171         arg = args;
4172         arg->next = NULL;
4173         next = &arg->next;
4174
4175         arg->type = PRINT_ATOM;
4176
4177         if (asprintf(&arg->atom.atom, "%lld", ip) < 0)
4178                 goto out_free;
4179
4180         /* skip the first "%ps: " */
4181         for (ptr = fmt + 5, bptr = data + field->offset;
4182              bptr < data + size && *ptr; ptr++) {
4183                 int ls = 0;
4184
4185                 if (*ptr == '%') {
4186  process_again:
4187                         ptr++;
4188                         switch (*ptr) {
4189                         case '%':
4190                                 break;
4191                         case 'l':
4192                                 ls++;
4193                                 goto process_again;
4194                         case 'L':
4195                                 ls = 2;
4196                                 goto process_again;
4197                         case '0' ... '9':
4198                                 goto process_again;
4199                         case '.':
4200                                 goto process_again;
4201                         case 'z':
4202                         case 'Z':
4203                                 ls = 1;
4204                                 goto process_again;
4205                         case 'p':
4206                                 ls = 1;
4207                                 /* fall through */
4208                         case 'd':
4209                         case 'u':
4210                         case 'x':
4211                         case 'i':
4212                                 switch (ls) {
4213                                 case 0:
4214                                         vsize = 4;
4215                                         break;
4216                                 case 1:
4217                                         vsize = pevent->long_size;
4218                                         break;
4219                                 case 2:
4220                                         vsize = 8;
4221                                         break;
4222                                 default:
4223                                         vsize = ls; /* ? */
4224                                         break;
4225                                 }
4226                         /* fall through */
4227                         case '*':
4228                                 if (*ptr == '*')
4229                                         vsize = 4;
4230
4231                                 /* the pointers are always 4 bytes aligned */
4232                                 bptr = (void *)(((unsigned long)bptr + 3) &
4233                                                 ~3);
4234                                 val = pevent_read_number(pevent, bptr, vsize);
4235                                 bptr += vsize;
4236                                 arg = alloc_arg();
4237                                 if (!arg) {
4238                                         do_warning_event(event, "%s(%d): not enough memory!",
4239                                                    __func__, __LINE__);
4240                                         goto out_free;
4241                                 }
4242                                 arg->next = NULL;
4243                                 arg->type = PRINT_ATOM;
4244                                 if (asprintf(&arg->atom.atom, "%lld", val) < 0) {
4245                                         free(arg);
4246                                         goto out_free;
4247                                 }
4248                                 *next = arg;
4249                                 next = &arg->next;
4250                                 /*
4251                                  * The '*' case means that an arg is used as the length.
4252                                  * We need to continue to figure out for what.
4253                                  */
4254                                 if (*ptr == '*')
4255                                         goto process_again;
4256
4257                                 break;
4258                         case 's':
4259                                 arg = alloc_arg();
4260                                 if (!arg) {
4261                                         do_warning_event(event, "%s(%d): not enough memory!",
4262                                                    __func__, __LINE__);
4263                                         goto out_free;
4264                                 }
4265                                 arg->next = NULL;
4266                                 arg->type = PRINT_BSTRING;
4267                                 arg->string.string = strdup(bptr);
4268                                 if (!arg->string.string)
4269                                         goto out_free;
4270                                 bptr += strlen(bptr) + 1;
4271                                 *next = arg;
4272                                 next = &arg->next;
4273                         default:
4274                                 break;
4275                         }
4276                 }
4277         }
4278
4279         return args;
4280
4281 out_free:
4282         free_args(args);
4283         return NULL;
4284 }
4285
4286 static char *
4287 get_bprint_format(void *data, int size __maybe_unused,
4288                   struct event_format *event)
4289 {
4290         struct pevent *pevent = event->pevent;
4291         unsigned long long addr;
4292         struct format_field *field;
4293         struct printk_map *printk;
4294         char *format;
4295
4296         field = pevent->bprint_fmt_field;
4297
4298         if (!field) {
4299                 field = pevent_find_field(event, "fmt");
4300                 if (!field) {
4301                         do_warning_event(event, "can't find format field for binary printk");
4302                         return NULL;
4303                 }
4304                 pevent->bprint_fmt_field = field;
4305         }
4306
4307         addr = pevent_read_number(pevent, data + field->offset, field->size);
4308
4309         printk = find_printk(pevent, addr);
4310         if (!printk) {
4311                 if (asprintf(&format, "%%pf: (NO FORMAT FOUND at %llx)\n", addr) < 0)
4312                         return NULL;
4313                 return format;
4314         }
4315
4316         if (asprintf(&format, "%s: %s", "%pf", printk->printk) < 0)
4317                 return NULL;
4318
4319         return format;
4320 }
4321
4322 static void print_mac_arg(struct trace_seq *s, int mac, void *data, int size,
4323                           struct event_format *event, struct print_arg *arg)
4324 {
4325         unsigned char *buf;
4326         const char *fmt = "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x";
4327
4328         if (arg->type == PRINT_FUNC) {
4329                 process_defined_func(s, data, size, event, arg);
4330                 return;
4331         }
4332
4333         if (arg->type != PRINT_FIELD) {
4334                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d",
4335                                  arg->type);
4336                 return;
4337         }
4338
4339         if (mac == 'm')
4340                 fmt = "%.2x%.2x%.2x%.2x%.2x%.2x";
4341         if (!arg->field.field) {
4342                 arg->field.field =
4343                         pevent_find_any_field(event, arg->field.name);
4344                 if (!arg->field.field) {
4345                         do_warning_event(event, "%s: field %s not found",
4346                                          __func__, arg->field.name);
4347                         return;
4348                 }
4349         }
4350         if (arg->field.field->size != 6) {
4351                 trace_seq_printf(s, "INVALIDMAC");
4352                 return;
4353         }
4354         buf = data + arg->field.field->offset;
4355         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
4356 }
4357
4358 static void print_ip4_addr(struct trace_seq *s, char i, unsigned char *buf)
4359 {
4360         const char *fmt;
4361
4362         if (i == 'i')
4363                 fmt = "%03d.%03d.%03d.%03d";
4364         else
4365                 fmt = "%d.%d.%d.%d";
4366
4367         trace_seq_printf(s, fmt, buf[0], buf[1], buf[2], buf[3]);
4368 }
4369
4370 static inline bool ipv6_addr_v4mapped(const struct in6_addr *a)
4371 {
4372         return ((unsigned long)(a->s6_addr32[0] | a->s6_addr32[1]) |
4373                 (unsigned long)(a->s6_addr32[2] ^ htonl(0x0000ffff))) == 0UL;
4374 }
4375
4376 static inline bool ipv6_addr_is_isatap(const struct in6_addr *addr)
4377 {
4378         return (addr->s6_addr32[2] | htonl(0x02000000)) == htonl(0x02005EFE);
4379 }
4380
4381 static void print_ip6c_addr(struct trace_seq *s, unsigned char *addr)
4382 {
4383         int i, j, range;
4384         unsigned char zerolength[8];
4385         int longest = 1;
4386         int colonpos = -1;
4387         uint16_t word;
4388         uint8_t hi, lo;
4389         bool needcolon = false;
4390         bool useIPv4;
4391         struct in6_addr in6;
4392
4393         memcpy(&in6, addr, sizeof(struct in6_addr));
4394
4395         useIPv4 = ipv6_addr_v4mapped(&in6) || ipv6_addr_is_isatap(&in6);
4396
4397         memset(zerolength, 0, sizeof(zerolength));
4398
4399         if (useIPv4)
4400                 range = 6;
4401         else
4402                 range = 8;
4403
4404         /* find position of longest 0 run */
4405         for (i = 0; i < range; i++) {
4406                 for (j = i; j < range; j++) {
4407                         if (in6.s6_addr16[j] != 0)
4408                                 break;
4409                         zerolength[i]++;
4410                 }
4411         }
4412         for (i = 0; i < range; i++) {
4413                 if (zerolength[i] > longest) {
4414                         longest = zerolength[i];
4415                         colonpos = i;
4416                 }
4417         }
4418         if (longest == 1)               /* don't compress a single 0 */
4419                 colonpos = -1;
4420
4421         /* emit address */
4422         for (i = 0; i < range; i++) {
4423                 if (i == colonpos) {
4424                         if (needcolon || i == 0)
4425                                 trace_seq_printf(s, ":");
4426                         trace_seq_printf(s, ":");
4427                         needcolon = false;
4428                         i += longest - 1;
4429                         continue;
4430                 }
4431                 if (needcolon) {
4432                         trace_seq_printf(s, ":");
4433                         needcolon = false;
4434                 }
4435                 /* hex u16 without leading 0s */
4436                 word = ntohs(in6.s6_addr16[i]);
4437                 hi = word >> 8;
4438                 lo = word & 0xff;
4439                 if (hi)
4440                         trace_seq_printf(s, "%x%02x", hi, lo);
4441                 else
4442                         trace_seq_printf(s, "%x", lo);
4443
4444                 needcolon = true;
4445         }
4446
4447         if (useIPv4) {
4448                 if (needcolon)
4449                         trace_seq_printf(s, ":");
4450                 print_ip4_addr(s, 'I', &in6.s6_addr[12]);
4451         }
4452
4453         return;
4454 }
4455
4456 static void print_ip6_addr(struct trace_seq *s, char i, unsigned char *buf)
4457 {
4458         int j;
4459
4460         for (j = 0; j < 16; j += 2) {
4461                 trace_seq_printf(s, "%02x%02x", buf[j], buf[j+1]);
4462                 if (i == 'I' && j < 14)
4463                         trace_seq_printf(s, ":");
4464         }
4465 }
4466
4467 /*
4468  * %pi4   print an IPv4 address with leading zeros
4469  * %pI4   print an IPv4 address without leading zeros
4470  * %pi6   print an IPv6 address without colons
4471  * %pI6   print an IPv6 address with colons
4472  * %pI6c  print an IPv6 address in compressed form with colons
4473  * %pISpc print an IP address based on sockaddr; p adds port.
4474  */
4475 static int print_ipv4_arg(struct trace_seq *s, const char *ptr, char i,
4476                           void *data, int size, struct event_format *event,
4477                           struct print_arg *arg)
4478 {
4479         unsigned char *buf;
4480
4481         if (arg->type == PRINT_FUNC) {
4482                 process_defined_func(s, data, size, event, arg);
4483                 return 0;
4484         }
4485
4486         if (arg->type != PRINT_FIELD) {
4487                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4488                 return 0;
4489         }
4490
4491         if (!arg->field.field) {
4492                 arg->field.field =
4493                         pevent_find_any_field(event, arg->field.name);
4494                 if (!arg->field.field) {
4495                         do_warning("%s: field %s not found",
4496                                    __func__, arg->field.name);
4497                         return 0;
4498                 }
4499         }
4500
4501         buf = data + arg->field.field->offset;
4502
4503         if (arg->field.field->size != 4) {
4504                 trace_seq_printf(s, "INVALIDIPv4");
4505                 return 0;
4506         }
4507         print_ip4_addr(s, i, buf);
4508
4509         return 0;
4510 }
4511
4512 static int print_ipv6_arg(struct trace_seq *s, const char *ptr, char i,
4513                           void *data, int size, struct event_format *event,
4514                           struct print_arg *arg)
4515 {
4516         char have_c = 0;
4517         unsigned char *buf;
4518         int rc = 0;
4519
4520         /* pI6c */
4521         if (i == 'I' && *ptr == 'c') {
4522                 have_c = 1;
4523                 ptr++;
4524                 rc++;
4525         }
4526
4527         if (arg->type == PRINT_FUNC) {
4528                 process_defined_func(s, data, size, event, arg);
4529                 return rc;
4530         }
4531
4532         if (arg->type != PRINT_FIELD) {
4533                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4534                 return rc;
4535         }
4536
4537         if (!arg->field.field) {
4538                 arg->field.field =
4539                         pevent_find_any_field(event, arg->field.name);
4540                 if (!arg->field.field) {
4541                         do_warning("%s: field %s not found",
4542                                    __func__, arg->field.name);
4543                         return rc;
4544                 }
4545         }
4546
4547         buf = data + arg->field.field->offset;
4548
4549         if (arg->field.field->size != 16) {
4550                 trace_seq_printf(s, "INVALIDIPv6");
4551                 return rc;
4552         }
4553
4554         if (have_c)
4555                 print_ip6c_addr(s, buf);
4556         else
4557                 print_ip6_addr(s, i, buf);
4558
4559         return rc;
4560 }
4561
4562 static int print_ipsa_arg(struct trace_seq *s, const char *ptr, char i,
4563                           void *data, int size, struct event_format *event,
4564                           struct print_arg *arg)
4565 {
4566         char have_c = 0, have_p = 0;
4567         unsigned char *buf;
4568         struct sockaddr_storage *sa;
4569         int rc = 0;
4570
4571         /* pISpc */
4572         if (i == 'I') {
4573                 if (*ptr == 'p') {
4574                         have_p = 1;
4575                         ptr++;
4576                         rc++;
4577                 }
4578                 if (*ptr == 'c') {
4579                         have_c = 1;
4580                         ptr++;
4581                         rc++;
4582                 }
4583         }
4584
4585         if (arg->type == PRINT_FUNC) {
4586                 process_defined_func(s, data, size, event, arg);
4587                 return rc;
4588         }
4589
4590         if (arg->type != PRINT_FIELD) {
4591                 trace_seq_printf(s, "ARG TYPE NOT FIELD BUT %d", arg->type);
4592                 return rc;
4593         }
4594
4595         if (!arg->field.field) {
4596                 arg->field.field =
4597                         pevent_find_any_field(event, arg->field.name);
4598                 if (!arg->field.field) {
4599                         do_warning("%s: field %s not found",
4600                                    __func__, arg->field.name);
4601                         return rc;
4602                 }
4603         }
4604
4605         sa = (struct sockaddr_storage *) (data + arg->field.field->offset);
4606
4607         if (sa->ss_family == AF_INET) {
4608                 struct sockaddr_in *sa4 = (struct sockaddr_in *) sa;
4609
4610                 if (arg->field.field->size < sizeof(struct sockaddr_in)) {
4611                         trace_seq_printf(s, "INVALIDIPv4");
4612                         return rc;
4613                 }
4614
4615                 print_ip4_addr(s, i, (unsigned char *) &sa4->sin_addr);
4616                 if (have_p)
4617                         trace_seq_printf(s, ":%d", ntohs(sa4->sin_port));
4618
4619
4620         } else if (sa->ss_family == AF_INET6) {
4621                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
4622
4623                 if (arg->field.field->size < sizeof(struct sockaddr_in6)) {
4624                         trace_seq_printf(s, "INVALIDIPv6");
4625                         return rc;
4626                 }
4627
4628                 if (have_p)
4629                         trace_seq_printf(s, "[");
4630
4631                 buf = (unsigned char *) &sa6->sin6_addr;
4632                 if (have_c)
4633                         print_ip6c_addr(s, buf);
4634                 else
4635                         print_ip6_addr(s, i, buf);
4636
4637                 if (have_p)
4638                         trace_seq_printf(s, "]:%d", ntohs(sa6->sin6_port));
4639         }
4640
4641         return rc;
4642 }
4643
4644 static int print_ip_arg(struct trace_seq *s, const char *ptr,
4645                         void *data, int size, struct event_format *event,
4646                         struct print_arg *arg)
4647 {
4648         char i = *ptr;  /* 'i' or 'I' */
4649         char ver;
4650         int rc = 0;
4651
4652         ptr++;
4653         rc++;
4654
4655         ver = *ptr;
4656         ptr++;
4657         rc++;
4658
4659         switch (ver) {
4660         case '4':
4661                 rc += print_ipv4_arg(s, ptr, i, data, size, event, arg);
4662                 break;
4663         case '6':
4664                 rc += print_ipv6_arg(s, ptr, i, data, size, event, arg);
4665                 break;
4666         case 'S':
4667                 rc += print_ipsa_arg(s, ptr, i, data, size, event, arg);
4668                 break;
4669         default:
4670                 return 0;
4671         }
4672
4673         return rc;
4674 }
4675
4676 static int is_printable_array(char *p, unsigned int len)
4677 {
4678         unsigned int i;
4679
4680         for (i = 0; i < len && p[i]; i++)
4681                 if (!isprint(p[i]) && !isspace(p[i]))
4682                     return 0;
4683         return 1;
4684 }
4685
4686 static void print_event_fields(struct trace_seq *s, void *data,
4687                                int size __maybe_unused,
4688                                struct event_format *event)
4689 {
4690         struct format_field *field;
4691         unsigned long long val;
4692         unsigned int offset, len, i;
4693
4694         field = event->format.fields;
4695         while (field) {
4696                 trace_seq_printf(s, " %s=", field->name);
4697                 if (field->flags & FIELD_IS_ARRAY) {
4698                         offset = field->offset;
4699                         len = field->size;
4700                         if (field->flags & FIELD_IS_DYNAMIC) {
4701                                 val = pevent_read_number(event->pevent, data + offset, len);
4702                                 offset = val;
4703                                 len = offset >> 16;
4704                                 offset &= 0xffff;
4705                         }
4706                         if (field->flags & FIELD_IS_STRING &&
4707                             is_printable_array(data + offset, len)) {
4708                                 trace_seq_printf(s, "%s", (char *)data + offset);
4709                         } else {
4710                                 trace_seq_puts(s, "ARRAY[");
4711                                 for (i = 0; i < len; i++) {
4712                                         if (i)
4713                                                 trace_seq_puts(s, ", ");
4714                                         trace_seq_printf(s, "%02x",
4715                                                          *((unsigned char *)data + offset + i));
4716                                 }
4717                                 trace_seq_putc(s, ']');
4718                                 field->flags &= ~FIELD_IS_STRING;
4719                         }
4720                 } else {
4721                         val = pevent_read_number(event->pevent, data + field->offset,
4722                                                  field->size);
4723                         if (field->flags & FIELD_IS_POINTER) {
4724                                 trace_seq_printf(s, "0x%llx", val);
4725                         } else if (field->flags & FIELD_IS_SIGNED) {
4726                                 switch (field->size) {
4727                                 case 4:
4728                                         /*
4729                                          * If field is long then print it in hex.
4730                                          * A long usually stores pointers.
4731                                          */
4732                                         if (field->flags & FIELD_IS_LONG)
4733                                                 trace_seq_printf(s, "0x%x", (int)val);
4734                                         else
4735                                                 trace_seq_printf(s, "%d", (int)val);
4736                                         break;
4737                                 case 2:
4738                                         trace_seq_printf(s, "%2d", (short)val);
4739                                         break;
4740                                 case 1:
4741                                         trace_seq_printf(s, "%1d", (char)val);
4742                                         break;
4743                                 default:
4744                                         trace_seq_printf(s, "%lld", val);
4745                                 }
4746                         } else {
4747                                 if (field->flags & FIELD_IS_LONG)
4748                                         trace_seq_printf(s, "0x%llx", val);
4749                                 else
4750                                         trace_seq_printf(s, "%llu", val);
4751                         }
4752                 }
4753                 field = field->next;
4754         }
4755 }
4756
4757 static void pretty_print(struct trace_seq *s, void *data, int size, struct event_format *event)
4758 {
4759         struct pevent *pevent = event->pevent;
4760         struct print_fmt *print_fmt = &event->print_fmt;
4761         struct print_arg *arg = print_fmt->args;
4762         struct print_arg *args = NULL;
4763         const char *ptr = print_fmt->format;
4764         unsigned long long val;
4765         struct func_map *func;
4766         const char *saveptr;
4767         struct trace_seq p;
4768         char *bprint_fmt = NULL;
4769         char format[32];
4770         int show_func;
4771         int len_as_arg;
4772         int len_arg;
4773         int len;
4774         int ls;
4775
4776         if (event->flags & EVENT_FL_FAILED) {
4777                 trace_seq_printf(s, "[FAILED TO PARSE]");
4778                 print_event_fields(s, data, size, event);
4779                 return;
4780         }
4781
4782         if (event->flags & EVENT_FL_ISBPRINT) {
4783                 bprint_fmt = get_bprint_format(data, size, event);
4784                 args = make_bprint_args(bprint_fmt, data, size, event);
4785                 arg = args;
4786                 ptr = bprint_fmt;
4787         }
4788
4789         for (; *ptr; ptr++) {
4790                 ls = 0;
4791                 if (*ptr == '\\') {
4792                         ptr++;
4793                         switch (*ptr) {
4794                         case 'n':
4795                                 trace_seq_putc(s, '\n');
4796                                 break;
4797                         case 't':
4798                                 trace_seq_putc(s, '\t');
4799                                 break;
4800                         case 'r':
4801                                 trace_seq_putc(s, '\r');
4802                                 break;
4803                         case '\\':
4804                                 trace_seq_putc(s, '\\');
4805                                 break;
4806                         default:
4807                                 trace_seq_putc(s, *ptr);
4808                                 break;
4809                         }
4810
4811                 } else if (*ptr == '%') {
4812                         saveptr = ptr;
4813                         show_func = 0;
4814                         len_as_arg = 0;
4815  cont_process:
4816                         ptr++;
4817                         switch (*ptr) {
4818                         case '%':
4819                                 trace_seq_putc(s, '%');
4820                                 break;
4821                         case '#':
4822                                 /* FIXME: need to handle properly */
4823                                 goto cont_process;
4824                         case 'h':
4825                                 ls--;
4826                                 goto cont_process;
4827                         case 'l':
4828                                 ls++;
4829                                 goto cont_process;
4830                         case 'L':
4831                                 ls = 2;
4832                                 goto cont_process;
4833                         case '*':
4834                                 /* The argument is the length. */
4835                                 if (!arg) {
4836                                         do_warning_event(event, "no argument match");
4837                                         event->flags |= EVENT_FL_FAILED;
4838                                         goto out_failed;
4839                                 }
4840                                 len_arg = eval_num_arg(data, size, event, arg);
4841                                 len_as_arg = 1;
4842                                 arg = arg->next;
4843                                 goto cont_process;
4844                         case '.':
4845                         case 'z':
4846                         case 'Z':
4847                         case '0' ... '9':
4848                         case '-':
4849                                 goto cont_process;
4850                         case 'p':
4851                                 if (pevent->long_size == 4)
4852                                         ls = 1;
4853                                 else
4854                                         ls = 2;
4855
4856                                 if (*(ptr+1) == 'F' ||
4857                                     *(ptr+1) == 'f') {
4858                                         ptr++;
4859                                         show_func = *ptr;
4860                                 } else if (*(ptr+1) == 'M' || *(ptr+1) == 'm') {
4861                                         print_mac_arg(s, *(ptr+1), data, size, event, arg);
4862                                         ptr++;
4863                                         arg = arg->next;
4864                                         break;
4865                                 } else if (*(ptr+1) == 'I' || *(ptr+1) == 'i') {
4866                                         int n;
4867
4868                                         n = print_ip_arg(s, ptr+1, data, size, event, arg);
4869                                         if (n > 0) {
4870                                                 ptr += n;
4871                                                 arg = arg->next;
4872                                                 break;
4873                                         }
4874                                 }
4875
4876                                 /* fall through */
4877                         case 'd':
4878                         case 'i':
4879                         case 'x':
4880                         case 'X':
4881                         case 'u':
4882                                 if (!arg) {
4883                                         do_warning_event(event, "no argument match");
4884                                         event->flags |= EVENT_FL_FAILED;
4885                                         goto out_failed;
4886                                 }
4887
4888                                 len = ((unsigned long)ptr + 1) -
4889                                         (unsigned long)saveptr;
4890
4891                                 /* should never happen */
4892                                 if (len > 31) {
4893                                         do_warning_event(event, "bad format!");
4894                                         event->flags |= EVENT_FL_FAILED;
4895                                         len = 31;
4896                                 }
4897
4898                                 memcpy(format, saveptr, len);
4899                                 format[len] = 0;
4900
4901                                 val = eval_num_arg(data, size, event, arg);
4902                                 arg = arg->next;
4903
4904                                 if (show_func) {
4905                                         func = find_func(pevent, val);
4906                                         if (func) {
4907                                                 trace_seq_puts(s, func->func);
4908                                                 if (show_func == 'F')
4909                                                         trace_seq_printf(s,
4910                                                                "+0x%llx",
4911                                                                val - func->addr);
4912                                                 break;
4913                                         }
4914                                 }
4915                                 if (pevent->long_size == 8 && ls &&
4916                                     sizeof(long) != 8) {
4917                                         char *p;
4918
4919                                         ls = 2;
4920                                         /* make %l into %ll */
4921                                         p = strchr(format, 'l');
4922                                         if (p)
4923                                                 memmove(p+1, p, strlen(p)+1);
4924                                         else if (strcmp(format, "%p") == 0)
4925                                                 strcpy(format, "0x%llx");
4926                                 }
4927                                 switch (ls) {
4928                                 case -2:
4929                                         if (len_as_arg)
4930                                                 trace_seq_printf(s, format, len_arg, (char)val);
4931                                         else
4932                                                 trace_seq_printf(s, format, (char)val);
4933                                         break;
4934                                 case -1:
4935                                         if (len_as_arg)
4936                                                 trace_seq_printf(s, format, len_arg, (short)val);
4937                                         else
4938                                                 trace_seq_printf(s, format, (short)val);
4939                                         break;
4940                                 case 0:
4941                                         if (len_as_arg)
4942                                                 trace_seq_printf(s, format, len_arg, (int)val);
4943                                         else
4944                                                 trace_seq_printf(s, format, (int)val);
4945                                         break;
4946                                 case 1:
4947                                         if (len_as_arg)
4948                                                 trace_seq_printf(s, format, len_arg, (long)val);
4949                                         else
4950                                                 trace_seq_printf(s, format, (long)val);
4951                                         break;
4952                                 case 2:
4953                                         if (len_as_arg)
4954                                                 trace_seq_printf(s, format, len_arg,
4955                                                                  (long long)val);
4956                                         else
4957                                                 trace_seq_printf(s, format, (long long)val);
4958                                         break;
4959                                 default:
4960                                         do_warning_event(event, "bad count (%d)", ls);
4961                                         event->flags |= EVENT_FL_FAILED;
4962                                 }
4963                                 break;
4964                         case 's':
4965                                 if (!arg) {
4966                                         do_warning_event(event, "no matching argument");
4967                                         event->flags |= EVENT_FL_FAILED;
4968                                         goto out_failed;
4969                                 }
4970
4971                                 len = ((unsigned long)ptr + 1) -
4972                                         (unsigned long)saveptr;
4973
4974                                 /* should never happen */
4975                                 if (len > 31) {
4976                                         do_warning_event(event, "bad format!");
4977                                         event->flags |= EVENT_FL_FAILED;
4978                                         len = 31;
4979                                 }
4980
4981                                 memcpy(format, saveptr, len);
4982                                 format[len] = 0;
4983                                 if (!len_as_arg)
4984                                         len_arg = -1;
4985                                 /* Use helper trace_seq */
4986                                 trace_seq_init(&p);
4987                                 print_str_arg(&p, data, size, event,
4988                                               format, len_arg, arg);
4989                                 trace_seq_terminate(&p);
4990                                 trace_seq_puts(s, p.buffer);
4991                                 trace_seq_destroy(&p);
4992                                 arg = arg->next;
4993                                 break;
4994                         default:
4995                                 trace_seq_printf(s, ">%c<", *ptr);
4996
4997                         }
4998                 } else
4999                         trace_seq_putc(s, *ptr);
5000         }
5001
5002         if (event->flags & EVENT_FL_FAILED) {
5003 out_failed:
5004                 trace_seq_printf(s, "[FAILED TO PARSE]");
5005         }
5006
5007         if (args) {
5008                 free_args(args);
5009                 free(bprint_fmt);
5010         }
5011 }
5012
5013 /**
5014  * pevent_data_lat_fmt - parse the data for the latency format
5015  * @pevent: a handle to the pevent
5016  * @s: the trace_seq to write to
5017  * @record: the record to read from
5018  *
5019  * This parses out the Latency format (interrupts disabled,
5020  * need rescheduling, in hard/soft interrupt, preempt count
5021  * and lock depth) and places it into the trace_seq.
5022  */
5023 void pevent_data_lat_fmt(struct pevent *pevent,
5024                          struct trace_seq *s, struct pevent_record *record)
5025 {
5026         static int check_lock_depth = 1;
5027         static int check_migrate_disable = 1;
5028         static int lock_depth_exists;
5029         static int migrate_disable_exists;
5030         unsigned int lat_flags;
5031         unsigned int pc;
5032         int lock_depth;
5033         int migrate_disable;
5034         int hardirq;
5035         int softirq;
5036         void *data = record->data;
5037
5038         lat_flags = parse_common_flags(pevent, data);
5039         pc = parse_common_pc(pevent, data);
5040         /* lock_depth may not always exist */
5041         if (lock_depth_exists)
5042                 lock_depth = parse_common_lock_depth(pevent, data);
5043         else if (check_lock_depth) {
5044                 lock_depth = parse_common_lock_depth(pevent, data);
5045                 if (lock_depth < 0)
5046                         check_lock_depth = 0;
5047                 else
5048                         lock_depth_exists = 1;
5049         }
5050
5051         /* migrate_disable may not always exist */
5052         if (migrate_disable_exists)
5053                 migrate_disable = parse_common_migrate_disable(pevent, data);
5054         else if (check_migrate_disable) {
5055                 migrate_disable = parse_common_migrate_disable(pevent, data);
5056                 if (migrate_disable < 0)
5057                         check_migrate_disable = 0;
5058                 else
5059                         migrate_disable_exists = 1;
5060         }
5061
5062         hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
5063         softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
5064
5065         trace_seq_printf(s, "%c%c%c",
5066                (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
5067                (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
5068                'X' : '.',
5069                (lat_flags & TRACE_FLAG_NEED_RESCHED) ?
5070                'N' : '.',
5071                (hardirq && softirq) ? 'H' :
5072                hardirq ? 'h' : softirq ? 's' : '.');
5073
5074         if (pc)
5075                 trace_seq_printf(s, "%x", pc);
5076         else
5077                 trace_seq_putc(s, '.');
5078
5079         if (migrate_disable_exists) {
5080                 if (migrate_disable < 0)
5081                         trace_seq_putc(s, '.');
5082                 else
5083                         trace_seq_printf(s, "%d", migrate_disable);
5084         }
5085
5086         if (lock_depth_exists) {
5087                 if (lock_depth < 0)
5088                         trace_seq_putc(s, '.');
5089                 else
5090                         trace_seq_printf(s, "%d", lock_depth);
5091         }
5092
5093         trace_seq_terminate(s);
5094 }
5095
5096 /**
5097  * pevent_data_type - parse out the given event type
5098  * @pevent: a handle to the pevent
5099  * @rec: the record to read from
5100  *
5101  * This returns the event id from the @rec.
5102  */
5103 int pevent_data_type(struct pevent *pevent, struct pevent_record *rec)
5104 {
5105         return trace_parse_common_type(pevent, rec->data);
5106 }
5107
5108 /**
5109  * pevent_data_event_from_type - find the event by a given type
5110  * @pevent: a handle to the pevent
5111  * @type: the type of the event.
5112  *
5113  * This returns the event form a given @type;
5114  */
5115 struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type)
5116 {
5117         return pevent_find_event(pevent, type);
5118 }
5119
5120 /**
5121  * pevent_data_pid - parse the PID from raw data
5122  * @pevent: a handle to the pevent
5123  * @rec: the record to parse
5124  *
5125  * This returns the PID from a raw data.
5126  */
5127 int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec)
5128 {
5129         return parse_common_pid(pevent, rec->data);
5130 }
5131
5132 /**
5133  * pevent_data_comm_from_pid - return the command line from PID
5134  * @pevent: a handle to the pevent
5135  * @pid: the PID of the task to search for
5136  *
5137  * This returns a pointer to the command line that has the given
5138  * @pid.
5139  */
5140 const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid)
5141 {
5142         const char *comm;
5143
5144         comm = find_cmdline(pevent, pid);
5145         return comm;
5146 }
5147
5148 static struct cmdline *
5149 pid_from_cmdlist(struct pevent *pevent, const char *comm, struct cmdline *next)
5150 {
5151         struct cmdline_list *cmdlist = (struct cmdline_list *)next;
5152
5153         if (cmdlist)
5154                 cmdlist = cmdlist->next;
5155         else
5156                 cmdlist = pevent->cmdlist;
5157
5158         while (cmdlist && strcmp(cmdlist->comm, comm) != 0)
5159                 cmdlist = cmdlist->next;
5160
5161         return (struct cmdline *)cmdlist;
5162 }
5163
5164 /**
5165  * pevent_data_pid_from_comm - return the pid from a given comm
5166  * @pevent: a handle to the pevent
5167  * @comm: the cmdline to find the pid from
5168  * @next: the cmdline structure to find the next comm
5169  *
5170  * This returns the cmdline structure that holds a pid for a given
5171  * comm, or NULL if none found. As there may be more than one pid for
5172  * a given comm, the result of this call can be passed back into
5173  * a recurring call in the @next paramater, and then it will find the
5174  * next pid.
5175  * Also, it does a linear seach, so it may be slow.
5176  */
5177 struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm,
5178                                           struct cmdline *next)
5179 {
5180         struct cmdline *cmdline;
5181
5182         /*
5183          * If the cmdlines have not been converted yet, then use
5184          * the list.
5185          */
5186         if (!pevent->cmdlines)
5187                 return pid_from_cmdlist(pevent, comm, next);
5188
5189         if (next) {
5190                 /*
5191                  * The next pointer could have been still from
5192                  * a previous call before cmdlines were created
5193                  */
5194                 if (next < pevent->cmdlines ||
5195                     next >= pevent->cmdlines + pevent->cmdline_count)
5196                         next = NULL;
5197                 else
5198                         cmdline  = next++;
5199         }
5200
5201         if (!next)
5202                 cmdline = pevent->cmdlines;
5203
5204         while (cmdline < pevent->cmdlines + pevent->cmdline_count) {
5205                 if (strcmp(cmdline->comm, comm) == 0)
5206                         return cmdline;
5207                 cmdline++;
5208         }
5209         return NULL;
5210 }
5211
5212 /**
5213  * pevent_cmdline_pid - return the pid associated to a given cmdline
5214  * @cmdline: The cmdline structure to get the pid from
5215  *
5216  * Returns the pid for a give cmdline. If @cmdline is NULL, then
5217  * -1 is returned.
5218  */
5219 int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline)
5220 {
5221         struct cmdline_list *cmdlist = (struct cmdline_list *)cmdline;
5222
5223         if (!cmdline)
5224                 return -1;
5225
5226         /*
5227          * If cmdlines have not been created yet, or cmdline is
5228          * not part of the array, then treat it as a cmdlist instead.
5229          */
5230         if (!pevent->cmdlines ||
5231             cmdline < pevent->cmdlines ||
5232             cmdline >= pevent->cmdlines + pevent->cmdline_count)
5233                 return cmdlist->pid;
5234
5235         return cmdline->pid;
5236 }
5237
5238 /**
5239  * pevent_data_comm_from_pid - parse the data into the print format
5240  * @s: the trace_seq to write to
5241  * @event: the handle to the event
5242  * @record: the record to read from
5243  *
5244  * This parses the raw @data using the given @event information and
5245  * writes the print format into the trace_seq.
5246  */
5247 void pevent_event_info(struct trace_seq *s, struct event_format *event,
5248                        struct pevent_record *record)
5249 {
5250         int print_pretty = 1;
5251
5252         if (event->pevent->print_raw || (event->flags & EVENT_FL_PRINTRAW))
5253                 print_event_fields(s, record->data, record->size, event);
5254         else {
5255
5256                 if (event->handler && !(event->flags & EVENT_FL_NOHANDLE))
5257                         print_pretty = event->handler(s, record, event,
5258                                                       event->context);
5259
5260                 if (print_pretty)
5261                         pretty_print(s, record->data, record->size, event);
5262         }
5263
5264         trace_seq_terminate(s);
5265 }
5266
5267 static bool is_timestamp_in_us(char *trace_clock, bool use_trace_clock)
5268 {
5269         if (!use_trace_clock)
5270                 return true;
5271
5272         if (!strcmp(trace_clock, "local") || !strcmp(trace_clock, "global")
5273             || !strcmp(trace_clock, "uptime") || !strcmp(trace_clock, "perf"))
5274                 return true;
5275
5276         /* trace_clock is setting in tsc or counter mode */
5277         return false;
5278 }
5279
5280 void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
5281                         struct pevent_record *record, bool use_trace_clock)
5282 {
5283         static const char *spaces = "                    "; /* 20 spaces */
5284         struct event_format *event;
5285         unsigned long secs;
5286         unsigned long usecs;
5287         unsigned long nsecs;
5288         const char *comm;
5289         void *data = record->data;
5290         int type;
5291         int pid;
5292         int len;
5293         int p;
5294         bool use_usec_format;
5295
5296         use_usec_format = is_timestamp_in_us(pevent->trace_clock,
5297                                                         use_trace_clock);
5298         if (use_usec_format) {
5299                 secs = record->ts / NSECS_PER_SEC;
5300                 nsecs = record->ts - secs * NSECS_PER_SEC;
5301         }
5302
5303         if (record->size < 0) {
5304                 do_warning("ug! negative record size %d", record->size);
5305                 return;
5306         }
5307
5308         type = trace_parse_common_type(pevent, data);
5309
5310         event = pevent_find_event(pevent, type);
5311         if (!event) {
5312                 do_warning("ug! no event found for type %d", type);
5313                 return;
5314         }
5315
5316         pid = parse_common_pid(pevent, data);
5317         comm = find_cmdline(pevent, pid);
5318
5319         if (pevent->latency_format) {
5320                 trace_seq_printf(s, "%8.8s-%-5d %3d",
5321                        comm, pid, record->cpu);
5322                 pevent_data_lat_fmt(pevent, s, record);
5323         } else
5324                 trace_seq_printf(s, "%16s-%-5d [%03d]", comm, pid, record->cpu);
5325
5326         if (use_usec_format) {
5327                 if (pevent->flags & PEVENT_NSEC_OUTPUT) {
5328                         usecs = nsecs;
5329                         p = 9;
5330                 } else {
5331                         usecs = (nsecs + 500) / NSECS_PER_USEC;
5332                         p = 6;
5333                 }
5334
5335                 trace_seq_printf(s, " %5lu.%0*lu: %s: ",
5336                                         secs, p, usecs, event->name);
5337         } else
5338                 trace_seq_printf(s, " %12llu: %s: ",
5339                                         record->ts, event->name);
5340
5341         /* Space out the event names evenly. */
5342         len = strlen(event->name);
5343         if (len < 20)
5344                 trace_seq_printf(s, "%.*s", 20 - len, spaces);
5345
5346         pevent_event_info(s, event, record);
5347 }
5348
5349 static int events_id_cmp(const void *a, const void *b)
5350 {
5351         struct event_format * const * ea = a;
5352         struct event_format * const * eb = b;
5353
5354         if ((*ea)->id < (*eb)->id)
5355                 return -1;
5356
5357         if ((*ea)->id > (*eb)->id)
5358                 return 1;
5359
5360         return 0;
5361 }
5362
5363 static int events_name_cmp(const void *a, const void *b)
5364 {
5365         struct event_format * const * ea = a;
5366         struct event_format * const * eb = b;
5367         int res;
5368
5369         res = strcmp((*ea)->name, (*eb)->name);
5370         if (res)
5371                 return res;
5372
5373         res = strcmp((*ea)->system, (*eb)->system);
5374         if (res)
5375                 return res;
5376
5377         return events_id_cmp(a, b);
5378 }
5379
5380 static int events_system_cmp(const void *a, const void *b)
5381 {
5382         struct event_format * const * ea = a;
5383         struct event_format * const * eb = b;
5384         int res;
5385
5386         res = strcmp((*ea)->system, (*eb)->system);
5387         if (res)
5388                 return res;
5389
5390         res = strcmp((*ea)->name, (*eb)->name);
5391         if (res)
5392                 return res;
5393
5394         return events_id_cmp(a, b);
5395 }
5396
5397 struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type sort_type)
5398 {
5399         struct event_format **events;
5400         int (*sort)(const void *a, const void *b);
5401
5402         events = pevent->sort_events;
5403
5404         if (events && pevent->last_type == sort_type)
5405                 return events;
5406
5407         if (!events) {
5408                 events = malloc(sizeof(*events) * (pevent->nr_events + 1));
5409                 if (!events)
5410                         return NULL;
5411
5412                 memcpy(events, pevent->events, sizeof(*events) * pevent->nr_events);
5413                 events[pevent->nr_events] = NULL;
5414
5415                 pevent->sort_events = events;
5416
5417                 /* the internal events are sorted by id */
5418                 if (sort_type == EVENT_SORT_ID) {
5419                         pevent->last_type = sort_type;
5420                         return events;
5421                 }
5422         }
5423
5424         switch (sort_type) {
5425         case EVENT_SORT_ID:
5426                 sort = events_id_cmp;
5427                 break;
5428         case EVENT_SORT_NAME:
5429                 sort = events_name_cmp;
5430                 break;
5431         case EVENT_SORT_SYSTEM:
5432                 sort = events_system_cmp;
5433                 break;
5434         default:
5435                 return events;
5436         }
5437
5438         qsort(events, pevent->nr_events, sizeof(*events), sort);
5439         pevent->last_type = sort_type;
5440
5441         return events;
5442 }
5443
5444 static struct format_field **
5445 get_event_fields(const char *type, const char *name,
5446                  int count, struct format_field *list)
5447 {
5448         struct format_field **fields;
5449         struct format_field *field;
5450         int i = 0;
5451
5452         fields = malloc(sizeof(*fields) * (count + 1));
5453         if (!fields)
5454                 return NULL;
5455
5456         for (field = list; field; field = field->next) {
5457                 fields[i++] = field;
5458                 if (i == count + 1) {
5459                         do_warning("event %s has more %s fields than specified",
5460                                 name, type);
5461                         i--;
5462                         break;
5463                 }
5464         }
5465
5466         if (i != count)
5467                 do_warning("event %s has less %s fields than specified",
5468                         name, type);
5469
5470         fields[i] = NULL;
5471
5472         return fields;
5473 }
5474
5475 /**
5476  * pevent_event_common_fields - return a list of common fields for an event
5477  * @event: the event to return the common fields of.
5478  *
5479  * Returns an allocated array of fields. The last item in the array is NULL.
5480  * The array must be freed with free().
5481  */
5482 struct format_field **pevent_event_common_fields(struct event_format *event)
5483 {
5484         return get_event_fields("common", event->name,
5485                                 event->format.nr_common,
5486                                 event->format.common_fields);
5487 }
5488
5489 /**
5490  * pevent_event_fields - return a list of event specific fields for an event
5491  * @event: the event to return the fields of.
5492  *
5493  * Returns an allocated array of fields. The last item in the array is NULL.
5494  * The array must be freed with free().
5495  */
5496 struct format_field **pevent_event_fields(struct event_format *event)
5497 {
5498         return get_event_fields("event", event->name,
5499                                 event->format.nr_fields,
5500                                 event->format.fields);
5501 }
5502
5503 static void print_fields(struct trace_seq *s, struct print_flag_sym *field)
5504 {
5505         trace_seq_printf(s, "{ %s, %s }", field->value, field->str);
5506         if (field->next) {
5507                 trace_seq_puts(s, ", ");
5508                 print_fields(s, field->next);
5509         }
5510 }
5511
5512 /* for debugging */
5513 static void print_args(struct print_arg *args)
5514 {
5515         int print_paren = 1;
5516         struct trace_seq s;
5517
5518         switch (args->type) {
5519         case PRINT_NULL:
5520                 printf("null");
5521                 break;
5522         case PRINT_ATOM:
5523                 printf("%s", args->atom.atom);
5524                 break;
5525         case PRINT_FIELD:
5526                 printf("REC->%s", args->field.name);
5527                 break;
5528         case PRINT_FLAGS:
5529                 printf("__print_flags(");
5530                 print_args(args->flags.field);
5531                 printf(", %s, ", args->flags.delim);
5532                 trace_seq_init(&s);
5533                 print_fields(&s, args->flags.flags);
5534                 trace_seq_do_printf(&s);
5535                 trace_seq_destroy(&s);
5536                 printf(")");
5537                 break;
5538         case PRINT_SYMBOL:
5539                 printf("__print_symbolic(");
5540                 print_args(args->symbol.field);
5541                 printf(", ");
5542                 trace_seq_init(&s);
5543                 print_fields(&s, args->symbol.symbols);
5544                 trace_seq_do_printf(&s);
5545                 trace_seq_destroy(&s);
5546                 printf(")");
5547                 break;
5548         case PRINT_HEX:
5549                 printf("__print_hex(");
5550                 print_args(args->hex.field);
5551                 printf(", ");
5552                 print_args(args->hex.size);
5553                 printf(")");
5554                 break;
5555         case PRINT_INT_ARRAY:
5556                 printf("__print_array(");
5557                 print_args(args->int_array.field);
5558                 printf(", ");
5559                 print_args(args->int_array.count);
5560                 printf(", ");
5561                 print_args(args->int_array.el_size);
5562                 printf(")");
5563                 break;
5564         case PRINT_STRING:
5565         case PRINT_BSTRING:
5566                 printf("__get_str(%s)", args->string.string);
5567                 break;
5568         case PRINT_BITMASK:
5569                 printf("__get_bitmask(%s)", args->bitmask.bitmask);
5570                 break;
5571         case PRINT_TYPE:
5572                 printf("(%s)", args->typecast.type);
5573                 print_args(args->typecast.item);
5574                 break;
5575         case PRINT_OP:
5576                 if (strcmp(args->op.op, ":") == 0)
5577                         print_paren = 0;
5578                 if (print_paren)
5579                         printf("(");
5580                 print_args(args->op.left);
5581                 printf(" %s ", args->op.op);
5582                 print_args(args->op.right);
5583                 if (print_paren)
5584                         printf(")");
5585                 break;
5586         default:
5587                 /* we should warn... */
5588                 return;
5589         }
5590         if (args->next) {
5591                 printf("\n");
5592                 print_args(args->next);
5593         }
5594 }
5595
5596 static void parse_header_field(const char *field,
5597                                int *offset, int *size, int mandatory)
5598 {
5599         unsigned long long save_input_buf_ptr;
5600         unsigned long long save_input_buf_siz;
5601         char *token;
5602         int type;
5603
5604         save_input_buf_ptr = input_buf_ptr;
5605         save_input_buf_siz = input_buf_siz;
5606
5607         if (read_expected(EVENT_ITEM, "field") < 0)
5608                 return;
5609         if (read_expected(EVENT_OP, ":") < 0)
5610                 return;
5611
5612         /* type */
5613         if (read_expect_type(EVENT_ITEM, &token) < 0)
5614                 goto fail;
5615         free_token(token);
5616
5617         /*
5618          * If this is not a mandatory field, then test it first.
5619          */
5620         if (mandatory) {
5621                 if (read_expected(EVENT_ITEM, field) < 0)
5622                         return;
5623         } else {
5624                 if (read_expect_type(EVENT_ITEM, &token) < 0)
5625                         goto fail;
5626                 if (strcmp(token, field) != 0)
5627                         goto discard;
5628                 free_token(token);
5629         }
5630
5631         if (read_expected(EVENT_OP, ";") < 0)
5632                 return;
5633         if (read_expected(EVENT_ITEM, "offset") < 0)
5634                 return;
5635         if (read_expected(EVENT_OP, ":") < 0)
5636                 return;
5637         if (read_expect_type(EVENT_ITEM, &token) < 0)
5638                 goto fail;
5639         *offset = atoi(token);
5640         free_token(token);
5641         if (read_expected(EVENT_OP, ";") < 0)
5642                 return;
5643         if (read_expected(EVENT_ITEM, "size") < 0)
5644                 return;
5645         if (read_expected(EVENT_OP, ":") < 0)
5646                 return;
5647         if (read_expect_type(EVENT_ITEM, &token) < 0)
5648                 goto fail;
5649         *size = atoi(token);
5650         free_token(token);
5651         if (read_expected(EVENT_OP, ";") < 0)
5652                 return;
5653         type = read_token(&token);
5654         if (type != EVENT_NEWLINE) {
5655                 /* newer versions of the kernel have a "signed" type */
5656                 if (type != EVENT_ITEM)
5657                         goto fail;
5658
5659                 if (strcmp(token, "signed") != 0)
5660                         goto fail;
5661
5662                 free_token(token);
5663
5664                 if (read_expected(EVENT_OP, ":") < 0)
5665                         return;
5666
5667                 if (read_expect_type(EVENT_ITEM, &token))
5668                         goto fail;
5669
5670                 free_token(token);
5671                 if (read_expected(EVENT_OP, ";") < 0)
5672                         return;
5673
5674                 if (read_expect_type(EVENT_NEWLINE, &token))
5675                         goto fail;
5676         }
5677  fail:
5678         free_token(token);
5679         return;
5680
5681  discard:
5682         input_buf_ptr = save_input_buf_ptr;
5683         input_buf_siz = save_input_buf_siz;
5684         *offset = 0;
5685         *size = 0;
5686         free_token(token);
5687 }
5688
5689 /**
5690  * pevent_parse_header_page - parse the data stored in the header page
5691  * @pevent: the handle to the pevent
5692  * @buf: the buffer storing the header page format string
5693  * @size: the size of @buf
5694  * @long_size: the long size to use if there is no header
5695  *
5696  * This parses the header page format for information on the
5697  * ring buffer used. The @buf should be copied from
5698  *
5699  * /sys/kernel/debug/tracing/events/header_page
5700  */
5701 int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size,
5702                              int long_size)
5703 {
5704         int ignore;
5705
5706         if (!size) {
5707                 /*
5708                  * Old kernels did not have header page info.
5709                  * Sorry but we just use what we find here in user space.
5710                  */
5711                 pevent->header_page_ts_size = sizeof(long long);
5712                 pevent->header_page_size_size = long_size;
5713                 pevent->header_page_data_offset = sizeof(long long) + long_size;
5714                 pevent->old_format = 1;
5715                 return -1;
5716         }
5717         init_input_buf(buf, size);
5718
5719         parse_header_field("timestamp", &pevent->header_page_ts_offset,
5720                            &pevent->header_page_ts_size, 1);
5721         parse_header_field("commit", &pevent->header_page_size_offset,
5722                            &pevent->header_page_size_size, 1);
5723         parse_header_field("overwrite", &pevent->header_page_overwrite,
5724                            &ignore, 0);
5725         parse_header_field("data", &pevent->header_page_data_offset,
5726                            &pevent->header_page_data_size, 1);
5727
5728         return 0;
5729 }
5730
5731 static int event_matches(struct event_format *event,
5732                          int id, const char *sys_name,
5733                          const char *event_name)
5734 {
5735         if (id >= 0 && id != event->id)
5736                 return 0;
5737
5738         if (event_name && (strcmp(event_name, event->name) != 0))
5739                 return 0;
5740
5741         if (sys_name && (strcmp(sys_name, event->system) != 0))
5742                 return 0;
5743
5744         return 1;
5745 }
5746
5747 static void free_handler(struct event_handler *handle)
5748 {
5749         free((void *)handle->sys_name);
5750         free((void *)handle->event_name);
5751         free(handle);
5752 }
5753
5754 static int find_event_handle(struct pevent *pevent, struct event_format *event)
5755 {
5756         struct event_handler *handle, **next;
5757
5758         for (next = &pevent->handlers; *next;
5759              next = &(*next)->next) {
5760                 handle = *next;
5761                 if (event_matches(event, handle->id,
5762                                   handle->sys_name,
5763                                   handle->event_name))
5764                         break;
5765         }
5766
5767         if (!(*next))
5768                 return 0;
5769
5770         pr_stat("overriding event (%d) %s:%s with new print handler",
5771                 event->id, event->system, event->name);
5772
5773         event->handler = handle->func;
5774         event->context = handle->context;
5775
5776         *next = handle->next;
5777         free_handler(handle);
5778
5779         return 1;
5780 }
5781
5782 /**
5783  * __pevent_parse_format - parse the event format
5784  * @buf: the buffer storing the event format string
5785  * @size: the size of @buf
5786  * @sys: the system the event belongs to
5787  *
5788  * This parses the event format and creates an event structure
5789  * to quickly parse raw data for a given event.
5790  *
5791  * These files currently come from:
5792  *
5793  * /sys/kernel/debug/tracing/events/.../.../format
5794  */
5795 enum pevent_errno __pevent_parse_format(struct event_format **eventp,
5796                                         struct pevent *pevent, const char *buf,
5797                                         unsigned long size, const char *sys)
5798 {
5799         struct event_format *event;
5800         int ret;
5801
5802         init_input_buf(buf, size);
5803
5804         *eventp = event = alloc_event();
5805         if (!event)
5806                 return PEVENT_ERRNO__MEM_ALLOC_FAILED;
5807
5808         event->name = event_read_name();
5809         if (!event->name) {
5810                 /* Bad event? */
5811                 ret = PEVENT_ERRNO__MEM_ALLOC_FAILED;
5812                 goto event_alloc_failed;
5813         }
5814
5815         if (strcmp(sys, "ftrace") == 0) {
5816                 event->flags |= EVENT_FL_ISFTRACE;
5817
5818                 if (strcmp(event->name, "bprint") == 0)
5819                         event->flags |= EVENT_FL_ISBPRINT;
5820         }
5821
5822         event->id = event_read_id();
5823         if (event->id < 0) {
5824                 ret = PEVENT_ERRNO__READ_ID_FAILED;
5825                 /*
5826                  * This isn't an allocation error actually.
5827                  * But as the ID is critical, just bail out.
5828                  */
5829                 goto event_alloc_failed;
5830         }
5831
5832         event->system = strdup(sys);
5833         if (!event->system) {
5834                 ret = PEVENT_ERRNO__MEM_ALLOC_FAILED;
5835                 goto event_alloc_failed;
5836         }
5837
5838         /* Add pevent to event so that it can be referenced */
5839         event->pevent = pevent;
5840
5841         ret = event_read_format(event);
5842         if (ret < 0) {
5843                 ret = PEVENT_ERRNO__READ_FORMAT_FAILED;
5844                 goto event_parse_failed;
5845         }
5846
5847         /*
5848          * If the event has an override, don't print warnings if the event
5849          * print format fails to parse.
5850          */
5851         if (pevent && find_event_handle(pevent, event))
5852                 show_warning = 0;
5853
5854         ret = event_read_print(event);
5855         show_warning = 1;
5856
5857         if (ret < 0) {
5858                 ret = PEVENT_ERRNO__READ_PRINT_FAILED;
5859                 goto event_parse_failed;
5860         }
5861
5862         if (!ret && (event->flags & EVENT_FL_ISFTRACE)) {
5863                 struct format_field *field;
5864                 struct print_arg *arg, **list;
5865
5866                 /* old ftrace had no args */
5867                 list = &event->print_fmt.args;
5868                 for (field = event->format.fields; field; field = field->next) {
5869                         arg = alloc_arg();
5870                         if (!arg) {
5871                                 event->flags |= EVENT_FL_FAILED;
5872                                 return PEVENT_ERRNO__OLD_FTRACE_ARG_FAILED;
5873                         }
5874                         arg->type = PRINT_FIELD;
5875                         arg->field.name = strdup(field->name);
5876                         if (!arg->field.name) {
5877                                 event->flags |= EVENT_FL_FAILED;
5878                                 free_arg(arg);
5879                                 return PEVENT_ERRNO__OLD_FTRACE_ARG_FAILED;
5880                         }
5881                         arg->field.field = field;
5882                         *list = arg;
5883                         list = &arg->next;
5884                 }
5885                 return 0;
5886         }
5887
5888         return 0;
5889
5890  event_parse_failed:
5891         event->flags |= EVENT_FL_FAILED;
5892         return ret;
5893
5894  event_alloc_failed:
5895         free(event->system);
5896         free(event->name);
5897         free(event);
5898         *eventp = NULL;
5899         return ret;
5900 }
5901
5902 static enum pevent_errno
5903 __pevent_parse_event(struct pevent *pevent,
5904                      struct event_format **eventp,
5905                      const char *buf, unsigned long size,
5906                      const char *sys)
5907 {
5908         int ret = __pevent_parse_format(eventp, pevent, buf, size, sys);
5909         struct event_format *event = *eventp;
5910
5911         if (event == NULL)
5912                 return ret;
5913
5914         if (pevent && add_event(pevent, event)) {
5915                 ret = PEVENT_ERRNO__MEM_ALLOC_FAILED;
5916                 goto event_add_failed;
5917         }
5918
5919 #define PRINT_ARGS 0
5920         if (PRINT_ARGS && event->print_fmt.args)
5921                 print_args(event->print_fmt.args);
5922
5923         return 0;
5924
5925 event_add_failed:
5926         pevent_free_format(event);
5927         return ret;
5928 }
5929
5930 /**
5931  * pevent_parse_format - parse the event format
5932  * @pevent: the handle to the pevent
5933  * @eventp: returned format
5934  * @buf: the buffer storing the event format string
5935  * @size: the size of @buf
5936  * @sys: the system the event belongs to
5937  *
5938  * This parses the event format and creates an event structure
5939  * to quickly parse raw data for a given event.
5940  *
5941  * These files currently come from:
5942  *
5943  * /sys/kernel/debug/tracing/events/.../.../format
5944  */
5945 enum pevent_errno pevent_parse_format(struct pevent *pevent,
5946                                       struct event_format **eventp,
5947                                       const char *buf,
5948                                       unsigned long size, const char *sys)
5949 {
5950         return __pevent_parse_event(pevent, eventp, buf, size, sys);
5951 }
5952
5953 /**
5954  * pevent_parse_event - parse the event format
5955  * @pevent: the handle to the pevent
5956  * @buf: the buffer storing the event format string
5957  * @size: the size of @buf
5958  * @sys: the system the event belongs to
5959  *
5960  * This parses the event format and creates an event structure
5961  * to quickly parse raw data for a given event.
5962  *
5963  * These files currently come from:
5964  *
5965  * /sys/kernel/debug/tracing/events/.../.../format
5966  */
5967 enum pevent_errno pevent_parse_event(struct pevent *pevent, const char *buf,
5968                                      unsigned long size, const char *sys)
5969 {
5970         struct event_format *event = NULL;
5971         return __pevent_parse_event(pevent, &event, buf, size, sys);
5972 }
5973
5974 #undef _PE
5975 #define _PE(code, str) str
5976 static const char * const pevent_error_str[] = {
5977         PEVENT_ERRORS
5978 };
5979 #undef _PE
5980
5981 int pevent_strerror(struct pevent *pevent __maybe_unused,
5982                     enum pevent_errno errnum, char *buf, size_t buflen)
5983 {
5984         int idx;
5985         const char *msg;
5986
5987         if (errnum >= 0) {
5988                 msg = strerror_r(errnum, buf, buflen);
5989                 if (msg != buf) {
5990                         size_t len = strlen(msg);
5991                         memcpy(buf, msg, min(buflen - 1, len));
5992                         *(buf + min(buflen - 1, len)) = '\0';
5993                 }
5994                 return 0;
5995         }
5996
5997         if (errnum <= __PEVENT_ERRNO__START ||
5998             errnum >= __PEVENT_ERRNO__END)
5999                 return -1;
6000
6001         idx = errnum - __PEVENT_ERRNO__START - 1;
6002         msg = pevent_error_str[idx];
6003         snprintf(buf, buflen, "%s", msg);
6004
6005         return 0;
6006 }
6007
6008 int get_field_val(struct trace_seq *s, struct format_field *field,
6009                   const char *name, struct pevent_record *record,
6010                   unsigned long long *val, int err)
6011 {
6012         if (!field) {
6013                 if (err)
6014                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6015                 return -1;
6016         }
6017
6018         if (pevent_read_number_field(field, record->data, val)) {
6019                 if (err)
6020                         trace_seq_printf(s, " %s=INVALID", name);
6021                 return -1;
6022         }
6023
6024         return 0;
6025 }
6026
6027 /**
6028  * pevent_get_field_raw - return the raw pointer into the data field
6029  * @s: The seq to print to on error
6030  * @event: the event that the field is for
6031  * @name: The name of the field
6032  * @record: The record with the field name.
6033  * @len: place to store the field length.
6034  * @err: print default error if failed.
6035  *
6036  * Returns a pointer into record->data of the field and places
6037  * the length of the field in @len.
6038  *
6039  * On failure, it returns NULL.
6040  */
6041 void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
6042                            const char *name, struct pevent_record *record,
6043                            int *len, int err)
6044 {
6045         struct format_field *field;
6046         void *data = record->data;
6047         unsigned offset;
6048         int dummy;
6049
6050         if (!event)
6051                 return NULL;
6052
6053         field = pevent_find_field(event, name);
6054
6055         if (!field) {
6056                 if (err)
6057                         trace_seq_printf(s, "<CANT FIND FIELD %s>", name);
6058                 return NULL;
6059         }
6060
6061         /* Allow @len to be NULL */
6062         if (!len)
6063                 len = &dummy;
6064
6065         offset = field->offset;
6066         if (field->flags & FIELD_IS_DYNAMIC) {
6067                 offset = pevent_read_number(event->pevent,
6068                                             data + offset, field->size);
6069                 *len = offset >> 16;
6070                 offset &= 0xffff;
6071         } else
6072                 *len = field->size;
6073
6074         return data + offset;
6075 }
6076
6077 /**
6078  * pevent_get_field_val - find a field and return its value
6079  * @s: The seq to print to on error
6080  * @event: the event that the field is for
6081  * @name: The name of the field
6082  * @record: The record with the field name.
6083  * @val: place to store the value of the field.
6084  * @err: print default error if failed.
6085  *
6086  * Returns 0 on success -1 on field not found.
6087  */
6088 int pevent_get_field_val(struct trace_seq *s, struct event_format *event,
6089                          const char *name, struct pevent_record *record,
6090                          unsigned long long *val, int err)
6091 {
6092         struct format_field *field;
6093
6094         if (!event)
6095                 return -1;
6096
6097         field = pevent_find_field(event, name);
6098
6099         return get_field_val(s, field, name, record, val, err);
6100 }
6101
6102 /**
6103  * pevent_get_common_field_val - find a common field and return its value
6104  * @s: The seq to print to on error
6105  * @event: the event that the field is for
6106  * @name: The name of the field
6107  * @record: The record with the field name.
6108  * @val: place to store the value of the field.
6109  * @err: print default error if failed.
6110  *
6111  * Returns 0 on success -1 on field not found.
6112  */
6113 int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event,
6114                                 const char *name, struct pevent_record *record,
6115                                 unsigned long long *val, int err)
6116 {
6117         struct format_field *field;
6118
6119         if (!event)
6120                 return -1;
6121
6122         field = pevent_find_common_field(event, name);
6123
6124         return get_field_val(s, field, name, record, val, err);
6125 }
6126
6127 /**
6128  * pevent_get_any_field_val - find a any field and return its value
6129  * @s: The seq to print to on error
6130  * @event: the event that the field is for
6131  * @name: The name of the field
6132  * @record: The record with the field name.
6133  * @val: place to store the value of the field.
6134  * @err: print default error if failed.
6135  *
6136  * Returns 0 on success -1 on field not found.
6137  */
6138 int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
6139                              const char *name, struct pevent_record *record,
6140                              unsigned long long *val, int err)
6141 {
6142         struct format_field *field;
6143
6144         if (!event)
6145                 return -1;
6146
6147         field = pevent_find_any_field(event, name);
6148
6149         return get_field_val(s, field, name, record, val, err);
6150 }
6151
6152 /**
6153  * pevent_print_num_field - print a field and a format
6154  * @s: The seq to print to
6155  * @fmt: The printf format to print the field with.
6156  * @event: the event that the field is for
6157  * @name: The name of the field
6158  * @record: The record with the field name.
6159  * @err: print default error if failed.
6160  *
6161  * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
6162  */
6163 int pevent_print_num_field(struct trace_seq *s, const char *fmt,
6164                            struct event_format *event, const char *name,
6165                            struct pevent_record *record, int err)
6166 {
6167         struct format_field *field = pevent_find_field(event, name);
6168         unsigned long long val;
6169
6170         if (!field)
6171                 goto failed;
6172
6173         if (pevent_read_number_field(field, record->data, &val))
6174                 goto failed;
6175
6176         return trace_seq_printf(s, fmt, val);
6177
6178  failed:
6179         if (err)
6180                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6181         return -1;
6182 }
6183
6184 /**
6185  * pevent_print_func_field - print a field and a format for function pointers
6186  * @s: The seq to print to
6187  * @fmt: The printf format to print the field with.
6188  * @event: the event that the field is for
6189  * @name: The name of the field
6190  * @record: The record with the field name.
6191  * @err: print default error if failed.
6192  *
6193  * Returns: 0 on success, -1 field not found, or 1 if buffer is full.
6194  */
6195 int pevent_print_func_field(struct trace_seq *s, const char *fmt,
6196                             struct event_format *event, const char *name,
6197                             struct pevent_record *record, int err)
6198 {
6199         struct format_field *field = pevent_find_field(event, name);
6200         struct pevent *pevent = event->pevent;
6201         unsigned long long val;
6202         struct func_map *func;
6203         char tmp[128];
6204
6205         if (!field)
6206                 goto failed;
6207
6208         if (pevent_read_number_field(field, record->data, &val))
6209                 goto failed;
6210
6211         func = find_func(pevent, val);
6212
6213         if (func)
6214                 snprintf(tmp, 128, "%s/0x%llx", func->func, func->addr - val);
6215         else
6216                 sprintf(tmp, "0x%08llx", val);
6217
6218         return trace_seq_printf(s, fmt, tmp);
6219
6220  failed:
6221         if (err)
6222                 trace_seq_printf(s, "CAN'T FIND FIELD \"%s\"", name);
6223         return -1;
6224 }
6225
6226 static void free_func_handle(struct pevent_function_handler *func)
6227 {
6228         struct pevent_func_params *params;
6229
6230         free(func->name);
6231
6232         while (func->params) {
6233                 params = func->params;
6234                 func->params = params->next;
6235                 free(params);
6236         }
6237
6238         free(func);
6239 }
6240
6241 /**
6242  * pevent_register_print_function - register a helper function
6243  * @pevent: the handle to the pevent
6244  * @func: the function to process the helper function
6245  * @ret_type: the return type of the helper function
6246  * @name: the name of the helper function
6247  * @parameters: A list of enum pevent_func_arg_type
6248  *
6249  * Some events may have helper functions in the print format arguments.
6250  * This allows a plugin to dynamically create a way to process one
6251  * of these functions.
6252  *
6253  * The @parameters is a variable list of pevent_func_arg_type enums that
6254  * must end with PEVENT_FUNC_ARG_VOID.
6255  */
6256 int pevent_register_print_function(struct pevent *pevent,
6257                                    pevent_func_handler func,
6258                                    enum pevent_func_arg_type ret_type,
6259                                    char *name, ...)
6260 {
6261         struct pevent_function_handler *func_handle;
6262         struct pevent_func_params **next_param;
6263         struct pevent_func_params *param;
6264         enum pevent_func_arg_type type;
6265         va_list ap;
6266         int ret;
6267
6268         func_handle = find_func_handler(pevent, name);
6269         if (func_handle) {
6270                 /*
6271                  * This is most like caused by the users own
6272                  * plugins updating the function. This overrides the
6273                  * system defaults.
6274                  */
6275                 pr_stat("override of function helper '%s'", name);
6276                 remove_func_handler(pevent, name);
6277         }
6278
6279         func_handle = calloc(1, sizeof(*func_handle));
6280         if (!func_handle) {
6281                 do_warning("Failed to allocate function handler");
6282                 return PEVENT_ERRNO__MEM_ALLOC_FAILED;
6283         }
6284
6285         func_handle->ret_type = ret_type;
6286         func_handle->name = strdup(name);
6287         func_handle->func = func;
6288         if (!func_handle->name) {
6289                 do_warning("Failed to allocate function name");
6290                 free(func_handle);
6291                 return PEVENT_ERRNO__MEM_ALLOC_FAILED;
6292         }
6293
6294         next_param = &(func_handle->params);
6295         va_start(ap, name);
6296         for (;;) {
6297                 type = va_arg(ap, enum pevent_func_arg_type);
6298                 if (type == PEVENT_FUNC_ARG_VOID)
6299                         break;
6300
6301                 if (type >= PEVENT_FUNC_ARG_MAX_TYPES) {
6302                         do_warning("Invalid argument type %d", type);
6303                         ret = PEVENT_ERRNO__INVALID_ARG_TYPE;
6304                         goto out_free;
6305                 }
6306
6307                 param = malloc(sizeof(*param));
6308                 if (!param) {
6309                         do_warning("Failed to allocate function param");
6310                         ret = PEVENT_ERRNO__MEM_ALLOC_FAILED;
6311                         goto out_free;
6312                 }
6313                 param->type = type;
6314                 param->next = NULL;
6315
6316                 *next_param = param;
6317                 next_param = &(param->next);
6318
6319                 func_handle->nr_args++;
6320         }
6321         va_end(ap);
6322
6323         func_handle->next = pevent->func_handlers;
6324         pevent->func_handlers = func_handle;
6325
6326         return 0;
6327  out_free:
6328         va_end(ap);
6329         free_func_handle(func_handle);
6330         return ret;
6331 }
6332
6333 /**
6334  * pevent_unregister_print_function - unregister a helper function
6335  * @pevent: the handle to the pevent
6336  * @func: the function to process the helper function
6337  * @name: the name of the helper function
6338  *
6339  * This function removes existing print handler for function @name.
6340  *
6341  * Returns 0 if the handler was removed successully, -1 otherwise.
6342  */
6343 int pevent_unregister_print_function(struct pevent *pevent,
6344                                      pevent_func_handler func, char *name)
6345 {
6346         struct pevent_function_handler *func_handle;
6347
6348         func_handle = find_func_handler(pevent, name);
6349         if (func_handle && func_handle->func == func) {
6350                 remove_func_handler(pevent, name);
6351                 return 0;
6352         }
6353         return -1;
6354 }
6355
6356 static struct event_format *pevent_search_event(struct pevent *pevent, int id,
6357                                                 const char *sys_name,
6358                                                 const char *event_name)
6359 {
6360         struct event_format *event;
6361
6362         if (id >= 0) {
6363                 /* search by id */
6364                 event = pevent_find_event(pevent, id);
6365                 if (!event)
6366                         return NULL;
6367                 if (event_name && (strcmp(event_name, event->name) != 0))
6368                         return NULL;
6369                 if (sys_name && (strcmp(sys_name, event->system) != 0))
6370                         return NULL;
6371         } else {
6372                 event = pevent_find_event_by_name(pevent, sys_name, event_name);
6373                 if (!event)
6374                         return NULL;
6375         }
6376         return event;
6377 }
6378
6379 /**
6380  * pevent_register_event_handler - register a way to parse an event
6381  * @pevent: the handle to the pevent
6382  * @id: the id of the event to register
6383  * @sys_name: the system name the event belongs to
6384  * @event_name: the name of the event
6385  * @func: the function to call to parse the event information
6386  * @context: the data to be passed to @func
6387  *
6388  * This function allows a developer to override the parsing of
6389  * a given event. If for some reason the default print format
6390  * is not sufficient, this function will register a function
6391  * for an event to be used to parse the data instead.
6392  *
6393  * If @id is >= 0, then it is used to find the event.
6394  * else @sys_name and @event_name are used.
6395  */
6396 int pevent_register_event_handler(struct pevent *pevent, int id,
6397                                   const char *sys_name, const char *event_name,
6398                                   pevent_event_handler_func func, void *context)
6399 {
6400         struct event_format *event;
6401         struct event_handler *handle;
6402
6403         event = pevent_search_event(pevent, id, sys_name, event_name);
6404         if (event == NULL)
6405                 goto not_found;
6406
6407         pr_stat("overriding event (%d) %s:%s with new print handler",
6408                 event->id, event->system, event->name);
6409
6410         event->handler = func;
6411         event->context = context;
6412         return 0;
6413
6414  not_found:
6415         /* Save for later use. */
6416         handle = calloc(1, sizeof(*handle));
6417         if (!handle) {
6418                 do_warning("Failed to allocate event handler");
6419                 return PEVENT_ERRNO__MEM_ALLOC_FAILED;
6420         }
6421
6422         handle->id = id;
6423         if (event_name)
6424                 handle->event_name = strdup(event_name);
6425         if (sys_name)
6426                 handle->sys_name = strdup(sys_name);
6427
6428         if ((event_name && !handle->event_name) ||
6429             (sys_name && !handle->sys_name)) {
6430                 do_warning("Failed to allocate event/sys name");
6431                 free((void *)handle->event_name);
6432                 free((void *)handle->sys_name);
6433                 free(handle);
6434                 return PEVENT_ERRNO__MEM_ALLOC_FAILED;
6435         }
6436
6437         handle->func = func;
6438         handle->next = pevent->handlers;
6439         pevent->handlers = handle;
6440         handle->context = context;
6441
6442         return -1;
6443 }
6444
6445 static int handle_matches(struct event_handler *handler, int id,
6446                           const char *sys_name, const char *event_name,
6447                           pevent_event_handler_func func, void *context)
6448 {
6449         if (id >= 0 && id != handler->id)
6450                 return 0;
6451
6452         if (event_name && (strcmp(event_name, handler->event_name) != 0))
6453                 return 0;
6454
6455         if (sys_name && (strcmp(sys_name, handler->sys_name) != 0))
6456                 return 0;
6457
6458         if (func != handler->func || context != handler->context)
6459                 return 0;
6460
6461         return 1;
6462 }
6463
6464 /**
6465  * pevent_unregister_event_handler - unregister an existing event handler
6466  * @pevent: the handle to the pevent
6467  * @id: the id of the event to unregister
6468  * @sys_name: the system name the handler belongs to
6469  * @event_name: the name of the event handler
6470  * @func: the function to call to parse the event information
6471  * @context: the data to be passed to @func
6472  *
6473  * This function removes existing event handler (parser).
6474  *
6475  * If @id is >= 0, then it is used to find the event.
6476  * else @sys_name and @event_name are used.
6477  *
6478  * Returns 0 if handler was removed successfully, -1 if event was not found.
6479  */
6480 int pevent_unregister_event_handler(struct pevent *pevent, int id,
6481                                     const char *sys_name, const char *event_name,
6482                                     pevent_event_handler_func func, void *context)
6483 {
6484         struct event_format *event;
6485         struct event_handler *handle;
6486         struct event_handler **next;
6487
6488         event = pevent_search_event(pevent, id, sys_name, event_name);
6489         if (event == NULL)
6490                 goto not_found;
6491
6492         if (event->handler == func && event->context == context) {
6493                 pr_stat("removing override handler for event (%d) %s:%s. Going back to default handler.",
6494                         event->id, event->system, event->name);
6495
6496                 event->handler = NULL;
6497                 event->context = NULL;
6498                 return 0;
6499         }
6500
6501 not_found:
6502         for (next = &pevent->handlers; *next; next = &(*next)->next) {
6503                 handle = *next;
6504                 if (handle_matches(handle, id, sys_name, event_name,
6505                                    func, context))
6506                         break;
6507         }
6508
6509         if (!(*next))
6510                 return -1;
6511
6512         *next = handle->next;
6513         free_handler(handle);
6514
6515         return 0;
6516 }
6517
6518 /**
6519  * pevent_alloc - create a pevent handle
6520  */
6521 struct pevent *pevent_alloc(void)
6522 {
6523         struct pevent *pevent = calloc(1, sizeof(*pevent));
6524
6525         if (pevent)
6526                 pevent->ref_count = 1;
6527
6528         return pevent;
6529 }
6530
6531 void pevent_ref(struct pevent *pevent)
6532 {
6533         pevent->ref_count++;
6534 }
6535
6536 void pevent_free_format_field(struct format_field *field)
6537 {
6538         free(field->type);
6539         if (field->alias != field->name)
6540                 free(field->alias);
6541         free(field->name);
6542         free(field);
6543 }
6544
6545 static void free_format_fields(struct format_field *field)
6546 {
6547         struct format_field *next;
6548
6549         while (field) {
6550                 next = field->next;
6551                 pevent_free_format_field(field);
6552                 field = next;
6553         }
6554 }
6555
6556 static void free_formats(struct format *format)
6557 {
6558         free_format_fields(format->common_fields);
6559         free_format_fields(format->fields);
6560 }
6561
6562 void pevent_free_format(struct event_format *event)
6563 {
6564         free(event->name);
6565         free(event->system);
6566
6567         free_formats(&event->format);
6568
6569         free(event->print_fmt.format);
6570         free_args(event->print_fmt.args);
6571
6572         free(event);
6573 }
6574
6575 /**
6576  * pevent_free - free a pevent handle
6577  * @pevent: the pevent handle to free
6578  */
6579 void pevent_free(struct pevent *pevent)
6580 {
6581         struct cmdline_list *cmdlist, *cmdnext;
6582         struct func_list *funclist, *funcnext;
6583         struct printk_list *printklist, *printknext;
6584         struct pevent_function_handler *func_handler;
6585         struct event_handler *handle;
6586         int i;
6587
6588         if (!pevent)
6589                 return;
6590
6591         cmdlist = pevent->cmdlist;
6592         funclist = pevent->funclist;
6593         printklist = pevent->printklist;
6594
6595         pevent->ref_count--;
6596         if (pevent->ref_count)
6597                 return;
6598
6599         if (pevent->cmdlines) {
6600                 for (i = 0; i < pevent->cmdline_count; i++)
6601                         free(pevent->cmdlines[i].comm);
6602                 free(pevent->cmdlines);
6603         }
6604
6605         while (cmdlist) {
6606                 cmdnext = cmdlist->next;
6607                 free(cmdlist->comm);
6608                 free(cmdlist);
6609                 cmdlist = cmdnext;
6610         }
6611
6612         if (pevent->func_map) {
6613                 for (i = 0; i < (int)pevent->func_count; i++) {
6614                         free(pevent->func_map[i].func);
6615                         free(pevent->func_map[i].mod);
6616                 }
6617                 free(pevent->func_map);
6618         }
6619
6620         while (funclist) {
6621                 funcnext = funclist->next;
6622                 free(funclist->func);
6623                 free(funclist->mod);
6624                 free(funclist);
6625                 funclist = funcnext;
6626         }
6627
6628         while (pevent->func_handlers) {
6629                 func_handler = pevent->func_handlers;
6630                 pevent->func_handlers = func_handler->next;
6631                 free_func_handle(func_handler);
6632         }
6633
6634         if (pevent->printk_map) {
6635                 for (i = 0; i < (int)pevent->printk_count; i++)
6636                         free(pevent->printk_map[i].printk);
6637                 free(pevent->printk_map);
6638         }
6639
6640         while (printklist) {
6641                 printknext = printklist->next;
6642                 free(printklist->printk);
6643                 free(printklist);
6644                 printklist = printknext;
6645         }
6646
6647         for (i = 0; i < pevent->nr_events; i++)
6648                 pevent_free_format(pevent->events[i]);
6649
6650         while (pevent->handlers) {
6651                 handle = pevent->handlers;
6652                 pevent->handlers = handle->next;
6653                 free_handler(handle);
6654         }
6655
6656         free(pevent->trace_clock);
6657         free(pevent->events);
6658         free(pevent->sort_events);
6659         free(pevent->func_resolver);
6660
6661         free(pevent);
6662 }
6663
6664 void pevent_unref(struct pevent *pevent)
6665 {
6666         pevent_free(pevent);
6667 }