root/tools/lib/traceevent/event-parse.c

DEFINITIONS

1. init_input_buf
2. tep_get_input_buf
3. tep_get_input_buf_ptr
4. tep_buffer_init
5. breakpoint
6. alloc_arg
7. cmdline_cmp
8. cmdline_slot_cmp
9. cmdline_init
10. find_cmdline
11. tep_is_pid_registered
12. add_new_comm
13. _tep_register_comm
14. tep_register_comm
15. tep_override_comm
16. func_cmp
17. func_bcmp
18. func_map_init
19. __find_func
20. tep_set_function_resolver
21. tep_reset_function_resolver
22. find_func
23. tep_find_function
24. tep_find_function_address
25. tep_register_function
26. tep_print_funcs
27. printk_cmp
28. printk_map_init
29. find_printk
30. tep_register_print_string
31. tep_print_printk
32. alloc_event
33. add_event
34. event_item_type
35. free_flag_sym
36. free_arg
37. get_type
38. __read_char
39. __peek_char
40. tep_peek_char
41. extend_token
42. __read_token
43. force_token
44. free_token
45. read_token
46. tep_read_token
47. tep_free_token
48. read_token_item
49. test_type
50. test_type_token
51. __read_expect_type
52. read_expect_type
53. __read_expected
54. read_expected
55. read_expected_item
56. event_read_name
57. event_read_id
58. field_is_string
59. field_is_dynamic
60. field_is_long
61. type_size
62. event_read_fields
63. event_read_format
64. process_arg
65. process_field_arg
66. process_cond
67. process_array
68. get_op_prio
69. set_op_prio
70. process_op
71. process_entry
72. alloc_and_process_delim
73. eval_type_str
74. eval_type
75. arg_num_eval
76. arg_eval
77. process_fields
78. process_flags
79. process_symbols
80. process_hex_common
81. process_hex
82. process_hex_str
83. process_int_array
84. process_dynamic_array
85. process_dynamic_array_len
86. process_paren
87. process_str
88. process_bitmask
89. find_func_handler
90. remove_func_handler
91. process_func_handler
92. process_function
93. process_arg_token
94. event_read_print_args
95. event_read_print
96. tep_find_common_field
97. tep_find_field
98. tep_find_any_field
99. tep_read_number
100. tep_read_number_field
101. get_common_info
102. __parse_common
103. trace_parse_common_type
104. parse_common_pid
105. parse_common_pc
106. parse_common_flags
107. parse_common_lock_depth
108. parse_common_migrate_disable
109. tep_find_event
110. tep_find_event_by_name
111. eval_num_arg
112. eval_flag
113. print_str_to_seq
114. print_bitmask_to_seq
115. print_str_arg
116. process_defined_func
117. free_args
118. make_bprint_args
119. get_bprint_format
120. print_mac_arg
121. print_ip4_addr
122. ipv6_addr_v4mapped
123. ipv6_addr_is_isatap
124. print_ip6c_addr
125. print_ip6_addr
126. print_ipv4_arg
127. print_ipv6_arg
128. print_ipsa_arg
129. print_ip_arg
130. is_printable_array
131. tep_print_field
132. tep_print_fields
133. pretty_print
134. data_latency_format
135. tep_data_type
136. tep_data_pid
137. tep_data_preempt_count
138. tep_data_flags
139. tep_data_comm_from_pid
140. pid_from_cmdlist
141. tep_data_pid_from_comm
142. tep_cmdline_pid
143. print_event_info
144. tep_find_event_by_record
145. print_event_time
146. print_string
147. print_int
148. tep_print_event_param_type
149. tep_print_event
150. events_id_cmp
151. events_name_cmp
152. events_system_cmp
153. list_events_copy
154. list_events_sort
155. tep_list_events
156. tep_list_events_copy
157. get_event_fields
158. tep_event_common_fields
159. tep_event_fields
160. print_fields
161. print_args
162. parse_header_field
163. tep_parse_header_page
164. event_matches
165. free_handler
166. find_event_handle
167. __tep_parse_format
168. __parse_event
169. tep_parse_format
170. tep_parse_event
171. get_field_val
172. tep_get_field_raw
173. tep_get_field_val
174. tep_get_common_field_val
175. tep_get_any_field_val
176. tep_print_num_field
177. tep_print_func_field
178. free_func_handle
179. tep_register_print_function
180. tep_unregister_print_function
181. search_event
182. tep_register_event_handler
183. handle_matches
184. tep_unregister_event_handler
185. tep_alloc
186. tep_ref
187. tep_get_ref
188. tep_free_format_field
189. free_format_fields
190. free_formats
191. tep_free_event
192. tep_free
193. tep_unref

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