1/* SPDX-License-Identifier: LGPL-2.1 */ 2/* 3 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> 4 * 5 */ 6#ifndef _PARSE_EVENTS_H 7#define _PARSE_EVENTS_H 8 9#include <stdbool.h> 10#include <stdarg.h> 11#include <stdio.h> 12#include <regex.h> 13#include <string.h> 14 15#include "trace-seq.h" 16 17#ifndef __maybe_unused 18#define __maybe_unused __attribute__((unused)) 19#endif 20 21#ifndef DEBUG_RECORD 22#define DEBUG_RECORD 0 23#endif 24 25struct tep_record { 26 unsigned long long ts; 27 unsigned long long offset; 28 long long missed_events; /* buffer dropped events before */ 29 int record_size; /* size of binary record */ 30 int size; /* size of data */ 31 void *data; 32 int cpu; 33 int ref_count; 34 int locked; /* Do not free, even if ref_count is zero */ 35 void *priv; 36#if DEBUG_RECORD 37 struct tep_record *prev; 38 struct tep_record *next; 39 long alloc_addr; 40#endif 41}; 42 43/* ----------------------- tep ----------------------- */ 44 45struct tep_handle; 46struct tep_event; 47 48typedef int (*tep_event_handler_func)(struct trace_seq *s, 49 struct tep_record *record, 50 struct tep_event *event, 51 void *context); 52 53typedef int (*tep_plugin_load_func)(struct tep_handle *tep); 54typedef int (*tep_plugin_unload_func)(struct tep_handle *tep); 55 56struct tep_plugin_option { 57 struct tep_plugin_option *next; 58 void *handle; 59 char *file; 60 char *name; 61 char *plugin_alias; 62 char *description; 63 const char *value; 64 void *priv; 65 int set; 66}; 67 68/* 69 * Plugin hooks that can be called: 70 * 71 * TEP_PLUGIN_LOADER: (required) 72 * The function name to initialized the plugin. 73 * 74 * int TEP_PLUGIN_LOADER(struct tep_handle *tep) 75 * 76 * TEP_PLUGIN_UNLOADER: (optional) 77 * The function called just before unloading 78 * 79 * int TEP_PLUGIN_UNLOADER(struct tep_handle *tep) 80 * 81 * TEP_PLUGIN_OPTIONS: (optional) 82 * Plugin options that can be set before loading 83 * 84 * struct tep_plugin_option TEP_PLUGIN_OPTIONS[] = { 85 * { 86 * .name = "option-name", 87 * .plugin_alias = "override-file-name", (optional) 88 * .description = "description of option to show users", 89 * }, 90 * { 91 * .name = NULL, 92 * }, 93 * }; 94 * 95 * Array must end with .name = NULL; 96 * 97 * 98 * .plugin_alias is used to give a shorter name to access 99 * the vairable. Useful if a plugin handles more than one event. 100 * 101 * If .value is not set, then it is considered a boolean and only 102 * .set will be processed. If .value is defined, then it is considered 103 * a string option and .set will be ignored. 104 * 105 * TEP_PLUGIN_ALIAS: (optional) 106 * The name to use for finding options (uses filename if not defined) 107 */ 108#define TEP_PLUGIN_LOADER tep_plugin_loader 109#define TEP_PLUGIN_UNLOADER tep_plugin_unloader 110#define TEP_PLUGIN_OPTIONS tep_plugin_options 111#define TEP_PLUGIN_ALIAS tep_plugin_alias 112#define _MAKE_STR(x) #x 113#define MAKE_STR(x) _MAKE_STR(x) 114#define TEP_PLUGIN_LOADER_NAME MAKE_STR(TEP_PLUGIN_LOADER) 115#define TEP_PLUGIN_UNLOADER_NAME MAKE_STR(TEP_PLUGIN_UNLOADER) 116#define TEP_PLUGIN_OPTIONS_NAME MAKE_STR(TEP_PLUGIN_OPTIONS) 117#define TEP_PLUGIN_ALIAS_NAME MAKE_STR(TEP_PLUGIN_ALIAS) 118 119enum 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, 128}; 129 130struct tep_format_field { 131 struct tep_format_field *next; 132 struct tep_event *event; 133 char *type; 134 char *name; 135 char *alias; 136 int offset; 137 int size; 138 unsigned int arraylen; 139 unsigned int elementsize; 140 unsigned long flags; 141}; 142 143struct tep_format { 144 int nr_common; 145 int nr_fields; 146 struct tep_format_field *common_fields; 147 struct tep_format_field *fields; 148}; 149 150struct tep_print_arg_atom { 151 char *atom; 152}; 153 154struct tep_print_arg_string { 155 char *string; 156 int offset; 157}; 158 159struct tep_print_arg_bitmask { 160 char *bitmask; 161 int offset; 162}; 163 164struct tep_print_arg_field { 165 char *name; 166 struct tep_format_field *field; 167}; 168 169struct tep_print_flag_sym { 170 struct tep_print_flag_sym *next; 171 char *value; 172 char *str; 173}; 174 175struct tep_print_arg_typecast { 176 char *type; 177 struct tep_print_arg *item; 178}; 179 180struct tep_print_arg_flags { 181 struct tep_print_arg *field; 182 char *delim; 183 struct tep_print_flag_sym *flags; 184}; 185 186struct tep_print_arg_symbol { 187 struct tep_print_arg *field; 188 struct tep_print_flag_sym *symbols; 189}; 190 191struct tep_print_arg_hex { 192 struct tep_print_arg *field; 193 struct tep_print_arg *size; 194}; 195 196struct tep_print_arg_int_array { 197 struct tep_print_arg *field; 198 struct tep_print_arg *count; 199 struct tep_print_arg *el_size; 200}; 201 202struct tep_print_arg_dynarray { 203 struct tep_format_field *field; 204 struct tep_print_arg *index; 205}; 206 207struct tep_print_arg; 208 209struct tep_print_arg_op { 210 char *op; 211 int prio; 212 struct tep_print_arg *left; 213 struct tep_print_arg *right; 214}; 215 216struct tep_function_handler; 217 218struct tep_print_arg_func { 219 struct tep_function_handler *func; 220 struct tep_print_arg *args; 221}; 222 223enum 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, 240}; 241 242struct tep_print_arg { 243 struct tep_print_arg *next; 244 enum tep_print_arg_type type; 245 union { 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; 258 }; 259}; 260 261struct tep_print_parse; 262 263struct tep_print_fmt { 264 char *format; 265 struct tep_print_arg *args; 266 struct tep_print_parse *print_cache; 267}; 268 269struct tep_event { 270 struct tep_handle *tep; 271 char *name; 272 int id; 273 int flags; 274 struct tep_format format; 275 struct tep_print_fmt print_fmt; 276 char *system; 277 tep_event_handler_func handler; 278 void *context; 279}; 280 281enum { 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, 289 290 TEP_EVENT_FL_FAILED = 0x80000000 291}; 292 293enum tep_event_sort_type { 294 TEP_EVENT_SORT_ID, 295 TEP_EVENT_SORT_NAME, 296 TEP_EVENT_SORT_SYSTEM, 297}; 298 299enum 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, 309}; 310 311typedef unsigned long long (*tep_func_handler)(struct trace_seq *s, 312 unsigned long long *args); 313 314enum tep_func_arg_type { 315 TEP_FUNC_ARG_VOID, 316 TEP_FUNC_ARG_INT, 317 TEP_FUNC_ARG_LONG, 318 TEP_FUNC_ARG_STRING, 319 TEP_FUNC_ARG_PTR, 320 TEP_FUNC_ARG_MAX_TYPES 321}; 322 323enum tep_flag { 324 TEP_NSEC_OUTPUT = 1, /* output in NSECS */ 325 TEP_DISABLE_SYS_PLUGINS = 1 << 1, 326 TEP_DISABLE_PLUGINS = 1 << 2, 327}; 328 329#define TEP_ERRORS \ 330 _PE(MEM_ALLOC_FAILED, "failed to allocate memory"), \ 331 _PE(PARSE_EVENT_FAILED, "failed to parse event"), \ 332 _PE(READ_ID_FAILED, "failed to read event id"), \ 333 _PE(READ_FORMAT_FAILED, "failed to read event format"), \ 334 _PE(READ_PRINT_FAILED, "failed to read event print fmt"), \ 335 _PE(OLD_FTRACE_ARG_FAILED,"failed to allocate field name for ftrace"),\ 336 _PE(INVALID_ARG_TYPE, "invalid argument type"), \ 337 _PE(INVALID_EXP_TYPE, "invalid expression type"), \ 338 _PE(INVALID_OP_TYPE, "invalid operator type"), \ 339 _PE(INVALID_EVENT_NAME, "invalid event name"), \ 340 _PE(EVENT_NOT_FOUND, "no event found"), \ 341 _PE(SYNTAX_ERROR, "syntax error"), \ 342 _PE(ILLEGAL_RVALUE, "illegal rvalue"), \ 343 _PE(ILLEGAL_LVALUE, "illegal lvalue for string comparison"), \ 344 _PE(INVALID_REGEX, "regex did not compute"), \ 345 _PE(ILLEGAL_STRING_CMP, "illegal comparison for string"), \ 346 _PE(ILLEGAL_INTEGER_CMP,"illegal comparison for integer"), \ 347 _PE(REPARENT_NOT_OP, "cannot reparent other than OP"), \ 348 _PE(REPARENT_FAILED, "failed to reparent filter OP"), \ 349 _PE(BAD_FILTER_ARG, "bad arg in filter tree"), \ 350 _PE(UNEXPECTED_TYPE, "unexpected type (not a value)"), \ 351 _PE(ILLEGAL_TOKEN, "illegal token"), \ 352 _PE(INVALID_PAREN, "open parenthesis cannot come here"), \ 353 _PE(UNBALANCED_PAREN, "unbalanced number of parenthesis"), \ 354 _PE(UNKNOWN_TOKEN, "unknown token"), \ 355 _PE(FILTER_NOT_FOUND, "no filter found"), \ 356 _PE(NOT_A_NUMBER, "must have number field"), \ 357 _PE(NO_FILTER, "no filters exists"), \ 358 _PE(FILTER_MISS, "record does not match to filter") 359 360#undef _PE 361#define _PE(__code, __str) TEP_ERRNO__ ## __code 362enum tep_errno { 363 TEP_ERRNO__SUCCESS = 0, 364 TEP_ERRNO__FILTER_MATCH = TEP_ERRNO__SUCCESS, 365 366 /* 367 * Choose an arbitrary negative big number not to clash with standard 368 * errno since SUS requires the errno has distinct positive values. 369 * See 'Issue 6' in the link below. 370 * 371 * https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html 372 */ 373 __TEP_ERRNO__START = -100000, 374 375 TEP_ERRORS, 376 377 __TEP_ERRNO__END, 378}; 379#undef _PE 380 381struct tep_plugin_list; 382 383#define INVALID_PLUGIN_LIST_OPTION ((char **)((unsigned long)-1)) 384 385enum tep_plugin_load_priority { 386 TEP_PLUGIN_FIRST, 387 TEP_PLUGIN_LAST, 388}; 389 390int tep_add_plugin_path(struct tep_handle *tep, char *path, 391 enum tep_plugin_load_priority prio); 392struct tep_plugin_list *tep_load_plugins(struct tep_handle *tep); 393void tep_unload_plugins(struct tep_plugin_list *plugin_list, 394 struct tep_handle *tep); 395void 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); 401char **tep_plugin_list_options(void); 402void tep_plugin_free_options_list(char **list); 403int tep_plugin_add_options(const char *name, 404 struct tep_plugin_option *options); 405int tep_plugin_add_option(const char *name, const char *val); 406void tep_plugin_remove_options(struct tep_plugin_option *options); 407void tep_plugin_print_options(struct trace_seq *s); 408void tep_print_plugins(struct trace_seq *s, 409 const char *prefix, const char *suffix, 410 const struct tep_plugin_list *list); 411 412/* tep_handle */ 413typedef char *(tep_func_resolver_t)(void *priv, 414 unsigned long long *addrp, char **modp); 415void tep_set_flag(struct tep_handle *tep, int flag); 416void tep_clear_flag(struct tep_handle *tep, enum tep_flag flag); 417bool tep_test_flag(struct tep_handle *tep, enum tep_flag flags); 418 419static inline int tep_is_bigendian(void) 420{ 421 unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 }; 422 unsigned int val; 423 424 memcpy(&val, str, 4); 425 return val == 0x01020304; 426} 427 428/* taken from kernel/trace/trace.h */ 429enum trace_flag_type { 430 TRACE_FLAG_IRQS_OFF = 0x01, 431 TRACE_FLAG_IRQS_NOSUPPORT = 0x02, 432 TRACE_FLAG_NEED_RESCHED = 0x04, 433 TRACE_FLAG_HARDIRQ = 0x08, 434 TRACE_FLAG_SOFTIRQ = 0x10, 435}; 436 437int tep_set_function_resolver(struct tep_handle *tep, 438 tep_func_resolver_t *func, void *priv); 439void tep_reset_function_resolver(struct tep_handle *tep); 440int tep_register_comm(struct tep_handle *tep, const char *comm, int pid); 441int tep_override_comm(struct tep_handle *tep, const char *comm, int pid); 442int tep_register_function(struct tep_handle *tep, char *name, 443 unsigned long long addr, char *mod); 444int tep_register_print_string(struct tep_handle *tep, const char *fmt, 445 unsigned long long addr); 446bool tep_is_pid_registered(struct tep_handle *tep, int pid); 447 448struct tep_event *tep_get_event(struct tep_handle *tep, int index); 449 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 459void 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 463int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size, 464 int long_size); 465 466enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf, 467 unsigned long size, const char *sys); 468enum tep_errno tep_parse_format(struct tep_handle *tep, 469 struct tep_event **eventp, 470 const char *buf, 471 unsigned long size, const char *sys); 472 473void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event, 474 const char *name, struct tep_record *record, 475 int *len, int err); 476 477int tep_get_field_val(struct trace_seq *s, struct tep_event *event, 478 const char *name, struct tep_record *record, 479 unsigned long long *val, int err); 480int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event, 481 const char *name, struct tep_record *record, 482 unsigned long long *val, int err); 483int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event, 484 const char *name, struct tep_record *record, 485 unsigned long long *val, int err); 486 487int tep_print_num_field(struct trace_seq *s, const char *fmt, 488 struct tep_event *event, const char *name, 489 struct tep_record *record, int err); 490 491int tep_print_func_field(struct trace_seq *s, const char *fmt, 492 struct tep_event *event, const char *name, 493 struct tep_record *record, int err); 494 495enum tep_reg_handler { 496 TEP_REGISTER_SUCCESS = 0, 497 TEP_REGISTER_SUCCESS_OVERWRITE, 498}; 499 500int tep_register_event_handler(struct tep_handle *tep, int id, 501 const char *sys_name, const char *event_name, 502 tep_event_handler_func func, void *context); 503int tep_unregister_event_handler(struct tep_handle *tep, int id, 504 const char *sys_name, const char *event_name, 505 tep_event_handler_func func, void *context); 506int tep_register_print_function(struct tep_handle *tep, 507 tep_func_handler func, 508 enum tep_func_arg_type ret_type, 509 char *name, ...); 510int tep_unregister_print_function(struct tep_handle *tep, 511 tep_func_handler func, char *name); 512 513struct tep_format_field *tep_find_common_field(struct tep_event *event, const char *name); 514struct tep_format_field *tep_find_field(struct tep_event *event, const char *name); 515struct tep_format_field *tep_find_any_field(struct tep_event *event, const char *name); 516 517const char *tep_find_function(struct tep_handle *tep, unsigned long long addr); 518unsigned long long 519tep_find_function_address(struct tep_handle *tep, unsigned long long addr); 520unsigned long long tep_read_number(struct tep_handle *tep, const void *ptr, int size); 521int tep_read_number_field(struct tep_format_field *field, const void *data, 522 unsigned long long *value); 523 524struct tep_event *tep_get_first_event(struct tep_handle *tep); 525int tep_get_events_count(struct tep_handle *tep); 526struct tep_event *tep_find_event(struct tep_handle *tep, int id); 527 528struct tep_event * 529tep_find_event_by_name(struct tep_handle *tep, const char *sys, const char *name); 530struct tep_event * 531tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record); 532 533int tep_data_type(struct tep_handle *tep, struct tep_record *rec); 534int tep_data_pid(struct tep_handle *tep, struct tep_record *rec); 535int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec); 536int tep_data_flags(struct tep_handle *tep, struct tep_record *rec); 537const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid); 538struct tep_cmdline; 539struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm, 540 struct tep_cmdline *next); 541int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline); 542 543void tep_print_field(struct trace_seq *s, void *data, 544 struct tep_format_field *field); 545void tep_print_fields(struct trace_seq *s, void *data, 546 int size __maybe_unused, struct tep_event *event); 547int tep_strerror(struct tep_handle *tep, enum tep_errno errnum, 548 char *buf, size_t buflen); 549 550struct tep_event **tep_list_events(struct tep_handle *tep, enum tep_event_sort_type); 551struct tep_event **tep_list_events_copy(struct tep_handle *tep, 552 enum tep_event_sort_type); 553struct tep_format_field **tep_event_common_fields(struct tep_event *event); 554struct tep_format_field **tep_event_fields(struct tep_event *event); 555 556enum tep_endian { 557 TEP_LITTLE_ENDIAN = 0, 558 TEP_BIG_ENDIAN 559}; 560int tep_get_cpus(struct tep_handle *tep); 561void tep_set_cpus(struct tep_handle *tep, int cpus); 562int tep_get_long_size(struct tep_handle *tep); 563void tep_set_long_size(struct tep_handle *tep, int long_size); 564int tep_get_page_size(struct tep_handle *tep); 565void tep_set_page_size(struct tep_handle *tep, int _page_size); 566bool tep_is_file_bigendian(struct tep_handle *tep); 567void tep_set_file_bigendian(struct tep_handle *tep, enum tep_endian endian); 568bool tep_is_local_bigendian(struct tep_handle *tep); 569void tep_set_local_bigendian(struct tep_handle *tep, enum tep_endian endian); 570int tep_get_header_page_size(struct tep_handle *tep); 571int tep_get_header_timestamp_size(struct tep_handle *tep); 572bool tep_is_old_format(struct tep_handle *tep); 573void tep_set_test_filters(struct tep_handle *tep, int test_filters); 574 575struct tep_handle *tep_alloc(void); 576void tep_free(struct tep_handle *tep); 577void tep_ref(struct tep_handle *tep); 578void tep_unref(struct tep_handle *tep); 579int tep_get_ref(struct tep_handle *tep); 580 581/* for debugging */ 582void tep_print_funcs(struct tep_handle *tep); 583void tep_print_printk(struct tep_handle *tep); 584 585/* ----------------------- filtering ----------------------- */ 586 587enum tep_filter_boolean_type { 588 TEP_FILTER_FALSE, 589 TEP_FILTER_TRUE, 590}; 591 592enum tep_filter_op_type { 593 TEP_FILTER_OP_AND = 1, 594 TEP_FILTER_OP_OR, 595 TEP_FILTER_OP_NOT, 596}; 597 598enum 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, 610}; 611 612enum 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, 625}; 626 627enum 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, 636}; 637 638enum tep_filter_value_type { 639 TEP_FILTER_NUMBER, 640 TEP_FILTER_STRING, 641 TEP_FILTER_CHAR 642}; 643 644struct tep_filter_arg; 645 646struct tep_filter_arg_boolean { 647 enum tep_filter_boolean_type value; 648}; 649 650struct tep_filter_arg_field { 651 struct tep_format_field *field; 652}; 653 654struct tep_filter_arg_value { 655 enum tep_filter_value_type type; 656 union { 657 char *str; 658 unsigned long long val; 659 }; 660}; 661 662struct tep_filter_arg_op { 663 enum tep_filter_op_type type; 664 struct tep_filter_arg *left; 665 struct tep_filter_arg *right; 666}; 667 668struct tep_filter_arg_exp { 669 enum tep_filter_exp_type type; 670 struct tep_filter_arg *left; 671 struct tep_filter_arg *right; 672}; 673 674struct tep_filter_arg_num { 675 enum tep_filter_cmp_type type; 676 struct tep_filter_arg *left; 677 struct tep_filter_arg *right; 678}; 679 680struct 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; 686}; 687 688struct tep_filter_arg { 689 enum tep_filter_arg_type type; 690 union { 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; 698 }; 699}; 700 701struct tep_filter_type { 702 int event_id; 703 struct tep_event *event; 704 struct tep_filter_arg *filter; 705}; 706 707#define TEP_FILTER_ERROR_BUFSZ 1024 708 709struct tep_event_filter { 710 struct tep_handle *tep; 711 int filters; 712 struct tep_filter_type *event_filters; 713 char error_buffer[TEP_FILTER_ERROR_BUFSZ]; 714}; 715 716struct tep_event_filter *tep_filter_alloc(struct tep_handle *tep); 717 718/* for backward compatibility */ 719#define FILTER_NONE TEP_ERRNO__NO_FILTER 720#define FILTER_NOEXIST TEP_ERRNO__FILTER_NOT_FOUND 721#define FILTER_MISS TEP_ERRNO__FILTER_MISS 722#define FILTER_MATCH TEP_ERRNO__FILTER_MATCH 723 724enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter, 725 const char *filter_str); 726 727enum tep_errno tep_filter_match(struct tep_event_filter *filter, 728 struct tep_record *record); 729 730int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err, 731 char *buf, size_t buflen); 732 733int tep_event_filtered(struct tep_event_filter *filter, 734 int event_id); 735 736void tep_filter_reset(struct tep_event_filter *filter); 737 738void tep_filter_free(struct tep_event_filter *filter); 739 740char *tep_filter_make_string(struct tep_event_filter *filter, int event_id); 741 742int tep_filter_remove_event(struct tep_event_filter *filter, 743 int event_id); 744 745int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source); 746 747int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2); 748 749#endif /* _PARSE_EVENTS_H */ 750