~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/lib/traceevent/event-parse.c

Version: ~ [ linux-5.13-rc1 ] ~ [ linux-5.12.2 ] ~ [ linux-5.11.19 ] ~ [ linux-5.10.35 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.117 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.190 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.232 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.268 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.268 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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