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 <stdbool.h> 24#include <stdarg.h> 25#include <stdio.h> 26#include <regex.h> 27#include <string.h> 28 29#ifndef __maybe_unused 30#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#endif 39 40#ifndef DEBUG_RECORD 41#define DEBUG_RECORD 0 42#endif 43 44struct pevent_record { 45 unsigned long long ts; 46 unsigned long long offset; 47 long long missed_events; /* buffer dropped events before */ 48 int record_size; /* size of binary record */ 49 int size; /* size of data */ 50 void *data; 51 int cpu; 52 int ref_count; 53 int locked; /* Do not free, even if ref_count is zero */ 54 void *priv; 55#if DEBUG_RECORD 56 struct pevent_record *prev; 57 struct pevent_record *next; 58 long alloc_addr; 59#endif 60}; 61 62enum 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 73struct 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 81void trace_seq_init(struct trace_seq *s); 82void trace_seq_reset(struct trace_seq *s); 83void trace_seq_destroy(struct trace_seq *s); 84 85extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...) 86 __attribute__ ((format (printf, 2, 3))); 87extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args) 88 __attribute__ ((format (printf, 2, 0))); 89 90extern int trace_seq_puts(struct trace_seq *s, const char *str); 91extern int trace_seq_putc(struct trace_seq *s, unsigned char c); 92 93extern void trace_seq_terminate(struct trace_seq *s); 94 95extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp); 96extern int trace_seq_do_printf(struct trace_seq *s); 97 98 99/* ----------------------- pevent ----------------------- */ 100 101struct pevent; 102struct event_format; 103 104typedef int (*pevent_event_handler_func)(struct trace_seq *s, 105 struct pevent_record *record, 106 struct event_format *event, 107 void *context); 108 109typedef int (*pevent_plugin_load_func)(struct pevent *pevent); 110typedef int (*pevent_plugin_unload_func)(struct pevent *pevent); 111 112struct pevent_plugin_option { 113 struct pevent_plugin_option *next; 114 void *handle; 115 char *file; 116 char *name; 117 char *plugin_alias; 118 char *description; 119 const char *value; 120 void *priv; 121 int set; 122}; 123 124/* 125 * Plugin hooks that can be called: 126 * 127 * PEVENT_PLUGIN_LOADER: (required) 128 * The function name to initialized the plugin. 129 * 130 * int PEVENT_PLUGIN_LOADER(struct pevent *pevent) 131 * 132 * PEVENT_PLUGIN_UNLOADER: (optional) 133 * The function called just before unloading 134 * 135 * int PEVENT_PLUGIN_UNLOADER(struct pevent *pevent) 136 * 137 * PEVENT_PLUGIN_OPTIONS: (optional) 138 * Plugin options that can be set before loading 139 * 140 * struct pevent_plugin_option PEVENT_PLUGIN_OPTIONS[] = { 141 * { 142 * .name = "option-name", 143 * .plugin_alias = "overide-file-name", (optional) 144 * .description = "description of option to show users", 145 * }, 146 * { 147 * .name = NULL, 148 * }, 149 * }; 150 * 151 * Array must end with .name = NULL; 152 * 153 * 154 * .plugin_alias is used to give a shorter name to access 155 * the vairable. Useful if a plugin handles more than one event. 156 * 157 * If .value is not set, then it is considered a boolean and only 158 * .set will be processed. If .value is defined, then it is considered 159 * a string option and .set will be ignored. 160 * 161 * PEVENT_PLUGIN_ALIAS: (optional) 162 * The name to use for finding options (uses filename if not defined) 163 */ 164#define PEVENT_PLUGIN_LOADER pevent_plugin_loader 165#define PEVENT_PLUGIN_UNLOADER pevent_plugin_unloader 166#define PEVENT_PLUGIN_OPTIONS pevent_plugin_options 167#define PEVENT_PLUGIN_ALIAS pevent_plugin_alias 168#define _MAKE_STR(x) #x 169#define MAKE_STR(x) _MAKE_STR(x) 170#define PEVENT_PLUGIN_LOADER_NAME MAKE_STR(PEVENT_PLUGIN_LOADER) 171#define PEVENT_PLUGIN_UNLOADER_NAME MAKE_STR(PEVENT_PLUGIN_UNLOADER) 172#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS) 173#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS) 174 175#define NSECS_PER_SEC 1000000000ULL 176#define NSECS_PER_USEC 1000ULL 177 178enum format_flags { 179 FIELD_IS_ARRAY = 1, 180 FIELD_IS_POINTER = 2, 181 FIELD_IS_SIGNED = 4, 182 FIELD_IS_STRING = 8, 183 FIELD_IS_DYNAMIC = 16, 184 FIELD_IS_LONG = 32, 185 FIELD_IS_FLAG = 64, 186 FIELD_IS_SYMBOLIC = 128, 187}; 188 189struct format_field { 190 struct format_field *next; 191 struct event_format *event; 192 char *type; 193 char *name; 194 char *alias; 195 int offset; 196 int size; 197 unsigned int arraylen; 198 unsigned int elementsize; 199 unsigned long flags; 200}; 201 202struct format { 203 int nr_common; 204 int nr_fields; 205 struct format_field *common_fields; 206 struct format_field *fields; 207}; 208 209struct print_arg_atom { 210 char *atom; 211}; 212 213struct print_arg_string { 214 char *string; 215 int offset; 216}; 217 218struct print_arg_bitmask { 219 char *bitmask; 220 int offset; 221}; 222 223struct print_arg_field { 224 char *name; 225 struct format_field *field; 226}; 227 228struct print_flag_sym { 229 struct print_flag_sym *next; 230 char *value; 231 char *str; 232}; 233 234struct print_arg_typecast { 235 char *type; 236 struct print_arg *item; 237}; 238 239struct print_arg_flags { 240 struct print_arg *field; 241 char *delim; 242 struct print_flag_sym *flags; 243}; 244 245struct print_arg_symbol { 246 struct print_arg *field; 247 struct print_flag_sym *symbols; 248}; 249 250struct print_arg_hex { 251 struct print_arg *field; 252 struct print_arg *size; 253}; 254 255struct print_arg_int_array { 256 struct print_arg *field; 257 struct print_arg *count; 258 struct print_arg *el_size; 259}; 260 261struct print_arg_dynarray { 262 struct format_field *field; 263 struct print_arg *index; 264}; 265 266struct print_arg; 267 268struct print_arg_op { 269 char *op; 270 int prio; 271 struct print_arg *left; 272 struct print_arg *right; 273}; 274 275struct pevent_function_handler; 276 277struct print_arg_func { 278 struct pevent_function_handler *func; 279 struct print_arg *args; 280}; 281 282enum print_arg_type { 283 PRINT_NULL, 284 PRINT_ATOM, 285 PRINT_FIELD, 286 PRINT_FLAGS, 287 PRINT_SYMBOL, 288 PRINT_HEX, 289 PRINT_INT_ARRAY, 290 PRINT_TYPE, 291 PRINT_STRING, 292 PRINT_BSTRING, 293 PRINT_DYNAMIC_ARRAY, 294 PRINT_OP, 295 PRINT_FUNC, 296 PRINT_BITMASK, 297 PRINT_DYNAMIC_ARRAY_LEN, 298}; 299 300struct print_arg { 301 struct print_arg *next; 302 enum print_arg_type type; 303 union { 304 struct print_arg_atom atom; 305 struct print_arg_field field; 306 struct print_arg_typecast typecast; 307 struct print_arg_flags flags; 308 struct print_arg_symbol symbol; 309 struct print_arg_hex hex; 310 struct print_arg_int_array int_array; 311 struct print_arg_func func; 312 struct print_arg_string string; 313 struct print_arg_bitmask bitmask; 314 struct print_arg_op op; 315 struct print_arg_dynarray dynarray; 316 }; 317}; 318 319struct print_fmt { 320 char *format; 321 struct print_arg *args; 322}; 323 324struct event_format { 325 struct pevent *pevent; 326 char *name; 327 int id; 328 int flags; 329 struct format format; 330 struct print_fmt print_fmt; 331 char *system; 332 pevent_event_handler_func handler; 333 void *context; 334}; 335 336enum { 337 EVENT_FL_ISFTRACE = 0x01, 338 EVENT_FL_ISPRINT = 0x02, 339 EVENT_FL_ISBPRINT = 0x04, 340 EVENT_FL_ISFUNCENT = 0x10, 341 EVENT_FL_ISFUNCRET = 0x20, 342 EVENT_FL_NOHANDLE = 0x40, 343 EVENT_FL_PRINTRAW = 0x80, 344 345 EVENT_FL_FAILED = 0x80000000 346}; 347 348enum event_sort_type { 349 EVENT_SORT_ID, 350 EVENT_SORT_NAME, 351 EVENT_SORT_SYSTEM, 352}; 353 354enum event_type { 355 EVENT_ERROR, 356 EVENT_NONE, 357 EVENT_SPACE, 358 EVENT_NEWLINE, 359 EVENT_OP, 360 EVENT_DELIM, 361 EVENT_ITEM, 362 EVENT_DQUOTE, 363 EVENT_SQUOTE, 364}; 365 366typedef unsigned long long (*pevent_func_handler)(struct trace_seq *s, 367 unsigned long long *args); 368 369enum pevent_func_arg_type { 370 PEVENT_FUNC_ARG_VOID, 371 PEVENT_FUNC_ARG_INT, 372 PEVENT_FUNC_ARG_LONG, 373 PEVENT_FUNC_ARG_STRING, 374 PEVENT_FUNC_ARG_PTR, 375 PEVENT_FUNC_ARG_MAX_TYPES 376}; 377 378enum pevent_flag { 379 PEVENT_NSEC_OUTPUT = 1, /* output in NSECS */ 380 PEVENT_DISABLE_SYS_PLUGINS = 1 << 1, 381 PEVENT_DISABLE_PLUGINS = 1 << 2, 382}; 383 384#define PEVENT_ERRORS \ 385 _PE(MEM_ALLOC_FAILED, "failed to allocate memory"), \ 386 _PE(PARSE_EVENT_FAILED, "failed to parse event"), \ 387 _PE(READ_ID_FAILED, "failed to read event id"), \ 388 _PE(READ_FORMAT_FAILED, "failed to read event format"), \ 389 _PE(READ_PRINT_FAILED, "failed to read event print fmt"), \ 390 _PE(OLD_FTRACE_ARG_FAILED,"failed to allocate field name for ftrace"),\ 391 _PE(INVALID_ARG_TYPE, "invalid argument type"), \ 392 _PE(INVALID_EXP_TYPE, "invalid expression type"), \ 393 _PE(INVALID_OP_TYPE, "invalid operator type"), \ 394 _PE(INVALID_EVENT_NAME, "invalid event name"), \ 395 _PE(EVENT_NOT_FOUND, "no event found"), \ 396 _PE(SYNTAX_ERROR, "syntax error"), \ 397 _PE(ILLEGAL_RVALUE, "illegal rvalue"), \ 398 _PE(ILLEGAL_LVALUE, "illegal lvalue for string comparison"), \ 399 _PE(INVALID_REGEX, "regex did not compute"), \ 400 _PE(ILLEGAL_STRING_CMP, "illegal comparison for string"), \ 401 _PE(ILLEGAL_INTEGER_CMP,"illegal comparison for integer"), \ 402 _PE(REPARENT_NOT_OP, "cannot reparent other than OP"), \ 403 _PE(REPARENT_FAILED, "failed to reparent filter OP"), \ 404 _PE(BAD_FILTER_ARG, "bad arg in filter tree"), \ 405 _PE(UNEXPECTED_TYPE, "unexpected type (not a value)"), \ 406 _PE(ILLEGAL_TOKEN, "illegal token"), \ 407 _PE(INVALID_PAREN, "open parenthesis cannot come here"), \ 408 _PE(UNBALANCED_PAREN, "unbalanced number of parenthesis"), \ 409 _PE(UNKNOWN_TOKEN, "unknown token"), \ 410 _PE(FILTER_NOT_FOUND, "no filter found"), \ 411 _PE(NOT_A_NUMBER, "must have number field"), \ 412 _PE(NO_FILTER, "no filters exists"), \ 413 _PE(FILTER_MISS, "record does not match to filter") 414 415#undef _PE 416#define _PE(__code, __str) PEVENT_ERRNO__ ## __code 417enum pevent_errno { 418 PEVENT_ERRNO__SUCCESS = 0, 419 PEVENT_ERRNO__FILTER_MATCH = PEVENT_ERRNO__SUCCESS, 420 421 /* 422 * Choose an arbitrary negative big number not to clash with standard 423 * errno since SUS requires the errno has distinct positive values. 424 * See 'Issue 6' in the link below. 425 * 426 * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html 427 */ 428 __PEVENT_ERRNO__START = -100000, 429 430 PEVENT_ERRORS, 431 432 __PEVENT_ERRNO__END, 433}; 434#undef _PE 435 436struct plugin_list; 437 438#define INVALID_PLUGIN_LIST_OPTION ((char **)((unsigned long)-1)) 439 440struct plugin_list *traceevent_load_plugins(struct pevent *pevent); 441void traceevent_unload_plugins(struct plugin_list *plugin_list, 442 struct pevent *pevent); 443char **traceevent_plugin_list_options(void); 444void traceevent_plugin_free_options_list(char **list); 445int traceevent_plugin_add_options(const char *name, 446 struct pevent_plugin_option *options); 447void traceevent_plugin_remove_options(struct pevent_plugin_option *options); 448void traceevent_print_plugins(struct trace_seq *s, 449 const char *prefix, const char *suffix, 450 const struct plugin_list *list); 451 452struct cmdline; 453struct cmdline_list; 454struct func_map; 455struct func_list; 456struct event_handler; 457struct func_resolver; 458 459typedef char *(pevent_func_resolver_t)(void *priv, 460 unsigned long long *addrp, char **modp); 461 462struct pevent { 463 int ref_count; 464 465 int header_page_ts_offset; 466 int header_page_ts_size; 467 int header_page_size_offset; 468 int header_page_size_size; 469 int header_page_data_offset; 470 int header_page_data_size; 471 int header_page_overwrite; 472 473 int file_bigendian; 474 int host_bigendian; 475 476 int latency_format; 477 478 int old_format; 479 480 int cpus; 481 int long_size; 482 int page_size; 483 484 struct cmdline *cmdlines; 485 struct cmdline_list *cmdlist; 486 int cmdline_count; 487 488 struct func_map *func_map; 489 struct func_resolver *func_resolver; 490 struct func_list *funclist; 491 unsigned int func_count; 492 493 struct printk_map *printk_map; 494 struct printk_list *printklist; 495 unsigned int printk_count; 496 497 498 struct event_format **events; 499 int nr_events; 500 struct event_format **sort_events; 501 enum event_sort_type last_type; 502 503 int type_offset; 504 int type_size; 505 506 int pid_offset; 507 int pid_size; 508 509 int pc_offset; 510 int pc_size; 511 512 int flags_offset; 513 int flags_size; 514 515 int ld_offset; 516 int ld_size; 517 518 int print_raw; 519 520 int test_filters; 521 522 int flags; 523 524 struct format_field *bprint_ip_field; 525 struct format_field *bprint_fmt_field; 526 struct format_field *bprint_buf_field; 527 528 struct event_handler *handlers; 529 struct pevent_function_handler *func_handlers; 530 531 /* cache */ 532 struct event_format *last_event; 533 534 char *trace_clock; 535}; 536 537static inline void pevent_set_flag(struct pevent *pevent, int flag) 538{ 539 pevent->flags |= flag; 540} 541 542static inline unsigned short 543__data2host2(struct pevent *pevent, unsigned short data) 544{ 545 unsigned short swap; 546 547 if (pevent->host_bigendian == pevent->file_bigendian) 548 return data; 549 550 swap = ((data & 0xffULL) << 8) | 551 ((data & (0xffULL << 8)) >> 8); 552 553 return swap; 554} 555 556static inline unsigned int 557__data2host4(struct pevent *pevent, unsigned int data) 558{ 559 unsigned int swap; 560 561 if (pevent->host_bigendian == pevent->file_bigendian) 562 return data; 563 564 swap = ((data & 0xffULL) << 24) | 565 ((data & (0xffULL << 8)) << 8) | 566 ((data & (0xffULL << 16)) >> 8) | 567 ((data & (0xffULL << 24)) >> 24); 568 569 return swap; 570} 571 572static inline unsigned long long 573__data2host8(struct pevent *pevent, unsigned long long data) 574{ 575 unsigned long long swap; 576 577 if (pevent->host_bigendian == pevent->file_bigendian) 578 return data; 579 580 swap = ((data & 0xffULL) << 56) | 581 ((data & (0xffULL << 8)) << 40) | 582 ((data & (0xffULL << 16)) << 24) | 583 ((data & (0xffULL << 24)) << 8) | 584 ((data & (0xffULL << 32)) >> 8) | 585 ((data & (0xffULL << 40)) >> 24) | 586 ((data & (0xffULL << 48)) >> 40) | 587 ((data & (0xffULL << 56)) >> 56); 588 589 return swap; 590} 591 592#define data2host2(pevent, ptr) __data2host2(pevent, *(unsigned short *)(ptr)) 593#define data2host4(pevent, ptr) __data2host4(pevent, *(unsigned int *)(ptr)) 594#define data2host8(pevent, ptr) \ 595({ \ 596 unsigned long long __val; \ 597 \ 598 memcpy(&__val, (ptr), sizeof(unsigned long long)); \ 599 __data2host8(pevent, __val); \ 600}) 601 602static inline int traceevent_host_bigendian(void) 603{ 604 unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 }; 605 unsigned int val; 606 607 memcpy(&val, str, 4); 608 return val == 0x01020304; 609} 610 611/* taken from kernel/trace/trace.h */ 612enum trace_flag_type { 613 TRACE_FLAG_IRQS_OFF = 0x01, 614 TRACE_FLAG_IRQS_NOSUPPORT = 0x02, 615 TRACE_FLAG_NEED_RESCHED = 0x04, 616 TRACE_FLAG_HARDIRQ = 0x08, 617 TRACE_FLAG_SOFTIRQ = 0x10, 618}; 619 620int pevent_set_function_resolver(struct pevent *pevent, 621 pevent_func_resolver_t *func, void *priv); 622void pevent_reset_function_resolver(struct pevent *pevent); 623int pevent_register_comm(struct pevent *pevent, const char *comm, int pid); 624int pevent_register_trace_clock(struct pevent *pevent, const char *trace_clock); 625int pevent_register_function(struct pevent *pevent, char *name, 626 unsigned long long addr, char *mod); 627int pevent_register_print_string(struct pevent *pevent, const char *fmt, 628 unsigned long long addr); 629int pevent_pid_is_registered(struct pevent *pevent, int pid); 630 631void pevent_print_event(struct pevent *pevent, struct trace_seq *s, 632 struct pevent_record *record, bool use_trace_clock); 633 634int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size, 635 int long_size); 636 637enum pevent_errno pevent_parse_event(struct pevent *pevent, const char *buf, 638 unsigned long size, const char *sys); 639enum pevent_errno pevent_parse_format(struct pevent *pevent, 640 struct event_format **eventp, 641 const char *buf, 642 unsigned long size, const char *sys); 643void pevent_free_format(struct event_format *event); 644void pevent_free_format_field(struct format_field *field); 645 646void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event, 647 const char *name, struct pevent_record *record, 648 int *len, int err); 649 650int pevent_get_field_val(struct trace_seq *s, struct event_format *event, 651 const char *name, struct pevent_record *record, 652 unsigned long long *val, int err); 653int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event, 654 const char *name, struct pevent_record *record, 655 unsigned long long *val, int err); 656int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event, 657 const char *name, struct pevent_record *record, 658 unsigned long long *val, int err); 659 660int pevent_print_num_field(struct trace_seq *s, const char *fmt, 661 struct event_format *event, const char *name, 662 struct pevent_record *record, int err); 663 664int pevent_print_func_field(struct trace_seq *s, const char *fmt, 665 struct event_format *event, const char *name, 666 struct pevent_record *record, int err); 667 668int pevent_register_event_handler(struct pevent *pevent, int id, 669 const char *sys_name, const char *event_name, 670 pevent_event_handler_func func, void *context); 671int pevent_unregister_event_handler(struct pevent *pevent, int id, 672 const char *sys_name, const char *event_name, 673 pevent_event_handler_func func, void *context); 674int pevent_register_print_function(struct pevent *pevent, 675 pevent_func_handler func, 676 enum pevent_func_arg_type ret_type, 677 char *name, ...); 678int pevent_unregister_print_function(struct pevent *pevent, 679 pevent_func_handler func, char *name); 680 681struct format_field *pevent_find_common_field(struct event_format *event, const char *name); 682struct format_field *pevent_find_field(struct event_format *event, const char *name); 683struct format_field *pevent_find_any_field(struct event_format *event, const char *name); 684 685const char *pevent_find_function(struct pevent *pevent, unsigned long long addr); 686unsigned long long 687pevent_find_function_address(struct pevent *pevent, unsigned long long addr); 688unsigned long long pevent_read_number(struct pevent *pevent, const void *ptr, int size); 689int pevent_read_number_field(struct format_field *field, const void *data, 690 unsigned long long *value); 691 692struct event_format *pevent_find_event(struct pevent *pevent, int id); 693 694struct event_format * 695pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name); 696 697void pevent_data_lat_fmt(struct pevent *pevent, 698 struct trace_seq *s, struct pevent_record *record); 699int pevent_data_type(struct pevent *pevent, struct pevent_record *rec); 700struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type); 701int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec); 702const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid); 703struct cmdline; 704struct cmdline *pevent_data_pid_from_comm(struct pevent *pevent, const char *comm, 705 struct cmdline *next); 706int pevent_cmdline_pid(struct pevent *pevent, struct cmdline *cmdline); 707 708void pevent_event_info(struct trace_seq *s, struct event_format *event, 709 struct pevent_record *record); 710int pevent_strerror(struct pevent *pevent, enum pevent_errno errnum, 711 char *buf, size_t buflen); 712 713struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type); 714struct format_field **pevent_event_common_fields(struct event_format *event); 715struct format_field **pevent_event_fields(struct event_format *event); 716 717static inline int pevent_get_cpus(struct pevent *pevent) 718{ 719 return pevent->cpus; 720} 721 722static inline void pevent_set_cpus(struct pevent *pevent, int cpus) 723{ 724 pevent->cpus = cpus; 725} 726 727static inline int pevent_get_long_size(struct pevent *pevent) 728{ 729 return pevent->long_size; 730} 731 732static inline void pevent_set_long_size(struct pevent *pevent, int long_size) 733{ 734 pevent->long_size = long_size; 735} 736 737static inline int pevent_get_page_size(struct pevent *pevent) 738{ 739 return pevent->page_size; 740} 741 742static inline void pevent_set_page_size(struct pevent *pevent, int _page_size) 743{ 744 pevent->page_size = _page_size; 745} 746 747static inline int pevent_is_file_bigendian(struct pevent *pevent) 748{ 749 return pevent->file_bigendian; 750} 751 752static inline void pevent_set_file_bigendian(struct pevent *pevent, int endian) 753{ 754 pevent->file_bigendian = endian; 755} 756 757static inline int pevent_is_host_bigendian(struct pevent *pevent) 758{ 759 return pevent->host_bigendian; 760} 761 762static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian) 763{ 764 pevent->host_bigendian = endian; 765} 766 767static inline int pevent_is_latency_format(struct pevent *pevent) 768{ 769 return pevent->latency_format; 770} 771 772static inline void pevent_set_latency_format(struct pevent *pevent, int lat) 773{ 774 pevent->latency_format = lat; 775} 776 777struct pevent *pevent_alloc(void); 778void pevent_free(struct pevent *pevent); 779void pevent_ref(struct pevent *pevent); 780void pevent_unref(struct pevent *pevent); 781 782/* access to the internal parser */ 783void pevent_buffer_init(const char *buf, unsigned long long size); 784enum event_type pevent_read_token(char **tok); 785void pevent_free_token(char *token); 786int pevent_peek_char(void); 787const char *pevent_get_input_buf(void); 788unsigned long long pevent_get_input_buf_ptr(void); 789 790/* for debugging */ 791void pevent_print_funcs(struct pevent *pevent); 792void pevent_print_printk(struct pevent *pevent); 793 794/* ----------------------- filtering ----------------------- */ 795 796enum filter_boolean_type { 797 FILTER_FALSE, 798 FILTER_TRUE, 799}; 800 801enum filter_op_type { 802 FILTER_OP_AND = 1, 803 FILTER_OP_OR, 804 FILTER_OP_NOT, 805}; 806 807enum filter_cmp_type { 808 FILTER_CMP_NONE, 809 FILTER_CMP_EQ, 810 FILTER_CMP_NE, 811 FILTER_CMP_GT, 812 FILTER_CMP_LT, 813 FILTER_CMP_GE, 814 FILTER_CMP_LE, 815 FILTER_CMP_MATCH, 816 FILTER_CMP_NOT_MATCH, 817 FILTER_CMP_REGEX, 818 FILTER_CMP_NOT_REGEX, 819}; 820 821enum filter_exp_type { 822 FILTER_EXP_NONE, 823 FILTER_EXP_ADD, 824 FILTER_EXP_SUB, 825 FILTER_EXP_MUL, 826 FILTER_EXP_DIV, 827 FILTER_EXP_MOD, 828 FILTER_EXP_RSHIFT, 829 FILTER_EXP_LSHIFT, 830 FILTER_EXP_AND, 831 FILTER_EXP_OR, 832 FILTER_EXP_XOR, 833 FILTER_EXP_NOT, 834}; 835 836enum filter_arg_type { 837 FILTER_ARG_NONE, 838 FILTER_ARG_BOOLEAN, 839 FILTER_ARG_VALUE, 840 FILTER_ARG_FIELD, 841 FILTER_ARG_EXP, 842 FILTER_ARG_OP, 843 FILTER_ARG_NUM, 844 FILTER_ARG_STR, 845}; 846 847enum filter_value_type { 848 FILTER_NUMBER, 849 FILTER_STRING, 850 FILTER_CHAR 851}; 852 853struct fliter_arg; 854 855struct filter_arg_boolean { 856 enum filter_boolean_type value; 857}; 858 859struct filter_arg_field { 860 struct format_field *field; 861}; 862 863struct filter_arg_value { 864 enum filter_value_type type; 865 union { 866 char *str; 867 unsigned long long val; 868 }; 869}; 870 871struct filter_arg_op { 872 enum filter_op_type type; 873 struct filter_arg *left; 874 struct filter_arg *right; 875}; 876 877struct filter_arg_exp { 878 enum filter_exp_type type; 879 struct filter_arg *left; 880 struct filter_arg *right; 881}; 882 883struct filter_arg_num { 884 enum filter_cmp_type type; 885 struct filter_arg *left; 886 struct filter_arg *right; 887}; 888 889struct filter_arg_str { 890 enum filter_cmp_type type; 891 struct format_field *field; 892 char *val; 893 char *buffer; 894 regex_t reg; 895}; 896 897struct filter_arg { 898 enum filter_arg_type type; 899 union { 900 struct filter_arg_boolean boolean; 901 struct filter_arg_field field; 902 struct filter_arg_value value; 903 struct filter_arg_op op; 904 struct filter_arg_exp exp; 905 struct filter_arg_num num; 906 struct filter_arg_str str; 907 }; 908}; 909 910struct filter_type { 911 int event_id; 912 struct event_format *event; 913 struct filter_arg *filter; 914}; 915 916#define PEVENT_FILTER_ERROR_BUFSZ 1024 917 918struct event_filter { 919 struct pevent *pevent; 920 int filters; 921 struct filter_type *event_filters; 922 char error_buffer[PEVENT_FILTER_ERROR_BUFSZ]; 923}; 924 925struct event_filter *pevent_filter_alloc(struct pevent *pevent); 926 927/* for backward compatibility */ 928#define FILTER_NONE PEVENT_ERRNO__NO_FILTER 929#define FILTER_NOEXIST PEVENT_ERRNO__FILTER_NOT_FOUND 930#define FILTER_MISS PEVENT_ERRNO__FILTER_MISS 931#define FILTER_MATCH PEVENT_ERRNO__FILTER_MATCH 932 933enum filter_trivial_type { 934 FILTER_TRIVIAL_FALSE, 935 FILTER_TRIVIAL_TRUE, 936 FILTER_TRIVIAL_BOTH, 937}; 938 939enum pevent_errno pevent_filter_add_filter_str(struct event_filter *filter, 940 const char *filter_str); 941 942enum pevent_errno pevent_filter_match(struct event_filter *filter, 943 struct pevent_record *record); 944 945int pevent_filter_strerror(struct event_filter *filter, enum pevent_errno err, 946 char *buf, size_t buflen); 947 948int pevent_event_filtered(struct event_filter *filter, 949 int event_id); 950 951void pevent_filter_reset(struct event_filter *filter); 952 953int pevent_filter_clear_trivial(struct event_filter *filter, 954 enum filter_trivial_type type); 955 956void pevent_filter_free(struct event_filter *filter); 957 958char *pevent_filter_make_string(struct event_filter *filter, int event_id); 959 960int pevent_filter_remove_event(struct event_filter *filter, 961 int event_id); 962 963int pevent_filter_event_has_trivial(struct event_filter *filter, 964 int event_id, 965 enum filter_trivial_type type); 966 967int pevent_filter_copy(struct event_filter *dest, struct event_filter *source); 968 969int pevent_update_trivial(struct event_filter *dest, struct event_filter *source, 970 enum filter_trivial_type type); 971 972int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2); 973 974#endif /* _PARSE_EVENTS_H */ 975