Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[sfrench/cifs-2.6.git] / tools / lib / traceevent / event-parse.c
1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
4  *
5  *
6  *  The parts for function graph printing was taken and modified from the
7  *  Linux Kernel that were written by
8  *    - Copyright (C) 2009  Frederic Weisbecker,
9  *  Frederic Weisbecker gave his permission to relicense the code to
10  *  the Lesser General Public License.
11  */
12 #include <inttypes.h>
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <stdarg.h>
17 #include <ctype.h>
18 #include <errno.h>
19 #include <stdint.h>
20 #include <limits.h>
21 #include <linux/time64.h>
22
23 #include <netinet/in.h>
24 #include "event-parse.h"
25
26 #include "event-parse-local.h"
27 #include "event-utils.h"
28 #include "trace-seq.h"
29
30 static const char *input_buf;
31 static unsigned long long input_buf_ptr;
32 static unsigned long long input_buf_siz;
33
34 static int is_flag_field;
35 static int is_symbolic_field;
36
37 static int show_warning = 1;
38
39 #define do_warning(fmt, ...)                            \
40         do {                                            \
41                 if (show_warning)                       \
42                         warning(fmt, ##__VA_ARGS__);    \
43         } while (0)
44
45 #define do_warning_event(event, fmt, ...)                       \
46         do {                                                    \
47                 if (!show_warning)                              \
48                         continue;                               \
49                                                                 \
50                 if (event)                                      \
51                         warning("[%s:%s] " fmt, event->system,  \
52                                 event->name, ##__VA_ARGS__);    \
53                 else                                            \
54                         warning(fmt, ##__VA_ARGS__);            \
55         } while (0)
56
57 static void init_input_buf(const char *buf, unsigned long long size)
58 {
59         input_buf = buf;
60         input_buf_siz = size;
61         input_buf_ptr = 0;
62 }
63
64 const char *tep_get_input_buf(void)
65 {
66         return input_buf;
67 }
68
69 unsigned long long tep_get_input_buf_ptr(void)
70 {
71         return input_buf_ptr;
72 }
73
74 struct event_handler {
75         struct event_handler            *next;
76         int                             id;
77         const char                      *sys_name;
78         const char                      *event_name;
79         tep_event_handler_func          func;
80         void                            *context;
81 };
82
83 struct func_params {
84         struct func_params      *next;
85         enum tep_func_arg_type  type;
86 };
87
88 struct tep_function_handler {
89         struct tep_function_handler     *next;
90         enum tep_func_arg_type          ret_type;
91         char                            *name;
92         tep_func_handler                func;
93         struct func_params              *params;
94         int                             nr_args;
95 };
96
97 static unsigned long long
98 process_defined_func(struct trace_seq *s, void *data, int size,
99                      struct tep_event_format *event, struct tep_print_arg *arg);
100
101 static void free_func_handle(struct tep_function_handler *func);
102
103 /**
104  * tep_buffer_init - init buffer for parsing
105  * @buf: buffer to parse
106  * @size: the size of the buffer
107  *
108  * For use with tep_read_token(), this initializes the internal
109  * buffer that tep_read_token() will parse.
110  */
111 void tep_buffer_init(const char *buf, unsigned long long size)
112 {
113         init_input_buf(buf, size);
114 }
115
116 void breakpoint(void)
117 {
118         static int x;
119         x++;
120 }
121
122 struct tep_print_arg *alloc_arg(void)
123 {
124         return calloc(1, sizeof(struct tep_print_arg));
125 }
126
127 struct cmdline {
128         char *comm;
129         int pid;
130 };
131
132 static int cmdline_cmp(const void *a, const void *b)
133 {
134         const struct cmdline *ca = a;
135         const struct cmdline *cb = b;
136
137         if (ca->pid < cb->pid)
138                 return -1;
139         if (ca->pid > cb->pid)
140                 return 1;
141
142         return 0;
143 }
144
145 struct cmdline_list {
146         struct cmdline_list     *next;
147         char                    *comm;
148         int                     pid;
149 };
150
151 static int cmdline_init(struct tep_handle *pevent)
152 {
153         struct cmdline_list *cmdlist = pevent->cmdlist;
154         struct cmdline_list *item;
155         struct cmdline *cmdlines;
156         int i;
157
158         cmdlines = malloc(sizeof(*cmdlines) * pevent->cmdline_count);
159         if (!cmdlines)
160                 return -1;
161
162         i = 0;
163         while (cmdlist) {
164                 cmdlines[i].pid = cmdlist->pid;
165                 cmdlines[i].comm = cmdlist->comm;
166                 i++;
167                 item = cmdlist;
168                 cmdlist = cmdlist->next;
169                 free(item);
170         }
171
172         qsort(cmdlines, pevent->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
173
174         pevent->cmdlines = cmdlines;
175         pevent->cmdlist = NULL;
176
177         return 0;
178 }
179
180 static const char *find_cmdline(struct tep_handle *pevent, int pid)
181 {
182         const struct cmdline *comm;
183         struct cmdline key;
184
185         if (!pid)
186                 return "<idle>";
187
188         if (!pevent->cmdlines && cmdline_init(pevent))
189                 return "<not enough memory for cmdlines!>";
190
191         key.pid = pid;
192
193         comm = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
194                        sizeof(*pevent->cmdlines), cmdline_cmp);
195
196         if (comm)
197                 return comm->comm;
198         return "<...>";
199 }
200
201 /**
202  * tep_pid_is_registered - return if a pid has a cmdline registered
203  * @pevent: handle for the pevent
204  * @pid: The pid to check if it has a cmdline registered with.
205  *
206  * Returns 1 if the pid has a cmdline mapped to it
207  * 0 otherwise.
208  */
209 int tep_pid_is_registered(struct tep_handle *pevent, int pid)
210 {
211         const struct cmdline *comm;
212         struct cmdline key;
213
214         if (!pid)
215                 return 1;
216
217         if (!pevent->cmdlines && cmdline_init(pevent))
218                 return 0;
219
220         key.pid = pid;
221
222         comm = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
223                        sizeof(*pevent->cmdlines), cmdline_cmp);
224
225         if (comm)
226                 return 1;
227         return 0;
228 }
229
230 /*
231  * If the command lines have been converted to an array, then
232  * we must add this pid. This is much slower than when cmdlines
233  * are added before the array is initialized.
234  */
235 static int add_new_comm(struct tep_handle *pevent, const char *comm, int pid)
236 {
237         struct cmdline *cmdlines = pevent->cmdlines;
238         const struct cmdline *cmdline;
239         struct cmdline key;
240
241         if (!pid)
242                 return 0;
243
244         /* avoid duplicates */
245         key.pid = pid;
246
247         cmdline = bsearch(&key, pevent->cmdlines, pevent->cmdline_count,
248                        sizeof(*pevent->cmdlines), cmdline_cmp);
249         if (cmdline) {
250                 errno = EEXIST;
251                 return -1;
252         }
253
254         cmdlines = realloc(cmdlines, sizeof(*cmdlines) * (pevent->cmdline_count + 1));
255         if (!cmdlines) {
256                 errno = ENOMEM;
257                 return -1;
258         }
259
260         cmdlines[pevent->cmdline_count].comm = strdup(comm);
261         if (!cmdlines[pevent->cmdline_count].comm) {
262                 free(cmdlines);
263                 errno = ENOMEM;
264                 return -1;
265         }
266
267         cmdlines[pevent->cmdline_count].pid = pid;
268                 
269         if (cmdlines[pevent->cmdline_count].comm)
270                 pevent->cmdline_count++;
271
272         qsort(cmdlines, pevent->cmdline_count, sizeof(*cmdlines), cmdline_cmp);
273         pevent->cmdlines = cmdlines;
274
275         return 0;
276 }
277
278 /**
279  * tep_register_comm - register a pid / comm mapping
280  * @pevent: handle for the pevent
281  * @comm: the command line to register
282  * @pid: the pid to map the command line to
283  *
284  * This adds a mapping to search for command line names with
285  * a given pid. The comm is duplicated.
286  */
287 int tep_register_comm(struct tep_handle *pevent, const char *comm, int pid)
288 {
289         struct cmdline_list *item;
290
291         if (pevent->cmdlines)
292                 return add_new_comm(pevent, comm, pid);
293
294         item = malloc(sizeof(*item));
295         if (!item)
296                 return -1;
297
298         if (comm)
299                 item->comm = strdup(comm);
300         else
301                 item->comm = strdup("<...>");
302         if (!item->comm) {
303                 free(item);
304                 return -1;
305         }
306         item->pid = pid;
307         item->next = pevent->cmdlist;
308
309         pevent->cmdlist = item;
310         pevent->cmdline_count++;
311
312         return 0;
313 }
314
315 int tep_register_trace_clock(struct tep_handle *pevent, const char *trace_clock)
316 {
317         pevent->trace_clock = strdup(trace_clock);
318         if (!pevent->trace_clock) {
319                 errno = ENOMEM;
320                 return -1;
321         }
322         return 0;
323 }
324
325 struct func_map {
326         unsigned long long              addr;
327         char                            *func;
328         char                            *mod;
329 };
330
331 struct func_list {
332         struct func_list        *next;
333         unsigned long long      addr;
334         char                    *func;
335         char                    *mod;
336 };
337
338 static int func_cmp(const void *a, const void *b)
339 {
340         const struct func_map *fa = a;
341         const struct func_map *fb = b;
342
343         if (fa->addr < fb->addr)
344                 return -1;
345         if (fa->addr > fb->addr)
346                 return 1;
347
348         return 0;
349 }
350
351 /*
352  * We are searching for a record in between, not an exact
353  * match.
354  */
355 static int func_bcmp(const void *a, const void *b)
356 {
357         const struct func_map *fa = a;
358         const struct func_map *fb = b;
359
360         if ((fa->addr == fb->addr) ||
361
362             (fa->addr > fb->addr &&
363              fa->addr < (fb+1)->addr))
364                 return 0;
365
366         if (fa->addr < fb->addr)
367                 return -1;
368
369         return 1;
370 }
371
372 static int func_map_init(struct tep_handle *pevent)
373 {
374         struct func_list *funclist;
375         struct func_list *item;
376         struct func_map *func_map;
377         int i;
378
379         func_map = malloc(sizeof(*func_map) * (pevent->func_count + 1));
380         if (!func_map)
381                 return -1;
382
383         funclist = pevent->funclist;
384
385         i = 0;
386         while (funclist) {
387                 func_map[i].func = funclist->func;
388                 func_map[i].addr = funclist->addr;
389                 func_map[i].mod = funclist->mod;
390                 i++;
391                 item = funclist;
392                 funclist = funclist->next;
393                 free(item);
394         }
395
396         qsort(func_map, pevent->func_count, sizeof(*func_map), func_cmp);
397
398         /*
399          * Add a special record at the end.
400          */
401         func_map[pevent->func_count].func = NULL;
402         func_map[pevent->func_count].addr = 0;
403         func_map[pevent->func_count].mod = NULL;
404
405         pevent->func_map = func_map;
406         pevent->funclist = NULL;
407
408         return 0;
409 }
410
411 static struct func_map *
412 __find_func(struct tep_handle *pevent, unsigned long long addr)
413 {
414         struct func_map *func;
415         struct func_map key;
416
417         if (!pevent->func_map)
418                 func_map_init(pevent);
419
420         key.addr = addr;
421
422         func = bsearch(&key, pevent->func_map, pevent->func_count,
423                        sizeof(*pevent->func_map), func_bcmp);
424
425         return func;
426 }
427
428 struct func_resolver {
429         tep_func_resolver_t     *func;
430         void                    *priv;
431         struct func_map         map;
432 };
433
434 /**
435  * tep_set_function_resolver - set an alternative function resolver
436  * @pevent: handle for the pevent
437  * @resolver: function to be used
438  * @priv: resolver function private state.
439  *
440  * Some tools may have already a way to resolve kernel functions, allow them to
441  * keep using it instead of duplicating all the entries inside
442  * pevent->funclist.
443  */
444 int tep_set_function_resolver(struct tep_handle *pevent,
445                               tep_func_resolver_t *func, void *priv)
446 {
447         struct func_resolver *resolver = malloc(sizeof(*resolver));
448
449         if (resolver == NULL)
450                 return -1;
451
452         resolver->func = func;
453         resolver->priv = priv;
454
455         free(pevent->func_resolver);
456         pevent->func_resolver = resolver;
457
458         return 0;
459 }
460
461 /**
462  * tep_reset_function_resolver - reset alternative function resolver
463  * @pevent: handle for the pevent
464  *
465  * Stop using whatever alternative resolver was set, use the default
466  * one instead.
467  */
468 void tep_reset_function_resolver(struct tep_handle *pevent)
469 {
470         free(pevent->func_resolver);
471         pevent->func_resolver = NULL;
472 }
473
474 static struct func_map *
475 find_func(struct tep_handle *pevent, unsigned long long addr)
476 {
477         struct func_map *map;
478
479         if (!pevent->func_resolver)
480                 return __find_func(pevent, addr);
481
482         map = &pevent->func_resolver->map;
483         map->mod  = NULL;
484         map->addr = addr;
485         map->func = pevent->func_resolver->func(pevent->func_resolver->priv,
486                                                 &map->addr, &map->mod);
487         if (map->func == NULL)
488                 return NULL;
489
490         return map;
491 }
492
493 /**
494  * tep_find_function - find a function by a given address
495  * @pevent: handle for the pevent
496  * @addr: the address to find the function with
497  *
498  * Returns a pointer to the function stored that has the given
499  * address. Note, the address does not have to be exact, it
500  * will select the function that would contain the address.
501  */
502 const char *tep_find_function(struct tep_handle *pevent, unsigned long long addr)
503 {
504         struct func_map *map;
505
506         map = find_func(pevent, addr);
507         if (!map)
508                 return NULL;
509
510         return map->func;
511 }
512
513 /**
514  * tep_find_function_address - find a function address by a given address
515  * @pevent: handle for the pevent
516  * @addr: the address to find the function with
517  *
518  * Returns the address the function starts at. This can be used in
519  * conjunction with tep_find_function to print both the function
520  * name and the function offset.
521  */
522 unsigned long long
523 tep_find_function_address(struct tep_handle *pevent, unsigned long long addr)
524 {
525         struct func_map *map;
526
527         map = find_func(pevent, addr);
528         if (!map)
529                 return 0;
530
531         return map->addr;
532 }
533
534 /**
535  * tep_register_function - register a function with a given address
536  * @pevent: handle for the pevent
537  * @function: the function name to register
538  * @addr: the address the function starts at
539  * @mod: the kernel module the function may be in (NULL for none)
540  *
541  * This registers a function name with an address and module.
542  * The @func passed in is duplicated.
543  */
544 int tep_register_function(struct tep_handle *pevent, char *func,
545                           unsigned long long addr, char *mod)
546 {
547         struct func_list *item = malloc(sizeof(*item));
548
549         if (!item)
550                 return -1;
551
552         item->next = pevent->funclist;
553         item->func = strdup(func);
554         if (!item->func)
555                 goto out_free;
556
557         if (mod) {
558                 item->mod = strdup(mod);
559                 if (!item->mod)
560                         goto out_free_func;
561         } else
562                 item->mod = NULL;
563         item->addr = addr;
564
565         pevent->funclist = item;
566         pevent->func_count++;
567
568         return 0;
569
570 out_free_func:
571         free(item->func);
572         item->func = NULL;
573 out_free:
574         free(item);
575         errno = ENOMEM;
576         return -1;
577 }
578
579 /**
580  * tep_print_funcs - print out the stored functions
581  * @pevent: handle for the pevent
582  *
583  * This prints out the stored functions.
584  */
585 void tep_print_funcs(struct tep_handle *pevent)
586 {
587         int i;
588
589         if (!pevent->func_map)
590                 func_map_init(pevent);
591
592         for (i = 0; i < (int)pevent->func_count; i++) {
593                 printf("%016llx %s",
594                        pevent->func_map[i].addr,
595                        pevent->func_map[i].func);
596                 if (pevent->func_map[i].mod)
597                         printf(" [%s]\n", pevent->func_map[i].mod);
598                 else
599                         printf("\n");
600         }
601 }
602
603 struct printk_map {
604         unsigned long long              addr;
605         char                            *printk;
606 };
607
608 struct printk_list {
609         struct printk_list      *next;
610         unsigned long long      addr;
611         char                    *printk;
612 };
613
614 static int printk_cmp(const void *a, const void *b)
615 {
616         const struct printk_map *pa = a;
617         const struct printk_map *pb = b;
618
619         if (pa->addr < pb->addr)
620                 return -1;
621         if (pa->addr > pb->addr)
622                 return 1;
623
624         return 0;
625 }
626
627 static int printk_map_init(struct tep_handle *pevent)
628 {
629         struct printk_list *printklist;
630         struct printk_list *item;
631         struct printk_map *printk_map;
632         int i;
633
634         printk_map = malloc(sizeof(*printk_map) * (pevent->printk_count + 1));
635         if (!printk_map)
636                 return -1;
637
638         printklist = pevent->printklist;
639
640         i = 0;
641         while (printklist) {
642                 printk_map[i].printk = printklist->printk;
643                 printk_map[i].addr = printklist->addr;
644                 i++;
645                 item = printklist;
646                 printklist = printklist->next;
647                 free(item);
648         }
649
650         qsort(printk_map, pevent->printk_count, sizeof(*printk_map), printk_cmp);
651
652         pevent->printk_map = printk_map;
653         pevent->printklist = NULL;
654
655         return 0;
656 }
657
658 static struct printk_map *
659 find_printk(struct tep_handle *pevent, unsigned long long addr)
660 {
661         struct printk_map *printk;
662         struct printk_map key;
663
664         if (!pevent->printk_map && printk_map_init(pevent))
665                 return NULL;
666
667         key.addr = addr;
668
669         printk = bsearch(&key, pevent->printk_map, pevent->printk_count,
670                          sizeof(*pevent->printk_map), printk_cmp);
671
672         return printk;
673 }
674
675 /**
676  * tep_register_print_string - register a string by its address
677  * @pevent: handle for the pevent
678  * @fmt: the string format to register
679  * @addr: the address the string was located at
680  *
681  * This registers a string by the address it was stored in the kernel.
682  * The @fmt passed in is duplicated.
683  */
684 int tep_register_print_string(struct tep_handle *pevent, const char *fmt,
685                               unsigned long long addr)
686 {
687         struct printk_list *item = malloc(sizeof(*item));
688         char *p;
689
690         if (!item)
691                 return -1;
692
693         item->next = pevent->printklist;
694         item->addr = addr;
695
696         /* Strip off quotes and '\n' from the end */
697         if (fmt[0] == '"')
698                 fmt++;
699         item->printk = strdup(fmt);
700         if (!item->printk)
701                 goto out_free;
702
703         p = item->printk + strlen(item->printk) - 1;
704         if (*p == '"')
705                 *p = 0;
706
707         p -= 2;
708         if (strcmp(p, "\\n") == 0)
709                 *p = 0;
710
711         pevent->printklist = item;
712         pevent->printk_count++;
713
714         return 0;
715
716 out_free:
717         free(item);
718         errno = ENOMEM;
719         return -1;
720 }
721
722 /**
723  * tep_print_printk - print out the stored strings
724  * @pevent: handle for the pevent
725  *
726  * This prints the string formats that were stored.
727  */
728 void tep_print_printk(struct tep_handle *pevent)
729 {
730         int i;
731
732         if (!pevent->printk_map)
733                 printk_map_init(pevent);
734
735         for (i = 0; i < (int)pevent->printk_count; i++) {
736                 printf("%016llx %s\n",
737                        pevent->printk_map[i].addr,
738                        pevent->printk_map[i].printk);
739         }
740 }
741
742 static struct tep_event_format *alloc_event(void)
743 {
744         return calloc(1, sizeof(struct tep_event_format));
745 }
746
747 static int add_event(struct tep_handle *pevent, struct tep_event_format *event)
748 {
749         int i;
750         struct tep_event_format **events = realloc(pevent->events, sizeof(event) *
751                                                   (pevent->nr_events + 1));
752         if (!events)
753                 return -1;
754
755         pevent->events = events;
756
757         for (i = 0; i < pevent->nr_events; i++) {
758                 if (pevent->events[i]->id > event->id)
759                         break;
760         }
761         if (i < pevent->nr_events)
762                 memmove(&pevent->events[i + 1],
763                         &pevent->events[i],
764                         sizeof(event) * (pevent->nr_events - i));
765
766         pevent->events[i] = event;
767         pevent->nr_events++;
768
769         event->pevent = pevent;
770
771         return 0;
772 }
773
774 static int event_item_type(enum tep_event_type type)
775 {
776         switch (type) {
777         case TEP_EVENT_ITEM ... TEP_EVENT_SQUOTE:
778                 return 1;
779         case TEP_EVENT_ERROR ... TEP_EVENT_DELIM:
780         default:
781                 return 0;
782         }
783 }
784
785 static void free_flag_sym(struct tep_print_flag_sym *fsym)
786 {
787         struct tep_print_flag_sym *next;
788
789         while (fsym) {
790                 next = fsym->next;
791                 free(fsym->value);
792                 free(fsym->str);
793                 free(fsym);
794                 fsym = next;
795         }
796 }
797
798 static void free_arg(struct tep_print_arg *arg)
799 {
800         struct tep_print_arg *farg;
801
802         if (!arg)
803                 return;
804
805         switch (arg->type) {
806         case TEP_PRINT_ATOM:
807                 free(arg->atom.atom);
808                 break;
809         case TEP_PRINT_FIELD:
810                 free(arg->field.name);
811                 break;
812         case TEP_PRINT_FLAGS:
813                 free_arg(arg->flags.field);
814                 free(arg->flags.delim);
815                 free_flag_sym(arg->flags.flags);
816                 break;
817         case TEP_PRINT_SYMBOL:
818                 free_arg(arg->symbol.field);
819                 free_flag_sym(arg->symbol.symbols);
820                 break;
821         case TEP_PRINT_HEX:
822         case TEP_PRINT_HEX_STR:
823                 free_arg(arg->hex.field);
824                 free_arg(arg->hex.size);
825                 break;
826         case TEP_PRINT_INT_ARRAY:
827                 free_arg(arg->int_array.field);
828                 free_arg(arg->int_array.count);
829                 free_arg(arg->int_array.el_size);
830                 break;
831         case TEP_PRINT_TYPE:
832                 free(arg->typecast.type);
833                 free_arg(arg->typecast.item);
834                 break;
835         case TEP_PRINT_STRING:
836         case TEP_PRINT_BSTRING:
837                 free(arg->string.string);
838                 break;
839         case TEP_PRINT_BITMASK:
840                 free(arg->bitmask.bitmask);
841                 break;
842         case TEP_PRINT_DYNAMIC_ARRAY:
843         case TEP_PRINT_DYNAMIC_ARRAY_LEN:
844                 free(arg->dynarray.index);
845                 break;
846         case TEP_PRINT_OP:
847                 free(arg->op.op);
848                 free_arg(arg->op.left);
849                 free_arg(arg->op.right);
850                 break;
851         case TEP_PRINT_FUNC:
852                 while (arg->func.args) {
853                         farg = arg->func.args;
854                         arg->func.args = farg->next;
855                         free_arg(farg);
856                 }
857                 break;
858
859         case TEP_PRINT_NULL:
860         default:
861                 break;
862         }
863
864         free(arg);
865 }
866
867 static enum tep_event_type get_type(int ch)
868 {
869         if (ch == '\n')
870                 return TEP_EVENT_NEWLINE;
871         if (isspace(ch))
872                 return TEP_EVENT_SPACE;
873         if (isalnum(ch) || ch == '_')
874                 return TEP_EVENT_ITEM;
875         if (ch == '\'')
876                 return TEP_EVENT_SQUOTE;
877         if (ch == '"')
878                 return TEP_EVENT_DQUOTE;
879         if (!isprint(ch))
880                 return TEP_EVENT_NONE;
881         if (ch == '(' || ch == ')' || ch == ',')
882                 return TEP_EVENT_DELIM;
883
884         return TEP_EVENT_OP;
885 }
886
887 static int __read_char(void)
888 {
889         if (input_buf_ptr >= input_buf_siz)
890                 return -1;
891
892         return input_buf[input_buf_ptr++];
893 }
894
895 static int __peek_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 /**
904  * tep_peek_char - peek at the next character that will be read
905  *
906  * Returns the next character read, or -1 if end of buffer.
907  */
908 int tep_peek_char(void)
909 {
910         return __peek_char();
911 }
912
913 static int extend_token(char **tok, char *buf, int size)
914 {
915         char *newtok = realloc(*tok, size);
916
917         if (!newtok) {
918                 free(*tok);
919                 *tok = NULL;
920                 return -1;
921         }
922
923         if (!*tok)
924                 strcpy(newtok, buf);
925         else
926                 strcat(newtok, buf);
927         *tok = newtok;
928
929         return 0;
930 }
931
932 static enum tep_event_type force_token(const char *str, char **tok);
933
934 static enum tep_event_type __read_token(char **tok)
935 {
936         char buf[BUFSIZ];
937         int ch, last_ch, quote_ch, next_ch;
938         int i = 0;
939         int tok_size = 0;
940         enum tep_event_type type;
941
942         *tok = NULL;
943
944
945         ch = __read_char();
946         if (ch < 0)
947                 return TEP_EVENT_NONE;
948
949         type = get_type(ch);
950         if (type == TEP_EVENT_NONE)
951                 return type;
952
953         buf[i++] = ch;
954
955         switch (type) {
956         case TEP_EVENT_NEWLINE:
957         case TEP_EVENT_DELIM:
958                 if (asprintf(tok, "%c", ch) < 0)
959                         return TEP_EVENT_ERROR;
960
961                 return type;
962
963         case TEP_EVENT_OP:
964                 switch (ch) {
965                 case '-':
966                         next_ch = __peek_char();
967                         if (next_ch == '>') {
968                                 buf[i++] = __read_char();
969                                 break;
970                         }
971                         /* fall through */
972                 case '+':
973                 case '|':
974                 case '&':
975                 case '>':
976                 case '<':
977                         last_ch = ch;
978                         ch = __peek_char();
979                         if (ch != last_ch)
980                                 goto test_equal;
981                         buf[i++] = __read_char();
982                         switch (last_ch) {
983                         case '>':
984                         case '<':
985                                 goto test_equal;
986                         default:
987                                 break;
988                         }
989                         break;
990                 case '!':
991                 case '=':
992                         goto test_equal;
993                 default: /* what should we do instead? */
994                         break;
995                 }
996                 buf[i] = 0;
997                 *tok = strdup(buf);
998                 return type;
999
1000  test_equal:
1001                 ch = __peek_char();
1002                 if (ch == '=')
1003                         buf[i++] = __read_char();
1004                 goto out;
1005
1006         case TEP_EVENT_DQUOTE:
1007         case TEP_EVENT_SQUOTE:
1008                 /* don't keep quotes */
1009                 i--;
1010                 quote_ch = ch;
1011                 last_ch = 0;
1012  concat:
1013                 do {
1014                         if (i == (BUFSIZ - 1)) {
1015                                 buf[i] = 0;
1016                                 tok_size += BUFSIZ;
1017
1018                                 if (extend_token(tok, buf, tok_size) < 0)
1019                                         return TEP_EVENT_NONE;
1020                                 i = 0;
1021                         }
1022                         last_ch = ch;
1023                         ch = __read_char();
1024                         buf[i++] = ch;
1025                         /* the '\' '\' will cancel itself */
1026                         if (ch == '\\' && last_ch == '\\')
1027                                 last_ch = 0;
1028                 } while (ch != quote_ch || last_ch == '\\');
1029                 /* remove the last quote */
1030                 i--;
1031
1032                 /*
1033                  * For strings (double quotes) check the next token.
1034                  * If it is another string, concatinate the two.
1035                  */
1036                 if (type == TEP_EVENT_DQUOTE) {
1037                         unsigned long long save_input_buf_ptr = input_buf_ptr;
1038
1039                         do {
1040                                 ch = __read_char();
1041                         } while (isspace(ch));
1042                         if (ch == '"')
1043                                 goto concat;
1044                         input_buf_ptr = save_input_buf_ptr;
1045                 }
1046
1047                 goto out;
1048
1049         case TEP_EVENT_ERROR ... TEP_EVENT_SPACE:
1050         case TEP_EVENT_ITEM:
1051         default:
1052                 break;
1053         }
1054
1055         while (get_type(__peek_char()) == type) {
1056                 if (i == (BUFSIZ - 1)) {
1057                         buf[i] = 0;
1058                         tok_size += BUFSIZ;
1059
1060                         if (extend_token(tok, buf, tok_size) < 0)
1061                                 return TEP_EVENT_NONE;
1062                         i = 0;
1063                 }
1064                 ch = __read_char();
1065                 buf[i++] = ch;
1066         }
1067
1068  out:
1069         buf[i] = 0;
1070         if (extend_token(tok, buf, tok_size + i + 1) < 0)
1071                 return TEP_EVENT_NONE;
1072
1073         if (type == TEP_EVENT_ITEM) {
1074                 /*
1075                  * Older versions of the kernel has a bug that
1076                  * creates invalid symbols and will break the mac80211
1077                  * parsing. This is a work around to that bug.
1078                  *
1079                  * See Linux kernel commit:
1080                  *  811cb50baf63461ce0bdb234927046131fc7fa8b
1081                  */
1082                 if (strcmp(*tok, "LOCAL_PR_FMT") == 0) {
1083                         free(*tok);
1084                         *tok = NULL;
1085                         return force_token("\"%s\" ", tok);
1086                 } else if (strcmp(*tok, "STA_PR_FMT") == 0) {
1087                         free(*tok);
1088                         *tok = NULL;
1089                         return force_token("\" sta:%pM\" ", tok);
1090                 } else if (strcmp(*tok, "VIF_PR_FMT") == 0) {
1091                         free(*tok);
1092                         *tok = NULL;
1093                         return force_token("\" vif:%p(%d)\" ", tok);
1094                 }
1095         }
1096
1097         return type;
1098 }
1099
1100 static enum tep_event_type force_token(const char *str, char **tok)
1101 {
1102         const char *save_input_buf;
1103         unsigned long long save_input_buf_ptr;
1104         unsigned long long save_input_buf_siz;
1105         enum tep_event_type type;
1106         
1107         /* save off the current input pointers */
1108         save_input_buf = input_buf;
1109         save_input_buf_ptr = input_buf_ptr;
1110         save_input_buf_siz = input_buf_siz;
1111
1112         init_input_buf(str, strlen(str));
1113
1114         type = __read_token(tok);
1115
1116         /* reset back to original token */
1117         input_buf = save_input_buf;
1118         input_buf_ptr = save_input_buf_ptr;
1119         input_buf_siz = save_input_buf_siz;
1120
1121         return type;
1122 }
1123
1124 static void free_token(char *tok)
1125 {
1126         if (tok)
1127                 free(tok);
1128 }
1129
1130 static enum tep_event_type read_token(char **tok)
1131 {
1132         enum tep_event_type type;
1133
1134         for (;;) {
1135                 type = __read_token(tok);
1136                 if (type != TEP_EVENT_SPACE)
1137                         return type;
1138
1139                 free_token(*tok);
1140         }
1141
1142         /* not reached */
1143         *tok = NULL;
1144         return TEP_EVENT_NONE;
1145 }
1146
1147 /**
1148  * tep_read_token - access to utilites to use the pevent parser
1149  * @tok: The token to return
1150  *
1151  * This will parse tokens from the string given by
1152  * tep_init_data().
1153  *
1154  * Returns the token type.
1155  */
1156 enum tep_event_type tep_read_token(char **tok)
1157 {
1158         return read_token(tok);
1159 }
1160
1161 /**
1162  * tep_free_token - free a token returned by tep_read_token
1163  * @token: the token to free
1164  */
1165 void tep_free_token(char *token)
1166 {
1167         free_token(token);
1168 }
1169
1170 /* no newline */
1171 static enum tep_event_type read_token_item(char **tok)
1172 {
1173         enum tep_event_type type;
1174
1175         for (;;) {
1176                 type = __read_token(tok);
1177                 if (type != TEP_EVENT_SPACE && type != TEP_EVENT_NEWLINE)
1178                         return type;
1179                 free_token(*tok);
1180                 *tok = NULL;
1181         }
1182
1183         /* not reached */
1184         *tok = NULL;
1185         return TEP_EVENT_NONE;
1186 }
1187
1188 static int test_type(enum tep_event_type type, enum tep_event_type expect)
1189 {
1190         if (type != expect) {
1191                 do_warning("Error: expected type %d but read %d",
1192                     expect, type);
1193                 return -1;
1194         }
1195         return 0;
1196 }
1197
1198 static int test_type_token(enum tep_event_type type, const char *token,
1199                     enum tep_event_type expect, const char *expect_tok)
1200 {
1201         if (type != expect) {
1202                 do_warning("Error: expected type %d but read %d",
1203                     expect, type);
1204                 return -1;
1205         }
1206
1207         if (strcmp(token, expect_tok) != 0) {
1208                 do_warning("Error: expected '%s' but read '%s'",
1209                     expect_tok, token);
1210                 return -1;
1211         }
1212         return 0;
1213 }
1214
1215 static int __read_expect_type(enum tep_event_type expect, char **tok, int newline_ok)
1216 {
1217         enum tep_event_type type;
1218
1219         if (newline_ok)
1220                 type = read_token(tok);
1221         else
1222                 type = read_token_item(tok);
1223         return test_type(type, expect);
1224 }
1225
1226 static int read_expect_type(enum tep_event_type expect, char **tok)
1227 {
1228         return __read_expect_type(expect, tok, 1);
1229 }
1230
1231 static int __read_expected(enum tep_event_type expect, const char *str,
1232                            int newline_ok)
1233 {
1234         enum tep_event_type type;
1235         char *token;
1236         int ret;
1237
1238         if (newline_ok)
1239                 type = read_token(&token);
1240         else
1241                 type = read_token_item(&token);
1242
1243         ret = test_type_token(type, token, expect, str);
1244
1245         free_token(token);
1246
1247         return ret;
1248 }
1249
1250 static int read_expected(enum tep_event_type expect, const char *str)
1251 {
1252         return __read_expected(expect, str, 1);
1253 }
1254
1255 static int read_expected_item(enum tep_event_type expect, const char *str)
1256 {
1257         return __read_expected(expect, str, 0);
1258 }
1259
1260 static char *event_read_name(void)
1261 {
1262         char *token;
1263
1264         if (read_expected(TEP_EVENT_ITEM, "name") < 0)
1265                 return NULL;
1266
1267         if (read_expected(TEP_EVENT_OP, ":") < 0)
1268                 return NULL;
1269
1270         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1271                 goto fail;
1272
1273         return token;
1274
1275  fail:
1276         free_token(token);
1277         return NULL;
1278 }
1279
1280 static int event_read_id(void)
1281 {
1282         char *token;
1283         int id;
1284
1285         if (read_expected_item(TEP_EVENT_ITEM, "ID") < 0)
1286                 return -1;
1287
1288         if (read_expected(TEP_EVENT_OP, ":") < 0)
1289                 return -1;
1290
1291         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1292                 goto fail;
1293
1294         id = strtoul(token, NULL, 0);
1295         free_token(token);
1296         return id;
1297
1298  fail:
1299         free_token(token);
1300         return -1;
1301 }
1302
1303 static int field_is_string(struct tep_format_field *field)
1304 {
1305         if ((field->flags & TEP_FIELD_IS_ARRAY) &&
1306             (strstr(field->type, "char") || strstr(field->type, "u8") ||
1307              strstr(field->type, "s8")))
1308                 return 1;
1309
1310         return 0;
1311 }
1312
1313 static int field_is_dynamic(struct tep_format_field *field)
1314 {
1315         if (strncmp(field->type, "__data_loc", 10) == 0)
1316                 return 1;
1317
1318         return 0;
1319 }
1320
1321 static int field_is_long(struct tep_format_field *field)
1322 {
1323         /* includes long long */
1324         if (strstr(field->type, "long"))
1325                 return 1;
1326
1327         return 0;
1328 }
1329
1330 static unsigned int type_size(const char *name)
1331 {
1332         /* This covers all TEP_FIELD_IS_STRING types. */
1333         static struct {
1334                 const char *type;
1335                 unsigned int size;
1336         } table[] = {
1337                 { "u8",   1 },
1338                 { "u16",  2 },
1339                 { "u32",  4 },
1340                 { "u64",  8 },
1341                 { "s8",   1 },
1342                 { "s16",  2 },
1343                 { "s32",  4 },
1344                 { "s64",  8 },
1345                 { "char", 1 },
1346                 { },
1347         };
1348         int i;
1349
1350         for (i = 0; table[i].type; i++) {
1351                 if (!strcmp(table[i].type, name))
1352                         return table[i].size;
1353         }
1354
1355         return 0;
1356 }
1357
1358 static int event_read_fields(struct tep_event_format *event, struct tep_format_field **fields)
1359 {
1360         struct tep_format_field *field = NULL;
1361         enum tep_event_type type;
1362         char *token;
1363         char *last_token;
1364         int count = 0;
1365
1366         do {
1367                 unsigned int size_dynamic = 0;
1368
1369                 type = read_token(&token);
1370                 if (type == TEP_EVENT_NEWLINE) {
1371                         free_token(token);
1372                         return count;
1373                 }
1374
1375                 count++;
1376
1377                 if (test_type_token(type, token, TEP_EVENT_ITEM, "field"))
1378                         goto fail;
1379                 free_token(token);
1380
1381                 type = read_token(&token);
1382                 /*
1383                  * The ftrace fields may still use the "special" name.
1384                  * Just ignore it.
1385                  */
1386                 if (event->flags & TEP_EVENT_FL_ISFTRACE &&
1387                     type == TEP_EVENT_ITEM && strcmp(token, "special") == 0) {
1388                         free_token(token);
1389                         type = read_token(&token);
1390                 }
1391
1392                 if (test_type_token(type, token, TEP_EVENT_OP, ":") < 0)
1393                         goto fail;
1394
1395                 free_token(token);
1396                 if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
1397                         goto fail;
1398
1399                 last_token = token;
1400
1401                 field = calloc(1, sizeof(*field));
1402                 if (!field)
1403                         goto fail;
1404
1405                 field->event = event;
1406
1407                 /* read the rest of the type */
1408                 for (;;) {
1409                         type = read_token(&token);
1410                         if (type == TEP_EVENT_ITEM ||
1411                             (type == TEP_EVENT_OP && strcmp(token, "*") == 0) ||
1412                             /*
1413                              * Some of the ftrace fields are broken and have
1414                              * an illegal "." in them.
1415                              */
1416                             (event->flags & TEP_EVENT_FL_ISFTRACE &&
1417                              type == TEP_EVENT_OP && strcmp(token, ".") == 0)) {
1418
1419                                 if (strcmp(token, "*") == 0)
1420                                         field->flags |= TEP_FIELD_IS_POINTER;
1421
1422                                 if (field->type) {
1423                                         char *new_type;
1424                                         new_type = realloc(field->type,
1425                                                            strlen(field->type) +
1426                                                            strlen(last_token) + 2);
1427                                         if (!new_type) {
1428                                                 free(last_token);
1429                                                 goto fail;
1430                                         }
1431                                         field->type = new_type;
1432                                         strcat(field->type, " ");
1433                                         strcat(field->type, last_token);
1434                                         free(last_token);
1435                                 } else
1436                                         field->type = last_token;
1437                                 last_token = token;
1438                                 continue;
1439                         }
1440
1441                         break;
1442                 }
1443
1444                 if (!field->type) {
1445                         do_warning_event(event, "%s: no type found", __func__);
1446                         goto fail;
1447                 }
1448                 field->name = field->alias = last_token;
1449
1450                 if (test_type(type, TEP_EVENT_OP))
1451                         goto fail;
1452
1453                 if (strcmp(token, "[") == 0) {
1454                         enum tep_event_type last_type = type;
1455                         char *brackets = token;
1456                         char *new_brackets;
1457                         int len;
1458
1459                         field->flags |= TEP_FIELD_IS_ARRAY;
1460
1461                         type = read_token(&token);
1462
1463                         if (type == TEP_EVENT_ITEM)
1464                                 field->arraylen = strtoul(token, NULL, 0);
1465                         else
1466                                 field->arraylen = 0;
1467
1468                         while (strcmp(token, "]") != 0) {
1469                                 if (last_type == TEP_EVENT_ITEM &&
1470                                     type == TEP_EVENT_ITEM)
1471                                         len = 2;
1472                                 else
1473                                         len = 1;
1474                                 last_type = type;
1475
1476                                 new_brackets = realloc(brackets,
1477                                                        strlen(brackets) +
1478                                                        strlen(token) + len);
1479                                 if (!new_brackets) {
1480                                         free(brackets);
1481                                         goto fail;
1482                                 }
1483                                 brackets = new_brackets;
1484                                 if (len == 2)
1485                                         strcat(brackets, " ");
1486                                 strcat(brackets, token);
1487                                 /* We only care about the last token */
1488                                 field->arraylen = strtoul(token, NULL, 0);
1489                                 free_token(token);
1490                                 type = read_token(&token);
1491                                 if (type == TEP_EVENT_NONE) {
1492                                         do_warning_event(event, "failed to find token");
1493                                         goto fail;
1494                                 }
1495                         }
1496
1497                         free_token(token);
1498
1499                         new_brackets = realloc(brackets, strlen(brackets) + 2);
1500                         if (!new_brackets) {
1501                                 free(brackets);
1502                                 goto fail;
1503                         }
1504                         brackets = new_brackets;
1505                         strcat(brackets, "]");
1506
1507                         /* add brackets to type */
1508
1509                         type = read_token(&token);
1510                         /*
1511                          * If the next token is not an OP, then it is of
1512                          * the format: type [] item;
1513                          */
1514                         if (type == TEP_EVENT_ITEM) {
1515                                 char *new_type;
1516                                 new_type = realloc(field->type,
1517                                                    strlen(field->type) +
1518                                                    strlen(field->name) +
1519                                                    strlen(brackets) + 2);
1520                                 if (!new_type) {
1521                                         free(brackets);
1522                                         goto fail;
1523                                 }
1524                                 field->type = new_type;
1525                                 strcat(field->type, " ");
1526                                 strcat(field->type, field->name);
1527                                 size_dynamic = type_size(field->name);
1528                                 free_token(field->name);
1529                                 strcat(field->type, brackets);
1530                                 field->name = field->alias = token;
1531                                 type = read_token(&token);
1532                         } else {
1533                                 char *new_type;
1534                                 new_type = realloc(field->type,
1535                                                    strlen(field->type) +
1536                                                    strlen(brackets) + 1);
1537                                 if (!new_type) {
1538                                         free(brackets);
1539                                         goto fail;
1540                                 }
1541                                 field->type = new_type;
1542                                 strcat(field->type, brackets);
1543                         }
1544                         free(brackets);
1545                 }
1546
1547                 if (field_is_string(field))
1548                         field->flags |= TEP_FIELD_IS_STRING;
1549                 if (field_is_dynamic(field))
1550                         field->flags |= TEP_FIELD_IS_DYNAMIC;
1551                 if (field_is_long(field))
1552                         field->flags |= TEP_FIELD_IS_LONG;
1553
1554                 if (test_type_token(type, token,  TEP_EVENT_OP, ";"))
1555                         goto fail;
1556                 free_token(token);
1557
1558                 if (read_expected(TEP_EVENT_ITEM, "offset") < 0)
1559                         goto fail_expect;
1560
1561                 if (read_expected(TEP_EVENT_OP, ":") < 0)
1562                         goto fail_expect;
1563
1564                 if (read_expect_type(TEP_EVENT_ITEM, &token))
1565                         goto fail;
1566                 field->offset = strtoul(token, NULL, 0);
1567                 free_token(token);
1568
1569                 if (read_expected(TEP_EVENT_OP, ";") < 0)
1570                         goto fail_expect;
1571
1572                 if (read_expected(TEP_EVENT_ITEM, "size") < 0)
1573                         goto fail_expect;
1574
1575                 if (read_expected(TEP_EVENT_OP, ":") < 0)
1576                         goto fail_expect;
1577
1578                 if (read_expect_type(TEP_EVENT_ITEM, &token))
1579                         goto fail;
1580                 field->size = strtoul(token, NULL, 0);
1581                 free_token(token);
1582
1583                 if (read_expected(TEP_EVENT_OP, ";") < 0)
1584                         goto fail_expect;
1585
1586                 type = read_token(&token);
1587                 if (type != TEP_EVENT_NEWLINE) {
1588                         /* newer versions of the kernel have a "signed" type */
1589                         if (test_type_token(type, token, TEP_EVENT_ITEM, "signed"))
1590                                 goto fail;
1591
1592                         free_token(token);
1593
1594                         if (read_expected(TEP_EVENT_OP, ":") < 0)
1595                                 goto fail_expect;
1596
1597                         if (read_expect_type(TEP_EVENT_ITEM, &token))
1598                                 goto fail;
1599
1600                         if (strtoul(token, NULL, 0))
1601                                 field->flags |= TEP_FIELD_IS_SIGNED;
1602
1603                         free_token(token);
1604                         if (read_expected(TEP_EVENT_OP, ";") < 0)
1605                                 goto fail_expect;
1606
1607                         if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1608                                 goto fail;
1609                 }
1610
1611                 free_token(token);
1612
1613                 if (field->flags & TEP_FIELD_IS_ARRAY) {
1614                         if (field->arraylen)
1615                                 field->elementsize = field->size / field->arraylen;
1616                         else if (field->flags & TEP_FIELD_IS_DYNAMIC)
1617                                 field->elementsize = size_dynamic;
1618                         else if (field->flags & TEP_FIELD_IS_STRING)
1619                                 field->elementsize = 1;
1620                         else if (field->flags & TEP_FIELD_IS_LONG)
1621                                 field->elementsize = event->pevent ?
1622                                                      event->pevent->long_size :
1623                                                      sizeof(long);
1624                 } else
1625                         field->elementsize = field->size;
1626
1627                 *fields = field;
1628                 fields = &field->next;
1629
1630         } while (1);
1631
1632         return 0;
1633
1634 fail:
1635         free_token(token);
1636 fail_expect:
1637         if (field) {
1638                 free(field->type);
1639                 free(field->name);
1640                 free(field);
1641         }
1642         return -1;
1643 }
1644
1645 static int event_read_format(struct tep_event_format *event)
1646 {
1647         char *token;
1648         int ret;
1649
1650         if (read_expected_item(TEP_EVENT_ITEM, "format") < 0)
1651                 return -1;
1652
1653         if (read_expected(TEP_EVENT_OP, ":") < 0)
1654                 return -1;
1655
1656         if (read_expect_type(TEP_EVENT_NEWLINE, &token))
1657                 goto fail;
1658         free_token(token);
1659
1660         ret = event_read_fields(event, &event->format.common_fields);
1661         if (ret < 0)
1662                 return ret;
1663         event->format.nr_common = ret;
1664
1665         ret = event_read_fields(event, &event->format.fields);
1666         if (ret < 0)
1667                 return ret;
1668         event->format.nr_fields = ret;
1669
1670         return 0;
1671
1672  fail:
1673         free_token(token);
1674         return -1;
1675 }
1676
1677 static enum tep_event_type
1678 process_arg_token(struct tep_event_format *event, struct tep_print_arg *arg,
1679                   char **tok, enum tep_event_type type);
1680
1681 static enum tep_event_type
1682 process_arg(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
1683 {
1684         enum tep_event_type type;
1685         char *token;
1686
1687         type = read_token(&token);
1688         *tok = token;
1689
1690         return process_arg_token(event, arg, tok, type);
1691 }
1692
1693 static enum tep_event_type
1694 process_op(struct tep_event_format *event, struct tep_print_arg *arg, char **tok);
1695
1696 /*
1697  * For __print_symbolic() and __print_flags, we need to completely
1698  * evaluate the first argument, which defines what to print next.
1699  */
1700 static enum tep_event_type
1701 process_field_arg(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
1702 {
1703         enum tep_event_type type;
1704
1705         type = process_arg(event, arg, tok);
1706
1707         while (type == TEP_EVENT_OP) {
1708                 type = process_op(event, arg, tok);
1709         }
1710
1711         return type;
1712 }
1713
1714 static enum tep_event_type
1715 process_cond(struct tep_event_format *event, struct tep_print_arg *top, char **tok)
1716 {
1717         struct tep_print_arg *arg, *left, *right;
1718         enum tep_event_type type;
1719         char *token = NULL;
1720
1721         arg = alloc_arg();
1722         left = alloc_arg();
1723         right = alloc_arg();
1724
1725         if (!arg || !left || !right) {
1726                 do_warning_event(event, "%s: not enough memory!", __func__);
1727                 /* arg will be freed at out_free */
1728                 free_arg(left);
1729                 free_arg(right);
1730                 goto out_free;
1731         }
1732
1733         arg->type = TEP_PRINT_OP;
1734         arg->op.left = left;
1735         arg->op.right = right;
1736
1737         *tok = NULL;
1738         type = process_arg(event, left, &token);
1739
1740  again:
1741         if (type == TEP_EVENT_ERROR)
1742                 goto out_free;
1743
1744         /* Handle other operations in the arguments */
1745         if (type == TEP_EVENT_OP && strcmp(token, ":") != 0) {
1746                 type = process_op(event, left, &token);
1747                 goto again;
1748         }
1749
1750         if (test_type_token(type, token, TEP_EVENT_OP, ":"))
1751                 goto out_free;
1752
1753         arg->op.op = token;
1754
1755         type = process_arg(event, right, &token);
1756
1757         top->op.right = arg;
1758
1759         *tok = token;
1760         return type;
1761
1762 out_free:
1763         /* Top may point to itself */
1764         top->op.right = NULL;
1765         free_token(token);
1766         free_arg(arg);
1767         return TEP_EVENT_ERROR;
1768 }
1769
1770 static enum tep_event_type
1771 process_array(struct tep_event_format *event, struct tep_print_arg *top, char **tok)
1772 {
1773         struct tep_print_arg *arg;
1774         enum tep_event_type type;
1775         char *token = NULL;
1776
1777         arg = alloc_arg();
1778         if (!arg) {
1779                 do_warning_event(event, "%s: not enough memory!", __func__);
1780                 /* '*tok' is set to top->op.op.  No need to free. */
1781                 *tok = NULL;
1782                 return TEP_EVENT_ERROR;
1783         }
1784
1785         *tok = NULL;
1786         type = process_arg(event, arg, &token);
1787         if (test_type_token(type, token, TEP_EVENT_OP, "]"))
1788                 goto out_free;
1789
1790         top->op.right = arg;
1791
1792         free_token(token);
1793         type = read_token_item(&token);
1794         *tok = token;
1795
1796         return type;
1797
1798 out_free:
1799         free_token(token);
1800         free_arg(arg);
1801         return TEP_EVENT_ERROR;
1802 }
1803
1804 static int get_op_prio(char *op)
1805 {
1806         if (!op[1]) {
1807                 switch (op[0]) {
1808                 case '~':
1809                 case '!':
1810                         return 4;
1811                 case '*':
1812                 case '/':
1813                 case '%':
1814                         return 6;
1815                 case '+':
1816                 case '-':
1817                         return 7;
1818                         /* '>>' and '<<' are 8 */
1819                 case '<':
1820                 case '>':
1821                         return 9;
1822                         /* '==' and '!=' are 10 */
1823                 case '&':
1824                         return 11;
1825                 case '^':
1826                         return 12;
1827                 case '|':
1828                         return 13;
1829                 case '?':
1830                         return 16;
1831                 default:
1832                         do_warning("unknown op '%c'", op[0]);
1833                         return -1;
1834                 }
1835         } else {
1836                 if (strcmp(op, "++") == 0 ||
1837                     strcmp(op, "--") == 0) {
1838                         return 3;
1839                 } else if (strcmp(op, ">>") == 0 ||
1840                            strcmp(op, "<<") == 0) {
1841                         return 8;
1842                 } else if (strcmp(op, ">=") == 0 ||
1843                            strcmp(op, "<=") == 0) {
1844                         return 9;
1845                 } else if (strcmp(op, "==") == 0 ||
1846                            strcmp(op, "!=") == 0) {
1847                         return 10;
1848                 } else if (strcmp(op, "&&") == 0) {
1849                         return 14;
1850                 } else if (strcmp(op, "||") == 0) {
1851                         return 15;
1852                 } else {
1853                         do_warning("unknown op '%s'", op);
1854                         return -1;
1855                 }
1856         }
1857 }
1858
1859 static int set_op_prio(struct tep_print_arg *arg)
1860 {
1861
1862         /* single ops are the greatest */
1863         if (!arg->op.left || arg->op.left->type == TEP_PRINT_NULL)
1864                 arg->op.prio = 0;
1865         else
1866                 arg->op.prio = get_op_prio(arg->op.op);
1867
1868         return arg->op.prio;
1869 }
1870
1871 /* Note, *tok does not get freed, but will most likely be saved */
1872 static enum tep_event_type
1873 process_op(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
1874 {
1875         struct tep_print_arg *left, *right = NULL;
1876         enum tep_event_type type;
1877         char *token;
1878
1879         /* the op is passed in via tok */
1880         token = *tok;
1881
1882         if (arg->type == TEP_PRINT_OP && !arg->op.left) {
1883                 /* handle single op */
1884                 if (token[1]) {
1885                         do_warning_event(event, "bad op token %s", token);
1886                         goto out_free;
1887                 }
1888                 switch (token[0]) {
1889                 case '~':
1890                 case '!':
1891                 case '+':
1892                 case '-':
1893                         break;
1894                 default:
1895                         do_warning_event(event, "bad op token %s", token);
1896                         goto out_free;
1897
1898                 }
1899
1900                 /* make an empty left */
1901                 left = alloc_arg();
1902                 if (!left)
1903                         goto out_warn_free;
1904
1905                 left->type = TEP_PRINT_NULL;
1906                 arg->op.left = left;
1907
1908                 right = alloc_arg();
1909                 if (!right)
1910                         goto out_warn_free;
1911
1912                 arg->op.right = right;
1913
1914                 /* do not free the token, it belongs to an op */
1915                 *tok = NULL;
1916                 type = process_arg(event, right, tok);
1917
1918         } else if (strcmp(token, "?") == 0) {
1919
1920                 left = alloc_arg();
1921                 if (!left)
1922                         goto out_warn_free;
1923
1924                 /* copy the top arg to the left */
1925                 *left = *arg;
1926
1927                 arg->type = TEP_PRINT_OP;
1928                 arg->op.op = token;
1929                 arg->op.left = left;
1930                 arg->op.prio = 0;
1931
1932                 /* it will set arg->op.right */
1933                 type = process_cond(event, arg, tok);
1934
1935         } else if (strcmp(token, ">>") == 0 ||
1936                    strcmp(token, "<<") == 0 ||
1937                    strcmp(token, "&") == 0 ||
1938                    strcmp(token, "|") == 0 ||
1939                    strcmp(token, "&&") == 0 ||
1940                    strcmp(token, "||") == 0 ||
1941                    strcmp(token, "-") == 0 ||
1942                    strcmp(token, "+") == 0 ||
1943                    strcmp(token, "*") == 0 ||
1944                    strcmp(token, "^") == 0 ||
1945                    strcmp(token, "/") == 0 ||
1946                    strcmp(token, "%") == 0 ||
1947                    strcmp(token, "<") == 0 ||
1948                    strcmp(token, ">") == 0 ||
1949                    strcmp(token, "<=") == 0 ||
1950                    strcmp(token, ">=") == 0 ||
1951                    strcmp(token, "==") == 0 ||
1952                    strcmp(token, "!=") == 0) {
1953
1954                 left = alloc_arg();
1955                 if (!left)
1956                         goto out_warn_free;
1957
1958                 /* copy the top arg to the left */
1959                 *left = *arg;
1960
1961                 arg->type = TEP_PRINT_OP;
1962                 arg->op.op = token;
1963                 arg->op.left = left;
1964                 arg->op.right = NULL;
1965
1966                 if (set_op_prio(arg) == -1) {
1967                         event->flags |= TEP_EVENT_FL_FAILED;
1968                         /* arg->op.op (= token) will be freed at out_free */
1969                         arg->op.op = NULL;
1970                         goto out_free;
1971                 }
1972
1973                 type = read_token_item(&token);
1974                 *tok = token;
1975
1976                 /* could just be a type pointer */
1977                 if ((strcmp(arg->op.op, "*") == 0) &&
1978                     type == TEP_EVENT_DELIM && (strcmp(token, ")") == 0)) {
1979                         char *new_atom;
1980
1981                         if (left->type != TEP_PRINT_ATOM) {
1982                                 do_warning_event(event, "bad pointer type");
1983                                 goto out_free;
1984                         }
1985                         new_atom = realloc(left->atom.atom,
1986                                             strlen(left->atom.atom) + 3);
1987                         if (!new_atom)
1988                                 goto out_warn_free;
1989
1990                         left->atom.atom = new_atom;
1991                         strcat(left->atom.atom, " *");
1992                         free(arg->op.op);
1993                         *arg = *left;
1994                         free(left);
1995
1996                         return type;
1997                 }
1998
1999                 right = alloc_arg();
2000                 if (!right)
2001                         goto out_warn_free;
2002
2003                 type = process_arg_token(event, right, tok, type);
2004                 if (type == TEP_EVENT_ERROR) {
2005                         free_arg(right);
2006                         /* token was freed in process_arg_token() via *tok */
2007                         token = NULL;
2008                         goto out_free;
2009                 }
2010
2011                 if (right->type == TEP_PRINT_OP &&
2012                     get_op_prio(arg->op.op) < get_op_prio(right->op.op)) {
2013                         struct tep_print_arg tmp;
2014
2015                         /* rotate ops according to the priority */
2016                         arg->op.right = right->op.left;
2017
2018                         tmp = *arg;
2019                         *arg = *right;
2020                         *right = tmp;
2021
2022                         arg->op.left = right;
2023                 } else {
2024                         arg->op.right = right;
2025                 }
2026
2027         } else if (strcmp(token, "[") == 0) {
2028
2029                 left = alloc_arg();
2030                 if (!left)
2031                         goto out_warn_free;
2032
2033                 *left = *arg;
2034
2035                 arg->type = TEP_PRINT_OP;
2036                 arg->op.op = token;
2037                 arg->op.left = left;
2038
2039                 arg->op.prio = 0;
2040
2041                 /* it will set arg->op.right */
2042                 type = process_array(event, arg, tok);
2043
2044         } else {
2045                 do_warning_event(event, "unknown op '%s'", token);
2046                 event->flags |= TEP_EVENT_FL_FAILED;
2047                 /* the arg is now the left side */
2048                 goto out_free;
2049         }
2050
2051         if (type == TEP_EVENT_OP && strcmp(*tok, ":") != 0) {
2052                 int prio;
2053
2054                 /* higher prios need to be closer to the root */
2055                 prio = get_op_prio(*tok);
2056
2057                 if (prio > arg->op.prio)
2058                         return process_op(event, arg, tok);
2059
2060                 return process_op(event, right, tok);
2061         }
2062
2063         return type;
2064
2065 out_warn_free:
2066         do_warning_event(event, "%s: not enough memory!", __func__);
2067 out_free:
2068         free_token(token);
2069         *tok = NULL;
2070         return TEP_EVENT_ERROR;
2071 }
2072
2073 static enum tep_event_type
2074 process_entry(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
2075               char **tok)
2076 {
2077         enum tep_event_type type;
2078         char *field;
2079         char *token;
2080
2081         if (read_expected(TEP_EVENT_OP, "->") < 0)
2082                 goto out_err;
2083
2084         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2085                 goto out_free;
2086         field = token;
2087
2088         arg->type = TEP_PRINT_FIELD;
2089         arg->field.name = field;
2090
2091         if (is_flag_field) {
2092                 arg->field.field = tep_find_any_field(event, arg->field.name);
2093                 arg->field.field->flags |= TEP_FIELD_IS_FLAG;
2094                 is_flag_field = 0;
2095         } else if (is_symbolic_field) {
2096                 arg->field.field = tep_find_any_field(event, arg->field.name);
2097                 arg->field.field->flags |= TEP_FIELD_IS_SYMBOLIC;
2098                 is_symbolic_field = 0;
2099         }
2100
2101         type = read_token(&token);
2102         *tok = token;
2103
2104         return type;
2105
2106  out_free:
2107         free_token(token);
2108  out_err:
2109         *tok = NULL;
2110         return TEP_EVENT_ERROR;
2111 }
2112
2113 static int alloc_and_process_delim(struct tep_event_format *event, char *next_token,
2114                                    struct tep_print_arg **print_arg)
2115 {
2116         struct tep_print_arg *field;
2117         enum tep_event_type type;
2118         char *token;
2119         int ret = 0;
2120
2121         field = alloc_arg();
2122         if (!field) {
2123                 do_warning_event(event, "%s: not enough memory!", __func__);
2124                 errno = ENOMEM;
2125                 return -1;
2126         }
2127
2128         type = process_arg(event, field, &token);
2129
2130         if (test_type_token(type, token, TEP_EVENT_DELIM, next_token)) {
2131                 errno = EINVAL;
2132                 ret = -1;
2133                 free_arg(field);
2134                 goto out_free_token;
2135         }
2136
2137         *print_arg = field;
2138
2139 out_free_token:
2140         free_token(token);
2141
2142         return ret;
2143 }
2144
2145 static char *arg_eval (struct tep_print_arg *arg);
2146
2147 static unsigned long long
2148 eval_type_str(unsigned long long val, const char *type, int pointer)
2149 {
2150         int sign = 0;
2151         char *ref;
2152         int len;
2153
2154         len = strlen(type);
2155
2156         if (pointer) {
2157
2158                 if (type[len-1] != '*') {
2159                         do_warning("pointer expected with non pointer type");
2160                         return val;
2161                 }
2162
2163                 ref = malloc(len);
2164                 if (!ref) {
2165                         do_warning("%s: not enough memory!", __func__);
2166                         return val;
2167                 }
2168                 memcpy(ref, type, len);
2169
2170                 /* chop off the " *" */
2171                 ref[len - 2] = 0;
2172
2173                 val = eval_type_str(val, ref, 0);
2174                 free(ref);
2175                 return val;
2176         }
2177
2178         /* check if this is a pointer */
2179         if (type[len - 1] == '*')
2180                 return val;
2181
2182         /* Try to figure out the arg size*/
2183         if (strncmp(type, "struct", 6) == 0)
2184                 /* all bets off */
2185                 return val;
2186
2187         if (strcmp(type, "u8") == 0)
2188                 return val & 0xff;
2189
2190         if (strcmp(type, "u16") == 0)
2191                 return val & 0xffff;
2192
2193         if (strcmp(type, "u32") == 0)
2194                 return val & 0xffffffff;
2195
2196         if (strcmp(type, "u64") == 0 ||
2197             strcmp(type, "s64"))
2198                 return val;
2199
2200         if (strcmp(type, "s8") == 0)
2201                 return (unsigned long long)(char)val & 0xff;
2202
2203         if (strcmp(type, "s16") == 0)
2204                 return (unsigned long long)(short)val & 0xffff;
2205
2206         if (strcmp(type, "s32") == 0)
2207                 return (unsigned long long)(int)val & 0xffffffff;
2208
2209         if (strncmp(type, "unsigned ", 9) == 0) {
2210                 sign = 0;
2211                 type += 9;
2212         }
2213
2214         if (strcmp(type, "char") == 0) {
2215                 if (sign)
2216                         return (unsigned long long)(char)val & 0xff;
2217                 else
2218                         return val & 0xff;
2219         }
2220
2221         if (strcmp(type, "short") == 0) {
2222                 if (sign)
2223                         return (unsigned long long)(short)val & 0xffff;
2224                 else
2225                         return val & 0xffff;
2226         }
2227
2228         if (strcmp(type, "int") == 0) {
2229                 if (sign)
2230                         return (unsigned long long)(int)val & 0xffffffff;
2231                 else
2232                         return val & 0xffffffff;
2233         }
2234
2235         return val;
2236 }
2237
2238 /*
2239  * Try to figure out the type.
2240  */
2241 static unsigned long long
2242 eval_type(unsigned long long val, struct tep_print_arg *arg, int pointer)
2243 {
2244         if (arg->type != TEP_PRINT_TYPE) {
2245                 do_warning("expected type argument");
2246                 return 0;
2247         }
2248
2249         return eval_type_str(val, arg->typecast.type, pointer);
2250 }
2251
2252 static int arg_num_eval(struct tep_print_arg *arg, long long *val)
2253 {
2254         long long left, right;
2255         int ret = 1;
2256
2257         switch (arg->type) {
2258         case TEP_PRINT_ATOM:
2259                 *val = strtoll(arg->atom.atom, NULL, 0);
2260                 break;
2261         case TEP_PRINT_TYPE:
2262                 ret = arg_num_eval(arg->typecast.item, val);
2263                 if (!ret)
2264                         break;
2265                 *val = eval_type(*val, arg, 0);
2266                 break;
2267         case TEP_PRINT_OP:
2268                 switch (arg->op.op[0]) {
2269                 case '|':
2270                         ret = arg_num_eval(arg->op.left, &left);
2271                         if (!ret)
2272                                 break;
2273                         ret = arg_num_eval(arg->op.right, &right);
2274                         if (!ret)
2275                                 break;
2276                         if (arg->op.op[1])
2277                                 *val = left || right;
2278                         else
2279                                 *val = left | right;
2280                         break;
2281                 case '&':
2282                         ret = arg_num_eval(arg->op.left, &left);
2283                         if (!ret)
2284                                 break;
2285                         ret = arg_num_eval(arg->op.right, &right);
2286                         if (!ret)
2287                                 break;
2288                         if (arg->op.op[1])
2289                                 *val = left && right;
2290                         else
2291                                 *val = left & right;
2292                         break;
2293                 case '<':
2294                         ret = arg_num_eval(arg->op.left, &left);
2295                         if (!ret)
2296                                 break;
2297                         ret = arg_num_eval(arg->op.right, &right);
2298                         if (!ret)
2299                                 break;
2300                         switch (arg->op.op[1]) {
2301                         case 0:
2302                                 *val = left < right;
2303                                 break;
2304                         case '<':
2305                                 *val = left << right;
2306                                 break;
2307                         case '=':
2308                                 *val = left <= right;
2309                                 break;
2310                         default:
2311                                 do_warning("unknown op '%s'", arg->op.op);
2312                                 ret = 0;
2313                         }
2314                         break;
2315                 case '>':
2316                         ret = arg_num_eval(arg->op.left, &left);
2317                         if (!ret)
2318                                 break;
2319                         ret = arg_num_eval(arg->op.right, &right);
2320                         if (!ret)
2321                                 break;
2322                         switch (arg->op.op[1]) {
2323                         case 0:
2324                                 *val = left > right;
2325                                 break;
2326                         case '>':
2327                                 *val = left >> right;
2328                                 break;
2329                         case '=':
2330                                 *val = left >= right;
2331                                 break;
2332                         default:
2333                                 do_warning("unknown op '%s'", arg->op.op);
2334                                 ret = 0;
2335                         }
2336                         break;
2337                 case '=':
2338                         ret = arg_num_eval(arg->op.left, &left);
2339                         if (!ret)
2340                                 break;
2341                         ret = arg_num_eval(arg->op.right, &right);
2342                         if (!ret)
2343                                 break;
2344
2345                         if (arg->op.op[1] != '=') {
2346                                 do_warning("unknown op '%s'", arg->op.op);
2347                                 ret = 0;
2348                         } else
2349                                 *val = left == right;
2350                         break;
2351                 case '!':
2352                         ret = arg_num_eval(arg->op.left, &left);
2353                         if (!ret)
2354                                 break;
2355                         ret = arg_num_eval(arg->op.right, &right);
2356                         if (!ret)
2357                                 break;
2358
2359                         switch (arg->op.op[1]) {
2360                         case '=':
2361                                 *val = left != right;
2362                                 break;
2363                         default:
2364                                 do_warning("unknown op '%s'", arg->op.op);
2365                                 ret = 0;
2366                         }
2367                         break;
2368                 case '-':
2369                         /* check for negative */
2370                         if (arg->op.left->type == TEP_PRINT_NULL)
2371                                 left = 0;
2372                         else
2373                                 ret = arg_num_eval(arg->op.left, &left);
2374                         if (!ret)
2375                                 break;
2376                         ret = arg_num_eval(arg->op.right, &right);
2377                         if (!ret)
2378                                 break;
2379                         *val = left - right;
2380                         break;
2381                 case '+':
2382                         if (arg->op.left->type == TEP_PRINT_NULL)
2383                                 left = 0;
2384                         else
2385                                 ret = arg_num_eval(arg->op.left, &left);
2386                         if (!ret)
2387                                 break;
2388                         ret = arg_num_eval(arg->op.right, &right);
2389                         if (!ret)
2390                                 break;
2391                         *val = left + right;
2392                         break;
2393                 case '~':
2394                         ret = arg_num_eval(arg->op.right, &right);
2395                         if (!ret)
2396                                 break;
2397                         *val = ~right;
2398                         break;
2399                 default:
2400                         do_warning("unknown op '%s'", arg->op.op);
2401                         ret = 0;
2402                 }
2403                 break;
2404
2405         case TEP_PRINT_NULL:
2406         case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2407         case TEP_PRINT_STRING:
2408         case TEP_PRINT_BSTRING:
2409         case TEP_PRINT_BITMASK:
2410         default:
2411                 do_warning("invalid eval type %d", arg->type);
2412                 ret = 0;
2413
2414         }
2415         return ret;
2416 }
2417
2418 static char *arg_eval (struct tep_print_arg *arg)
2419 {
2420         long long val;
2421         static char buf[20];
2422
2423         switch (arg->type) {
2424         case TEP_PRINT_ATOM:
2425                 return arg->atom.atom;
2426         case TEP_PRINT_TYPE:
2427                 return arg_eval(arg->typecast.item);
2428         case TEP_PRINT_OP:
2429                 if (!arg_num_eval(arg, &val))
2430                         break;
2431                 sprintf(buf, "%lld", val);
2432                 return buf;
2433
2434         case TEP_PRINT_NULL:
2435         case TEP_PRINT_FIELD ... TEP_PRINT_SYMBOL:
2436         case TEP_PRINT_STRING:
2437         case TEP_PRINT_BSTRING:
2438         case TEP_PRINT_BITMASK:
2439         default:
2440                 do_warning("invalid eval type %d", arg->type);
2441                 break;
2442         }
2443
2444         return NULL;
2445 }
2446
2447 static enum tep_event_type
2448 process_fields(struct tep_event_format *event, struct tep_print_flag_sym **list, char **tok)
2449 {
2450         enum tep_event_type type;
2451         struct tep_print_arg *arg = NULL;
2452         struct tep_print_flag_sym *field;
2453         char *token = *tok;
2454         char *value;
2455
2456         do {
2457                 free_token(token);
2458                 type = read_token_item(&token);
2459                 if (test_type_token(type, token, TEP_EVENT_OP, "{"))
2460                         break;
2461
2462                 arg = alloc_arg();
2463                 if (!arg)
2464                         goto out_free;
2465
2466                 free_token(token);
2467                 type = process_arg(event, arg, &token);
2468
2469                 if (type == TEP_EVENT_OP)
2470                         type = process_op(event, arg, &token);
2471
2472                 if (type == TEP_EVENT_ERROR)
2473                         goto out_free;
2474
2475                 if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2476                         goto out_free;
2477
2478                 field = calloc(1, sizeof(*field));
2479                 if (!field)
2480                         goto out_free;
2481
2482                 value = arg_eval(arg);
2483                 if (value == NULL)
2484                         goto out_free_field;
2485                 field->value = strdup(value);
2486                 if (field->value == NULL)
2487                         goto out_free_field;
2488
2489                 free_arg(arg);
2490                 arg = alloc_arg();
2491                 if (!arg)
2492                         goto out_free;
2493
2494                 free_token(token);
2495                 type = process_arg(event, arg, &token);
2496                 if (test_type_token(type, token, TEP_EVENT_OP, "}"))
2497                         goto out_free_field;
2498
2499                 value = arg_eval(arg);
2500                 if (value == NULL)
2501                         goto out_free_field;
2502                 field->str = strdup(value);
2503                 if (field->str == NULL)
2504                         goto out_free_field;
2505                 free_arg(arg);
2506                 arg = NULL;
2507
2508                 *list = field;
2509                 list = &field->next;
2510
2511                 free_token(token);
2512                 type = read_token_item(&token);
2513         } while (type == TEP_EVENT_DELIM && strcmp(token, ",") == 0);
2514
2515         *tok = token;
2516         return type;
2517
2518 out_free_field:
2519         free_flag_sym(field);
2520 out_free:
2521         free_arg(arg);
2522         free_token(token);
2523         *tok = NULL;
2524
2525         return TEP_EVENT_ERROR;
2526 }
2527
2528 static enum tep_event_type
2529 process_flags(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2530 {
2531         struct tep_print_arg *field;
2532         enum tep_event_type type;
2533         char *token = NULL;
2534
2535         memset(arg, 0, sizeof(*arg));
2536         arg->type = TEP_PRINT_FLAGS;
2537
2538         field = alloc_arg();
2539         if (!field) {
2540                 do_warning_event(event, "%s: not enough memory!", __func__);
2541                 goto out_free;
2542         }
2543
2544         type = process_field_arg(event, field, &token);
2545
2546         /* Handle operations in the first argument */
2547         while (type == TEP_EVENT_OP)
2548                 type = process_op(event, field, &token);
2549
2550         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2551                 goto out_free_field;
2552         free_token(token);
2553
2554         arg->flags.field = field;
2555
2556         type = read_token_item(&token);
2557         if (event_item_type(type)) {
2558                 arg->flags.delim = token;
2559                 type = read_token_item(&token);
2560         }
2561
2562         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2563                 goto out_free;
2564
2565         type = process_fields(event, &arg->flags.flags, &token);
2566         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2567                 goto out_free;
2568
2569         free_token(token);
2570         type = read_token_item(tok);
2571         return type;
2572
2573 out_free_field:
2574         free_arg(field);
2575 out_free:
2576         free_token(token);
2577         *tok = NULL;
2578         return TEP_EVENT_ERROR;
2579 }
2580
2581 static enum tep_event_type
2582 process_symbols(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2583 {
2584         struct tep_print_arg *field;
2585         enum tep_event_type type;
2586         char *token = NULL;
2587
2588         memset(arg, 0, sizeof(*arg));
2589         arg->type = TEP_PRINT_SYMBOL;
2590
2591         field = alloc_arg();
2592         if (!field) {
2593                 do_warning_event(event, "%s: not enough memory!", __func__);
2594                 goto out_free;
2595         }
2596
2597         type = process_field_arg(event, field, &token);
2598
2599         if (test_type_token(type, token, TEP_EVENT_DELIM, ","))
2600                 goto out_free_field;
2601
2602         arg->symbol.field = field;
2603
2604         type = process_fields(event, &arg->symbol.symbols, &token);
2605         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2606                 goto out_free;
2607
2608         free_token(token);
2609         type = read_token_item(tok);
2610         return type;
2611
2612 out_free_field:
2613         free_arg(field);
2614 out_free:
2615         free_token(token);
2616         *tok = NULL;
2617         return TEP_EVENT_ERROR;
2618 }
2619
2620 static enum tep_event_type
2621 process_hex_common(struct tep_event_format *event, struct tep_print_arg *arg,
2622                    char **tok, enum tep_print_arg_type type)
2623 {
2624         memset(arg, 0, sizeof(*arg));
2625         arg->type = type;
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         arg->hex.field = NULL;
2638 out:
2639         *tok = NULL;
2640         return TEP_EVENT_ERROR;
2641 }
2642
2643 static enum tep_event_type
2644 process_hex(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2645 {
2646         return process_hex_common(event, arg, tok, TEP_PRINT_HEX);
2647 }
2648
2649 static enum tep_event_type
2650 process_hex_str(struct tep_event_format *event, struct tep_print_arg *arg,
2651                 char **tok)
2652 {
2653         return process_hex_common(event, arg, tok, TEP_PRINT_HEX_STR);
2654 }
2655
2656 static enum tep_event_type
2657 process_int_array(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2658 {
2659         memset(arg, 0, sizeof(*arg));
2660         arg->type = TEP_PRINT_INT_ARRAY;
2661
2662         if (alloc_and_process_delim(event, ",", &arg->int_array.field))
2663                 goto out;
2664
2665         if (alloc_and_process_delim(event, ",", &arg->int_array.count))
2666                 goto free_field;
2667
2668         if (alloc_and_process_delim(event, ")", &arg->int_array.el_size))
2669                 goto free_size;
2670
2671         return read_token_item(tok);
2672
2673 free_size:
2674         free_arg(arg->int_array.count);
2675         arg->int_array.count = NULL;
2676 free_field:
2677         free_arg(arg->int_array.field);
2678         arg->int_array.field = NULL;
2679 out:
2680         *tok = NULL;
2681         return TEP_EVENT_ERROR;
2682 }
2683
2684 static enum tep_event_type
2685 process_dynamic_array(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2686 {
2687         struct tep_format_field *field;
2688         enum tep_event_type type;
2689         char *token;
2690
2691         memset(arg, 0, sizeof(*arg));
2692         arg->type = TEP_PRINT_DYNAMIC_ARRAY;
2693
2694         /*
2695          * The item within the parenthesis is another field that holds
2696          * the index into where the array starts.
2697          */
2698         type = read_token(&token);
2699         *tok = token;
2700         if (type != TEP_EVENT_ITEM)
2701                 goto out_free;
2702
2703         /* Find the field */
2704
2705         field = tep_find_field(event, token);
2706         if (!field)
2707                 goto out_free;
2708
2709         arg->dynarray.field = field;
2710         arg->dynarray.index = 0;
2711
2712         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2713                 goto out_free;
2714
2715         free_token(token);
2716         type = read_token_item(&token);
2717         *tok = token;
2718         if (type != TEP_EVENT_OP || strcmp(token, "[") != 0)
2719                 return type;
2720
2721         free_token(token);
2722         arg = alloc_arg();
2723         if (!arg) {
2724                 do_warning_event(event, "%s: not enough memory!", __func__);
2725                 *tok = NULL;
2726                 return TEP_EVENT_ERROR;
2727         }
2728
2729         type = process_arg(event, arg, &token);
2730         if (type == TEP_EVENT_ERROR)
2731                 goto out_free_arg;
2732
2733         if (!test_type_token(type, token, TEP_EVENT_OP, "]"))
2734                 goto out_free_arg;
2735
2736         free_token(token);
2737         type = read_token_item(tok);
2738         return type;
2739
2740  out_free_arg:
2741         free_arg(arg);
2742  out_free:
2743         free_token(token);
2744         *tok = NULL;
2745         return TEP_EVENT_ERROR;
2746 }
2747
2748 static enum tep_event_type
2749 process_dynamic_array_len(struct tep_event_format *event, struct tep_print_arg *arg,
2750                           char **tok)
2751 {
2752         struct tep_format_field *field;
2753         enum tep_event_type type;
2754         char *token;
2755
2756         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2757                 goto out_free;
2758
2759         arg->type = TEP_PRINT_DYNAMIC_ARRAY_LEN;
2760
2761         /* Find the field */
2762         field = tep_find_field(event, token);
2763         if (!field)
2764                 goto out_free;
2765
2766         arg->dynarray.field = field;
2767         arg->dynarray.index = 0;
2768
2769         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2770                 goto out_err;
2771
2772         type = read_token(&token);
2773         *tok = token;
2774
2775         return type;
2776
2777  out_free:
2778         free_token(token);
2779  out_err:
2780         *tok = NULL;
2781         return TEP_EVENT_ERROR;
2782 }
2783
2784 static enum tep_event_type
2785 process_paren(struct tep_event_format *event, struct tep_print_arg *arg, char **tok)
2786 {
2787         struct tep_print_arg *item_arg;
2788         enum tep_event_type type;
2789         char *token;
2790
2791         type = process_arg(event, arg, &token);
2792
2793         if (type == TEP_EVENT_ERROR)
2794                 goto out_free;
2795
2796         if (type == TEP_EVENT_OP)
2797                 type = process_op(event, arg, &token);
2798
2799         if (type == TEP_EVENT_ERROR)
2800                 goto out_free;
2801
2802         if (test_type_token(type, token, TEP_EVENT_DELIM, ")"))
2803                 goto out_free;
2804
2805         free_token(token);
2806         type = read_token_item(&token);
2807
2808         /*
2809          * If the next token is an item or another open paren, then
2810          * this was a typecast.
2811          */
2812         if (event_item_type(type) ||
2813             (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0)) {
2814
2815                 /* make this a typecast and contine */
2816
2817                 /* prevous must be an atom */
2818                 if (arg->type != TEP_PRINT_ATOM) {
2819                         do_warning_event(event, "previous needed to be TEP_PRINT_ATOM");
2820                         goto out_free;
2821                 }
2822
2823                 item_arg = alloc_arg();
2824                 if (!item_arg) {
2825                         do_warning_event(event, "%s: not enough memory!",
2826                                          __func__);
2827                         goto out_free;
2828                 }
2829
2830                 arg->type = TEP_PRINT_TYPE;
2831                 arg->typecast.type = arg->atom.atom;
2832                 arg->typecast.item = item_arg;
2833                 type = process_arg_token(event, item_arg, &token, type);
2834
2835         }
2836
2837         *tok = token;
2838         return type;
2839
2840  out_free:
2841         free_token(token);
2842         *tok = NULL;
2843         return TEP_EVENT_ERROR;
2844 }
2845
2846
2847 static enum tep_event_type
2848 process_str(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
2849             char **tok)
2850 {
2851         enum tep_event_type type;
2852         char *token;
2853
2854         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2855                 goto out_free;
2856
2857         arg->type = TEP_PRINT_STRING;
2858         arg->string.string = token;
2859         arg->string.offset = -1;
2860
2861         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2862                 goto out_err;
2863
2864         type = read_token(&token);
2865         *tok = token;
2866
2867         return type;
2868
2869  out_free:
2870         free_token(token);
2871  out_err:
2872         *tok = NULL;
2873         return TEP_EVENT_ERROR;
2874 }
2875
2876 static enum tep_event_type
2877 process_bitmask(struct tep_event_format *event __maybe_unused, struct tep_print_arg *arg,
2878                 char **tok)
2879 {
2880         enum tep_event_type type;
2881         char *token;
2882
2883         if (read_expect_type(TEP_EVENT_ITEM, &token) < 0)
2884                 goto out_free;
2885
2886         arg->type = TEP_PRINT_BITMASK;
2887         arg->bitmask.bitmask = token;
2888         arg->bitmask.offset = -1;
2889
2890         if (read_expected(TEP_EVENT_DELIM, ")") < 0)
2891                 goto out_err;
2892
2893         type = read_token(&token);
2894         *tok = token;
2895
2896         return type;
2897
2898  out_free:
2899         free_token(token);
2900  out_err:
2901         *tok = NULL;
2902         return TEP_EVENT_ERROR;
2903 }
2904
2905 static struct tep_function_handler *
2906 find_func_handler(struct tep_handle *pevent, char *func_name)
2907 {
2908         struct tep_function_handler *func;
2909
2910         if (!pevent)
2911                 return NULL;
2912
2913         for (func = pevent->func_handlers; func; func = func->next) {
2914                 if (strcmp(func->name, func_name) == 0)
2915                         break;
2916         }
2917
2918         return func;
2919 }
2920
2921 static void remove_func_handler(struct tep_handle *pevent, char *func_name)
2922 {
2923         struct tep_function_handler *func;
2924         struct tep_function_handler **next;
2925
2926         next = &pevent->func_handlers;
2927         while ((func = *next)) {
2928                 if (strcmp(func->name, func_name) == 0) {
2929                         *next = func->next;
2930                         free_func_handle(func);
2931                         break;
2932                 }
2933                 next = &func->next;
2934         }
2935 }
2936
2937 static enum tep_event_type
2938 process_func_handler(struct tep_event_format *event, struct tep_function_handler *func,
2939                      struct tep_print_arg *arg, char **tok)
2940 {
2941         struct tep_print_arg **next_arg;
2942         struct tep_print_arg *farg;
2943         enum tep_event_type type;
2944         char *token;
2945         int i;
2946
2947         arg->type = TEP_PRINT_FUNC;
2948         arg->func.func = func;
2949
2950         *tok = NULL;
2951
2952         next_arg = &(arg->func.args);
2953         for (i = 0; i < func->nr_args; i++) {
2954                 farg = alloc_arg();
2955                 if (!farg) {
2956                         do_warning_event(event, "%s: not enough memory!",
2957                                          __func__);
2958                         return TEP_EVENT_ERROR;
2959                 }
2960
2961                 type = process_arg(event, farg, &token);
2962                 if (i < (func->nr_args - 1)) {
2963                         if (type != TEP_EVENT_DELIM || strcmp(token, ",") != 0) {
2964                                 do_warning_event(event,
2965                                         "Error: function '%s()' expects %d arguments but event %s only uses %d",
2966                                         func->name, func->nr_args,
2967                                         event->name, i + 1);
2968                                 goto err;
2969                         }
2970                 } else {
2971                         if (type != TEP_EVENT_DELIM || strcmp(token, ")") != 0) {
2972                                 do_warning_event(event,
2973                                         "Error: function '%s()' only expects %d arguments but event %s has more",
2974                                         func->name, func->nr_args, event->name);
2975                                 goto err;
2976                         }
2977                 }
2978
2979                 *next_arg = farg;
2980                 next_arg = &(farg->next);
2981                 free_token(token);
2982         }
2983
2984         type = read_token(&token);
2985         *tok = token;
2986
2987         return type;
2988
2989 err:
2990         free_arg(farg);
2991         free_token(token);
2992         return TEP_EVENT_ERROR;
2993 }
2994
2995 static enum tep_event_type
2996 process_function(struct tep_event_format *event, struct tep_print_arg *arg,
2997                  char *token, char **tok)
2998 {
2999         struct tep_function_handler *func;
3000
3001         if (strcmp(token, "__print_flags") == 0) {
3002                 free_token(token);
3003                 is_flag_field = 1;
3004                 return process_flags(event, arg, tok);
3005         }
3006         if (strcmp(token, "__print_symbolic") == 0) {
3007                 free_token(token);
3008                 is_symbolic_field = 1;
3009                 return process_symbols(event, arg, tok);
3010         }
3011         if (strcmp(token, "__print_hex") == 0) {
3012                 free_token(token);
3013                 return process_hex(event, arg, tok);
3014         }
3015         if (strcmp(token, "__print_hex_str") == 0) {
3016                 free_token(token);
3017                 return process_hex_str(event, arg, tok);
3018         }
3019         if (strcmp(token, "__print_array") == 0) {
3020                 free_token(token);
3021                 return process_int_array(event, arg, tok);
3022         }
3023         if (strcmp(token, "__get_str") == 0) {
3024                 free_token(token);
3025                 return process_str(event, arg, tok);
3026         }
3027         if (strcmp(token, "__get_bitmask") == 0) {
3028                 free_token(token);
3029                 return process_bitmask(event, arg, tok);
3030         }
3031         if (strcmp(token, "__get_dynamic_array") == 0) {
3032                 free_token(token);
3033                 return process_dynamic_array(event, arg, tok);
3034         }
3035         if (strcmp(token, "__get_dynamic_array_len") == 0) {
3036                 free_token(token);
3037                 return process_dynamic_array_len(event, arg, tok);
3038         }
3039
3040         func = find_func_handler(event->pevent, token);
3041         if (func) {
3042                 free_token(token);
3043                 return process_func_handler(event, func, arg, tok);
3044         }
3045
3046         do_warning_event(event, "function %s not defined", token);
3047         free_token(token);
3048         return TEP_EVENT_ERROR;
3049 }
3050
3051 static enum tep_event_type
3052 process_arg_token(struct tep_event_format *event, struct tep_print_arg *arg,
3053                   char **tok, enum tep_event_type type)
3054 {
3055         char *token;
3056         char *atom;
3057
3058         token = *tok;
3059
3060         switch (type) {
3061         case TEP_EVENT_ITEM:
3062                 if (strcmp(token, "REC") == 0) {
3063                         free_token(token);
3064                         type = process_entry(event, arg, &token);
3065                         break;
3066                 }
3067                 atom = token;
3068                 /* test the next token */
3069                 type = read_token_item(&token);
3070
3071                 /*
3072                  * If the next token is a parenthesis, then this
3073                  * is a function.
3074                  */
3075                 if (type == TEP_EVENT_DELIM && strcmp(token, "(") == 0) {
3076                         free_token(token);
3077                         token = NULL;
3078                         /* this will free atom. */
3079                         type = process_function(event, arg, atom, &token);
3080                         break;
3081                 }
3082                 /* atoms can be more than one token long */
3083                 while (type == TEP_EVENT_ITEM) {
3084                         char *new_atom;
3085                         new_atom = realloc(atom,
3086                                            strlen(atom) + strlen(token) + 2);
3087                         if (!new_atom) {
3088                                 free(atom);
3089                                 *tok = NULL;
3090                                 free_token(token);
3091                                 return TEP_EVENT_ERROR;
3092                         }
3093                         atom = new_atom;
3094                         strcat(atom, " ");
3095                         strcat(atom, token);
3096                         free_token(token);
3097                         type = read_token_item(&token);
3098                 }
3099
3100                 arg->type = TEP_PRINT_ATOM;
3101                 arg->atom.atom = atom;
3102                 break;
3103
3104         case TEP_EVENT_DQUOTE:
3105         case TEP_EVENT_SQUOTE:
3106                 arg->type = TEP_PRINT_ATOM;
3107                 arg->atom.atom = token;
3108                 type = read_token_item(&token);
3109                 break;
3110         case TEP_EVENT_DELIM:
3111                 if (strcmp(token, "(") == 0) {
3112                         free_token(token);
3113                         type = process_paren(event, arg, &token);
3114                         break;
3115                 }
3116         case TEP_EVENT_OP:
3117                 /* handle single ops */
3118                 arg->type = TEP_PRINT_OP;
3119                 arg->op.op = token;
3120                 arg->op.left = NULL;
3121                 type = process_op(event, arg, &token);
3122
3123                 /* On error, the op is freed */
3124                 if (type == TEP_EVENT_ERROR)
3125                         arg->op.op = NULL;
3126
3127                 /* return error type if errored */
3128                 break;
3129
3130         case TEP_EVENT_ERROR ... TEP_EVENT_NEWLINE:
3131         default:
3132                 do_warning_event(event, "unexpected type %d", type);
3133                 return TEP_EVENT_ERROR;
3134         }
3135         *tok = token;
3136
3137         return type;
3138 }
3139
3140 static int event_read_print_args(struct tep_event_format *event, struct tep_print_arg **list)
3141 {