tools/lib/traceevent/event-parse.c

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