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