tools/lib/traceevent/event-parse.c

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