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