1 /* 2 * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt (at) 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 41 struct 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 64 struct trace_seq { 65 char *buffer; 66 unsigned int buffer_size; 67 unsigned int len; 68 unsigned int readpos; 69 }; 70 71 void trace_seq_init(struct trace_seq *s); 72 void trace_seq_reset(struct trace_seq *s); 73 void trace_seq_destroy(struct trace_seq *s); 74 75 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...) 76 __attribute__ ((format (printf, 2, 3))); 77 extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args) 78 __attribute__ ((format (printf, 2, 0))); 79 80 extern int trace_seq_puts(struct trace_seq *s, const char *str); 81 extern int trace_seq_putc(struct trace_seq *s, unsigned char c); 82 83 extern void trace_seq_terminate(struct trace_seq *s); 84 85 extern int trace_seq_do_printf(struct trace_seq *s); 86 87 88 /* ----------------------- pevent ----------------------- */ 89 90 struct pevent; 91 struct event_format; 92 93 typedef int (*pevent_event_handler_func)(struct trace_seq *s, 94 struct pevent_record *record, 95 struct event_format *event, 96 void *context); 97 98 typedef int (*pevent_plugin_load_func)(struct pevent *pevent); 99 typedef int (*pevent_plugin_unload_func)(void); 100 101 struct 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 163 enum 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 174 struct 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 186 struct format { 187 int nr_common; 188 int nr_fields; 189 struct format_field *common_fields; 190 struct format_field *fields; 191 }; 192 193 struct print_arg_atom { 194 char *atom; 195 }; 196 197 struct print_arg_string { 198 char *string; 199 int offset; 200 }; 201 202 struct print_arg_field { 203 char *name; 204 struct format_field *field; 205 }; 206 207 struct print_flag_sym { 208 struct print_flag_sym *next; 209 char *value; 210 char *str; 211 }; 212 213 struct print_arg_typecast { 214 char *type; 215 struct print_arg *item; 216 }; 217 218 struct print_arg_flags { 219 struct print_arg *field; 220 char *delim; 221 struct print_flag_sym *flags; 222 }; 223 224 struct print_arg_symbol { 225 struct print_arg *field; 226 struct print_flag_sym *symbols; 227 }; 228 229 struct print_arg_hex { 230 struct print_arg *field; 231 struct print_arg *size; 232 }; 233 234 struct print_arg_dynarray { 235 struct format_field *field; 236 struct print_arg *index; 237 }; 238 239 struct print_arg; 240 241 struct print_arg_op { 242 char *op; 243 int prio; 244 struct print_arg *left; 245 struct print_arg *right; 246 }; 247 248 struct pevent_function_handler; 249 250 struct print_arg_func { 251 struct pevent_function_handler *func; 252 struct print_arg *args; 253 }; 254 255 enum 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 270 struct 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 287 struct print_fmt { 288 char *format; 289 struct print_arg *args; 290 }; 291 292 struct 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 304 enum { 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 314 enum event_sort_type { 315 EVENT_SORT_ID, 316 EVENT_SORT_NAME, 317 EVENT_SORT_SYSTEM, 318 }; 319 320 enum 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 332 typedef unsigned long long (*pevent_func_handler)(struct trace_seq *s, 333 unsigned long long *args); 334 335 enum 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 344 enum 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 359 enum 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 377 struct cmdline; 378 struct cmdline_list; 379 struct func_map; 380 struct func_list; 381 struct event_handler; 382 383 struct 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 455 static inline void pevent_set_flag(struct pevent *pevent, int flag) 456 { 457 pevent->flags |= flag; 458 } 459 460 static 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 474 static 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 490 static 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 */ 521 enum 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 529 int pevent_register_comm(struct pevent *pevent, const char *comm, int pid); 530 int pevent_register_function(struct pevent *pevent, char *name, 531 unsigned long long addr, char *mod); 532 int pevent_register_print_string(struct pevent *pevent, char *fmt, 533 unsigned long long addr); 534 int pevent_pid_is_registered(struct pevent *pevent, int pid); 535 536 void pevent_print_event(struct pevent *pevent, struct trace_seq *s, 537 struct pevent_record *record); 538 539 int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size, 540 int long_size); 541 542 enum pevent_errno pevent_parse_event(struct pevent *pevent, const char *buf, 543 unsigned long size, const char *sys); 544 enum pevent_errno pevent_parse_format(struct event_format **eventp, const char *buf, 545 unsigned long size, const char *sys); 546 void pevent_free_format(struct event_format *event); 547 548 void *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 552 int 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); 555 int 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); 558 int 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 562 int 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 566 int 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); 569 int pevent_register_print_function(struct pevent *pevent, 570 pevent_func_handler func, 571 enum pevent_func_arg_type ret_type, 572 char *name, ...); 573 574 struct format_field *pevent_find_common_field(struct event_format *event, const char *name); 575 struct format_field *pevent_find_field(struct event_format *event, const char *name); 576 struct format_field *pevent_find_any_field(struct event_format *event, const char *name); 577 578 const char *pevent_find_function(struct pevent *pevent, unsigned long long addr); 579 unsigned long long 580 pevent_find_function_address(struct pevent *pevent, unsigned long long addr); 581 unsigned long long pevent_read_number(struct pevent *pevent, const void *ptr, int size); 582 int pevent_read_number_field(struct format_field *field, const void *data, 583 unsigned long long *value); 584 585 struct event_format *pevent_find_event(struct pevent *pevent, int id); 586 587 struct event_format * 588 pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name); 589 590 void pevent_data_lat_fmt(struct pevent *pevent, 591 struct trace_seq *s, struct pevent_record *record); 592 int pevent_data_type(struct pevent *pevent, struct pevent_record *rec); 593 struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type); 594 int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec); 595 const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid); 596 void pevent_event_info(struct trace_seq *s, struct event_format *event, 597 struct pevent_record *record); 598 int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum, 599 char *buf, size_t buflen); 600 601 struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type); 602 struct format_field **pevent_event_common_fields(struct event_format *event); 603 struct format_field **pevent_event_fields(struct event_format *event); 604 605 static inline int pevent_get_cpus(struct pevent *pevent) 606 { 607 return pevent->cpus; 608 } 609 610 static inline void pevent_set_cpus(struct pevent *pevent, int cpus) 611 { 612 pevent->cpus = cpus; 613 } 614 615 static inline int pevent_get_long_size(struct pevent *pevent) 616 { 617 return pevent->long_size; 618 } 619 620 static inline void pevent_set_long_size(struct pevent *pevent, int long_size) 621 { 622 pevent->long_size = long_size; 623 } 624 625 static inline int pevent_get_page_size(struct pevent *pevent) 626 { 627 return pevent->page_size; 628 } 629 630 static inline void pevent_set_page_size(struct pevent *pevent, int _page_size) 631 { 632 pevent->page_size = _page_size; 633 } 634 635 static inline int pevent_is_file_bigendian(struct pevent *pevent) 636 { 637 return pevent->file_bigendian; 638 } 639 640 static inline void pevent_set_file_bigendian(struct pevent *pevent, int endian) 641 { 642 pevent->file_bigendian = endian; 643 } 644 645 static inline int pevent_is_host_bigendian(struct pevent *pevent) 646 { 647 return pevent->host_bigendian; 648 } 649 650 static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian) 651 { 652 pevent->host_bigendian = endian; 653 } 654 655 static inline int pevent_is_latency_format(struct pevent *pevent) 656 { 657 return pevent->latency_format; 658 } 659 660 static inline void pevent_set_latency_format(struct pevent *pevent, int lat) 661 { 662 pevent->latency_format = lat; 663 } 664 665 struct pevent *pevent_alloc(void); 666 void pevent_free(struct pevent *pevent); 667 void pevent_ref(struct pevent *pevent); 668 void pevent_unref(struct pevent *pevent); 669 670 /* access to the internal parser */ 671 void pevent_buffer_init(const char *buf, unsigned long long size); 672 enum event_type pevent_read_token(char **tok); 673 void pevent_free_token(char *token); 674 int pevent_peek_char(void); 675 const char *pevent_get_input_buf(void); 676 unsigned long long pevent_get_input_buf_ptr(void); 677 678 /* for debugging */ 679 void pevent_print_funcs(struct pevent *pevent); 680 void pevent_print_printk(struct pevent *pevent); 681 682 /* ----------------------- filtering ----------------------- */ 683 684 enum filter_boolean_type { 685 FILTER_FALSE, 686 FILTER_TRUE, 687 }; 688 689 enum filter_op_type { 690 FILTER_OP_AND = 1, 691 FILTER_OP_OR, 692 FILTER_OP_NOT, 693 }; 694 695 enum 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 709 enum 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 724 enum 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 735 enum filter_value_type { 736 FILTER_NUMBER, 737 FILTER_STRING, 738 FILTER_CHAR 739 }; 740 741 struct fliter_arg; 742 743 struct filter_arg_boolean { 744 enum filter_boolean_type value; 745 }; 746 747 struct filter_arg_field { 748 struct format_field *field; 749 }; 750 751 struct filter_arg_value { 752 enum filter_value_type type; 753 union { 754 char *str; 755 unsigned long long val; 756 }; 757 }; 758 759 struct filter_arg_op { 760 enum filter_op_type type; 761 struct filter_arg *left; 762 struct filter_arg *right; 763 }; 764 765 struct filter_arg_exp { 766 enum filter_exp_type type; 767 struct filter_arg *left; 768 struct filter_arg *right; 769 }; 770 771 struct filter_arg_num { 772 enum filter_cmp_type type; 773 struct filter_arg *left; 774 struct filter_arg *right; 775 }; 776 777 struct 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 785 struct 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 798 struct filter_type { 799 int event_id; 800 struct event_format *event; 801 struct filter_arg *filter; 802 }; 803 804 struct event_filter { 805 struct pevent *pevent; 806 int filters; 807 struct filter_type *event_filters; 808 }; 809 810 struct 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 817 enum filter_trivial_type { 818 FILTER_TRIVIAL_FALSE, 819 FILTER_TRIVIAL_TRUE, 820 FILTER_TRIVIAL_BOTH, 821 }; 822 823 int pevent_filter_add_filter_str(struct event_filter *filter, 824 const char *filter_str, 825 char **error_str); 826 827 828 int pevent_filter_match(struct event_filter *filter, 829 struct pevent_record *record); 830 831 int pevent_event_filtered(struct event_filter *filter, 832 int event_id); 833 834 void pevent_filter_reset(struct event_filter *filter); 835 836 void pevent_filter_clear_trivial(struct event_filter *filter, 837 enum filter_trivial_type type); 838 839 void pevent_filter_free(struct event_filter *filter); 840 841 char *pevent_filter_make_string(struct event_filter *filter, int event_id); 842 843 int pevent_filter_remove_event(struct event_filter *filter, 844 int event_id); 845 846 int pevent_filter_event_has_trivial(struct event_filter *filter, 847 int event_id, 848 enum filter_trivial_type type); 849 850 int pevent_filter_copy(struct event_filter *dest, struct event_filter *source); 851 852 int pevent_update_trivial(struct event_filter *dest, struct event_filter *source, 853 enum filter_trivial_type type); 854 855 int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2); 856 857 #endif /* _PARSE_EVENTS_H */ 858
