1/* 2 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> 3 * 4 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; 8 * version 2.1 of the License (not later!) 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public 16 * License along with this program; if not, see <http://www.gnu.org/licenses> 17 * 18 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 19 */ 20#ifndef _PARSE_EVENTS_H 21#define _PARSE_EVENTS_H 22 23#include <stdarg.h> 24#include <regex.h> 25 26#ifndef __maybe_unused 27#define __maybe_unused __attribute__((unused)) 28#endif 29 30/* ----------------------- trace_seq ----------------------- */ 31 32 33#ifndef TRACE_SEQ_BUF_SIZE 34#define TRACE_SEQ_BUF_SIZE 4096 35#endif 36 37#ifndef DEBUG_RECORD 38#define DEBUG_RECORD 0 39#endif 40 41struct pevent_record { 42 unsigned long long ts; 43 unsigned long long offset; 44 long long missed_events; /* buffer dropped events before */ 45 int record_size; /* size of binary record */ 46 int size; /* size of data */ 47 void *data; 48 int cpu; 49 int ref_count; 50 int locked; /* Do not free, even if ref_count is zero */ 51 void *priv; 52#if DEBUG_RECORD 53 struct pevent_record *prev; 54 struct pevent_record *next; 55 long alloc_addr; 56#endif 57}; 58 59/* 60 * Trace sequences are used to allow a function to call several other functions 61 * to create a string of data to use (up to a max of PAGE_SIZE). 62 */ 63 64struct trace_seq { 65 char *buffer; 66 unsigned int buffer_size; 67 unsigned int len; 68 unsigned int readpos; 69}; 70 71void trace_seq_init(struct trace_seq *s); 72void trace_seq_reset(struct trace_seq *s); 73void trace_seq_destroy(struct trace_seq *s); 74 75extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...) 76 __attribute__ ((format (printf, 2, 3))); 77extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args) 78 __attribute__ ((format (printf, 2, 0))); 79 80extern int trace_seq_puts(struct trace_seq *s, const char *str); 81extern int trace_seq_putc(struct trace_seq *s, unsigned char c); 82 83extern void trace_seq_terminate(struct trace_seq *s); 84 85extern int trace_seq_do_printf(struct trace_seq *s); 86 87 88/* ----------------------- pevent ----------------------- */ 89 90struct pevent; 91struct event_format; 92 93typedef int (*pevent_event_handler_func)(struct trace_seq *s, 94 struct pevent_record *record, 95 struct event_format *event, 96 void *context); 97 98typedef int (*pevent_plugin_load_func)(struct pevent *pevent); 99typedef int (*pevent_plugin_unload_func)(void); 100 101struct plugin_option { 102 struct plugin_option *next; 103 void *handle; 104 char *file; 105 char *name; 106 char *plugin_alias; 107 char *description; 108 char *value; 109 void *priv; 110 int set; 111}; 112 113/* 114 * Plugin hooks that can be called: 115 * 116 * PEVENT_PLUGIN_LOADER: (required) 117 * The function name to initialized the plugin. 118 * 119 * int PEVENT_PLUGIN_LOADER(struct pevent *pevent) 120 * 121 * PEVENT_PLUGIN_UNLOADER: (optional) 122 * The function called just before unloading 123 * 124 * int PEVENT_PLUGIN_UNLOADER(void) 125 * 126 * PEVENT_PLUGIN_OPTIONS: (optional) 127 * Plugin options that can be set before loading 128 * 129 * struct plugin_option PEVENT_PLUGIN_OPTIONS[] = { 130 * { 131 * .name = "option-name", 132 * .plugin_alias = "overide-file-name", (optional) 133 * .description = "description of option to show users", 134 * }, 135 * { 136 * .name = NULL, 137 * }, 138 * }; 139 * 140 * Array must end with .name = NULL; 141 * 142 * 143 * .plugin_alias is used to give a shorter name to access 144 * the vairable. Useful if a plugin handles more than one event. 145 * 146 * PEVENT_PLUGIN_ALIAS: (optional) 147 * The name to use for finding options (uses filename if not defined) 148 */ 149#define PEVENT_PLUGIN_LOADER pevent_plugin_loader 150#define PEVENT_PLUGIN_UNLOADER pevent_plugin_unloader 151#define PEVENT_PLUGIN_OPTIONS pevent_plugin_options 152#define PEVENT_PLUGIN_ALIAS pevent_plugin_alias 153#define _MAKE_STR(x) #x 154#define MAKE_STR(x) _MAKE_STR(x) 155#define PEVENT_PLUGIN_LOADER_NAME MAKE_STR(PEVENT_PLUGIN_LOADER) 156#define PEVENT_PLUGIN_UNLOADER_NAME MAKE_STR(PEVENT_PLUGIN_UNLOADER) 157#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS) 158#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS) 159 160#define NSECS_PER_SEC 1000000000ULL 161#define NSECS_PER_USEC 1000ULL 162 163enum format_flags { 164 FIELD_IS_ARRAY = 1, 165 FIELD_IS_POINTER = 2, 166 FIELD_IS_SIGNED = 4, 167 FIELD_IS_STRING = 8, 168 FIELD_IS_DYNAMIC = 16, 169 FIELD_IS_LONG = 32, 170 FIELD_IS_FLAG = 64, 171 FIELD_IS_SYMBOLIC = 128, 172}; 173 174struct format_field { 175 struct format_field *next; 176 struct event_format *event; 177 char *type; 178 char *name; 179 int offset; 180 int size; 181 unsigned int arraylen; 182 unsigned int elementsize; 183 unsigned long flags; 184}; 185 186struct format { 187 int nr_common; 188 int nr_fields; 189 struct format_field *common_fields; 190 struct format_field *fields; 191}; 192 193struct print_arg_atom { 194 char *atom; 195}; 196 197struct print_arg_string { 198 char *string; 199 int offset; 200}; 201 202struct print_arg_field { 203 char *name; 204 struct format_field *field; 205}; 206 207struct print_flag_sym { 208 struct print_flag_sym *next; 209 char *value; 210 char *str; 211}; 212 213struct print_arg_typecast { 214 char *type; 215 struct print_arg *item; 216}; 217 218struct print_arg_flags { 219 struct print_arg *field; 220 char *delim; 221 struct print_flag_sym *flags; 222}; 223 224struct print_arg_symbol { 225 struct print_arg *field; 226 struct print_flag_sym *symbols; 227}; 228 229struct print_arg_hex { 230 struct print_arg *field; 231 struct print_arg *size; 232}; 233 234struct print_arg_dynarray { 235 struct format_field *field; 236 struct print_arg *index; 237}; 238 239struct print_arg; 240 241struct print_arg_op { 242 char *op; 243 int prio; 244 struct print_arg *left; 245 struct print_arg *right; 246}; 247 248struct pevent_function_handler; 249 250struct print_arg_func { 251 struct pevent_function_handler *func; 252 struct print_arg *args; 253}; 254 255enum print_arg_type { 256 PRINT_NULL, 257 PRINT_ATOM, 258 PRINT_FIELD, 259 PRINT_FLAGS, 260 PRINT_SYMBOL, 261 PRINT_HEX, 262 PRINT_TYPE, 263 PRINT_STRING, 264 PRINT_BSTRING, 265 PRINT_DYNAMIC_ARRAY, 266 PRINT_OP, 267 PRINT_FUNC, 268}; 269 270struct print_arg { 271 struct print_arg *next; 272 enum print_arg_type type; 273 union { 274 struct print_arg_atom atom; 275 struct print_arg_field field; 276 struct print_arg_typecast typecast; 277 struct print_arg_flags flags; 278 struct print_arg_symbol symbol; 279 struct print_arg_hex hex; 280 struct print_arg_func func; 281 struct print_arg_string string; 282 struct print_arg_op op; 283 struct print_arg_dynarray dynarray; 284 }; 285}; 286 287struct print_fmt { 288 char *format; 289 struct print_arg *args; 290}; 291 292struct event_format { 293 struct pevent *pevent; 294 char *name; 295 int id; 296 int flags; 297 struct format format; 298 struct print_fmt print_fmt; 299 char *system; 300 pevent_event_handler_func handler; 301 void *context; 302}; 303 304enum { 305 EVENT_FL_ISFTRACE = 0x01, 306 EVENT_FL_ISPRINT = 0x02, 307 EVENT_FL_ISBPRINT = 0x04, 308 EVENT_FL_ISFUNCENT = 0x10, 309 EVENT_FL_ISFUNCRET = 0x20, 310 311 EVENT_FL_FAILED = 0x80000000 312}; 313 314enum event_sort_type { 315 EVENT_SORT_ID, 316 EVENT_SORT_NAME, 317 EVENT_SORT_SYSTEM, 318}; 319 320enum event_type { 321 EVENT_ERROR, 322 EVENT_NONE, 323 EVENT_SPACE, 324 EVENT_NEWLINE, 325 EVENT_OP, 326 EVENT_DELIM, 327 EVENT_ITEM, 328 EVENT_DQUOTE, 329 EVENT_SQUOTE, 330}; 331 332typedef unsigned long long (*pevent_func_handler)(struct trace_seq *s, 333 unsigned long long *args); 334 335enum pevent_func_arg_type { 336 PEVENT_FUNC_ARG_VOID, 337 PEVENT_FUNC_ARG_INT, 338 PEVENT_FUNC_ARG_LONG, 339 PEVENT_FUNC_ARG_STRING, 340 PEVENT_FUNC_ARG_PTR, 341 PEVENT_FUNC_ARG_MAX_TYPES 342}; 343 344enum pevent_flag { 345 PEVENT_NSEC_OUTPUT = 1, /* output in NSECS */ 346}; 347 348#define PEVENT_ERRORS \ 349 _PE(MEM_ALLOC_FAILED, "failed to allocate memory"), \ 350 _PE(PARSE_EVENT_FAILED, "failed to parse event"), \ 351 _PE(READ_ID_FAILED, "failed to read event id"), \ 352 _PE(READ_FORMAT_FAILED, "failed to read event format"), \ 353 _PE(READ_PRINT_FAILED, "failed to read event print fmt"), \ 354 _PE(OLD_FTRACE_ARG_FAILED,"failed to allocate field name for ftrace"),\ 355 _PE(INVALID_ARG_TYPE, "invalid argument type") 356 357#undef _PE 358#define _PE(__code, __str) PEVENT_ERRNO__ ## __code 359enum pevent_errno { 360 PEVENT_ERRNO__SUCCESS = 0, 361 362 /* 363 * Choose an arbitrary negative big number not to clash with standard 364 * errno since SUS requires the errno has distinct positive values. 365 * See 'Issue 6' in the link below. 366 * 367 * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html 368 */ 369 __PEVENT_ERRNO__START = -100000, 370 371 PEVENT_ERRORS, 372 373 __PEVENT_ERRNO__END, 374}; 375#undef _PE 376 377struct cmdline; 378struct cmdline_list; 379struct func_map; 380struct func_list; 381struct event_handler; 382 383struct pevent { 384 int ref_count; 385 386 int header_page_ts_offset; 387 int header_page_ts_size; 388 int header_page_size_offset; 389 int header_page_size_size; 390 int header_page_data_offset; 391 int header_page_data_size; 392 int header_page_overwrite; 393 394 int file_bigendian; 395 int host_bigendian; 396 397 int latency_format; 398 399 int old_format; 400 401 int cpus; 402 int long_size; 403 int page_size; 404 405 struct cmdline *cmdlines; 406 struct cmdline_list *cmdlist; 407 int cmdline_count; 408 409 struct func_map *func_map; 410 struct func_list *funclist; 411 unsigned int func_count; 412 413 struct printk_map *printk_map; 414 struct printk_list *printklist; 415 unsigned int printk_count; 416 417 418 struct event_format **events; 419 int nr_events; 420 struct event_format **sort_events; 421 enum event_sort_type last_type; 422 423 int type_offset; 424 int type_size; 425 426 int pid_offset; 427 int pid_size; 428 429 int pc_offset; 430 int pc_size; 431 432 int flags_offset; 433 int flags_size; 434 435 int ld_offset; 436 int ld_size; 437 438 int print_raw; 439 440 int test_filters; 441 442 int flags; 443 444 struct format_field *bprint_ip_field; 445 struct format_field *bprint_fmt_field; 446 struct format_field *bprint_buf_field; 447 448 struct event_handler *handlers; 449 struct pevent_function_handler *func_handlers; 450 451 /* cache */ 452 struct event_format *last_event; 453}; 454 455static inline void pevent_set_flag(struct pevent *pevent, int flag) 456{ 457 pevent->flags |= flag; 458} 459 460static inline unsigned short 461__data2host2(struct pevent *pevent, unsigned short data) 462{ 463 unsigned short swap; 464 465 if (pevent->host_bigendian == pevent->file_bigendian) 466 return data; 467 468 swap = ((data & 0xffULL) << 8) | 469 ((data & (0xffULL << 8)) >> 8); 470 471 return swap; 472} 473 474static inline unsigned int 475__data2host4(struct pevent *pevent, unsigned int data) 476{ 477 unsigned int swap; 478 479 if (pevent->host_bigendian == pevent->file_bigendian) 480 return data; 481 482 swap = ((data & 0xffULL) << 24) | 483 ((data & (0xffULL << 8)) << 8) | 484 ((data & (0xffULL << 16)) >> 8) | 485 ((data & (0xffULL << 24)) >> 24); 486 487 return swap; 488} 489 490static inline unsigned long long 491__data2host8(struct pevent *pevent, unsigned long long data) 492{ 493 unsigned long long swap; 494 495 if (pevent->host_bigendian == pevent->file_bigendian) 496 return data; 497 498 swap = ((data & 0xffULL) << 56) | 499 ((data & (0xffULL << 8)) << 40) | 500 ((data & (0xffULL << 16)) << 24) | 501 ((data & (0xffULL << 24)) << 8) | 502 ((data & (0xffULL << 32)) >> 8) | 503 ((data & (0xffULL << 40)) >> 24) | 504 ((data & (0xffULL << 48)) >> 40) | 505 ((data & (0xffULL << 56)) >> 56); 506 507 return swap; 508} 509 510#define data2host2(pevent, ptr) __data2host2(pevent, *(unsigned short *)(ptr)) 511#define data2host4(pevent, ptr) __data2host4(pevent, *(unsigned int *)(ptr)) 512#define data2host8(pevent, ptr) \ 513({ \ 514 unsigned long long __val; \ 515 \ 516 memcpy(&__val, (ptr), sizeof(unsigned long long)); \ 517 __data2host8(pevent, __val); \ 518}) 519 520/* taken from kernel/trace/trace.h */ 521enum trace_flag_type { 522 TRACE_FLAG_IRQS_OFF = 0x01, 523 TRACE_FLAG_IRQS_NOSUPPORT = 0x02, 524 TRACE_FLAG_NEED_RESCHED = 0x04, 525 TRACE_FLAG_HARDIRQ = 0x08, 526 TRACE_FLAG_SOFTIRQ = 0x10, 527}; 528 529int pevent_register_comm(struct pevent *pevent, const char *comm, int pid); 530int pevent_register_function(struct pevent *pevent, char *name, 531 unsigned long long addr, char *mod); 532int pevent_register_print_string(struct pevent *pevent, char *fmt, 533 unsigned long long addr); 534int pevent_pid_is_registered(struct pevent *pevent, int pid); 535 536void pevent_print_event(struct pevent *pevent, struct trace_seq *s, 537 struct pevent_record *record); 538 539int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size, 540 int long_size); 541 542enum pevent_errno pevent_parse_event(struct pevent *pevent, const char *buf, 543 unsigned long size, const char *sys); 544enum pevent_errno pevent_parse_format(struct event_format **eventp, const char *buf, 545 unsigned long size, const char *sys); 546void pevent_free_format(struct event_format *event); 547 548void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event, 549 const char *name, struct pevent_record *record, 550 int *len, int err); 551 552int pevent_get_field_val(struct trace_seq *s, struct event_format *event, 553 const char *name, struct pevent_record *record, 554 unsigned long long *val, int err); 555int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event, 556 const char *name, struct pevent_record *record, 557 unsigned long long *val, int err); 558int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event, 559 const char *name, struct pevent_record *record, 560 unsigned long long *val, int err); 561 562int pevent_print_num_field(struct trace_seq *s, const char *fmt, 563 struct event_format *event, const char *name, 564 struct pevent_record *record, int err); 565 566int pevent_register_event_handler(struct pevent *pevent, int id, 567 const char *sys_name, const char *event_name, 568 pevent_event_handler_func func, void *context); 569int pevent_register_print_function(struct pevent *pevent, 570 pevent_func_handler func, 571 enum pevent_func_arg_type ret_type, 572 char *name, ...); 573 574struct format_field *pevent_find_common_field(struct event_format *event, const char *name); 575struct format_field *pevent_find_field(struct event_format *event, const char *name); 576struct format_field *pevent_find_any_field(struct event_format *event, const char *name); 577 578const char *pevent_find_function(struct pevent *pevent, unsigned long long addr); 579unsigned long long 580pevent_find_function_address(struct pevent *pevent, unsigned long long addr); 581unsigned long long pevent_read_number(struct pevent *pevent, const void *ptr, int size); 582int pevent_read_number_field(struct format_field *field, const void *data, 583 unsigned long long *value); 584 585struct event_format *pevent_find_event(struct pevent *pevent, int id); 586 587struct event_format * 588pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name); 589 590void pevent_data_lat_fmt(struct pevent *pevent, 591 struct trace_seq *s, struct pevent_record *record); 592int pevent_data_type(struct pevent *pevent, struct pevent_record *rec); 593struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type); 594int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec); 595const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid); 596void pevent_event_info(struct trace_seq *s, struct event_format *event, 597 struct pevent_record *record); 598int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum, 599 char *buf, size_t buflen); 600 601struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type); 602struct format_field **pevent_event_common_fields(struct event_format *event); 603struct format_field **pevent_event_fields(struct event_format *event); 604 605static inline int pevent_get_cpus(struct pevent *pevent) 606{ 607 return pevent->cpus; 608} 609 610static inline void pevent_set_cpus(struct pevent *pevent, int cpus) 611{ 612 pevent->cpus = cpus; 613} 614 615static inline int pevent_get_long_size(struct pevent *pevent) 616{ 617 return pevent->long_size; 618} 619 620static inline void pevent_set_long_size(struct pevent *pevent, int long_size) 621{ 622 pevent->long_size = long_size; 623} 624 625static inline int pevent_get_page_size(struct pevent *pevent) 626{ 627 return pevent->page_size; 628} 629 630static inline void pevent_set_page_size(struct pevent *pevent, int _page_size) 631{ 632 pevent->page_size = _page_size; 633} 634 635static inline int pevent_is_file_bigendian(struct pevent *pevent) 636{ 637 return pevent->file_bigendian; 638} 639 640static inline void pevent_set_file_bigendian(struct pevent *pevent, int endian) 641{ 642 pevent->file_bigendian = endian; 643} 644 645static inline int pevent_is_host_bigendian(struct pevent *pevent) 646{ 647 return pevent->host_bigendian; 648} 649 650static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian) 651{ 652 pevent->host_bigendian = endian; 653} 654 655static inline int pevent_is_latency_format(struct pevent *pevent) 656{ 657 return pevent->latency_format; 658} 659 660static inline void pevent_set_latency_format(struct pevent *pevent, int lat) 661{ 662 pevent->latency_format = lat; 663} 664 665struct pevent *pevent_alloc(void); 666void pevent_free(struct pevent *pevent); 667void pevent_ref(struct pevent *pevent); 668void pevent_unref(struct pevent *pevent); 669 670/* access to the internal parser */ 671void pevent_buffer_init(const char *buf, unsigned long long size); 672enum event_type pevent_read_token(char **tok); 673void pevent_free_token(char *token); 674int pevent_peek_char(void); 675const char *pevent_get_input_buf(void); 676unsigned long long pevent_get_input_buf_ptr(void); 677 678/* for debugging */ 679void pevent_print_funcs(struct pevent *pevent); 680void pevent_print_printk(struct pevent *pevent); 681 682/* ----------------------- filtering ----------------------- */ 683 684enum filter_boolean_type { 685 FILTER_FALSE, 686 FILTER_TRUE, 687}; 688 689enum filter_op_type { 690 FILTER_OP_AND = 1, 691 FILTER_OP_OR, 692 FILTER_OP_NOT, 693}; 694 695enum filter_cmp_type { 696 FILTER_CMP_NONE, 697 FILTER_CMP_EQ, 698 FILTER_CMP_NE, 699 FILTER_CMP_GT, 700 FILTER_CMP_LT, 701 FILTER_CMP_GE, 702 FILTER_CMP_LE, 703 FILTER_CMP_MATCH, 704 FILTER_CMP_NOT_MATCH, 705 FILTER_CMP_REGEX, 706 FILTER_CMP_NOT_REGEX, 707}; 708 709enum filter_exp_type { 710 FILTER_EXP_NONE, 711 FILTER_EXP_ADD, 712 FILTER_EXP_SUB, 713 FILTER_EXP_MUL, 714 FILTER_EXP_DIV, 715 FILTER_EXP_MOD, 716 FILTER_EXP_RSHIFT, 717 FILTER_EXP_LSHIFT, 718 FILTER_EXP_AND, 719 FILTER_EXP_OR, 720 FILTER_EXP_XOR, 721 FILTER_EXP_NOT, 722}; 723 724enum filter_arg_type { 725 FILTER_ARG_NONE, 726 FILTER_ARG_BOOLEAN, 727 FILTER_ARG_VALUE, 728 FILTER_ARG_FIELD, 729 FILTER_ARG_EXP, 730 FILTER_ARG_OP, 731 FILTER_ARG_NUM, 732 FILTER_ARG_STR, 733}; 734 735enum filter_value_type { 736 FILTER_NUMBER, 737 FILTER_STRING, 738 FILTER_CHAR 739}; 740 741struct fliter_arg; 742 743struct filter_arg_boolean { 744 enum filter_boolean_type value; 745}; 746 747struct filter_arg_field { 748 struct format_field *field; 749}; 750 751struct filter_arg_value { 752 enum filter_value_type type; 753 union { 754 char *str; 755 unsigned long long val; 756 }; 757}; 758 759struct filter_arg_op { 760 enum filter_op_type type; 761 struct filter_arg *left; 762 struct filter_arg *right; 763}; 764 765struct filter_arg_exp { 766 enum filter_exp_type type; 767 struct filter_arg *left; 768 struct filter_arg *right; 769}; 770 771struct filter_arg_num { 772 enum filter_cmp_type type; 773 struct filter_arg *left; 774 struct filter_arg *right; 775}; 776 777struct filter_arg_str { 778 enum filter_cmp_type type; 779 struct format_field *field; 780 char *val; 781 char *buffer; 782 regex_t reg; 783}; 784 785struct filter_arg { 786 enum filter_arg_type type; 787 union { 788 struct filter_arg_boolean boolean; 789 struct filter_arg_field field; 790 struct filter_arg_value value; 791 struct filter_arg_op op; 792 struct filter_arg_exp exp; 793 struct filter_arg_num num; 794 struct filter_arg_str str; 795 }; 796}; 797 798struct filter_type { 799 int event_id; 800 struct event_format *event; 801 struct filter_arg *filter; 802}; 803 804struct event_filter { 805 struct pevent *pevent; 806 int filters; 807 struct filter_type *event_filters; 808}; 809 810struct event_filter *pevent_filter_alloc(struct pevent *pevent); 811 812#define FILTER_NONE -2 813#define FILTER_NOEXIST -1 814#define FILTER_MISS 0 815#define FILTER_MATCH 1 816 817enum filter_trivial_type { 818 FILTER_TRIVIAL_FALSE, 819 FILTER_TRIVIAL_TRUE, 820 FILTER_TRIVIAL_BOTH, 821}; 822 823int pevent_filter_add_filter_str(struct event_filter *filter, 824 const char *filter_str, 825 char **error_str); 826 827 828int pevent_filter_match(struct event_filter *filter, 829 struct pevent_record *record); 830 831int pevent_event_filtered(struct event_filter *filter, 832 int event_id); 833 834void pevent_filter_reset(struct event_filter *filter); 835 836void pevent_filter_clear_trivial(struct event_filter *filter, 837 enum filter_trivial_type type); 838 839void pevent_filter_free(struct event_filter *filter); 840 841char *pevent_filter_make_string(struct event_filter *filter, int event_id); 842 843int pevent_filter_remove_event(struct event_filter *filter, 844 int event_id); 845 846int pevent_filter_event_has_trivial(struct event_filter *filter, 847 int event_id, 848 enum filter_trivial_type type); 849 850int pevent_filter_copy(struct event_filter *dest, struct event_filter *source); 851 852int pevent_update_trivial(struct event_filter *dest, struct event_filter *source, 853 enum filter_trivial_type type); 854 855int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2); 856 857#endif /* _PARSE_EVENTS_H */ 858