~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,21 +1,7 @@
	1	+/* SPDX-License-Identifier: LGPL-2.1 */
1	2	/*
2	3	* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
3	4	*
4		- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5		- * This program is free software; you can redistribute it and/or
6		- * modify it under the terms of the GNU Lesser General Public
7		- * License as published by the Free Software Foundation;
8		- * version 2.1 of the License (not later!)
9		- *
10		- * This program is distributed in the hope that it will be useful,
11		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
12		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13		- * GNU Lesser General Public License for more details.
14		- *
15		- * You should have received a copy of the GNU Lesser General Public
16		- * License along with this program; if not, see <http://www.gnu.org/licenses>
17		- *
18		- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19	5	*/
20	6	#ifndef _PARSE_EVENTS_H
21	7	#define _PARSE_EVENTS_H
..	..	@@ -26,15 +12,10 @@
26	12	#include <regex.h>
27	13	#include <string.h>
28	14
	15	+#include "trace-seq.h"
	16	+
29	17	#ifndef __maybe_unused
30	18	#define __maybe_unused __attribute__((unused))
31		-#endif
32		-
33		-/* ----------------------- trace_seq ----------------------- */
34		-
35		-
36		-#ifndef TRACE_SEQ_BUF_SIZE
37		-#define TRACE_SEQ_BUF_SIZE 4096
38	19	#endif
39	20
40	21	#ifndef DEBUG_RECORD
..	..	@@ -59,55 +40,18 @@
59	40	#endif
60	41	};
61	42
62		-enum trace_seq_fail {
63		- TRACE_SEQ__GOOD,
64		- TRACE_SEQ__BUFFER_POISONED,
65		- TRACE_SEQ__MEM_ALLOC_FAILED,
66		-};
67		-
68		-/*
69		- * Trace sequences are used to allow a function to call several other functions
70		- * to create a string of data to use (up to a max of PAGE_SIZE).
71		- */
72		-
73		-struct trace_seq {
74		- char *buffer;
75		- unsigned int buffer_size;
76		- unsigned int len;
77		- unsigned int readpos;
78		- enum trace_seq_fail state;
79		-};
80		-
81		-void trace_seq_init(struct trace_seq *s);
82		-void trace_seq_reset(struct trace_seq *s);
83		-void trace_seq_destroy(struct trace_seq *s);
84		-
85		-extern int trace_seq_printf(struct trace_seq s, const char fmt, ...)
86		- __attribute__ ((format (printf, 2, 3)));
87		-extern int trace_seq_vprintf(struct trace_seq s, const char fmt, va_list args)
88		- __attribute__ ((format (printf, 2, 0)));
89		-
90		-extern int trace_seq_puts(struct trace_seq s, const char str);
91		-extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
92		-
93		-extern void trace_seq_terminate(struct trace_seq *s);
94		-
95		-extern int trace_seq_do_fprintf(struct trace_seq s, FILE fp);
96		-extern int trace_seq_do_printf(struct trace_seq *s);
97		-
98		-
99		-/* ----------------------- pevent ----------------------- */
	43	+/* ----------------------- tep ----------------------- */
100	44
101	45	struct tep_handle;
102		-struct event_format;
	46	+struct tep_event;
103	47
104	48	typedef int (tep_event_handler_func)(struct trace_seq s,
105	49	struct tep_record *record,
106		- struct event_format *event,
	50	+ struct tep_event *event,
107	51	void *context);
108	52
109		-typedef int (tep_plugin_load_func)(struct tep_handle pevent);
110		-typedef int (tep_plugin_unload_func)(struct tep_handle pevent);
	53	+typedef int (tep_plugin_load_func)(struct tep_handle tep);
	54	+typedef int (tep_plugin_unload_func)(struct tep_handle tep);
