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