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