111	55
112	56	struct tep_plugin_option {
113	57	struct tep_plugin_option *next;
..	..	@@ -127,12 +71,12 @@
127	71	* TEP_PLUGIN_LOADER: (required)
128	72	* The function name to initialized the plugin.
129	73	*
130		- * int TEP_PLUGIN_LOADER(struct tep_handle *pevent)
	74	+ * int TEP_PLUGIN_LOADER(struct tep_handle *tep)
131	75	*
132	76	* TEP_PLUGIN_UNLOADER: (optional)
133	77	* The function called just before unloading
134	78	*
135		- * int TEP_PLUGIN_UNLOADER(struct tep_handle *pevent)
	79	+ * int TEP_PLUGIN_UNLOADER(struct tep_handle *tep)
136	80	*
137	81	* TEP_PLUGIN_OPTIONS: (optional)
138	82	* Plugin options that can be set before loading
..	..	@@ -172,20 +116,20 @@
172	116	#define TEP_PLUGIN_OPTIONS_NAME MAKE_STR(TEP_PLUGIN_OPTIONS)
173	117	#define TEP_PLUGIN_ALIAS_NAME MAKE_STR(TEP_PLUGIN_ALIAS)
174	118
175		-enum format_flags {
176		- FIELD_IS_ARRAY = 1,
177		- FIELD_IS_POINTER = 2,
178		- FIELD_IS_SIGNED = 4,
179		- FIELD_IS_STRING = 8,
180		- FIELD_IS_DYNAMIC = 16,
181		- FIELD_IS_LONG = 32,
182		- FIELD_IS_FLAG = 64,
183		- FIELD_IS_SYMBOLIC = 128,
	119	+enum tep_format_flags {
	120	+ TEP_FIELD_IS_ARRAY = 1,
	121	+ TEP_FIELD_IS_POINTER = 2,
	122	+ TEP_FIELD_IS_SIGNED = 4,
	123	+ TEP_FIELD_IS_STRING = 8,
	124	+ TEP_FIELD_IS_DYNAMIC = 16,
	125	+ TEP_FIELD_IS_LONG = 32,
	126	+ TEP_FIELD_IS_FLAG = 64,
	127	+ TEP_FIELD_IS_SYMBOLIC = 128,
184	128	};
185	129
186		-struct format_field {
187		- struct format_field *next;
188		- struct event_format *event;
	130	+struct tep_format_field {
	131	+ struct tep_format_field *next;
	132	+ struct tep_event *event;
189	133	char *type;
190	134	char *name;
191	135	char *alias;
..	..	@@ -196,169 +140,172 @@
196	140	unsigned long flags;
197	141	};
198	142
199		-struct format {
	143	+struct tep_format {
200	144	int nr_common;
201	145	int nr_fields;
202		- struct format_field *common_fields;
203		- struct format_field *fields;
	146	+ struct tep_format_field *common_fields;
	147	+ struct tep_format_field *fields;
204	148	};
205	149
206		-struct print_arg_atom {
	150	+struct tep_print_arg_atom {
207	151	char *atom;
208	152	};
209	153
210		-struct print_arg_string {
	154	+struct tep_print_arg_string {
211	155	char *string;
212	156	int offset;
213	157	};
214	158
215		-struct print_arg_bitmask {
	159	+struct tep_print_arg_bitmask {
216	160	char *bitmask;
217	161	int offset;
218	162	};
219	163
220		-struct print_arg_field {
	164	+struct tep_print_arg_field {
221	165	char *name;
222		- struct format_field *field;
	166	+ struct tep_format_field *field;
223	167	};
224	168
225		-struct print_flag_sym {
226		- struct print_flag_sym *next;
227		- char *value;
228		- char *str;
	169	+struct tep_print_flag_sym {
	170	+ struct tep_print_flag_sym *next;
	171	+ char *value;
	172	+ char *str;
229	173	};
230	174
231		-struct print_arg_typecast {
	175	+struct tep_print_arg_typecast {
232	176	char *type;
233		- struct print_arg *item;
	177	+ struct tep_print_arg *item;
234	178	};
235	179
236		-struct print_arg_flags {
237		- struct print_arg *field;
238		- char *delim;
239		- struct print_flag_sym *flags;
	180	+struct tep_print_arg_flags {
	181	+ struct tep_print_arg *field;
	182	+ char *delim;
	183	+ struct tep_print_flag_sym *flags;
240	184	};
241	185
242		-struct print_arg_symbol {
243		- struct print_arg *field;
244		- struct print_flag_sym *symbols;
	186	+struct tep_print_arg_symbol {
	187	+ struct tep_print_arg *field;
	188	+ struct tep_print_flag_sym *symbols;
245	189	};
246	190
247		-struct print_arg_hex {
248		- struct print_arg *field;
249		- struct print_arg *size;
	191	+struct tep_print_arg_hex {
	192	+ struct tep_print_arg *field;
	193	+ struct tep_print_arg *size;
250	194	};
251	195
252		-struct print_arg_int_array {
253		- struct print_arg *field;
254		- struct print_arg *count;
255		- struct print_arg *el_size;
	196	+struct tep_print_arg_int_array {
	197	+ struct tep_print_arg *field;
	198	+ struct tep_print_arg *count;
	199	+ struct tep_print_arg *el_size;
256	200	};
257	201
258		-struct print_arg_dynarray {
259		- struct format_field *field;
260		- struct print_arg *index;
	202	+struct tep_print_arg_dynarray {
	203	+ struct tep_format_field *field;
	204	+ struct tep_print_arg *index;
261	205	};
262	206
263		-struct print_arg;
	207	+struct tep_print_arg;
264	208
265		-struct print_arg_op {
	209	+struct tep_print_arg_op {
266	210	char *op;
267	211	int prio;
268		- struct print_arg *left;
269		- struct print_arg *right;
	212	+ struct tep_print_arg *left;
	213	+ struct tep_print_arg *right;
270	214	};
271	215
272	216	struct tep_function_handler;
273	217
274		-struct print_arg_func {
	218	+struct tep_print_arg_func {
275	219	struct tep_function_handler *func;
276		- struct print_arg *args;
	220	+ struct tep_print_arg *args;
277	221	};
278	222
279		-enum print_arg_type {
280		- PRINT_NULL,
281		- PRINT_ATOM,
282		- PRINT_FIELD,
283		- PRINT_FLAGS,
284		- PRINT_SYMBOL,
285		- PRINT_HEX,
286		- PRINT_INT_ARRAY,
287		- PRINT_TYPE,
288		- PRINT_STRING,
289		- PRINT_BSTRING,
290		- PRINT_DYNAMIC_ARRAY,
291		- PRINT_OP,
292		- PRINT_FUNC,
293		- PRINT_BITMASK,
294		- PRINT_DYNAMIC_ARRAY_LEN,
295		- PRINT_HEX_STR,
	223	+enum tep_print_arg_type {
	224	+ TEP_PRINT_NULL,
	225	+ TEP_PRINT_ATOM,
	226	+ TEP_PRINT_FIELD,
	227	+ TEP_PRINT_FLAGS,
	228	+ TEP_PRINT_SYMBOL,
	229	+ TEP_PRINT_HEX,
	230	+ TEP_PRINT_INT_ARRAY,
	231	+ TEP_PRINT_TYPE,
	232	+ TEP_PRINT_STRING,
	233	+ TEP_PRINT_BSTRING,
	234	+ TEP_PRINT_DYNAMIC_ARRAY,
	235	+ TEP_PRINT_OP,
	236	+ TEP_PRINT_FUNC,
	237	+ TEP_PRINT_BITMASK,
	238	+ TEP_PRINT_DYNAMIC_ARRAY_LEN,
	239	+ TEP_PRINT_HEX_STR,
296	240	};
297	241
298		-struct print_arg {
299		- struct print_arg *next;
300		- enum print_arg_type type;
	242	+struct tep_print_arg {
	243	+ struct tep_print_arg *next;
	244	+ enum tep_print_arg_type type;
301	245	union {
302		- struct print_arg_atom atom;
303		- struct print_arg_field field;
304		- struct print_arg_typecast typecast;
305		- struct print_arg_flags flags;
306		- struct print_arg_symbol symbol;
307		- struct print_arg_hex hex;
308		- struct print_arg_int_array int_array;
309		- struct print_arg_func func;
310		- struct print_arg_string string;
311		- struct print_arg_bitmask bitmask;
312		- struct print_arg_op op;
313		- struct print_arg_dynarray dynarray;
	246	+ struct tep_print_arg_atom atom;
	247	+ struct tep_print_arg_field field;
	248	+ struct tep_print_arg_typecast typecast;
	249	+ struct tep_print_arg_flags flags;
	250	+ struct tep_print_arg_symbol symbol;
	251	+ struct tep_print_arg_hex hex;
	252	+ struct tep_print_arg_int_array int_array;
	253	+ struct tep_print_arg_func func;
	254	+ struct tep_print_arg_string string;
	255	+ struct tep_print_arg_bitmask bitmask;
	256	+ struct tep_print_arg_op op;
	257	+ struct tep_print_arg_dynarray dynarray;
314	258	};
315	259	};
316	260
317		-struct print_fmt {
	261	+struct tep_print_parse;
	262	+
	263	+struct tep_print_fmt {
318	264	char *format;
319		- struct print_arg *args;
	265	+ struct tep_print_arg *args;
	266	+ struct tep_print_parse *print_cache;
320	267	};
321	268
322		-struct event_format {
323		- struct tep_handle *pevent;
	269	+struct tep_event {
	270	+ struct tep_handle *tep;
324	271	char *name;
325	272	int id;
326	273	int flags;
327		- struct format format;
328		- struct print_fmt print_fmt;
	274	+ struct tep_format format;
	275	+ struct tep_print_fmt print_fmt;
329	276	char *system;
330	277	tep_event_handler_func handler;
331	278	void *context;
332	279	};
333	280
334	281	enum {
335		- EVENT_FL_ISFTRACE = 0x01,
336		- EVENT_FL_ISPRINT = 0x02,
337		- EVENT_FL_ISBPRINT = 0x04,
338		- EVENT_FL_ISFUNCENT = 0x10,
339		- EVENT_FL_ISFUNCRET = 0x20,
340		- EVENT_FL_NOHANDLE = 0x40,
341		- EVENT_FL_PRINTRAW = 0x80,
	282	+ TEP_EVENT_FL_ISFTRACE = 0x01,
	283	+ TEP_EVENT_FL_ISPRINT = 0x02,
	284	+ TEP_EVENT_FL_ISBPRINT = 0x04,
	285	+ TEP_EVENT_FL_ISFUNCENT = 0x10,
	286	+ TEP_EVENT_FL_ISFUNCRET = 0x20,
	287	+ TEP_EVENT_FL_NOHANDLE = 0x40,
	288	+ TEP_EVENT_FL_PRINTRAW = 0x80,
342	289
343		- EVENT_FL_FAILED = 0x80000000
	290	+ TEP_EVENT_FL_FAILED = 0x80000000
344	291	};
345	292
346		-enum event_sort_type {
347		- EVENT_SORT_ID,
348		- EVENT_SORT_NAME,
349		- EVENT_SORT_SYSTEM,
	293	+enum tep_event_sort_type {
	294	+ TEP_EVENT_SORT_ID,
	295	+ TEP_EVENT_SORT_NAME,
	296	+ TEP_EVENT_SORT_SYSTEM,
350	297	};
351	298
352		-enum event_type {
353		- EVENT_ERROR,
354		- EVENT_NONE,
355		- EVENT_SPACE,
356		- EVENT_NEWLINE,
357		- EVENT_OP,
358		- EVENT_DELIM,
359		- EVENT_ITEM,
360		- EVENT_DQUOTE,
361		- EVENT_SQUOTE,
	299	+enum tep_event_type {
	300	+ TEP_EVENT_ERROR,
	301	+ TEP_EVENT_NONE,
	302	+ TEP_EVENT_SPACE,
	303	+ TEP_EVENT_NEWLINE,
	304	+ TEP_EVENT_OP,
	305	+ TEP_EVENT_DELIM,
	306	+ TEP_EVENT_ITEM,
	307	+ TEP_EVENT_DQUOTE,
	308	+ TEP_EVENT_SQUOTE,
362	309	};
363	310
364	311	typedef unsigned long long (tep_func_handler)(struct trace_seq s,
..	..	@@ -421,7 +368,7 @@
421	368	* errno since SUS requires the errno has distinct positive values.
422	369	* See 'Issue 6' in the link below.
423	370	*
424		- * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
	371	+ * https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
425	372	*/
426	373	__TEP_ERRNO__START = -100000,
427	374
..	..	@@ -431,173 +378,45 @@
431	378	};
432	379	#undef _PE
433	380
434		-struct plugin_list;
	381	+struct tep_plugin_list;
435	382
436	383	#define INVALID_PLUGIN_LIST_OPTION ((char **)((unsigned long)-1))
437	384
438		-struct plugin_list tep_load_plugins(struct tep_handle pevent);
439		-void tep_unload_plugins(struct plugin_list *plugin_list,
440		- struct tep_handle *pevent);
	385	+enum tep_plugin_load_priority {
	386	+ TEP_PLUGIN_FIRST,
	387	+ TEP_PLUGIN_LAST,
	388	+};
	389	+
	390	+int tep_add_plugin_path(struct tep_handle tep, char path,
	391	+ enum tep_plugin_load_priority prio);
	392	+struct tep_plugin_list tep_load_plugins(struct tep_handle tep);
	393	+void tep_unload_plugins(struct tep_plugin_list *plugin_list,
	394	+ struct tep_handle *tep);
	395	+void tep_load_plugins_hook(struct tep_handle tep, const char suffix,
	396	+ void (load_plugin)(struct tep_handle tep,
	397	+ const char *path,
	398	+ const char *name,
	399	+ void *data),
	400	+ void *data);
441	401	char **tep_plugin_list_options(void);
442	402	void tep_plugin_free_options_list(char **list);
443	403	int tep_plugin_add_options(const char *name,
444	404	struct tep_plugin_option *options);
	405	+int tep_plugin_add_option(const char name, const char val);
445	406	void tep_plugin_remove_options(struct tep_plugin_option *options);
	407	+void tep_plugin_print_options(struct trace_seq *s);
446	408	void tep_print_plugins(struct trace_seq *s,
447	409	const char prefix, const char suffix,
448		- const struct plugin_list *list);
	410	+ const struct tep_plugin_list *list);
449	411
450		-struct cmdline;
451		-struct cmdline_list;
452		-struct func_map;
453		-struct func_list;
454		-struct event_handler;
455		-struct func_resolver;
456		-
	412	+/* tep_handle */
457	413	typedef char (tep_func_resolver_t)(void priv,
458	414	unsigned long long addrp, char *modp);
	415	+void tep_set_flag(struct tep_handle *tep, int flag);
	416	+void tep_clear_flag(struct tep_handle *tep, enum tep_flag flag);
	417	+bool tep_test_flag(struct tep_handle *tep, enum tep_flag flags);
459	418
460		-struct tep_handle {
461		- int ref_count;
462		-
463		- int header_page_ts_offset;
464		- int header_page_ts_size;
465		- int header_page_size_offset;
466		- int header_page_size_size;
467		- int header_page_data_offset;
468		- int header_page_data_size;
469		- int header_page_overwrite;
470		-
471		- int file_bigendian;
472		- int host_bigendian;
473		-
474		- int latency_format;
475		-
476		- int old_format;
477		-
478		- int cpus;
479		- int long_size;
480		- int page_size;
481		-
482		- struct cmdline *cmdlines;
483		- struct cmdline_list *cmdlist;
484		- int cmdline_count;
485		-
486		- struct func_map *func_map;
487		- struct func_resolver *func_resolver;
488		- struct func_list *funclist;
489		- unsigned int func_count;
490		-
491		- struct printk_map *printk_map;
492		- struct printk_list *printklist;
493		- unsigned int printk_count;
494		-
495		-
496		- struct event_format **events;
497		- int nr_events;
498		- struct event_format **sort_events;
499		- enum event_sort_type last_type;
500		-
501		- int type_offset;
502		- int type_size;
503		-
504		- int pid_offset;
505		- int pid_size;
506		-
507		- int pc_offset;
508		- int pc_size;
509		-
510		- int flags_offset;
511		- int flags_size;
512		-
513		- int ld_offset;
514		- int ld_size;
515		-
516		- int print_raw;
517		-
518		- int test_filters;
519		-
520		- int flags;
521		-
522		- struct format_field *bprint_ip_field;
523		- struct format_field *bprint_fmt_field;
524		- struct format_field *bprint_buf_field;
525		-
526		- struct event_handler *handlers;
527		- struct tep_function_handler *func_handlers;
528		-
529		- /* cache */
530		- struct event_format *last_event;
531		-
532		- char *trace_clock;
533		-};
534		-
535		-static inline void tep_set_flag(struct tep_handle *pevent, int flag)
536		-{
537		- pevent->flags \|= flag;
538		-}
539		-
540		-static inline unsigned short
541		-__data2host2(struct tep_handle *pevent, unsigned short data)
542		-{
543		- unsigned short swap;
544		-
545		- if (pevent->host_bigendian == pevent->file_bigendian)
546		- return data;
547		-
548		- swap = ((data & 0xffULL) << 8) \|
549		- ((data & (0xffULL << 8)) >> 8);
550		-
551		- return swap;
552		-}
553		-
554		-static inline unsigned int
555		-__data2host4(struct tep_handle *pevent, unsigned int data)
556		-{
557		- unsigned int swap;
558		-
559		- if (pevent->host_bigendian == pevent->file_bigendian)
560		- return data;
561		-
562		- swap = ((data & 0xffULL) << 24) \|
563		- ((data & (0xffULL << 8)) << 8) \|
564		- ((data & (0xffULL << 16)) >> 8) \|
565		- ((data & (0xffULL << 24)) >> 24);
566		-
567		- return swap;
568		-}
569		-
570		-static inline unsigned long long
571		-__data2host8(struct tep_handle *pevent, unsigned long long data)
572		-{
573		- unsigned long long swap;
574		-
575		- if (pevent->host_bigendian == pevent->file_bigendian)
576		- return data;
577		-
578		- swap = ((data & 0xffULL) << 56) \|
579		- ((data & (0xffULL << 8)) << 40) \|
580		- ((data & (0xffULL << 16)) << 24) \|
581		- ((data & (0xffULL << 24)) << 8) \|
582		- ((data & (0xffULL << 32)) >> 8) \|
583		- ((data & (0xffULL << 40)) >> 24) \|
584		- ((data & (0xffULL << 48)) >> 40) \|
585		- ((data & (0xffULL << 56)) >> 56);
586		-
587		- return swap;
588		-}
589		-
590		-#define data2host2(pevent, ptr) __data2host2(pevent, (unsigned short )(ptr))
591		-#define data2host4(pevent, ptr) __data2host4(pevent, (unsigned int )(ptr))
592		-#define data2host8(pevent, ptr) \
593		-({ \
594		- unsigned long long __val; \
595		- \
596		- memcpy(&__val, (ptr), sizeof(unsigned long long)); \
597		- __data2host8(pevent, __val); \
598		-})
599		-
600		-static inline int tep_host_bigendian(void)
	419	+static inline int tep_is_bigendian(void)
601	420	{
602	421	unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 };
603	422	unsigned int val;
..	..	@@ -615,331 +434,286 @@
615	434	TRACE_FLAG_SOFTIRQ = 0x10,
616	435	};
617	436
618		-int tep_set_function_resolver(struct tep_handle *pevent,
	437	+int tep_set_function_resolver(struct tep_handle *tep,
619	438	tep_func_resolver_t func, void priv);
620		-void tep_reset_function_resolver(struct tep_handle *pevent);
621		-int tep_register_comm(struct tep_handle pevent, const char comm, int pid);
622		-int tep_register_trace_clock(struct tep_handle pevent, const char trace_clock);
623		-int tep_register_function(struct tep_handle pevent, char name,
	439	+void tep_reset_function_resolver(struct tep_handle *tep);
	440	+int tep_register_comm(struct tep_handle tep, const char comm, int pid);
	441	+int tep_override_comm(struct tep_handle tep, const char comm, int pid);
	442	+int tep_register_function(struct tep_handle tep, char name,
624	443	unsigned long long addr, char *mod);
625		-int tep_register_print_string(struct tep_handle pevent, const char fmt,
	444	+int tep_register_print_string(struct tep_handle tep, const char fmt,
626	445	unsigned long long addr);
627		-int tep_pid_is_registered(struct tep_handle *pevent, int pid);
	446	+bool tep_is_pid_registered(struct tep_handle *tep, int pid);
628	447
629		-void tep_print_event_task(struct tep_handle pevent, struct trace_seq s,
630		- struct event_format *event,
631		- struct tep_record *record);
632		-void tep_print_event_time(struct tep_handle pevent, struct trace_seq s,
633		- struct event_format *event,
634		- struct tep_record *record,
635		- bool use_trace_clock);
636		-void tep_print_event_data(struct tep_handle pevent, struct trace_seq s,
637		- struct event_format *event,
638		- struct tep_record *record);
639		-void tep_print_event(struct tep_handle pevent, struct trace_seq s,
640		- struct tep_record *record, bool use_trace_clock);
	448	+struct tep_event tep_get_event(struct tep_handle tep, int index);
641	449
642		-int tep_parse_header_page(struct tep_handle pevent, char buf, unsigned long size,
	450	+#define TEP_PRINT_INFO "INFO"
	451	+#define TEP_PRINT_INFO_RAW "INFO_RAW"
	452	+#define TEP_PRINT_COMM "COMM"
	453	+#define TEP_PRINT_LATENCY "LATENCY"
	454	+#define TEP_PRINT_NAME "NAME"
	455	+#define TEP_PRINT_PID 1U
	456	+#define TEP_PRINT_TIME 2U
	457	+#define TEP_PRINT_CPU 3U
	458	+
	459	+void tep_print_event(struct tep_handle tep, struct trace_seq s,
	460	+ struct tep_record record, const char fmt, ...)
	461	+ __attribute__ ((format (printf, 4, 5)));
	462	+
	463	+int tep_parse_header_page(struct tep_handle tep, char buf, unsigned long size,
643	464	int long_size);
644	465
645		-enum tep_errno tep_parse_event(struct tep_handle pevent, const char buf,
	466	+enum tep_errno tep_parse_event(struct tep_handle tep, const char buf,
646	467	unsigned long size, const char *sys);
647		-enum tep_errno tep_parse_format(struct tep_handle *pevent,
648		- struct event_format **eventp,
	468	+enum tep_errno tep_parse_format(struct tep_handle *tep,
	469	+ struct tep_event **eventp,
649	470	const char *buf,
650	471	unsigned long size, const char *sys);
651		-void tep_free_format(struct event_format *event);
652		-void tep_free_format_field(struct format_field *field);
653	472
654		-void tep_get_field_raw(struct trace_seq s, struct event_format *event,
	473	+void tep_get_field_raw(struct trace_seq s, struct tep_event *event,
655	474	const char name, struct tep_record record,
656	475	int *len, int err);
657	476
658		-int tep_get_field_val(struct trace_seq s, struct event_format event,
	477	+int tep_get_field_val(struct trace_seq s, struct tep_event event,
659	478	const char name, struct tep_record record,
660	479	unsigned long long *val, int err);
661		-int tep_get_common_field_val(struct trace_seq s, struct event_format event,
	480	+int tep_get_common_field_val(struct trace_seq s, struct tep_event event,
662	481	const char name, struct tep_record record,
663	482	unsigned long long *val, int err);
664		-int tep_get_any_field_val(struct trace_seq s, struct event_format event,
	483	+int tep_get_any_field_val(struct trace_seq s, struct tep_event event,
665	484	const char name, struct tep_record record,
666	485	unsigned long long *val, int err);
667	486
668	487	int tep_print_num_field(struct trace_seq s, const char fmt,
669		- struct event_format event, const char name,
670		- struct tep_record *record, int err);
	488	+ struct tep_event event, const char name,
	489	+ struct tep_record *record, int err);
671	490
672	491	int tep_print_func_field(struct trace_seq s, const char fmt,
673		- struct event_format event, const char name,
	492	+ struct tep_event event, const char name,
674	493	struct tep_record *record, int err);
675	494
676		-int tep_register_event_handler(struct tep_handle *pevent, int id,
	495	+enum tep_reg_handler {
	496	+ TEP_REGISTER_SUCCESS = 0,
	497	+ TEP_REGISTER_SUCCESS_OVERWRITE,
	498	+};
	499	+
	500	+int tep_register_event_handler(struct tep_handle *tep, int id,
677	501	const char sys_name, const char event_name,
678	502	tep_event_handler_func func, void *context);
679		-int tep_unregister_event_handler(struct tep_handle *pevent, int id,
	503	+int tep_unregister_event_handler(struct tep_handle *tep, int id,
680	504	const char sys_name, const char event_name,
681	505	tep_event_handler_func func, void *context);
682		-int tep_register_print_function(struct tep_handle *pevent,
	506	+int tep_register_print_function(struct tep_handle *tep,
683	507	tep_func_handler func,
684	508	enum tep_func_arg_type ret_type,
685	509	char *name, ...);
686		-int tep_unregister_print_function(struct tep_handle *pevent,
	510	+int tep_unregister_print_function(struct tep_handle *tep,
687	511	tep_func_handler func, char *name);
688	512
689		-struct format_field tep_find_common_field(struct event_format event, const char *name);
690		-struct format_field tep_find_field(struct event_format event, const char *name);
691		-struct format_field tep_find_any_field(struct event_format event, const char *name);
	513	+struct tep_format_field tep_find_common_field(struct tep_event event, const char *name);
	514	+struct tep_format_field tep_find_field(struct tep_event event, const char *name);
	515	+struct tep_format_field tep_find_any_field(struct tep_event event, const char *name);
692	516
693		-const char tep_find_function(struct tep_handle pevent, unsigned long long addr);
	517	+const char tep_find_function(struct tep_handle tep, unsigned long long addr);
694	518	unsigned long long
695		-tep_find_function_address(struct tep_handle *pevent, unsigned long long addr);
696		-unsigned long long tep_read_number(struct tep_handle pevent, const void ptr, int size);
697		-int tep_read_number_field(struct format_field field, const void data,
	519	+tep_find_function_address(struct tep_handle *tep, unsigned long long addr);
	520	+unsigned long long tep_read_number(struct tep_handle tep, const void ptr, int size);
	521	+int tep_read_number_field(struct tep_format_field field, const void data,
698	522	unsigned long long *value);
699	523
700		-struct event_format tep_find_event(struct tep_handle pevent, int id);
	524	+struct tep_event tep_get_first_event(struct tep_handle tep);
	525	+int tep_get_events_count(struct tep_handle *tep);
	526	+struct tep_event tep_find_event(struct tep_handle tep, int id);
701	527
702		-struct event_format *
703		-tep_find_event_by_name(struct tep_handle pevent, const char sys, const char *name);
	528	+struct tep_event *
	529	+tep_find_event_by_name(struct tep_handle tep, const char sys, const char *name);
	530	+struct tep_event *
	531	+tep_find_event_by_record(struct tep_handle tep, struct tep_record record);
704	532
705		-struct event_format *
706		-tep_find_event_by_record(struct tep_handle pevent, struct tep_record record);
707		-
708		-void tep_data_lat_fmt(struct tep_handle *pevent,
709		- struct trace_seq s, struct tep_record record);
710		-int tep_data_type(struct tep_handle pevent, struct tep_record rec);
711		-struct event_format tep_data_event_from_type(struct tep_handle pevent, int type);
712		-int tep_data_pid(struct tep_handle pevent, struct tep_record rec);
713		-int tep_data_preempt_count(struct tep_handle pevent, struct tep_record rec);
714		-int tep_data_flags(struct tep_handle pevent, struct tep_record rec);
715		-const char tep_data_comm_from_pid(struct tep_handle pevent, int pid);
716		-struct cmdline;
717		-struct cmdline tep_data_pid_from_comm(struct tep_handle pevent, const char *comm,
718		- struct cmdline *next);
719		-int tep_cmdline_pid(struct tep_handle pevent, struct cmdline cmdline);
	533	+int tep_data_type(struct tep_handle tep, struct tep_record rec);
	534	+int tep_data_pid(struct tep_handle tep, struct tep_record rec);
	535	+int tep_data_preempt_count(struct tep_handle tep, struct tep_record rec);
	536	+int tep_data_flags(struct tep_handle tep, struct tep_record rec);
	537	+const char tep_data_comm_from_pid(struct tep_handle tep, int pid);
	538	+struct tep_cmdline;
	539	+struct tep_cmdline tep_data_pid_from_comm(struct tep_handle tep, const char *comm,
	540	+ struct tep_cmdline *next);
	541	+int tep_cmdline_pid(struct tep_handle tep, struct tep_cmdline cmdline);
720	542
721	543	void tep_print_field(struct trace_seq s, void data,
722		- struct format_field *field);
	544	+ struct tep_format_field *field);
723	545	void tep_print_fields(struct trace_seq s, void data,
724		- int size __maybe_unused, struct event_format *event);
725		-void tep_event_info(struct trace_seq s, struct event_format event,
726		- struct tep_record *record);
727		-int tep_strerror(struct tep_handle *pevent, enum tep_errno errnum,
728		- char *buf, size_t buflen);
	546	+ int size __maybe_unused, struct tep_event *event);
	547	+int tep_strerror(struct tep_handle *tep, enum tep_errno errnum,
	548	+ char *buf, size_t buflen);
729	549
730		-struct event_format *tep_list_events(struct tep_handle pevent, enum event_sort_type);
731		-struct format_field *tep_event_common_fields(struct event_format event);
732		-struct format_field *tep_event_fields(struct event_format event);
	550	+struct tep_event *tep_list_events(struct tep_handle tep, enum tep_event_sort_type);
	551	+struct tep_event *tep_list_events_copy(struct tep_handle tep,
	552	+ enum tep_event_sort_type);
	553	+struct tep_format_field *tep_event_common_fields(struct tep_event event);
	554	+struct tep_format_field *tep_event_fields(struct tep_event event);
733	555
734		-static inline int tep_get_cpus(struct tep_handle *pevent)
735		-{
736		- return pevent->cpus;
737		-}
738		-
739		-static inline void tep_set_cpus(struct tep_handle *pevent, int cpus)
740		-{
741		- pevent->cpus = cpus;
742		-}
743		-
744		-static inline int tep_get_long_size(struct tep_handle *pevent)
745		-{
746		- return pevent->long_size;
747		-}
748		-
749		-static inline void tep_set_long_size(struct tep_handle *pevent, int long_size)
750		-{
751		- pevent->long_size = long_size;
752		-}
753		-
754		-static inline int tep_get_page_size(struct tep_handle *pevent)
755		-{
756		- return pevent->page_size;
757		-}
758		-
759		-static inline void tep_set_page_size(struct tep_handle *pevent, int _page_size)
760		-{
761		- pevent->page_size = _page_size;
762		-}
763		-
764		-static inline int tep_is_file_bigendian(struct tep_handle *pevent)
765		-{
766		- return pevent->file_bigendian;
767		-}
768		-
769		-static inline void tep_set_file_bigendian(struct tep_handle *pevent, int endian)
770		-{
771		- pevent->file_bigendian = endian;
772		-}
773		-
774		-static inline int tep_is_host_bigendian(struct tep_handle *pevent)
775		-{
776		- return pevent->host_bigendian;
777		-}
778		-
779		-static inline void tep_set_host_bigendian(struct tep_handle *pevent, int endian)
780		-{
781		- pevent->host_bigendian = endian;
782		-}
783		-
784		-static inline int tep_is_latency_format(struct tep_handle *pevent)
785		-{
786		- return pevent->latency_format;
787		-}
788		-
789		-static inline void tep_set_latency_format(struct tep_handle *pevent, int lat)
790		-{
791		- pevent->latency_format = lat;
792		-}
	556	+enum tep_endian {
	557	+ TEP_LITTLE_ENDIAN = 0,
	558	+ TEP_BIG_ENDIAN
	559	+};
	560	+int tep_get_cpus(struct tep_handle *tep);
	561	+void tep_set_cpus(struct tep_handle *tep, int cpus);
	562	+int tep_get_long_size(struct tep_handle *tep);
	563	+void tep_set_long_size(struct tep_handle *tep, int long_size);
	564	+int tep_get_page_size(struct tep_handle *tep);
	565	+void tep_set_page_size(struct tep_handle *tep, int _page_size);
	566	+bool tep_is_file_bigendian(struct tep_handle *tep);
	567	+void tep_set_file_bigendian(struct tep_handle *tep, enum tep_endian endian);
	568	+bool tep_is_local_bigendian(struct tep_handle *tep);
	569	+void tep_set_local_bigendian(struct tep_handle *tep, enum tep_endian endian);
	570	+int tep_get_header_page_size(struct tep_handle *tep);
	571	+int tep_get_header_timestamp_size(struct tep_handle *tep);
	572	+bool tep_is_old_format(struct tep_handle *tep);
	573	+void tep_set_test_filters(struct tep_handle *tep, int test_filters);
793	574
794	575	struct tep_handle *tep_alloc(void);
795		-void tep_free(struct tep_handle *pevent);
796		-void tep_ref(struct tep_handle *pevent);
797		-void tep_unref(struct tep_handle *pevent);
798		-
799		-/* access to the internal parser */
800		-void tep_buffer_init(const char *buf, unsigned long long size);
801		-enum event_type tep_read_token(char **tok);
802		-void tep_free_token(char *token);
803		-int tep_peek_char(void);
804		-const char *tep_get_input_buf(void);
805		-unsigned long long tep_get_input_buf_ptr(void);
	576	+void tep_free(struct tep_handle *tep);
	577	+void tep_ref(struct tep_handle *tep);
	578	+void tep_unref(struct tep_handle *tep);
	579	+int tep_get_ref(struct tep_handle *tep);
806	580
807	581	/* for debugging */
808		-void tep_print_funcs(struct tep_handle *pevent);
809		-void tep_print_printk(struct tep_handle *pevent);
	582	+void tep_print_funcs(struct tep_handle *tep);
	583	+void tep_print_printk(struct tep_handle *tep);
810	584
811	585	/* ----------------------- filtering ----------------------- */
812	586
813		-enum filter_boolean_type {
814		- FILTER_FALSE,
815		- FILTER_TRUE,
	587	+enum tep_filter_boolean_type {
	588	+ TEP_FILTER_FALSE,
	589	+ TEP_FILTER_TRUE,
816	590	};
817	591
818		-enum filter_op_type {
819		- FILTER_OP_AND = 1,
820		- FILTER_OP_OR,
821		- FILTER_OP_NOT,
	592	+enum tep_filter_op_type {
	593	+ TEP_FILTER_OP_AND = 1,
	594	+ TEP_FILTER_OP_OR,
	595	+ TEP_FILTER_OP_NOT,
822	596	};
823	597
824		-enum filter_cmp_type {
825		- FILTER_CMP_NONE,
826		- FILTER_CMP_EQ,
827		- FILTER_CMP_NE,
828		- FILTER_CMP_GT,
829		- FILTER_CMP_LT,
830		- FILTER_CMP_GE,
831		- FILTER_CMP_LE,
832		- FILTER_CMP_MATCH,
833		- FILTER_CMP_NOT_MATCH,
834		- FILTER_CMP_REGEX,
835		- FILTER_CMP_NOT_REGEX,
	598	+enum tep_filter_cmp_type {
	599	+ TEP_FILTER_CMP_NONE,
	600	+ TEP_FILTER_CMP_EQ,
	601	+ TEP_FILTER_CMP_NE,
	602	+ TEP_FILTER_CMP_GT,
	603	+ TEP_FILTER_CMP_LT,
	604	+ TEP_FILTER_CMP_GE,
	605	+ TEP_FILTER_CMP_LE,
	606	+ TEP_FILTER_CMP_MATCH,
	607	+ TEP_FILTER_CMP_NOT_MATCH,
	608	+ TEP_FILTER_CMP_REGEX,
	609	+ TEP_FILTER_CMP_NOT_REGEX,
836	610	};
837	611
838		-enum filter_exp_type {
839		- FILTER_EXP_NONE,
840		- FILTER_EXP_ADD,
841		- FILTER_EXP_SUB,
842		- FILTER_EXP_MUL,
843		- FILTER_EXP_DIV,
844		- FILTER_EXP_MOD,
845		- FILTER_EXP_RSHIFT,
846		- FILTER_EXP_LSHIFT,
847		- FILTER_EXP_AND,
848		- FILTER_EXP_OR,
849		- FILTER_EXP_XOR,
850		- FILTER_EXP_NOT,
	612	+enum tep_filter_exp_type {
	613	+ TEP_FILTER_EXP_NONE,
	614	+ TEP_FILTER_EXP_ADD,
	615	+ TEP_FILTER_EXP_SUB,
	616	+ TEP_FILTER_EXP_MUL,
	617	+ TEP_FILTER_EXP_DIV,
	618	+ TEP_FILTER_EXP_MOD,
	619	+ TEP_FILTER_EXP_RSHIFT,
	620	+ TEP_FILTER_EXP_LSHIFT,
	621	+ TEP_FILTER_EXP_AND,
	622	+ TEP_FILTER_EXP_OR,
	623	+ TEP_FILTER_EXP_XOR,
	624	+ TEP_FILTER_EXP_NOT,
851	625	};
852	626
853		-enum filter_arg_type {
854		- FILTER_ARG_NONE,
855		- FILTER_ARG_BOOLEAN,
856		- FILTER_ARG_VALUE,
857		- FILTER_ARG_FIELD,
858		- FILTER_ARG_EXP,
859		- FILTER_ARG_OP,
860		- FILTER_ARG_NUM,
861		- FILTER_ARG_STR,
	627	+enum tep_filter_arg_type {
	628	+ TEP_FILTER_ARG_NONE,
	629	+ TEP_FILTER_ARG_BOOLEAN,
	630	+ TEP_FILTER_ARG_VALUE,
	631	+ TEP_FILTER_ARG_FIELD,
	632	+ TEP_FILTER_ARG_EXP,
	633	+ TEP_FILTER_ARG_OP,
	634	+ TEP_FILTER_ARG_NUM,
	635	+ TEP_FILTER_ARG_STR,
862	636	};
863	637
864		-enum filter_value_type {
865		- FILTER_NUMBER,
866		- FILTER_STRING,
867		- FILTER_CHAR
	638	+enum tep_filter_value_type {
	639	+ TEP_FILTER_NUMBER,
	640	+ TEP_FILTER_STRING,
	641	+ TEP_FILTER_CHAR
868	642	};
869	643
870		-struct fliter_arg;
	644	+struct tep_filter_arg;
871	645
872		-struct filter_arg_boolean {
873		- enum filter_boolean_type value;
	646	+struct tep_filter_arg_boolean {
	647	+ enum tep_filter_boolean_type value;
874	648	};
875	649
876		-struct filter_arg_field {
877		- struct format_field *field;
	650	+struct tep_filter_arg_field {
	651	+ struct tep_format_field *field;
878	652	};
879	653
880		-struct filter_arg_value {
881		- enum filter_value_type type;
	654	+struct tep_filter_arg_value {
	655	+ enum tep_filter_value_type type;
882	656	union {
883	657	char *str;
884	658	unsigned long long val;
885	659	};
886	660	};
887	661
888		-struct filter_arg_op {
889		- enum filter_op_type type;
890		- struct filter_arg *left;
891		- struct filter_arg *right;
	662	+struct tep_filter_arg_op {
	663	+ enum tep_filter_op_type type;
	664	+ struct tep_filter_arg *left;
	665	+ struct tep_filter_arg *right;
892	666	};
893	667
894		-struct filter_arg_exp {
895		- enum filter_exp_type type;
896		- struct filter_arg *left;
897		- struct filter_arg *right;
	668	+struct tep_filter_arg_exp {
	669	+ enum tep_filter_exp_type type;
	670	+ struct tep_filter_arg *left;
	671	+ struct tep_filter_arg *right;
898	672	};
899	673
900		-struct filter_arg_num {
901		- enum filter_cmp_type type;
902		- struct filter_arg *left;
903		- struct filter_arg *right;
	674	+struct tep_filter_arg_num {
	675	+ enum tep_filter_cmp_type type;
	676	+ struct tep_filter_arg *left;
	677	+ struct tep_filter_arg *right;
904	678	};
905	679
906		-struct filter_arg_str {
907		- enum filter_cmp_type type;
908		- struct format_field *field;
909		- char *val;
910		- char *buffer;
911		- regex_t reg;
	680	+struct tep_filter_arg_str {
	681	+ enum tep_filter_cmp_type type;
	682	+ struct tep_format_field *field;
	683	+ char *val;
	684	+ char *buffer;
	685	+ regex_t reg;
912	686	};
913	687
914		-struct filter_arg {
915		- enum filter_arg_type type;
	688	+struct tep_filter_arg {
	689	+ enum tep_filter_arg_type type;
916	690	union {
917		- struct filter_arg_boolean boolean;
918		- struct filter_arg_field field;
919		- struct filter_arg_value value;
920		- struct filter_arg_op op;
921		- struct filter_arg_exp exp;
922		- struct filter_arg_num num;
923		- struct filter_arg_str str;
	691	+ struct tep_filter_arg_boolean boolean;
	692	+ struct tep_filter_arg_field field;
	693	+ struct tep_filter_arg_value value;
	694	+ struct tep_filter_arg_op op;
	695	+ struct tep_filter_arg_exp exp;
	696	+ struct tep_filter_arg_num num;
	697	+ struct tep_filter_arg_str str;
924	698	};
925	699	};
926	700
927		-struct filter_type {
	701	+struct tep_filter_type {
928	702	int event_id;
929		- struct event_format *event;
930		- struct filter_arg *filter;
	703	+ struct tep_event *event;
	704	+ struct tep_filter_arg *filter;
931	705	};
932	706
933	707	#define TEP_FILTER_ERROR_BUFSZ 1024
934	708
935		-struct event_filter {
936		- struct tep_handle *pevent;
	709	+struct tep_event_filter {
	710	+ struct tep_handle *tep;
937	711	int filters;
938		- struct filter_type *event_filters;
	712	+ struct tep_filter_type *event_filters;
939	713	char error_buffer[TEP_FILTER_ERROR_BUFSZ];
940	714	};
941	715
942		-struct event_filter tep_filter_alloc(struct tep_handle pevent);
	716	+struct tep_event_filter tep_filter_alloc(struct tep_handle tep);
943	717
944	718	/* for backward compatibility */
945	719	#define FILTER_NONE TEP_ERRNO__NO_FILTER
..	..	@@ -947,45 +721,29 @@
947	721	#define FILTER_MISS TEP_ERRNO__FILTER_MISS
948	722	#define FILTER_MATCH TEP_ERRNO__FILTER_MATCH
949	723
950		-enum filter_trivial_type {
951		- FILTER_TRIVIAL_FALSE,
952		- FILTER_TRIVIAL_TRUE,
953		- FILTER_TRIVIAL_BOTH,
954		-};
955		-
956		-enum tep_errno tep_filter_add_filter_str(struct event_filter *filter,
	724	+enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter,
957	725	const char *filter_str);
958	726
959		-enum tep_errno tep_filter_match(struct event_filter *filter,
	727	+enum tep_errno tep_filter_match(struct tep_event_filter *filter,
960	728	struct tep_record *record);
961	729
962		-int tep_filter_strerror(struct event_filter *filter, enum tep_errno err,
	730	+int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err,
963	731	char *buf, size_t buflen);
964	732
965		-int tep_event_filtered(struct event_filter *filter,
	733	+int tep_event_filtered(struct tep_event_filter *filter,
966	734	int event_id);
967	735
968		-void tep_filter_reset(struct event_filter *filter);
	736	+void tep_filter_reset(struct tep_event_filter *filter);
969	737
970		-int tep_filter_clear_trivial(struct event_filter *filter,
971		- enum filter_trivial_type type);
	738	+void tep_filter_free(struct tep_event_filter *filter);
972	739
973		-void tep_filter_free(struct event_filter *filter);
	740	+char tep_filter_make_string(struct tep_event_filter filter, int event_id);
974	741
975		-char tep_filter_make_string(struct event_filter filter, int event_id);
976		-
977		-int tep_filter_remove_event(struct event_filter *filter,
	742	+int tep_filter_remove_event(struct tep_event_filter *filter,
978	743	int event_id);
979	744
980		-int tep_filter_event_has_trivial(struct event_filter *filter,
981		- int event_id,
982		- enum filter_trivial_type type);
	745	+int tep_filter_copy(struct tep_event_filter dest, struct tep_event_filter source);
983	746
984		-int tep_filter_copy(struct event_filter dest, struct event_filter source);
985		-
986		-int tep_update_trivial(struct event_filter dest, struct event_filter source,
987		- enum filter_trivial_type type);
988		-
989		-int tep_filter_compare(struct event_filter filter1, struct event_filter filter2);
	747	+int tep_filter_compare(struct tep_event_filter filter1, struct tep_event_filter filter2);
990	748
991	749	#endif /* _PARSE_EVENTS_H */