Skip to content

L
linux
Commit 73787190 authored by Ingo Molnar's avatar Ingo Molnar
Browse files
Options

Merge branch 'perf/parse-events-4' of git://github.com/fweisbec/tracing into perf/core 

Conflicts:
	tools/perf/Makefile

This tree from Frederic unifies the perf and trace-cmd trace event format
parsing code into a single library.

Powertop and other tools will also be able to make use of it.
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parents 6f5e3577 1c698186
Hide whitespace changes
Inline Side-by-side
Showing with 9161 additions and 3313 deletions
tools/lib/traceevent/Makefile 0 → 100644
View file @ 73787190
# trace-cmd version
EP_VERSION = 1
EP_PATCHLEVEL = 1
EP_EXTRAVERSION = 0
# file format version
FILE_VERSION = 6
MAKEFLAGS += --no-print-directory
# Makefiles suck: This macro sets a default value of $(2) for the
# variable named by $(1), unless the variable has been set by
# environment or command line. This is necessary for CC and AR
# because make sets default values, so the simpler ?= approach
# won't work as expected.
define allow-override
$(if $(or $(findstring environment,$(origin $(1))),\
$(findstring command line,$(origin $(1)))),,\
$(eval $(1) = $(2)))
endef
# Allow setting CC and AR, or setting CROSS_COMPILE as a prefix.
$(call allow-override,CC,$(CROSS_COMPILE)gcc)
$(call allow-override,AR,$(CROSS_COMPILE)ar)
EXT = -std=gnu99
INSTALL = install
# Use DESTDIR for installing into a different root directory.
# This is useful for building a package. The program will be
# installed in this directory as if it was the root directory.
# Then the build tool can move it later.
DESTDIR ?=
DESTDIR_SQ = '$(subst ','\'',$(DESTDIR))'
prefix ?= /usr/local
bindir_relative = bin
bindir = $(prefix)/$(bindir_relative)
man_dir = $(prefix)/share/man
man_dir_SQ = '$(subst ','\'',$(man_dir))'
html_install = $(prefix)/share/kernelshark/html
html_install_SQ = '$(subst ','\'',$(html_install))'
img_install = $(prefix)/share/kernelshark/html/images
img_install_SQ = '$(subst ','\'',$(img_install))'
export man_dir man_dir_SQ html_install html_install_SQ INSTALL
export img_install img_install_SQ
export DESTDIR DESTDIR_SQ
# copy a bit from Linux kbuild
ifeq ("$(origin V)", "command line")
VERBOSE = $(V)
endif
ifndef VERBOSE
VERBOSE = 0
endif
ifeq ("$(origin O)", "command line")
BUILD_OUTPUT := $(O)
endif
ifeq ($(BUILD_SRC),)
ifneq ($(BUILD_OUTPUT),)
define build_output
$(if $(VERBOSE:1=),@)$(MAKE) -C $(BUILD_OUTPUT) \
BUILD_SRC=$(CURDIR) -f $(CURDIR)/Makefile $1
endef
saved-output := $(BUILD_OUTPUT)
BUILD_OUTPUT := $(shell cd $(BUILD_OUTPUT) && /bin/pwd)
$(if $(BUILD_OUTPUT),, \
$(error output directory "$(saved-output)" does not exist))
all: sub-make
gui: force
$(call build_output, all_cmd)
$(filter-out gui,$(MAKECMDGOALS)): sub-make
sub-make: force
$(call build_output, $(MAKECMDGOALS))
# Leave processing to above invocation of make
skip-makefile := 1
endif # BUILD_OUTPUT
endif # BUILD_SRC
# We process the rest of the Makefile if this is the final invocation of make
ifeq ($(skip-makefile),)
srctree := $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR))
objtree := $(CURDIR)
src := $(srctree)
obj := $(objtree)
export prefix bindir src obj
# Shell quotes
bindir_SQ = $(subst ','\'',$(bindir))
bindir_relative_SQ = $(subst ','\'',$(bindir_relative))
LIB_FILE = libtraceevent.a libtraceevent.so
CONFIG_INCLUDES =
CONFIG_LIBS =
CONFIG_FLAGS =
VERSION = $(EP_VERSION)
PATCHLEVEL = $(EP_PATCHLEVEL)
EXTRAVERSION = $(EP_EXTRAVERSION)
OBJ = $@
N =
export Q VERBOSE
EVENT_PARSE_VERSION = $(EP_VERSION).$(EP_PATCHLEVEL).$(EP_EXTRAVERSION)
INCLUDES = -I. -I/usr/local/include $(CONFIG_INCLUDES)
# Set compile option CFLAGS if not set elsewhere
CFLAGS ?= -g -Wall
# Append required CFLAGS
override CFLAGS += $(CONFIG_FLAGS) $(INCLUDES) $(PLUGIN_DIR_SQ)
override CFLAGS += $(udis86-flags)
ifeq ($(VERBOSE),1)
Q =
print_compile =
print_app_build =
print_fpic_compile =
print_shared_lib_compile =
print_plugin_obj_compile =
print_plugin_build =
print_install =
else
Q = @
print_compile = echo ' CC '$(OBJ);
print_app_build = echo ' BUILD '$(OBJ);
print_fpic_compile = echo ' CC FPIC '$(OBJ);
print_shared_lib_compile = echo ' BUILD SHARED LIB '$(OBJ);
print_plugin_obj_compile = echo ' CC PLUGIN OBJ '$(OBJ);
print_plugin_build = echo ' CC PLUGI '$(OBJ);
print_static_lib_build = echo ' BUILD STATIC LIB '$(OBJ);
print_install = echo ' INSTALL '$1' to $(DESTDIR_SQ)$2';
endif
do_fpic_compile = \
($(print_fpic_compile) \
$(CC) -c $(CFLAGS) $(EXT) -fPIC $< -o $@)
do_app_build = \
($(print_app_build) \
$(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS))
do_compile_shared_library = \
($(print_shared_lib_compile) \
$(CC) --shared $^ -o $@)
do_compile_plugin_obj = \
($(print_plugin_obj_compile) \
$(CC) -c $(CFLAGS) -fPIC -o $@ $<)
do_plugin_build = \
($(print_plugin_build) \
$(CC) $(CFLAGS) -shared -nostartfiles -o $@ $<)
do_build_static_lib = \
($(print_static_lib_build) \
$(RM) $@; $(AR) rcs $@ $^)
define do_compile
$(print_compile) \
$(CC) -c $(CFLAGS) $(EXT) $< -o $(obj)/$@;
endef
$(obj)/%.o: $(src)/%.c
$(Q)$(call do_compile)
%.o: $(src)/%.c
$(Q)$(call do_compile)
PEVENT_LIB_OBJS = event-parse.o trace-seq.o parse-filter.o parse-utils.o
ALL_OBJS = $(PEVENT_LIB_OBJS)
CMD_TARGETS = $(LIB_FILE)
TARGETS = $(CMD_TARGETS)
all: all_cmd
all_cmd: $(CMD_TARGETS)
libtraceevent.so: $(PEVENT_LIB_OBJS)
$(Q)$(do_compile_shared_library)
libtraceevent.a: $(PEVENT_LIB_OBJS)
$(Q)$(do_build_static_lib)
$(PEVENT_LIB_OBJS): %.o: $(src)/%.c
$(Q)$(do_fpic_compile)
define make_version.h
(echo '/* This file is automatically generated. Do not modify. */'; \
echo \#define VERSION_CODE $(shell \
expr $(VERSION) \* 256 + $(PATCHLEVEL)); \
echo '#define EXTRAVERSION ' $(EXTRAVERSION); \
echo '#define VERSION_STRING "'$(VERSION).$(PATCHLEVEL).$(EXTRAVERSION)'"'; \
echo '#define FILE_VERSION '$(FILE_VERSION); \
) > $1
endef
define update_version.h
($(call make_version.h, $@.tmp); \
if [ -r $@ ] && cmp -s $@ $@.tmp; then \
rm -f $@.tmp; \
else \
echo ' UPDATE $@'; \
mv -f $@.tmp $@; \
fi);
endef
ep_version.h: force
$(Q)$(N)$(call update_version.h)
VERSION_FILES = ep_version.h
define update_dir
(echo $1 > $@.tmp; \
if [ -r $@ ] && cmp -s $@ $@.tmp; then \
rm -f $@.tmp; \
else \
echo ' UPDATE $@'; \
mv -f $@.tmp $@; \
fi);
endef
## make deps
all_objs := $(sort $(ALL_OBJS))
all_deps := $(all_objs:%.o=.%.d)
define check_deps
$(CC) -M $(CFLAGS) $< > $@;
endef
$(gui_deps): ks_version.h
$(non_gui_deps): tc_version.h
$(all_deps): .%.d: $(src)/%.c
$(Q)$(call check_deps)
$(all_objs) : %.o : .%.d
dep_includes := $(wildcard $(all_deps))
ifneq ($(dep_includes),)
include $(dep_includes)
endif
tags: force
$(RM) tags
find . -name '*.[ch]' | xargs ctags --extra=+f --c-kinds=+px
TAGS: force
$(RM) TAGS
find . -name '*.[ch]' | xargs etags
define do_install
$(print_install) \
if [ ! -d '$(DESTDIR_SQ)$2' ]; then \
$(INSTALL) -d -m 755 '$(DESTDIR_SQ)$2'; \
fi; \
$(INSTALL) $1 '$(DESTDIR_SQ)$2'
endef
install_lib: all_cmd install_plugins install_python
$(Q)$(call do_install,$(LIB_FILE),$(bindir_SQ))
install: install_lib
clean:
$(RM) *.o *~ $(TARGETS) *.a *.so $(VERSION_FILES).*.d
$(RM) tags TAGS
endif # skip-makefile
PHONY += force
force:
# Declare the contents of the .PHONY variable as phony. We keep that
# information in a variable so we can use it in if_changed and friends.
.PHONY: $(PHONY)
tools/lib/traceevent/event-parse.c 0 → 100644
View file @ 73787190
This source diff could not be displayed because it is too large. You can view the blob instead.
tools/lib/traceevent/event-parse.h 0 → 100644
View file @ 73787190
/*
* Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License (not later!)
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#ifndef _PARSE_EVENTS_H
#define _PARSE_EVENTS_H
#include <stdarg.h>
#include <regex.h>
#ifndef __unused
#define __unused __attribute__ ((unused))
#endif
/* ----------------------- trace_seq ----------------------- */
#ifndef TRACE_SEQ_BUF_SIZE
#define TRACE_SEQ_BUF_SIZE 4096
#endif
#ifndef DEBUG_RECORD
#define DEBUG_RECORD 0
#endif
struct pevent_record {
unsigned long long ts;
unsigned long long offset;
long long missed_events; /* buffer dropped events before */
int record_size; /* size of binary record */
int size; /* size of data */
void *data;
int cpu;
int ref_count;
int locked; /* Do not free, even if ref_count is zero */
void *private;
#if DEBUG_RECORD
struct pevent_record *prev;
struct pevent_record *next;
long alloc_addr;
#endif
};
/*
* Trace sequences are used to allow a function to call several other functions
* to create a string of data to use (up to a max of PAGE_SIZE).
*/
struct trace_seq {
char *buffer;
unsigned int buffer_size;
unsigned int len;
unsigned int readpos;
};
void trace_seq_init(struct trace_seq *s);
void trace_seq_destroy(struct trace_seq *s);
extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
__attribute__ ((format (printf, 2, 3)));
extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
__attribute__ ((format (printf, 2, 0)));
extern int trace_seq_puts(struct trace_seq *s, const char *str);
extern int trace_seq_putc(struct trace_seq *s, unsigned char c);
extern void trace_seq_terminate(struct trace_seq *s);
extern int trace_seq_do_printf(struct trace_seq *s);
/* ----------------------- pevent ----------------------- */
struct pevent;
struct event_format;
typedef int (*pevent_event_handler_func)(struct trace_seq *s,
struct pevent_record *record,
struct event_format *event,
void *context);
typedef int (*pevent_plugin_load_func)(struct pevent *pevent);
typedef int (*pevent_plugin_unload_func)(void);
struct plugin_option {
struct plugin_option *next;
void *handle;
char *file;
char *name;
char *plugin_alias;
char *description;
char *value;
void *private;
int set;
};
/*
* Plugin hooks that can be called:
*
* PEVENT_PLUGIN_LOADER: (required)
* The function name to initialized the plugin.
*
* int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
*
* PEVENT_PLUGIN_UNLOADER: (optional)
* The function called just before unloading
*
* int PEVENT_PLUGIN_UNLOADER(void)
*
* PEVENT_PLUGIN_OPTIONS: (optional)
* Plugin options that can be set before loading
*
* struct plugin_option PEVENT_PLUGIN_OPTIONS[] = {
* {
* .name = "option-name",
* .plugin_alias = "overide-file-name", (optional)
* .description = "description of option to show users",
* },
* {
* .name = NULL,
* },
* };
*
* Array must end with .name = NULL;
*
*
* .plugin_alias is used to give a shorter name to access
* the vairable. Useful if a plugin handles more than one event.
*
* PEVENT_PLUGIN_ALIAS: (optional)
* The name to use for finding options (uses filename if not defined)
*/
#define PEVENT_PLUGIN_LOADER pevent_plugin_loader
#define PEVENT_PLUGIN_UNLOADER pevent_plugin_unloader
#define PEVENT_PLUGIN_OPTIONS pevent_plugin_options
#define PEVENT_PLUGIN_ALIAS pevent_plugin_alias
#define _MAKE_STR(x) #x
#define MAKE_STR(x) _MAKE_STR(x)
#define PEVENT_PLUGIN_LOADER_NAME MAKE_STR(PEVENT_PLUGIN_LOADER)
#define PEVENT_PLUGIN_UNLOADER_NAME MAKE_STR(PEVENT_PLUGIN_UNLOADER)
#define PEVENT_PLUGIN_OPTIONS_NAME MAKE_STR(PEVENT_PLUGIN_OPTIONS)
#define PEVENT_PLUGIN_ALIAS_NAME MAKE_STR(PEVENT_PLUGIN_ALIAS)
#define NSECS_PER_SEC 1000000000ULL
#define NSECS_PER_USEC 1000ULL
enum format_flags {
FIELD_IS_ARRAY = 1,
FIELD_IS_POINTER = 2,
FIELD_IS_SIGNED = 4,
FIELD_IS_STRING = 8,
FIELD_IS_DYNAMIC = 16,
FIELD_IS_LONG = 32,
FIELD_IS_FLAG = 64,
FIELD_IS_SYMBOLIC = 128,
};
struct format_field {
struct format_field *next;
struct event_format *event;
char *type;
char *name;
int offset;
int size;
unsigned int arraylen;
unsigned int elementsize;
unsigned long flags;
};
struct format {
int nr_common;
int nr_fields;
struct format_field *common_fields;
struct format_field *fields;
};
struct print_arg_atom {
char *atom;
};
struct print_arg_string {
char *string;
int offset;
};
struct print_arg_field {
char *name;
struct format_field *field;
};
struct print_flag_sym {
struct print_flag_sym *next;
char *value;
char *str;
};
struct print_arg_typecast {
char *type;
struct print_arg *item;
};
struct print_arg_flags {
struct print_arg *field;
char *delim;
struct print_flag_sym *flags;
};
struct print_arg_symbol {
struct print_arg *field;
struct print_flag_sym *symbols;
};
struct print_arg_dynarray {
struct format_field *field;
struct print_arg *index;
};
struct print_arg;
struct print_arg_op {
char *op;
int prio;
struct print_arg *left;
struct print_arg *right;
};
struct pevent_function_handler;
struct print_arg_func {
struct pevent_function_handler *func;
struct print_arg *args;
};
enum print_arg_type {
PRINT_NULL,
PRINT_ATOM,
PRINT_FIELD,
PRINT_FLAGS,
PRINT_SYMBOL,
PRINT_TYPE,
PRINT_STRING,
PRINT_BSTRING,
PRINT_DYNAMIC_ARRAY,
PRINT_OP,
PRINT_FUNC,
};
struct print_arg {
struct print_arg *next;
enum print_arg_type type;
union {
struct print_arg_atom atom;
struct print_arg_field field;
struct print_arg_typecast typecast;
struct print_arg_flags flags;
struct print_arg_symbol symbol;
struct print_arg_func func;
struct print_arg_string string;
struct print_arg_op op;
struct print_arg_dynarray dynarray;
};
};
struct print_fmt {
char *format;
struct print_arg *args;
};
struct event_format {
struct pevent *pevent;
char *name;
int id;
int flags;
struct format format;
struct print_fmt print_fmt;
char *system;
pevent_event_handler_func handler;
void *context;
};
enum {
EVENT_FL_ISFTRACE = 0x01,
EVENT_FL_ISPRINT = 0x02,
EVENT_FL_ISBPRINT = 0x04,
EVENT_FL_ISFUNCENT = 0x10,
EVENT_FL_ISFUNCRET = 0x20,
EVENT_FL_FAILED = 0x80000000
};
enum event_sort_type {
EVENT_SORT_ID,
EVENT_SORT_NAME,
EVENT_SORT_SYSTEM,
};
enum event_type {
EVENT_ERROR,
EVENT_NONE,
EVENT_SPACE,
EVENT_NEWLINE,
EVENT_OP,
EVENT_DELIM,
EVENT_ITEM,
EVENT_DQUOTE,
EVENT_SQUOTE,
};
typedef unsigned long long (*pevent_func_handler)(struct trace_seq *s,
unsigned long long *args);
enum pevent_func_arg_type {
PEVENT_FUNC_ARG_VOID,
PEVENT_FUNC_ARG_INT,
PEVENT_FUNC_ARG_LONG,
PEVENT_FUNC_ARG_STRING,
PEVENT_FUNC_ARG_PTR,
PEVENT_FUNC_ARG_MAX_TYPES
};
enum pevent_flag {
PEVENT_NSEC_OUTPUT = 1, /* output in NSECS */
};
struct cmdline;
struct cmdline_list;
struct func_map;
struct func_list;
struct event_handler;
struct pevent {
int ref_count;
int header_page_ts_offset;
int header_page_ts_size;
int header_page_size_offset;
int header_page_size_size;
int header_page_data_offset;
int header_page_data_size;
int header_page_overwrite;
int file_bigendian;
int host_bigendian;
int latency_format;
int old_format;
int cpus;
int long_size;
struct cmdline *cmdlines;
struct cmdline_list *cmdlist;
int cmdline_count;
struct func_map *func_map;
struct func_list *funclist;
unsigned int func_count;
struct printk_map *printk_map;
struct printk_list *printklist;
unsigned int printk_count;
struct event_format **events;
int nr_events;
struct event_format **sort_events;
enum event_sort_type last_type;
int type_offset;
int type_size;
int pid_offset;
int pid_size;
int pc_offset;
int pc_size;
int flags_offset;
int flags_size;
int ld_offset;
int ld_size;
int print_raw;
int test_filters;
int flags;
struct format_field *bprint_ip_field;
struct format_field *bprint_fmt_field;
struct format_field *bprint_buf_field;
struct event_handler *handlers;
struct pevent_function_handler *func_handlers;
/* cache */
struct event_format *last_event;
};
static inline void pevent_set_flag(struct pevent *pevent, int flag)
{
pevent->flags |= flag;
}
static inline unsigned short
__data2host2(struct pevent *pevent, unsigned short data)
{
unsigned short swap;
if (pevent->host_bigendian == pevent->file_bigendian)
return data;
swap = ((data & 0xffULL) << 8) |
((data & (0xffULL << 8)) >> 8);
return swap;
}
static inline unsigned int
__data2host4(struct pevent *pevent, unsigned int data)
{
unsigned int swap;
if (pevent->host_bigendian == pevent->file_bigendian)
return data;
swap = ((data & 0xffULL) << 24) |
((data & (0xffULL << 8)) << 8) |
((data & (0xffULL << 16)) >> 8) |
((data & (0xffULL << 24)) >> 24);
return swap;
}
static inline unsigned long long
__data2host8(struct pevent *pevent, unsigned long long data)
{
unsigned long long swap;
if (pevent->host_bigendian == pevent->file_bigendian)
return data;
swap = ((data & 0xffULL) << 56) |
((data & (0xffULL << 8)) << 40) |
((data & (0xffULL << 16)) << 24) |
((data & (0xffULL << 24)) << 8) |
((data & (0xffULL << 32)) >> 8) |
((data & (0xffULL << 40)) >> 24) |
((data & (0xffULL << 48)) >> 40) |
((data & (0xffULL << 56)) >> 56);
return swap;
}
#define data2host2(pevent, ptr) __data2host2(pevent, *(unsigned short *)(ptr))
#define data2host4(pevent, ptr) __data2host4(pevent, *(unsigned int *)(ptr))
#define data2host8(pevent, ptr) \
({ \
unsigned long long __val; \
\
memcpy(&__val, (ptr), sizeof(unsigned long long)); \
__data2host8(pevent, __val); \
})
/* taken from kernel/trace/trace.h */
enum trace_flag_type {
TRACE_FLAG_IRQS_OFF = 0x01,
TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
TRACE_FLAG_NEED_RESCHED = 0x04,
TRACE_FLAG_HARDIRQ = 0x08,
TRACE_FLAG_SOFTIRQ = 0x10,
};
int pevent_register_comm(struct pevent *pevent, const char *comm, int pid);
int pevent_register_function(struct pevent *pevent, char *name,
unsigned long long addr, char *mod);
int pevent_register_print_string(struct pevent *pevent, char *fmt,
unsigned long long addr);
int pevent_pid_is_registered(struct pevent *pevent, int pid);
void pevent_print_event(struct pevent *pevent, struct trace_seq *s,
struct pevent_record *record);
int pevent_parse_header_page(struct pevent *pevent, char *buf, unsigned long size,
int long_size);
int pevent_parse_event(struct pevent *pevent, const char *buf,
unsigned long size, const char *sys);
void *pevent_get_field_raw(struct trace_seq *s, struct event_format *event,
const char *name, struct pevent_record *record,
int *len, int err);
int pevent_get_field_val(struct trace_seq *s, struct event_format *event,
const char *name, struct pevent_record *record,
unsigned long long *val, int err);
int pevent_get_common_field_val(struct trace_seq *s, struct event_format *event,
const char *name, struct pevent_record *record,
unsigned long long *val, int err);
int pevent_get_any_field_val(struct trace_seq *s, struct event_format *event,
const char *name, struct pevent_record *record,
unsigned long long *val, int err);
int pevent_print_num_field(struct trace_seq *s, const char *fmt,
struct event_format *event, const char *name,
struct pevent_record *record, int err);
int pevent_register_event_handler(struct pevent *pevent, int id, char *sys_name, char *event_name,
pevent_event_handler_func func, void *context);
int pevent_register_print_function(struct pevent *pevent,
pevent_func_handler func,
enum pevent_func_arg_type ret_type,
char *name, ...);
struct format_field *pevent_find_common_field(struct event_format *event, const char *name);
struct format_field *pevent_find_field(struct event_format *event, const char *name);
struct format_field *pevent_find_any_field(struct event_format *event, const char *name);
const char *pevent_find_function(struct pevent *pevent, unsigned long long addr);
unsigned long long
pevent_find_function_address(struct pevent *pevent, unsigned long long addr);
unsigned long long pevent_read_number(struct pevent *pevent, const void *ptr, int size);
int pevent_read_number_field(struct format_field *field, const void *data,
unsigned long long *value);
struct event_format *pevent_find_event(struct pevent *pevent, int id);
struct event_format *
pevent_find_event_by_name(struct pevent *pevent, const char *sys, const char *name);
void pevent_data_lat_fmt(struct pevent *pevent,
struct trace_seq *s, struct pevent_record *record);
int pevent_data_type(struct pevent *pevent, struct pevent_record *rec);
struct event_format *pevent_data_event_from_type(struct pevent *pevent, int type);
int pevent_data_pid(struct pevent *pevent, struct pevent_record *rec);
const char *pevent_data_comm_from_pid(struct pevent *pevent, int pid);
void pevent_event_info(struct trace_seq *s, struct event_format *event,
struct pevent_record *record);
struct event_format **pevent_list_events(struct pevent *pevent, enum event_sort_type);
struct format_field **pevent_event_common_fields(struct event_format *event);
struct format_field **pevent_event_fields(struct event_format *event);
static inline int pevent_get_cpus(struct pevent *pevent)
{
return pevent->cpus;
}
static inline void pevent_set_cpus(struct pevent *pevent, int cpus)
{
pevent->cpus = cpus;
}
static inline int pevent_get_long_size(struct pevent *pevent)
{
return pevent->long_size;
}
static inline void pevent_set_long_size(struct pevent *pevent, int long_size)
{
pevent->long_size = long_size;
}
static inline int pevent_is_file_bigendian(struct pevent *pevent)
{
return pevent->file_bigendian;
}
static inline void pevent_set_file_bigendian(struct pevent *pevent, int endian)
{
pevent->file_bigendian = endian;
}
static inline int pevent_is_host_bigendian(struct pevent *pevent)
{
return pevent->host_bigendian;
}
static inline void pevent_set_host_bigendian(struct pevent *pevent, int endian)
{
pevent->host_bigendian = endian;
}
static inline int pevent_is_latency_format(struct pevent *pevent)
{
return pevent->latency_format;
}
static inline void pevent_set_latency_format(struct pevent *pevent, int lat)
{
pevent->latency_format = lat;
}
struct pevent *pevent_alloc(void);
void pevent_free(struct pevent *pevent);
void pevent_ref(struct pevent *pevent);
void pevent_unref(struct pevent *pevent);
/* access to the internal parser */
void pevent_buffer_init(const char *buf, unsigned long long size);
enum event_type pevent_read_token(char **tok);
void pevent_free_token(char *token);
int pevent_peek_char(void);
const char *pevent_get_input_buf(void);
unsigned long long pevent_get_input_buf_ptr(void);
/* for debugging */
void pevent_print_funcs(struct pevent *pevent);
void pevent_print_printk(struct pevent *pevent);
/* ----------------------- filtering ----------------------- */
enum filter_boolean_type {
FILTER_FALSE,
FILTER_TRUE,
};
enum filter_op_type {
FILTER_OP_AND = 1,
FILTER_OP_OR,
FILTER_OP_NOT,
};
enum filter_cmp_type {
FILTER_CMP_NONE,
FILTER_CMP_EQ,
FILTER_CMP_NE,
FILTER_CMP_GT,
FILTER_CMP_LT,
FILTER_CMP_GE,
FILTER_CMP_LE,
FILTER_CMP_MATCH,
FILTER_CMP_NOT_MATCH,
FILTER_CMP_REGEX,
FILTER_CMP_NOT_REGEX,
};
enum filter_exp_type {
FILTER_EXP_NONE,
FILTER_EXP_ADD,
FILTER_EXP_SUB,
FILTER_EXP_MUL,
FILTER_EXP_DIV,
FILTER_EXP_MOD,
FILTER_EXP_RSHIFT,
FILTER_EXP_LSHIFT,
FILTER_EXP_AND,
FILTER_EXP_OR,
FILTER_EXP_XOR,
FILTER_EXP_NOT,
};
enum filter_arg_type {
FILTER_ARG_NONE,
FILTER_ARG_BOOLEAN,
FILTER_ARG_VALUE,
FILTER_ARG_FIELD,
FILTER_ARG_EXP,
FILTER_ARG_OP,
FILTER_ARG_NUM,
FILTER_ARG_STR,
};
enum filter_value_type {
FILTER_NUMBER,
FILTER_STRING,
FILTER_CHAR
};
struct fliter_arg;
struct filter_arg_boolean {
enum filter_boolean_type value;
};
struct filter_arg_field {
struct format_field *field;
};
struct filter_arg_value {
enum filter_value_type type;
union {
char *str;
unsigned long long val;
};
};
struct filter_arg_op {
enum filter_op_type type;
struct filter_arg *left;
struct filter_arg *right;
};
struct filter_arg_exp {
enum filter_exp_type type;
struct filter_arg *left;
struct filter_arg *right;
};
struct filter_arg_num {
enum filter_cmp_type type;
struct filter_arg *left;
struct filter_arg *right;
};
struct filter_arg_str {
enum filter_cmp_type type;
struct format_field *field;
char *val;
char *buffer;
regex_t reg;
};
struct filter_arg {
enum filter_arg_type type;
union {
struct filter_arg_boolean boolean;
struct filter_arg_field field;
struct filter_arg_value value;
struct filter_arg_op op;
struct filter_arg_exp exp;
struct filter_arg_num num;
struct filter_arg_str str;
};
};
struct filter_type {
int event_id;
struct event_format *event;
struct filter_arg *filter;
};
struct event_filter {
struct pevent *pevent;
int filters;
struct filter_type *event_filters;
};
struct event_filter *pevent_filter_alloc(struct pevent *pevent);
#define FILTER_NONE -2
#define FILTER_NOEXIST -1
#define FILTER_MISS 0
#define FILTER_MATCH 1
enum filter_trivial_type {
FILTER_TRIVIAL_FALSE,
FILTER_TRIVIAL_TRUE,
FILTER_TRIVIAL_BOTH,
};
int pevent_filter_add_filter_str(struct event_filter *filter,
const char *filter_str,
char **error_str);
int pevent_filter_match(struct event_filter *filter,
struct pevent_record *record);
int pevent_event_filtered(struct event_filter *filter,
int event_id);
void pevent_filter_reset(struct event_filter *filter);
void pevent_filter_clear_trivial(struct event_filter *filter,
enum filter_trivial_type type);
void pevent_filter_free(struct event_filter *filter);
char *pevent_filter_make_string(struct event_filter *filter, int event_id);
int pevent_filter_remove_event(struct event_filter *filter,
int event_id);
int pevent_filter_event_has_trivial(struct event_filter *filter,
int event_id,
enum filter_trivial_type type);
int pevent_filter_copy(struct event_filter *dest, struct event_filter *source);
int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
enum filter_trivial_type type);
int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2);
#endif /* _PARSE_EVENTS_H */
tools/lib/traceevent/event-utils.h 0 → 100644
View file @ 73787190
/*
* Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License (not later!)
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#ifndef __UTIL_H
#define __UTIL_H
#include <ctype.h>
/* Can be overridden */
void die(const char *fmt, ...);
void *malloc_or_die(unsigned int size);
void warning(const char *fmt, ...);
void pr_stat(const char *fmt, ...);
void vpr_stat(const char *fmt, va_list ap);
/* Always available */
void __die(const char *fmt, ...);
void __warning(const char *fmt, ...);
void __pr_stat(const char *fmt, ...);
void __vdie(const char *fmt, ...);
void __vwarning(const char *fmt, ...);
void __vpr_stat(const char *fmt, ...);
static inline char *strim(char *string)
{
char *ret;
if (!string)
return NULL;
while (*string) {
if (!isspace(*string))
break;
string++;
}
ret = string;
string = ret + strlen(ret) - 1;
while (string > ret) {
if (!isspace(*string))
break;
string--;
}
string[1] = 0;
return ret;
}
static inline int has_text(const char *text)
{
if (!text)
return 0;
while (*text) {
if (!isspace(*text))
return 1;
text++;
}
return 0;
}
#endif
tools/lib/traceevent/parse-filter.c 0 → 100644
View file @ 73787190
/*
* Copyright (C) 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License (not later!)
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <sys/types.h>
#include "event-parse.h"
#include "event-utils.h"
#define COMM "COMM"
static struct format_field comm = {
.name = "COMM",
};
struct event_list {
struct event_list *next;
struct event_format *event;
};
#define MAX_ERR_STR_SIZE 256
static void show_error(char **error_str, const char *fmt, ...)
{
unsigned long long index;
const char *input;
char *error;
va_list ap;
int len;
int i;
if (!error_str)
return;
input = pevent_get_input_buf();
index = pevent_get_input_buf_ptr();
len = input ? strlen(input) : 0;
error = malloc_or_die(MAX_ERR_STR_SIZE + (len*2) + 3);
if (len) {
strcpy(error, input);
error[len] = '\n';
for (i = 1; i < len && i < index; i++)
error[len+i] = ' ';
error[len + i] = '^';
error[len + i + 1] = '\n';
len += i+2;
}
va_start(ap, fmt);
vsnprintf(error + len, MAX_ERR_STR_SIZE, fmt, ap);
va_end(ap);
*error_str = error;
}
static void free_token(char *token)
{
pevent_free_token(token);
}
static enum event_type read_token(char **tok)
{
enum event_type type;
char *token = NULL;
do {
free_token(token);
type = pevent_read_token(&token);
} while (type == EVENT_NEWLINE || type == EVENT_SPACE);
/* If token is = or ! check to see if the next char is ~ */
if (token &&
(strcmp(token, "=") == 0 || strcmp(token, "!") == 0) &&
pevent_peek_char() == '~') {
/* append it */
*tok = malloc(3);
sprintf(*tok, "%c%c", *token, '~');
free_token(token);
/* Now remove the '~' from the buffer */
pevent_read_token(&token);
free_token(token);
} else
*tok = token;
return type;
}
static int filter_cmp(const void *a, const void *b)
{
const struct filter_type *ea = a;
const struct filter_type *eb = b;
if (ea->event_id < eb->event_id)
return -1;
if (ea->event_id > eb->event_id)
return 1;
return 0;
}
static struct filter_type *
find_filter_type(struct event_filter *filter, int id)
{
struct filter_type *filter_type;
struct filter_type key;
key.event_id = id;
filter_type = bsearch(&key, filter->event_filters,
filter->filters,
sizeof(*filter->event_filters),
filter_cmp);
return filter_type;
}
static struct filter_type *
add_filter_type(struct event_filter *filter, int id)
{
struct filter_type *filter_type;
int i;
filter_type = find_filter_type(filter, id);
if (filter_type)
return filter_type;
if (!filter->filters)
filter->event_filters =
malloc_or_die(sizeof(*filter->event_filters));
else {
filter->event_filters =
realloc(filter->event_filters,
sizeof(*filter->event_filters) *
(filter->filters + 1));
if (!filter->event_filters)
die("Could not allocate filter");
}
for (i = 0; i < filter->filters; i++) {
if (filter->event_filters[i].event_id > id)
break;
}
if (i < filter->filters)
memmove(&filter->event_filters[i+1],
&filter->event_filters[i],
sizeof(*filter->event_filters) *
(filter->filters - i));
filter_type = &filter->event_filters[i];
filter_type->event_id = id;
filter_type->event = pevent_find_event(filter->pevent, id);
filter_type->filter = NULL;
filter->filters++;
return filter_type;
}
/**
* pevent_filter_alloc - create a new event filter
* @pevent: The pevent that this filter is associated with
*/
struct event_filter *pevent_filter_alloc(struct pevent *pevent)
{
struct event_filter *filter;
filter = malloc_or_die(sizeof(*filter));
memset(filter, 0, sizeof(*filter));
filter->pevent = pevent;
pevent_ref(pevent);
return filter;
}
static struct filter_arg *allocate_arg(void)
{
struct filter_arg *arg;
arg = malloc_or_die(sizeof(*arg));
memset(arg, 0, sizeof(*arg));
return arg;
}
static void free_arg(struct filter_arg *arg)
{
if (!arg)
return;
switch (arg->type) {
case FILTER_ARG_NONE:
case FILTER_ARG_BOOLEAN:
case FILTER_ARG_NUM:
break;
case FILTER_ARG_STR:
free(arg->str.val);
regfree(&arg->str.reg);
free(arg->str.buffer);
break;
case FILTER_ARG_OP:
free_arg(arg->op.left);
free_arg(arg->op.right);
default:
break;
}
free(arg);
}
static void add_event(struct event_list **events,
struct event_format *event)
{
struct event_list *list;
list = malloc_or_die(sizeof(*list));
list->next = *events;
*events = list;
list->event = event;
}
static int event_match(struct event_format *event,
regex_t *sreg, regex_t *ereg)
{
if (sreg) {
return !regexec(sreg, event->system, 0, NULL, 0) &&
!regexec(ereg, event->name, 0, NULL, 0);
}
return !regexec(ereg, event->system, 0, NULL, 0) ||
!regexec(ereg, event->name, 0, NULL, 0);
}
static int
find_event(struct pevent *pevent, struct event_list **events,
char *sys_name, char *event_name)
{
struct event_format *event;
regex_t ereg;
regex_t sreg;
int match = 0;
char *reg;
int ret;
int i;
if (!event_name) {
/* if no name is given, then swap sys and name */
event_name = sys_name;
sys_name = NULL;
}
reg = malloc_or_die(strlen(event_name) + 3);
sprintf(reg, "^%s$", event_name);
ret = regcomp(&ereg, reg, REG_ICASE|REG_NOSUB);
free(reg);
if (ret)
return -1;
if (sys_name) {
reg = malloc_or_die(strlen(sys_name) + 3);
sprintf(reg, "^%s$", sys_name);
ret = regcomp(&sreg, reg, REG_ICASE|REG_NOSUB);
free(reg);
if (ret) {
regfree(&ereg);
return -1;
}
}
for (i = 0; i < pevent->nr_events; i++) {
event = pevent->events[i];
if (event_match(event, sys_name ? &sreg : NULL, &ereg)) {
match = 1;
add_event(events, event);
}
}
regfree(&ereg);
if (sys_name)
regfree(&sreg);
if (!match)
return -1;
return 0;
}
static void free_events(struct event_list *events)
{
struct event_list *event;
while (events) {
event = events;
events = events->next;
free(event);
}
}
static struct filter_arg *
create_arg_item(struct event_format *event,
const char *token, enum filter_arg_type type,
char **error_str)
{
struct format_field *field;
struct filter_arg *arg;
arg = allocate_arg();
switch (type) {
case EVENT_SQUOTE:
case EVENT_DQUOTE:
arg->type = FILTER_ARG_VALUE;
arg->value.type =
type == EVENT_DQUOTE ? FILTER_STRING : FILTER_CHAR;
arg->value.str = strdup(token);
if (!arg->value.str)
die("malloc string");
break;
case EVENT_ITEM:
/* if it is a number, then convert it */
if (isdigit(token[0])) {
arg->type = FILTER_ARG_VALUE;
arg->value.type = FILTER_NUMBER;
arg->value.val = strtoull(token, NULL, 0);
break;
}
/* Consider this a field */
field = pevent_find_any_field(event, token);
if (!field) {
if (strcmp(token, COMM) != 0) {
/* not a field, Make it false */
arg->type = FILTER_ARG_BOOLEAN;
arg->boolean.value = FILTER_FALSE;
break;
}
/* If token is 'COMM' then it is special */
field = &comm;
}
arg->type = FILTER_ARG_FIELD;
arg->field.field = field;
break;
default:
free_arg(arg);
show_error(error_str, "expected a value but found %s",
token);
return NULL;
}
return arg;
}
static struct filter_arg *
create_arg_op(enum filter_op_type btype)
{
struct filter_arg *arg;
arg = allocate_arg();
arg->type = FILTER_ARG_OP;
arg->op.type = btype;
return arg;
}
static struct filter_arg *
create_arg_exp(enum filter_exp_type etype)
{
struct filter_arg *arg;
arg = allocate_arg();
arg->type = FILTER_ARG_EXP;
arg->op.type = etype;
return arg;
}
static struct filter_arg *
create_arg_cmp(enum filter_exp_type etype)
{
struct filter_arg *arg;
arg = allocate_arg();
/* Use NUM and change if necessary */
arg->type = FILTER_ARG_NUM;
arg->op.type = etype;
return arg;
}
static int add_right(struct filter_arg *op, struct filter_arg *arg,
char **error_str)
{
struct filter_arg *left;
char *str;
int op_type;
int ret;
switch (op->type) {
case FILTER_ARG_EXP:
if (op->exp.right)
goto out_fail;
op->exp.right = arg;
break;
case FILTER_ARG_OP:
if (op->op.right)
goto out_fail;
op->op.right = arg;
break;
case FILTER_ARG_NUM:
if (op->op.right)
goto out_fail;
/*
* The arg must be num, str, or field
*/
switch (arg->type) {
case FILTER_ARG_VALUE:
case FILTER_ARG_FIELD:
break;
default:
show_error(error_str,
"Illegal rvalue");
return -1;
}
/*
* Depending on the type, we may need to
* convert this to a string or regex.
*/
switch (arg->value.type) {
case FILTER_CHAR:
/*
* A char should be converted to number if
* the string is 1 byte, and the compare
* is not a REGEX.
*/
if (strlen(arg->value.str) == 1 &&
op->num.type != FILTER_CMP_REGEX &&
op->num.type != FILTER_CMP_NOT_REGEX) {
arg->value.type = FILTER_NUMBER;
goto do_int;
}
/* fall through */
case FILTER_STRING:
/* convert op to a string arg */
op_type = op->num.type;
left = op->num.left;
str = arg->value.str;
/* reset the op for the new field */
memset(op, 0, sizeof(*op));
/*
* If left arg was a field not found then
* NULL the entire op.
*/
if (left->type == FILTER_ARG_BOOLEAN) {
free_arg(left);
free_arg(arg);
op->type = FILTER_ARG_BOOLEAN;
op->boolean.value = FILTER_FALSE;
break;
}
/* Left arg must be a field */
if (left->type != FILTER_ARG_FIELD) {
show_error(error_str,
"Illegal lvalue for string comparison");
return -1;
}
/* Make sure this is a valid string compare */
switch (op_type) {
case FILTER_CMP_EQ:
op_type = FILTER_CMP_MATCH;
break;
case FILTER_CMP_NE:
op_type = FILTER_CMP_NOT_MATCH;
break;
case FILTER_CMP_REGEX:
case FILTER_CMP_NOT_REGEX:
ret = regcomp(&op->str.reg, str, REG_ICASE|REG_NOSUB);
if (ret) {
show_error(error_str,
"RegEx '%s' did not compute",
str);
return -1;
}
break;
default:
show_error(error_str,
"Illegal comparison for string");
return -1;
}
op->type = FILTER_ARG_STR;
op->str.type = op_type;
op->str.field = left->field.field;
op->str.val = strdup(str);
if (!op->str.val)
die("malloc string");
/*
* Need a buffer to copy data for tests
*/
op->str.buffer = malloc_or_die(op->str.field->size + 1);
/* Null terminate this buffer */
op->str.buffer[op->str.field->size] = 0;
/* We no longer have left or right args */
free_arg(arg);
free_arg(left);
break;
case FILTER_NUMBER:
do_int:
switch (op->num.type) {
case FILTER_CMP_REGEX:
case FILTER_CMP_NOT_REGEX:
show_error(error_str,
"Op not allowed with integers");
return -1;
default:
break;
}
/* numeric compare */
op->num.right = arg;
break;
default:
goto out_fail;
}
break;
default:
goto out_fail;
}
return 0;
out_fail:
show_error(error_str,
"Syntax error");
return -1;
}
static struct filter_arg *
rotate_op_right(struct filter_arg *a, struct filter_arg *b)
{
struct filter_arg *arg;
arg = a->op.right;
a->op.right = b;
return arg;
}
static int add_left(struct filter_arg *op, struct filter_arg *arg)
{
switch (op->type) {
case FILTER_ARG_EXP:
if (arg->type == FILTER_ARG_OP)
arg = rotate_op_right(arg, op);
op->exp.left = arg;
break;
case FILTER_ARG_OP:
op->op.left = arg;
break;
case FILTER_ARG_NUM:
if (arg->type == FILTER_ARG_OP)
arg = rotate_op_right(arg, op);
/* left arg of compares must be a field */
if (arg->type != FILTER_ARG_FIELD &&
arg->type != FILTER_ARG_BOOLEAN)
return -1;
op->num.left = arg;
break;
default:
return -1;
}
return 0;
}
enum op_type {
OP_NONE,
OP_BOOL,
OP_NOT,
OP_EXP,
OP_CMP,
};
static enum op_type process_op(const char *token,
enum filter_op_type *btype,
enum filter_cmp_type *ctype,
enum filter_exp_type *etype)
{
*btype = FILTER_OP_NOT;
*etype = FILTER_EXP_NONE;
*ctype = FILTER_CMP_NONE;
if (strcmp(token, "&&") == 0)
*btype = FILTER_OP_AND;
else if (strcmp(token, "||") == 0)
*btype = FILTER_OP_OR;
else if (strcmp(token, "!") == 0)
return OP_NOT;
if (*btype != FILTER_OP_NOT)
return OP_BOOL;
/* Check for value expressions */
if (strcmp(token, "+") == 0) {
*etype = FILTER_EXP_ADD;
} else if (strcmp(token, "-") == 0) {
*etype = FILTER_EXP_SUB;
} else if (strcmp(token, "*") == 0) {
*etype = FILTER_EXP_MUL;
} else if (strcmp(token, "/") == 0) {
*etype = FILTER_EXP_DIV;
} else if (strcmp(token, "%") == 0) {
*etype = FILTER_EXP_MOD;
} else if (strcmp(token, ">>") == 0) {
*etype = FILTER_EXP_RSHIFT;
} else if (strcmp(token, "<<") == 0) {
*etype = FILTER_EXP_LSHIFT;
} else if (strcmp(token, "&") == 0) {
*etype = FILTER_EXP_AND;
} else if (strcmp(token, "|") == 0) {
*etype = FILTER_EXP_OR;
} else if (strcmp(token, "^") == 0) {
*etype = FILTER_EXP_XOR;
} else if (strcmp(token, "~") == 0)
*etype = FILTER_EXP_NOT;
if (*etype != FILTER_EXP_NONE)
return OP_EXP;
/* Check for compares */
if (strcmp(token, "==") == 0)
*ctype = FILTER_CMP_EQ;
else if (strcmp(token, "!=") == 0)
*ctype = FILTER_CMP_NE;
else if (strcmp(token, "<") == 0)
*ctype = FILTER_CMP_LT;
else if (strcmp(token, ">") == 0)
*ctype = FILTER_CMP_GT;
else if (strcmp(token, "<=") == 0)
*ctype = FILTER_CMP_LE;
else if (strcmp(token, ">=") == 0)
*ctype = FILTER_CMP_GE;
else if (strcmp(token, "=~") == 0)
*ctype = FILTER_CMP_REGEX;
else if (strcmp(token, "!~") == 0)
*ctype = FILTER_CMP_NOT_REGEX;
else
return OP_NONE;
return OP_CMP;
}
static int check_op_done(struct filter_arg *arg)
{
switch (arg->type) {
case FILTER_ARG_EXP:
return arg->exp.right != NULL;
case FILTER_ARG_OP:
return arg->op.right != NULL;
case FILTER_ARG_NUM:
return arg->num.right != NULL;
case FILTER_ARG_STR:
/* A string conversion is always done */
return 1;
case FILTER_ARG_BOOLEAN:
/* field not found, is ok */
return 1;
default:
return 0;
}
}
enum filter_vals {
FILTER_VAL_NORM,
FILTER_VAL_FALSE,
FILTER_VAL_TRUE,
};
void reparent_op_arg(struct filter_arg *parent, struct filter_arg *old_child,
struct filter_arg *arg)
{
struct filter_arg *other_child;
struct filter_arg **ptr;
if (parent->type != FILTER_ARG_OP &&
arg->type != FILTER_ARG_OP)
die("can not reparent other than OP");
/* Get the sibling */
if (old_child->op.right == arg) {
ptr = &old_child->op.right;
other_child = old_child->op.left;
} else if (old_child->op.left == arg) {
ptr = &old_child->op.left;
other_child = old_child->op.right;
} else
die("Error in reparent op, find other child");
/* Detach arg from old_child */
*ptr = NULL;
/* Check for root */
if (parent == old_child) {
free_arg(other_child);
*parent = *arg;
/* Free arg without recussion */
free(arg);
return;
}
if (parent->op.right == old_child)
ptr = &parent->op.right;
else if (parent->op.left == old_child)
ptr = &parent->op.left;
else
die("Error in reparent op");
*ptr = arg;
free_arg(old_child);
}
enum filter_vals test_arg(struct filter_arg *parent, struct filter_arg *arg)
{
enum filter_vals lval, rval;
switch (arg->type) {
/* bad case */
case FILTER_ARG_BOOLEAN:
return FILTER_VAL_FALSE + arg->boolean.value;
/* good cases: */
case FILTER_ARG_STR:
case FILTER_ARG_VALUE:
case FILTER_ARG_FIELD:
return FILTER_VAL_NORM;
case FILTER_ARG_EXP:
lval = test_arg(arg, arg->exp.left);
if (lval != FILTER_VAL_NORM)
return lval;
rval = test_arg(arg, arg->exp.right);
if (rval != FILTER_VAL_NORM)
return rval;
return FILTER_VAL_NORM;
case FILTER_ARG_NUM:
lval = test_arg(arg, arg->num.left);
if (lval != FILTER_VAL_NORM)
return lval;
rval = test_arg(arg, arg->num.right);
if (rval != FILTER_VAL_NORM)
return rval;
return FILTER_VAL_NORM;
case FILTER_ARG_OP:
if (arg->op.type != FILTER_OP_NOT) {
lval = test_arg(arg, arg->op.left);
switch (lval) {
case FILTER_VAL_NORM:
break;
case FILTER_VAL_TRUE:
if (arg->op.type == FILTER_OP_OR)
return FILTER_VAL_TRUE;
rval = test_arg(arg, arg->op.right);
if (rval != FILTER_VAL_NORM)
return rval;
reparent_op_arg(parent, arg, arg->op.right);
return FILTER_VAL_NORM;
case FILTER_VAL_FALSE:
if (arg->op.type == FILTER_OP_AND)
return FILTER_VAL_FALSE;
rval = test_arg(arg, arg->op.right);
if (rval != FILTER_VAL_NORM)
return rval;
reparent_op_arg(parent, arg, arg->op.right);
return FILTER_VAL_NORM;
}
}
rval = test_arg(arg, arg->op.right);
switch (rval) {
case FILTER_VAL_NORM:
break;
case FILTER_VAL_TRUE:
if (arg->op.type == FILTER_OP_OR)
return FILTER_VAL_TRUE;
if (arg->op.type == FILTER_OP_NOT)
return FILTER_VAL_FALSE;
reparent_op_arg(parent, arg, arg->op.left);
return FILTER_VAL_NORM;
case FILTER_VAL_FALSE:
if (arg->op.type == FILTER_OP_AND)
return FILTER_VAL_FALSE;
if (arg->op.type == FILTER_OP_NOT)
return FILTER_VAL_TRUE;
reparent_op_arg(parent, arg, arg->op.left);
return FILTER_VAL_NORM;
}
return FILTER_VAL_NORM;
default:
die("bad arg in filter tree");
}
return FILTER_VAL_NORM;
}
/* Remove any unknown event fields */
static struct filter_arg *collapse_tree(struct filter_arg *arg)
{
enum filter_vals ret;
ret = test_arg(arg, arg);
switch (ret) {
case FILTER_VAL_NORM:
return arg;
case FILTER_VAL_TRUE:
case FILTER_VAL_FALSE:
free_arg(arg);
arg = allocate_arg();
arg->type = FILTER_ARG_BOOLEAN;
arg->boolean.value = ret == FILTER_VAL_TRUE;
}
return arg;
}
static int
process_filter(struct event_format *event, struct filter_arg **parg,
char **error_str, int not)
{
enum event_type type;
char *token = NULL;
struct filter_arg *current_op = NULL;
struct filter_arg *current_exp = NULL;
struct filter_arg *left_item = NULL;
struct filter_arg *arg = NULL;
enum op_type op_type;
enum filter_op_type btype;
enum filter_exp_type etype;
enum filter_cmp_type ctype;
int ret;
*parg = NULL;
do {
free(token);
type = read_token(&token);
switch (type) {
case EVENT_SQUOTE:
case EVENT_DQUOTE:
case EVENT_ITEM:
arg = create_arg_item(event, token, type, error_str);
if (!arg)
goto fail;
if (!left_item)
left_item = arg;
else if (current_exp) {
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
left_item = NULL;
/* Not's only one one expression */
if (not) {
arg = NULL;
if (current_op)
goto fail_print;
free(token);
*parg = current_exp;
return 0;
}
} else
goto fail_print;
arg = NULL;
break;
case EVENT_DELIM:
if (*token == ',') {
show_error(error_str,
"Illegal token ','");
goto fail;
}
if (*token == '(') {
if (left_item) {
show_error(error_str,
"Open paren can not come after item");
goto fail;
}
if (current_exp) {
show_error(error_str,
"Open paren can not come after expression");
goto fail;
}
ret = process_filter(event, &arg, error_str, 0);
if (ret != 1) {
if (ret == 0)
show_error(error_str,
"Unbalanced number of '('");
goto fail;
}
ret = 0;
/* A not wants just one expression */
if (not) {
if (current_op)
goto fail_print;
*parg = arg;
return 0;
}
if (current_op)
ret = add_right(current_op, arg, error_str);
else
current_exp = arg;
if (ret < 0)
goto fail;
} else { /* ')' */
if (!current_op && !current_exp)
goto fail_print;
/* Make sure everything is finished at this level */
if (current_exp && !check_op_done(current_exp))
goto fail_print;
if (current_op && !check_op_done(current_op))
goto fail_print;
if (current_op)
*parg = current_op;
else
*parg = current_exp;
return 1;
}
break;
case EVENT_OP:
op_type = process_op(token, &btype, &ctype, &etype);
/* All expect a left arg except for NOT */
switch (op_type) {
case OP_BOOL:
/* Logic ops need a left expression */
if (!current_exp && !current_op)
goto fail_print;
/* fall through */
case OP_NOT:
/* logic only processes ops and exp */
if (left_item)
goto fail_print;
break;
case OP_EXP:
case OP_CMP:
if (!left_item)
goto fail_print;
break;
case OP_NONE:
show_error(error_str,
"Unknown op token %s", token);
goto fail;
}
ret = 0;
switch (op_type) {
case OP_BOOL:
arg = create_arg_op(btype);
if (current_op)
ret = add_left(arg, current_op);
else
ret = add_left(arg, current_exp);
current_op = arg;
current_exp = NULL;
break;
case OP_NOT:
arg = create_arg_op(btype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
current_exp = arg;
ret = process_filter(event, &arg, error_str, 1);
if (ret < 0)
goto fail;
ret = add_right(current_exp, arg, error_str);
if (ret < 0)
goto fail;
break;
case OP_EXP:
case OP_CMP:
if (op_type == OP_EXP)
arg = create_arg_exp(etype);
else
arg = create_arg_cmp(ctype);
if (current_op)
ret = add_right(current_op, arg, error_str);
if (ret < 0)
goto fail;
ret = add_left(arg, left_item);
if (ret < 0) {
arg = NULL;
goto fail_print;
}
current_exp = arg;
break;
default:
break;
}
arg = NULL;
if (ret < 0)
goto fail_print;
break;
case EVENT_NONE:
break;
default:
goto fail_print;
}
} while (type != EVENT_NONE);
if (!current_op && !current_exp)
goto fail_print;
if (!current_op)
current_op = current_exp;
current_op = collapse_tree(current_op);
*parg = current_op;
return 0;
fail_print:
show_error(error_str, "Syntax error");
fail:
free_arg(current_op);
free_arg(current_exp);
free_arg(arg);
free(token);
return -1;
}
static int
process_event(struct event_format *event, const char *filter_str,
struct filter_arg **parg, char **error_str)
{
int ret;
pevent_buffer_init(filter_str, strlen(filter_str));
ret = process_filter(event, parg, error_str, 0);
if (ret == 1) {
show_error(error_str,
"Unbalanced number of ')'");
return -1;
}
if (ret < 0)
return ret;
/* If parg is NULL, then make it into FALSE */
if (!*parg) {
*parg = allocate_arg();
(*parg)->type = FILTER_ARG_BOOLEAN;
(*parg)->boolean.value = FILTER_FALSE;
}
return 0;
}
static int filter_event(struct event_filter *filter,
struct event_format *event,
const char *filter_str, char **error_str)
{
struct filter_type *filter_type;
struct filter_arg *arg;
int ret;
if (filter_str) {
ret = process_event(event, filter_str, &arg, error_str);
if (ret < 0)
return ret;
} else {
/* just add a TRUE arg */
arg = allocate_arg();
arg->type = FILTER_ARG_BOOLEAN;
arg->boolean.value = FILTER_TRUE;
}
filter_type = add_filter_type(filter, event->id);
if (filter_type->filter)
free_arg(filter_type->filter);
filter_type->filter = arg;
return 0;
}
/**
* pevent_filter_add_filter_str - add a new filter
* @filter: the event filter to add to
* @filter_str: the filter string that contains the filter
* @error_str: string containing reason for failed filter
*
* Returns 0 if the filter was successfully added
* -1 if there was an error.
*
* On error, if @error_str points to a string pointer,
* it is set to the reason that the filter failed.
* This string must be freed with "free".
*/
int pevent_filter_add_filter_str(struct event_filter *filter,
const char *filter_str,
char **error_str)
{
struct pevent *pevent = filter->pevent;
struct event_list *event;
struct event_list *events = NULL;
const char *filter_start;
const char *next_event;
char *this_event;
char *event_name = NULL;
char *sys_name = NULL;
char *sp;
int rtn = 0;
int len;
int ret;
/* clear buffer to reset show error */
pevent_buffer_init("", 0);
if (error_str)
*error_str = NULL;
filter_start = strchr(filter_str, ':');
if (filter_start)
len = filter_start - filter_str;
else
len = strlen(filter_str);
do {
next_event = strchr(filter_str, ',');
if (next_event &&
(!filter_start || next_event < filter_start))
len = next_event - filter_str;
else if (filter_start)
len = filter_start - filter_str;
else
len = strlen(filter_str);
this_event = malloc_or_die(len + 1);
memcpy(this_event, filter_str, len);
this_event[len] = 0;
if (next_event)
next_event++;
filter_str = next_event;
sys_name = strtok_r(this_event, "/", &sp);
event_name = strtok_r(NULL, "/", &sp);
if (!sys_name) {
show_error(error_str, "No filter found");
/* This can only happen when events is NULL, but still */
free_events(events);
free(this_event);
return -1;
}
/* Find this event */
ret = find_event(pevent, &events, strim(sys_name), strim(event_name));
if (ret < 0) {
if (event_name)
show_error(error_str,
"No event found under '%s.%s'",
sys_name, event_name);
else
show_error(error_str,
"No event found under '%s'",
sys_name);
free_events(events);
free(this_event);
return -1;
}
free(this_event);
} while (filter_str);
/* Skip the ':' */
if (filter_start)
filter_start++;
/* filter starts here */
for (event = events; event; event = event->next) {
ret = filter_event(filter, event->event, filter_start,
error_str);
/* Failures are returned if a parse error happened */
if (ret < 0)
rtn = ret;
if (ret >= 0 && pevent->test_filters) {
char *test;
test = pevent_filter_make_string(filter, event->event->id);
printf(" '%s: %s'\n", event->event->name, test);
free(test);
}
}
free_events(events);
if (rtn >= 0 && pevent->test_filters)
exit(0);
return rtn;
}
static void free_filter_type(struct filter_type *filter_type)
{
free_arg(filter_type->filter);
}
/**
* pevent_filter_remove_event - remove a filter for an event
* @filter: the event filter to remove from
* @event_id: the event to remove a filter for
*
* Removes the filter saved for an event defined by @event_id
* from the @filter.
*
* Returns 1: if an event was removed
* 0: if the event was not found
*/
int pevent_filter_remove_event(struct event_filter *filter,
int event_id)
{
struct filter_type *filter_type;
unsigned long len;
if (!filter->filters)
return 0;
filter_type = find_filter_type(filter, event_id);
if (!filter_type)
return 0;
free_filter_type(filter_type);
/* The filter_type points into the event_filters array */
len = (unsigned long)(filter->event_filters + filter->filters) -
(unsigned long)(filter_type + 1);
memmove(filter_type, filter_type + 1, len);
filter->filters--;
memset(&filter->event_filters[filter->filters], 0,
sizeof(*filter_type));
return 1;
}
/**
* pevent_filter_reset - clear all filters in a filter
* @filter: the event filter to reset
*
* Removes all filters from a filter and resets it.
*/
void pevent_filter_reset(struct event_filter *filter)
{
int i;
for (i = 0; i < filter->filters; i++)
free_filter_type(&filter->event_filters[i]);
free(filter->event_filters);
filter->filters = 0;
filter->event_filters = NULL;
}
void pevent_filter_free(struct event_filter *filter)
{
pevent_unref(filter->pevent);
pevent_filter_reset(filter);
free(filter);
}
static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg);
static int copy_filter_type(struct event_filter *filter,
struct event_filter *source,
struct filter_type *filter_type)
{
struct filter_arg *arg;
struct event_format *event;
const char *sys;
const char *name;
char *str;
/* Can't assume that the pevent's are the same */
sys = filter_type->event->system;
name = filter_type->event->name;
event = pevent_find_event_by_name(filter->pevent, sys, name);
if (!event)
return -1;
str = arg_to_str(source, filter_type->filter);
if (!str)
return -1;
if (strcmp(str, "TRUE") == 0 || strcmp(str, "FALSE") == 0) {
/* Add trivial event */
arg = allocate_arg();
arg->type = FILTER_ARG_BOOLEAN;
if (strcmp(str, "TRUE") == 0)
arg->boolean.value = 1;
else
arg->boolean.value = 0;
filter_type = add_filter_type(filter, event->id);
filter_type->filter = arg;
free(str);
return 0;
}
filter_event(filter, event, str, NULL);
free(str);
return 0;
}
/**
* pevent_filter_copy - copy a filter using another filter
* @dest - the filter to copy to
* @source - the filter to copy from
*
* Returns 0 on success and -1 if not all filters were copied
*/
int pevent_filter_copy(struct event_filter *dest, struct event_filter *source)
{
int ret = 0;
int i;
pevent_filter_reset(dest);
for (i = 0; i < source->filters; i++) {
if (copy_filter_type(dest, source, &source->event_filters[i]))
ret = -1;
}
return ret;
}
/**
* pevent_update_trivial - update the trivial filters with the given filter
* @dest - the filter to update
* @source - the filter as the source of the update
* @type - the type of trivial filter to update.
*
* Scan dest for trivial events matching @type to replace with the source.
*
* Returns 0 on success and -1 if there was a problem updating, but
* events may have still been updated on error.
*/
int pevent_update_trivial(struct event_filter *dest, struct event_filter *source,
enum filter_trivial_type type)
{
struct pevent *src_pevent;
struct pevent *dest_pevent;
struct event_format *event;
struct filter_type *filter_type;
struct filter_arg *arg;
char *str;
int i;
src_pevent = source->pevent;
dest_pevent = dest->pevent;
/* Do nothing if either of the filters has nothing to filter */
if (!dest->filters || !source->filters)
return 0;
for (i = 0; i < dest->filters; i++) {
filter_type = &dest->event_filters[i];
arg = filter_type->filter;
if (arg->type != FILTER_ARG_BOOLEAN)
continue;
if ((arg->boolean.value && type == FILTER_TRIVIAL_FALSE) ||
(!arg->boolean.value && type == FILTER_TRIVIAL_TRUE))
continue;
event = filter_type->event;
if (src_pevent != dest_pevent) {
/* do a look up */
event = pevent_find_event_by_name(src_pevent,
event->system,
event->name);
if (!event)
return -1;
}
str = pevent_filter_make_string(source, event->id);
if (!str)
continue;
/* Don't bother if the filter is trivial too */
if (strcmp(str, "TRUE") != 0 && strcmp(str, "FALSE") != 0)
filter_event(dest, event, str, NULL);
free(str);
}
return 0;
}
/**
* pevent_filter_clear_trivial - clear TRUE and FALSE filters
* @filter: the filter to remove trivial filters from
* @type: remove only true, false, or both
*
* Removes filters that only contain a TRUE or FALES boolean arg.
*/
void pevent_filter_clear_trivial(struct event_filter *filter,
enum filter_trivial_type type)
{
struct filter_type *filter_type;
int count = 0;
int *ids;
int i;
if (!filter->filters)
return;
/*
* Two steps, first get all ids with trivial filters.
* then remove those ids.
*/
for (i = 0; i < filter->filters; i++) {
filter_type = &filter->event_filters[i];
if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
continue;
switch (type) {
case FILTER_TRIVIAL_FALSE:
if (filter_type->filter->boolean.value)
continue;
case FILTER_TRIVIAL_TRUE:
if (!filter_type->filter->boolean.value)
continue;
default:
break;
}
if (count)
ids = realloc(ids, sizeof(*ids) * (count + 1));
else
ids = malloc(sizeof(*ids));
if (!ids)
die("Can't allocate ids");
ids[count++] = filter_type->event_id;
}
if (!count)
return;
for (i = 0; i < count; i++)
pevent_filter_remove_event(filter, ids[i]);
free(ids);
}
/**
* pevent_filter_event_has_trivial - return true event contains trivial filter
* @filter: the filter with the information
* @event_id: the id of the event to test
* @type: trivial type to test for (TRUE, FALSE, EITHER)
*
* Returns 1 if the event contains a matching trivial type
* otherwise 0.
*/
int pevent_filter_event_has_trivial(struct event_filter *filter,
int event_id,
enum filter_trivial_type type)
{
struct filter_type *filter_type;
if (!filter->filters)
return 0;
filter_type = find_filter_type(filter, event_id);
if (!filter_type)
return 0;
if (filter_type->filter->type != FILTER_ARG_BOOLEAN)
return 0;
switch (type) {
case FILTER_TRIVIAL_FALSE:
return !filter_type->filter->boolean.value;
case FILTER_TRIVIAL_TRUE:
return filter_type->filter->boolean.value;
default:
return 1;
}
}
static int test_filter(struct event_format *event,
struct filter_arg *arg, struct pevent_record *record);
static const char *
get_comm(struct event_format *event, struct pevent_record *record)
{
const char *comm;
int pid;
pid = pevent_data_pid(event->pevent, record);
comm = pevent_data_comm_from_pid(event->pevent, pid);
return comm;
}
static unsigned long long
get_value(struct event_format *event,
struct format_field *field, struct pevent_record *record)
{
unsigned long long val;
/* Handle our dummy "comm" field */
if (field == &comm) {
const char *name;
name = get_comm(event, record);
return (unsigned long long)name;
}
pevent_read_number_field(field, record->data, &val);
if (!(field->flags & FIELD_IS_SIGNED))
return val;
switch (field->size) {
case 1:
return (char)val;
case 2:
return (short)val;
case 4:
return (int)val;
case 8:
return (long long)val;
}
return val;
}
static unsigned long long
get_arg_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record);
static unsigned long long
get_exp_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record)
{
unsigned long long lval, rval;
lval = get_arg_value(event, arg->exp.left, record);
rval = get_arg_value(event, arg->exp.right, record);
switch (arg->exp.type) {
case FILTER_EXP_ADD:
return lval + rval;
case FILTER_EXP_SUB:
return lval - rval;
case FILTER_EXP_MUL:
return lval * rval;
case FILTER_EXP_DIV:
return lval / rval;
case FILTER_EXP_MOD:
return lval % rval;
case FILTER_EXP_RSHIFT:
return lval >> rval;
case FILTER_EXP_LSHIFT:
return lval << rval;
case FILTER_EXP_AND:
return lval & rval;
case FILTER_EXP_OR:
return lval | rval;
case FILTER_EXP_XOR:
return lval ^ rval;
case FILTER_EXP_NOT:
default:
die("error in exp");
}
return 0;
}
static unsigned long long
get_arg_value(struct event_format *event, struct filter_arg *arg, struct pevent_record *record)
{
switch (arg->type) {
case FILTER_ARG_FIELD:
return get_value(event, arg->field.field, record);
case FILTER_ARG_VALUE:
if (arg->value.type != FILTER_NUMBER)
die("must have number field!");
return arg->value.val;
case FILTER_ARG_EXP:
return get_exp_value(event, arg, record);
default:
die("oops in filter");
}
return 0;
}
static int test_num(struct event_format *event,
struct filter_arg *arg, struct pevent_record *record)
{
unsigned long long lval, rval;
lval = get_arg_value(event, arg->num.left, record);
rval = get_arg_value(event, arg->num.right, record);
switch (arg->num.type) {
case FILTER_CMP_EQ:
return lval == rval;
case FILTER_CMP_NE:
return lval != rval;
case FILTER_CMP_GT:
return lval > rval;
case FILTER_CMP_LT:
return lval < rval;
case FILTER_CMP_GE:
return lval >= rval;
case FILTER_CMP_LE:
return lval <= rval;
default:
/* ?? */
return 0;
}
}
static const char *get_field_str(struct filter_arg *arg, struct pevent_record *record)
{
const char *val = record->data + arg->str.field->offset;
/*
* We need to copy the data since we can't be sure the field
* is null terminated.
*/
if (*(val + arg->str.field->size - 1)) {
/* copy it */
memcpy(arg->str.buffer, val, arg->str.field->size);
/* the buffer is already NULL terminated */
val = arg->str.buffer;
}
return val;
}
static int test_str(struct event_format *event,
struct filter_arg *arg, struct pevent_record *record)
{
const char *val;
if (arg->str.field == &comm)
val = get_comm(event, record);
else
val = get_field_str(arg, record);
switch (arg->str.type) {
case FILTER_CMP_MATCH:
return strcmp(val, arg->str.val) == 0;
case FILTER_CMP_NOT_MATCH:
return strcmp(val, arg->str.val) != 0;
case FILTER_CMP_REGEX:
/* Returns zero on match */
return !regexec(&arg->str.reg, val, 0, NULL, 0);
case FILTER_CMP_NOT_REGEX:
return regexec(&arg->str.reg, val, 0, NULL, 0);
default:
/* ?? */
return 0;
}
}
static int test_op(struct event_format *event,
struct filter_arg *arg, struct pevent_record *record)
{
switch (arg->op.type) {
case FILTER_OP_AND:
return test_filter(event, arg->op.left, record) &&
test_filter(event, arg->op.right, record);
case FILTER_OP_OR:
return test_filter(event, arg->op.left, record) ||
test_filter(event, arg->op.right, record);
case FILTER_OP_NOT:
return !test_filter(event, arg->op.right, record);
default:
/* ?? */
return 0;
}
}
static int test_filter(struct event_format *event,
struct filter_arg *arg, struct pevent_record *record)
{
switch (arg->type) {
case FILTER_ARG_BOOLEAN:
/* easy case */
return arg->boolean.value;
case FILTER_ARG_OP:
return test_op(event, arg, record);
case FILTER_ARG_NUM:
return test_num(event, arg, record);
case FILTER_ARG_STR:
return test_str(event, arg, record);
case FILTER_ARG_EXP:
case FILTER_ARG_VALUE:
case FILTER_ARG_FIELD:
/*
* Expressions, fields and values evaluate
* to true if they return non zero
*/
return !!get_arg_value(event, arg, record);
default:
die("oops!");
/* ?? */
return 0;
}
}
/**
* pevent_event_filtered - return true if event has filter
* @filter: filter struct with filter information
* @event_id: event id to test if filter exists
*
* Returns 1 if filter found for @event_id
* otherwise 0;
*/
int pevent_event_filtered(struct event_filter *filter,
int event_id)
{
struct filter_type *filter_type;
if (!filter->filters)
return 0;
filter_type = find_filter_type(filter, event_id);
return filter_type ? 1 : 0;
}
/**
* pevent_filter_match - test if a record matches a filter
* @filter: filter struct with filter information
* @record: the record to test against the filter
*
* Returns:
* 1 - filter found for event and @record matches
* 0 - filter found for event and @record does not match
* -1 - no filter found for @record's event
* -2 - if no filters exist
*/
int pevent_filter_match(struct event_filter *filter,
struct pevent_record *record)
{
struct pevent *pevent = filter->pevent;
struct filter_type *filter_type;
int event_id;
if (!filter->filters)
return FILTER_NONE;
event_id = pevent_data_type(pevent, record);
filter_type = find_filter_type(filter, event_id);
if (!filter_type)
return FILTER_NOEXIST;
return test_filter(filter_type->event, filter_type->filter, record) ?
FILTER_MATCH : FILTER_MISS;
}
static char *op_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *str = NULL;
char *left = NULL;
char *right = NULL;
char *op = NULL;
int left_val = -1;
int right_val = -1;
int val;
int len;
switch (arg->op.type) {
case FILTER_OP_AND:
op = "&&";
/* fall through */
case FILTER_OP_OR:
if (!op)
op = "||";
left = arg_to_str(filter, arg->op.left);
right = arg_to_str(filter, arg->op.right);
if (!left || !right)
break;
/* Try to consolidate boolean values */
if (strcmp(left, "TRUE") == 0)
left_val = 1;
else if (strcmp(left, "FALSE") == 0)
left_val = 0;
if (strcmp(right, "TRUE") == 0)
right_val = 1;
else if (strcmp(right, "FALSE") == 0)
right_val = 0;
if (left_val >= 0) {
if ((arg->op.type == FILTER_OP_AND && !left_val) ||
(arg->op.type == FILTER_OP_OR && left_val)) {
/* Just return left value */
str = left;
left = NULL;
break;
}
if (right_val >= 0) {
/* just evaluate this. */
val = 0;
switch (arg->op.type) {
case FILTER_OP_AND:
val = left_val && right_val;
break;
case FILTER_OP_OR:
val = left_val || right_val;
break;
default:
break;
}
str = malloc_or_die(6);
if (val)
strcpy(str, "TRUE");
else
strcpy(str, "FALSE");
break;
}
}
if (right_val >= 0) {
if ((arg->op.type == FILTER_OP_AND && !right_val) ||
(arg->op.type == FILTER_OP_OR && right_val)) {
/* Just return right value */
str = right;
right = NULL;
break;
}
/* The right value is meaningless */
str = left;
left = NULL;
break;
}
len = strlen(left) + strlen(right) + strlen(op) + 10;
str = malloc_or_die(len);
snprintf(str, len, "(%s) %s (%s)",
left, op, right);
break;
case FILTER_OP_NOT:
op = "!";
right = arg_to_str(filter, arg->op.right);
if (!right)
break;
/* See if we can consolidate */
if (strcmp(right, "TRUE") == 0)
right_val = 1;
else if (strcmp(right, "FALSE") == 0)
right_val = 0;
if (right_val >= 0) {
/* just return the opposite */
str = malloc_or_die(6);
if (right_val)
strcpy(str, "FALSE");
else
strcpy(str, "TRUE");
break;
}
len = strlen(right) + strlen(op) + 3;
str = malloc_or_die(len);
snprintf(str, len, "%s(%s)", op, right);
break;
default:
/* ?? */
break;
}
free(left);
free(right);
return str;
}
static char *val_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *str;
str = malloc_or_die(30);
snprintf(str, 30, "%lld", arg->value.val);
return str;
}
static char *field_to_str(struct event_filter *filter, struct filter_arg *arg)
{
return strdup(arg->field.field->name);
}
static char *exp_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *lstr;
char *rstr;
char *op;
char *str;
int len;
lstr = arg_to_str(filter, arg->exp.left);
rstr = arg_to_str(filter, arg->exp.right);
switch (arg->exp.type) {
case FILTER_EXP_ADD:
op = "+";
break;
case FILTER_EXP_SUB:
op = "-";
break;
case FILTER_EXP_MUL:
op = "*";
break;
case FILTER_EXP_DIV:
op = "/";
break;
case FILTER_EXP_MOD:
op = "%";
break;
case FILTER_EXP_RSHIFT:
op = ">>";
break;
case FILTER_EXP_LSHIFT:
op = "<<";
break;
case FILTER_EXP_AND:
op = "&";
break;
case FILTER_EXP_OR:
op = "|";
break;
case FILTER_EXP_XOR:
op = "^";
break;
default:
die("oops in exp");
}
len = strlen(op) + strlen(lstr) + strlen(rstr) + 4;
str = malloc_or_die(len);
snprintf(str, len, "%s %s %s", lstr, op, rstr);
free(lstr);
free(rstr);
return str;
}
static char *num_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *lstr;
char *rstr;
char *str = NULL;
char *op = NULL;
int len;
lstr = arg_to_str(filter, arg->num.left);
rstr = arg_to_str(filter, arg->num.right);
switch (arg->num.type) {
case FILTER_CMP_EQ:
op = "==";
/* fall through */
case FILTER_CMP_NE:
if (!op)
op = "!=";
/* fall through */
case FILTER_CMP_GT:
if (!op)
op = ">";
/* fall through */
case FILTER_CMP_LT:
if (!op)
op = "<";
/* fall through */
case FILTER_CMP_GE:
if (!op)
op = ">=";
/* fall through */
case FILTER_CMP_LE:
if (!op)
op = "<=";
len = strlen(lstr) + strlen(op) + strlen(rstr) + 4;
str = malloc_or_die(len);
sprintf(str, "%s %s %s", lstr, op, rstr);
break;
default:
/* ?? */
break;
}
free(lstr);
free(rstr);
return str;
}
static char *str_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *str = NULL;
char *op = NULL;
int len;
switch (arg->str.type) {
case FILTER_CMP_MATCH:
op = "==";
/* fall through */
case FILTER_CMP_NOT_MATCH:
if (!op)
op = "!=";
/* fall through */
case FILTER_CMP_REGEX:
if (!op)
op = "=~";
/* fall through */
case FILTER_CMP_NOT_REGEX:
if (!op)
op = "!~";
len = strlen(arg->str.field->name) + strlen(op) +
strlen(arg->str.val) + 6;
str = malloc_or_die(len);
snprintf(str, len, "%s %s \"%s\"",
arg->str.field->name,
op, arg->str.val);
break;
default:
/* ?? */
break;
}
return str;
}
static char *arg_to_str(struct event_filter *filter, struct filter_arg *arg)
{
char *str;
switch (arg->type) {
case FILTER_ARG_BOOLEAN:
str = malloc_or_die(6);
if (arg->boolean.value)
strcpy(str, "TRUE");
else
strcpy(str, "FALSE");
return str;
case FILTER_ARG_OP:
return op_to_str(filter, arg);
case FILTER_ARG_NUM:
return num_to_str(filter, arg);
case FILTER_ARG_STR:
return str_to_str(filter, arg);
case FILTER_ARG_VALUE:
return val_to_str(filter, arg);
case FILTER_ARG_FIELD:
return field_to_str(filter, arg);
case FILTER_ARG_EXP:
return exp_to_str(filter, arg);
default:
/* ?? */
return NULL;
}
}
/**
* pevent_filter_make_string - return a string showing the filter
* @filter: filter struct with filter information
* @event_id: the event id to return the filter string with
*
* Returns a string that displays the filter contents.
* This string must be freed with free(str).
* NULL is returned if no filter is found.
*/
char *
pevent_filter_make_string(struct event_filter *filter, int event_id)
{
struct filter_type *filter_type;
if (!filter->filters)
return NULL;
filter_type = find_filter_type(filter, event_id);
if (!filter_type)
return NULL;
return arg_to_str(filter, filter_type->filter);
}
/**
* pevent_filter_compare - compare two filters and return if they are the same
* @filter1: Filter to compare with @filter2
* @filter2: Filter to compare with @filter1
*
* Returns:
* 1 if the two filters hold the same content.
* 0 if they do not.
*/
int pevent_filter_compare(struct event_filter *filter1, struct event_filter *filter2)
{
struct filter_type *filter_type1;
struct filter_type *filter_type2;
char *str1, *str2;
int result;
int i;
/* Do the easy checks first */
if (filter1->filters != filter2->filters)
return 0;
if (!filter1->filters && !filter2->filters)
return 1;
/*
* Now take a look at each of the events to see if they have the same
* filters to them.
*/
for (i = 0; i < filter1->filters; i++) {
filter_type1 = &filter1->event_filters[i];
filter_type2 = find_filter_type(filter2, filter_type1->event_id);
if (!filter_type2)
break;
if (filter_type1->filter->type != filter_type2->filter->type)
break;
switch (filter_type1->filter->type) {
case FILTER_TRIVIAL_FALSE:
case FILTER_TRIVIAL_TRUE:
/* trivial types just need the type compared */
continue;
default:
break;
}
/* The best way to compare complex filters is with strings */
str1 = arg_to_str(filter1, filter_type1->filter);
str2 = arg_to_str(filter2, filter_type2->filter);
result = strcmp(str1, str2) != 0;
free(str1);
free(str2);
if (result)
break;
}
if (i < filter1->filters)
return 0;
return 1;
}
tools/lib/traceevent/parse-utils.c 0 → 100644
View file @ 73787190
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#define __weak __attribute__((weak))
void __vdie(const char *fmt, va_list ap)
{
int ret = errno;
if (errno)
perror("trace-cmd");
else
ret = -1;
fprintf(stderr, " ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
exit(ret);
}
void __die(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vdie(fmt, ap);
va_end(ap);
}
void __weak die(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vdie(fmt, ap);
va_end(ap);
}
void __vwarning(const char *fmt, va_list ap)
{
if (errno)
perror("trace-cmd");
errno = 0;
fprintf(stderr, " ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
}
void __warning(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vwarning(fmt, ap);
va_end(ap);
}
void __weak warning(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vwarning(fmt, ap);
va_end(ap);
}
void __vpr_stat(const char *fmt, va_list ap)
{
vprintf(fmt, ap);
printf("\n");
}
void __pr_stat(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vpr_stat(fmt, ap);
va_end(ap);
}
void __weak vpr_stat(const char *fmt, va_list ap)
{
__vpr_stat(fmt, ap);
}
void __weak pr_stat(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
__vpr_stat(fmt, ap);
va_end(ap);
}
void __weak *malloc_or_die(unsigned int size)
{
void *data;
data = malloc(size);
if (!data)
die("malloc");
return data;
}
tools/lib/traceevent/trace-seq.c 0 → 100644
View file @ 73787190
/*
* Copyright (C) 2009 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License (not later!)
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "event-parse.h"
#include "event-utils.h"
/*
* The TRACE_SEQ_POISON is to catch the use of using
* a trace_seq structure after it was destroyed.
*/
#define TRACE_SEQ_POISON ((void *)0xdeadbeef)
#define TRACE_SEQ_CHECK(s) \
do { \
if ((s)->buffer == TRACE_SEQ_POISON) \
die("Usage of trace_seq after it was destroyed"); \
} while (0)
/**
* trace_seq_init - initialize the trace_seq structure
* @s: a pointer to the trace_seq structure to initialize
*/
void trace_seq_init(struct trace_seq *s)
{
s->len = 0;
s->readpos = 0;
s->buffer_size = TRACE_SEQ_BUF_SIZE;
s->buffer = malloc_or_die(s->buffer_size);
}
/**
* trace_seq_destroy - free up memory of a trace_seq
* @s: a pointer to the trace_seq to free the buffer
*
* Only frees the buffer, not the trace_seq struct itself.
*/
void trace_seq_destroy(struct trace_seq *s)
{
if (!s)
return;
TRACE_SEQ_CHECK(s);
free(s->buffer);
s->buffer = TRACE_SEQ_POISON;
}
static void expand_buffer(struct trace_seq *s)
{
s->buffer_size += TRACE_SEQ_BUF_SIZE;
s->buffer = realloc(s->buffer, s->buffer_size);
if (!s->buffer)
die("Can't allocate trace_seq buffer memory");
}
/**
* trace_seq_printf - sequence printing of trace information
* @s: trace sequence descriptor
* @fmt: printf format string
*
* It returns 0 if the trace oversizes the buffer's free
* space, 1 otherwise.
*
* The tracer may use either sequence operations or its own
* copy to user routines. To simplify formating of a trace
* trace_seq_printf is used to store strings into a special
* buffer (@s). Then the output may be either used by
* the sequencer or pulled into another buffer.
*/
int
trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
{
va_list ap;
int len;
int ret;
TRACE_SEQ_CHECK(s);
try_again:
len = (s->buffer_size - 1) - s->len;
va_start(ap, fmt);
ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
va_end(ap);
if (ret >= len) {
expand_buffer(s);
goto try_again;
}
s->len += ret;
return 1;
}
/**
* trace_seq_vprintf - sequence printing of trace information
* @s: trace sequence descriptor
* @fmt: printf format string
*
* The tracer may use either sequence operations or its own
* copy to user routines. To simplify formating of a trace
* trace_seq_printf is used to store strings into a special
* buffer (@s). Then the output may be either used by
* the sequencer or pulled into another buffer.
*/
int
trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
{
int len;
int ret;
TRACE_SEQ_CHECK(s);
try_again:
len = (s->buffer_size - 1) - s->len;
ret = vsnprintf(s->buffer + s->len, len, fmt, args);
if (ret >= len) {
expand_buffer(s);
goto try_again;
}
s->len += ret;
return len;
}
/**
* trace_seq_puts - trace sequence printing of simple string
* @s: trace sequence descriptor
* @str: simple string to record
*
* The tracer may use either the sequence operations or its own
* copy to user routines. This function records a simple string
* into a special buffer (@s) for later retrieval by a sequencer
* or other mechanism.
*/
int trace_seq_puts(struct trace_seq *s, const char *str)
{
int len;
TRACE_SEQ_CHECK(s);
len = strlen(str);
while (len > ((s->buffer_size - 1) - s->len))
expand_buffer(s);
memcpy(s->buffer + s->len, str, len);
s->len += len;
return len;
}
int trace_seq_putc(struct trace_seq *s, unsigned char c)
{
TRACE_SEQ_CHECK(s);
while (s->len >= (s->buffer_size - 1))
expand_buffer(s);
s->buffer[s->len++] = c;
return 1;
}
void trace_seq_terminate(struct trace_seq *s)
{
TRACE_SEQ_CHECK(s);
/* There's always one character left on the buffer */
s->buffer[s->len] = 0;
}
int trace_seq_do_printf(struct trace_seq *s)
{
TRACE_SEQ_CHECK(s);
return printf("%.*s", s->len, s->buffer);
}
tools/perf/Makefile
View file @ 73787190
...@@ -149,7 +149,7 @@ endif ...@@ -149,7 +149,7 @@ endif
### --- END CONFIGURATION SECTION --- ### --- END CONFIGURATION SECTION ---
BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)/util -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE BASIC_CFLAGS = -Iutil/include -Iarch/$(ARCH)/include -I$(OUTPUT)/util -I$(EVENT_PARSE_DIR) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE
BASIC_LDFLAGS = BASIC_LDFLAGS =
# Guard against environment variables # Guard against environment variables
...@@ -178,6 +178,17 @@ $(OUTPUT)python/perf.so: $(PYRF_OBJS) $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS) ...@@ -178,6 +178,17 @@ $(OUTPUT)python/perf.so: $(PYRF_OBJS) $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH)) SCRIPTS = $(patsubst %.sh,%,$(SCRIPT_SH))
EVENT_PARSE_DIR = ../lib/traceevent/
ifeq ("$(origin O)", "command line")
EP_PATH=$(OUTPUT)/
else
EP_PATH=$(EVENT_PARSE_DIR)/
endif
LIBPARSEVENT = $(EP_PATH)libtraceevent.a
EP_LIB := -L$(EP_PATH) -ltraceevent
# #
# Single 'perf' binary right now: # Single 'perf' binary right now:
# #
...@@ -300,6 +311,7 @@ LIB_H += util/cpumap.h ...@@ -300,6 +311,7 @@ LIB_H += util/cpumap.h
LIB_H += util/top.h LIB_H += util/top.h
LIB_H += $(ARCH_INCLUDE) LIB_H += $(ARCH_INCLUDE)
LIB_H += util/cgroup.h LIB_H += util/cgroup.h
LIB_H += $(EVENT_PARSE_DIR)event-parse.h
LIB_H += util/target.h LIB_H += util/target.h
LIB_OBJS += $(OUTPUT)util/abspath.o LIB_OBJS += $(OUTPUT)util/abspath.o
...@@ -398,7 +410,7 @@ BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o ...@@ -398,7 +410,7 @@ BUILTIN_OBJS += $(OUTPUT)builtin-kvm.o
BUILTIN_OBJS += $(OUTPUT)builtin-test.o BUILTIN_OBJS += $(OUTPUT)builtin-test.o
BUILTIN_OBJS += $(OUTPUT)builtin-inject.o BUILTIN_OBJS += $(OUTPUT)builtin-inject.o
PERFLIBS = $(LIB_FILE) PERFLIBS = $(LIB_FILE) $(LIBPARSEVENT)
# Files needed for the python binding, perf.so # Files needed for the python binding, perf.so
# pyrf is just an internal name needed for all those wrappers. # pyrf is just an internal name needed for all those wrappers.
...@@ -807,6 +819,10 @@ $(sort $(dir $(DIRECTORY_DEPS))): ...@@ -807,6 +819,10 @@ $(sort $(dir $(DIRECTORY_DEPS))):
$(LIB_FILE): $(LIB_OBJS) $(LIB_FILE): $(LIB_OBJS)
$(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS) $(QUIET_AR)$(RM) $@ && $(AR) rcs $@ $(LIB_OBJS)
# libparsevent.a
$(LIBPARSEVENT):
make -C $(EVENT_PARSE_DIR) $(COMMAND_O) libtraceevent.a
help: help:
@echo 'Perf make targets:' @echo 'Perf make targets:'
@echo ' doc - make *all* documentation (see below)' @echo ' doc - make *all* documentation (see below)'
......
tools/perf/builtin-kmem.c
View file @ 73787190
...@@ -192,7 +192,7 @@ static void insert_caller_stat(unsigned long call_site, ...@@ -192,7 +192,7 @@ static void insert_caller_stat(unsigned long call_site,
} }
static void process_alloc_event(void *data, static void process_alloc_event(void *data,
struct event *event, struct event_format *event,
int cpu, int cpu,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used, struct thread *thread __used,
...@@ -253,7 +253,7 @@ static struct alloc_stat *search_alloc_stat(unsigned long ptr, ...@@ -253,7 +253,7 @@ static struct alloc_stat *search_alloc_stat(unsigned long ptr,
} }
static void process_free_event(void *data, static void process_free_event(void *data,
struct event *event, struct event_format *event,
int cpu, int cpu,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -281,7 +281,7 @@ static void process_free_event(void *data, ...@@ -281,7 +281,7 @@ static void process_free_event(void *data,
static void process_raw_event(union perf_event *raw_event __used, void *data, static void process_raw_event(union perf_event *raw_event __used, void *data,
int cpu, u64 timestamp, struct thread *thread) int cpu, u64 timestamp, struct thread *thread)
{ {
struct event *event; struct event_format *event;
int type; int type;
type = trace_parse_common_type(data); type = trace_parse_common_type(data);
......
tools/perf/builtin-lock.c
View file @ 73787190
...@@ -356,25 +356,25 @@ struct trace_release_event { ...@@ -356,25 +356,25 @@ struct trace_release_event {
struct trace_lock_handler { struct trace_lock_handler {
void (*acquire_event)(struct trace_acquire_event *, void (*acquire_event)(struct trace_acquire_event *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*acquired_event)(struct trace_acquired_event *, void (*acquired_event)(struct trace_acquired_event *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*contended_event)(struct trace_contended_event *, void (*contended_event)(struct trace_contended_event *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*release_event)(struct trace_release_event *, void (*release_event)(struct trace_release_event *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
...@@ -416,7 +416,7 @@ enum acquire_flags { ...@@ -416,7 +416,7 @@ enum acquire_flags {
static void static void
report_lock_acquire_event(struct trace_acquire_event *acquire_event, report_lock_acquire_event(struct trace_acquire_event *acquire_event,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -480,7 +480,7 @@ report_lock_acquire_event(struct trace_acquire_event *acquire_event, ...@@ -480,7 +480,7 @@ report_lock_acquire_event(struct trace_acquire_event *acquire_event,
static void static void
report_lock_acquired_event(struct trace_acquired_event *acquired_event, report_lock_acquired_event(struct trace_acquired_event *acquired_event,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -536,7 +536,7 @@ report_lock_acquired_event(struct trace_acquired_event *acquired_event, ...@@ -536,7 +536,7 @@ report_lock_acquired_event(struct trace_acquired_event *acquired_event,
static void static void
report_lock_contended_event(struct trace_contended_event *contended_event, report_lock_contended_event(struct trace_contended_event *contended_event,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -583,7 +583,7 @@ report_lock_contended_event(struct trace_contended_event *contended_event, ...@@ -583,7 +583,7 @@ report_lock_contended_event(struct trace_contended_event *contended_event,
static void static void
report_lock_release_event(struct trace_release_event *release_event, report_lock_release_event(struct trace_release_event *release_event,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -647,7 +647,7 @@ static struct trace_lock_handler *trace_handler; ...@@ -647,7 +647,7 @@ static struct trace_lock_handler *trace_handler;
static void static void
process_lock_acquire_event(void *data, process_lock_acquire_event(void *data,
struct event *event __used, struct event_format *event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -666,7 +666,7 @@ process_lock_acquire_event(void *data, ...@@ -666,7 +666,7 @@ process_lock_acquire_event(void *data,
static void static void
process_lock_acquired_event(void *data, process_lock_acquired_event(void *data,
struct event *event __used, struct event_format *event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -684,7 +684,7 @@ process_lock_acquired_event(void *data, ...@@ -684,7 +684,7 @@ process_lock_acquired_event(void *data,
static void static void
process_lock_contended_event(void *data, process_lock_contended_event(void *data,
struct event *event __used, struct event_format *event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -702,7 +702,7 @@ process_lock_contended_event(void *data, ...@@ -702,7 +702,7 @@ process_lock_contended_event(void *data,
static void static void
process_lock_release_event(void *data, process_lock_release_event(void *data,
struct event *event __used, struct event_format *event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -721,7 +721,7 @@ process_lock_release_event(void *data, ...@@ -721,7 +721,7 @@ process_lock_release_event(void *data,
static void static void
process_raw_event(void *data, int cpu, u64 timestamp, struct thread *thread) process_raw_event(void *data, int cpu, u64 timestamp, struct thread *thread)
{ {
struct event *event; struct event_format *event;
int type; int type;
type = trace_parse_common_type(data); type = trace_parse_common_type(data);
......
tools/perf/builtin-sched.c
View file @ 73787190
...@@ -728,34 +728,34 @@ struct trace_migrate_task_event { ...@@ -728,34 +728,34 @@ struct trace_migrate_task_event {
struct trace_sched_handler { struct trace_sched_handler {
void (*switch_event)(struct trace_switch_event *, void (*switch_event)(struct trace_switch_event *,
struct machine *, struct machine *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*runtime_event)(struct trace_runtime_event *, void (*runtime_event)(struct trace_runtime_event *,
struct machine *, struct machine *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*wakeup_event)(struct trace_wakeup_event *, void (*wakeup_event)(struct trace_wakeup_event *,
struct machine *, struct machine *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*fork_event)(struct trace_fork_event *, void (*fork_event)(struct trace_fork_event *,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
void (*migrate_task_event)(struct trace_migrate_task_event *, void (*migrate_task_event)(struct trace_migrate_task_event *,
struct machine *machine, struct machine *machine,
struct event *, struct event_format *,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread); struct thread *thread);
...@@ -765,7 +765,7 @@ struct trace_sched_handler { ...@@ -765,7 +765,7 @@ struct trace_sched_handler {
static void static void
replay_wakeup_event(struct trace_wakeup_event *wakeup_event, replay_wakeup_event(struct trace_wakeup_event *wakeup_event,
struct machine *machine __used, struct machine *machine __used,
struct event *event, struct event_format *event,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -792,7 +792,7 @@ static u64 cpu_last_switched[MAX_CPUS]; ...@@ -792,7 +792,7 @@ static u64 cpu_last_switched[MAX_CPUS];
static void static void
replay_switch_event(struct trace_switch_event *switch_event, replay_switch_event(struct trace_switch_event *switch_event,
struct machine *machine __used, struct machine *machine __used,
struct event *event, struct event_format *event,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
...@@ -835,7 +835,7 @@ replay_switch_event(struct trace_switch_event *switch_event, ...@@ -835,7 +835,7 @@ replay_switch_event(struct trace_switch_event *switch_event,
static void static void
replay_fork_event(struct trace_fork_event *fork_event, replay_fork_event(struct trace_fork_event *fork_event,
struct event *event, struct event_format *event,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -944,7 +944,7 @@ static void thread_atoms_insert(struct thread *thread) ...@@ -944,7 +944,7 @@ static void thread_atoms_insert(struct thread *thread)
static void static void
latency_fork_event(struct trace_fork_event *fork_event __used, latency_fork_event(struct trace_fork_event *fork_event __used,
struct event *event __used, struct event_format *event __used,
int cpu __used, int cpu __used,
u64 timestamp __used, u64 timestamp __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -1026,7 +1026,7 @@ add_sched_in_event(struct work_atoms *atoms, u64 timestamp) ...@@ -1026,7 +1026,7 @@ add_sched_in_event(struct work_atoms *atoms, u64 timestamp)
static void static void
latency_switch_event(struct trace_switch_event *switch_event, latency_switch_event(struct trace_switch_event *switch_event,
struct machine *machine, struct machine *machine,
struct event *event __used, struct event_format *event __used,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
...@@ -1079,7 +1079,7 @@ latency_switch_event(struct trace_switch_event *switch_event, ...@@ -1079,7 +1079,7 @@ latency_switch_event(struct trace_switch_event *switch_event,
static void static void
latency_runtime_event(struct trace_runtime_event *runtime_event, latency_runtime_event(struct trace_runtime_event *runtime_event,
struct machine *machine, struct machine *machine,
struct event *event __used, struct event_format *event __used,
int cpu, int cpu,
u64 timestamp, u64 timestamp,
struct thread *this_thread __used) struct thread *this_thread __used)
...@@ -1102,7 +1102,7 @@ latency_runtime_event(struct trace_runtime_event *runtime_event, ...@@ -1102,7 +1102,7 @@ latency_runtime_event(struct trace_runtime_event *runtime_event,
static void static void
latency_wakeup_event(struct trace_wakeup_event *wakeup_event, latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
struct machine *machine, struct machine *machine,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
...@@ -1150,7 +1150,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event, ...@@ -1150,7 +1150,7 @@ latency_wakeup_event(struct trace_wakeup_event *wakeup_event,
static void static void
latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event, latency_migrate_task_event(struct trace_migrate_task_event *migrate_task_event,
struct machine *machine, struct machine *machine,
struct event *__event __used, struct event_format *__event __used,
int cpu __used, int cpu __used,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
...@@ -1361,7 +1361,7 @@ static struct trace_sched_handler *trace_handler; ...@@ -1361,7 +1361,7 @@ static struct trace_sched_handler *trace_handler;
static void static void
process_sched_wakeup_event(struct perf_tool *tool __used, process_sched_wakeup_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine, struct machine *machine,
struct thread *thread) struct thread *thread)
...@@ -1398,7 +1398,7 @@ static char next_shortname2 = '0'; ...@@ -1398,7 +1398,7 @@ static char next_shortname2 = '0';
static void static void
map_switch_event(struct trace_switch_event *switch_event, map_switch_event(struct trace_switch_event *switch_event,
struct machine *machine, struct machine *machine,
struct event *event __used, struct event_format *event __used,
int this_cpu, int this_cpu,
u64 timestamp, u64 timestamp,
struct thread *thread __used) struct thread *thread __used)
...@@ -1476,7 +1476,7 @@ map_switch_event(struct trace_switch_event *switch_event, ...@@ -1476,7 +1476,7 @@ map_switch_event(struct trace_switch_event *switch_event,
static void static void
process_sched_switch_event(struct perf_tool *tool __used, process_sched_switch_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine, struct machine *machine,
struct thread *thread) struct thread *thread)
...@@ -1512,7 +1512,7 @@ process_sched_switch_event(struct perf_tool *tool __used, ...@@ -1512,7 +1512,7 @@ process_sched_switch_event(struct perf_tool *tool __used,
static void static void
process_sched_runtime_event(struct perf_tool *tool __used, process_sched_runtime_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine, struct machine *machine,
struct thread *thread) struct thread *thread)
...@@ -1532,7 +1532,7 @@ process_sched_runtime_event(struct perf_tool *tool __used, ...@@ -1532,7 +1532,7 @@ process_sched_runtime_event(struct perf_tool *tool __used,
static void static void
process_sched_fork_event(struct perf_tool *tool __used, process_sched_fork_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine __used, struct machine *machine __used,
struct thread *thread) struct thread *thread)
...@@ -1554,7 +1554,7 @@ process_sched_fork_event(struct perf_tool *tool __used, ...@@ -1554,7 +1554,7 @@ process_sched_fork_event(struct perf_tool *tool __used,
static void static void
process_sched_exit_event(struct perf_tool *tool __used, process_sched_exit_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample __used, struct perf_sample *sample __used,
struct machine *machine __used, struct machine *machine __used,
struct thread *thread __used) struct thread *thread __used)
...@@ -1565,7 +1565,7 @@ process_sched_exit_event(struct perf_tool *tool __used, ...@@ -1565,7 +1565,7 @@ process_sched_exit_event(struct perf_tool *tool __used,
static void static void
process_sched_migrate_task_event(struct perf_tool *tool __used, process_sched_migrate_task_event(struct perf_tool *tool __used,
struct event *event, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine, struct machine *machine,
struct thread *thread) struct thread *thread)
...@@ -1586,7 +1586,7 @@ process_sched_migrate_task_event(struct perf_tool *tool __used, ...@@ -1586,7 +1586,7 @@ process_sched_migrate_task_event(struct perf_tool *tool __used,
sample->time, thread); sample->time, thread);
} }
typedef void (*tracepoint_handler)(struct perf_tool *tool, struct event *event, typedef void (*tracepoint_handler)(struct perf_tool *tool, struct event_format *event,
struct perf_sample *sample, struct perf_sample *sample,
struct machine *machine, struct machine *machine,
struct thread *thread); struct thread *thread);
......
tools/perf/builtin-script.c
View file @ 73787190
...@@ -261,7 +261,7 @@ static void print_sample_start(struct perf_sample *sample, ...@@ -261,7 +261,7 @@ static void print_sample_start(struct perf_sample *sample,
struct perf_event_attr *attr) struct perf_event_attr *attr)
{ {
int type; int type;
struct event *event; struct event_format *event;
const char *evname = NULL; const char *evname = NULL;
unsigned long secs; unsigned long secs;
unsigned long usecs; unsigned long usecs;
......
tools/perf/util/scripting-engines/trace-event-python.c
View file @ 73787190
...@@ -37,7 +37,7 @@ PyMODINIT_FUNC initperf_trace_context(void); ...@@ -37,7 +37,7 @@ PyMODINIT_FUNC initperf_trace_context(void);
#define FTRACE_MAX_EVENT \ #define FTRACE_MAX_EVENT \
((1 << (sizeof(unsigned short) * 8)) - 1) ((1 << (sizeof(unsigned short) * 8)) - 1)
struct event *events[FTRACE_MAX_EVENT]; struct event_format *events[FTRACE_MAX_EVENT];
#define MAX_FIELDS 64 #define MAX_FIELDS 64
#define N_COMMON_FIELDS 7 #define N_COMMON_FIELDS 7
...@@ -136,7 +136,7 @@ static void define_field(enum print_arg_type field_type, ...@@ -136,7 +136,7 @@ static void define_field(enum print_arg_type field_type,
Py_DECREF(t); Py_DECREF(t);
} }
static void define_event_symbols(struct event *event, static void define_event_symbols(struct event_format *event,
const char *ev_name, const char *ev_name,
struct print_arg *args) struct print_arg *args)
{ {
...@@ -178,6 +178,10 @@ static void define_event_symbols(struct event *event, ...@@ -178,6 +178,10 @@ static void define_event_symbols(struct event *event,
define_event_symbols(event, ev_name, args->op.right); define_event_symbols(event, ev_name, args->op.right);
break; break;
default: default:
/* gcc warns for these? */
case PRINT_BSTRING:
case PRINT_DYNAMIC_ARRAY:
case PRINT_FUNC:
/* we should warn... */ /* we should warn... */
return; return;
} }
...@@ -186,10 +190,10 @@ static void define_event_symbols(struct event *event, ...@@ -186,10 +190,10 @@ static void define_event_symbols(struct event *event,
define_event_symbols(event, ev_name, args->next); define_event_symbols(event, ev_name, args->next);
} }
static inline struct event *find_cache_event(int type) static inline struct event_format *find_cache_event(int type)
{ {
static char ev_name[256]; static char ev_name[256];
struct event *event; struct event_format *event;
if (events[type]) if (events[type])
return events[type]; return events[type];
...@@ -216,7 +220,7 @@ static void python_process_event(union perf_event *pevent __unused, ...@@ -216,7 +220,7 @@ static void python_process_event(union perf_event *pevent __unused,
struct format_field *field; struct format_field *field;
unsigned long long val; unsigned long long val;
unsigned long s, ns; unsigned long s, ns;
struct event *event; struct event_format *event;
unsigned n = 0; unsigned n = 0;
int type; int type;
int pid; int pid;
...@@ -436,7 +440,7 @@ static int python_stop_script(void) ...@@ -436,7 +440,7 @@ static int python_stop_script(void)
static int python_generate_script(const char *outfile) static int python_generate_script(const char *outfile)
{ {
struct event *event = NULL; struct event_format *event = NULL;
struct format_field *f; struct format_field *f;
char fname[PATH_MAX]; char fname[PATH_MAX];
int not_first, count; int not_first, count;
......
tools/perf/util/trace-event-info.c
View file @ 73787190
...@@ -68,7 +68,7 @@ struct events { ...@@ -68,7 +68,7 @@ struct events {
}; };
void *malloc_or_die(unsigned int size) static void *malloc_or_die(unsigned int size)
{ {
void *data; void *data;
...@@ -448,6 +448,8 @@ static void tracing_data_header(void) ...@@ -448,6 +448,8 @@ static void tracing_data_header(void)
else else
buf[0] = 0; buf[0] = 0;
read_trace_init(buf[0], buf[0]);
write_or_die(buf, 1); write_or_die(buf, 1);
/* save size of long */ /* save size of long */
......
tools/perf/util/trace-event-parse.c
View file @ 73787190
...@@ -17,3137 +17,343 @@ ...@@ -17,3137 +17,343 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
* *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*
* The parts for function graph printing was taken and modified from the
* Linux Kernel that were written by Frederic Weisbecker.
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <ctype.h>
#include <errno.h> #include <errno.h>
#include "../perf.h" #include "../perf.h"
#include "util.h" #include "util.h"
#include "trace-event.h" #include "trace-event.h"
int header_page_ts_offset;
int header_page_ts_size;
int header_page_size_offset;
int header_page_size_size; int header_page_size_size;
int header_page_overwrite_offset; int header_page_ts_size;
int header_page_overwrite_size;
int header_page_data_offset; int header_page_data_offset;
int header_page_data_size;
bool latency_format; struct pevent *perf_pevent;
static struct pevent *pevent;
static char *input_buf;
static unsigned long long input_buf_ptr;
static unsigned long long input_buf_siz;
static int cpus; bool latency_format;
static int long_size;
static int is_flag_field;
static int is_symbolic_field;
static struct format_field *
find_any_field(struct event *event, const char *name);
static void init_input_buf(char *buf, unsigned long long size) int read_trace_init(int file_bigendian, int host_bigendian)
{ {
input_buf = buf; if (pevent)
input_buf_siz = size; return 0;
input_buf_ptr = 0;
}
struct cmdline {
char *comm;
int pid;
};
static struct cmdline *cmdlines;
static int cmdline_count;
static int cmdline_cmp(const void *a, const void *b) perf_pevent = pevent_alloc();
{ pevent = perf_pevent;
const struct cmdline *ca = a;
const struct cmdline *cb = b;
if (ca->pid < cb->pid) pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
return -1; pevent_set_file_bigendian(pevent, file_bigendian);
if (ca->pid > cb->pid) pevent_set_host_bigendian(pevent, host_bigendian);
return 1;
return 0; return 0;
} }
void parse_cmdlines(char *file, int size __unused) static int get_common_field(struct scripting_context *context,
int *offset, int *size, const char *type)
{ {
struct cmdline_list { struct event_format *event;
struct cmdline_list *next; struct format_field *field;
char *comm;
int pid;
} *list = NULL, *item;
char *line;
char *next = NULL;
int i;
line = strtok_r(file, "\n", &next);
while (line) {
item = malloc_or_die(sizeof(*item));
sscanf(line, "%d %as", &item->pid,
(float *)(void *)&item->comm); /* workaround gcc warning */
item->next = list;
list = item;
line = strtok_r(NULL, "\n", &next);
cmdline_count++;
}
cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count); if (!*size) {
if (!pevent->events)
return 0;
i = 0; event = pevent->events[0];
while (list) { field = pevent_find_common_field(event, type);
cmdlines[i].pid = list->pid; if (!field)
cmdlines[i].comm = list->comm; return 0;
i++; *offset = field->offset;
item = list; *size = field->size;
list = list->next;
free(item);
} }
qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp); return pevent_read_number(pevent, context->event_data + *offset, *size);
} }
static struct func_map { int common_lock_depth(struct scripting_context *context)
unsigned long long addr;
char *func;
char *mod;
} *func_list;
static unsigned int func_count;
static int func_cmp(const void *a, const void *b)
{ {
const struct func_map *fa = a; static int offset;
const struct func_map *fb = b; static int size;
int ret;
if (fa->addr < fb->addr) ret = get_common_field(context, &size, &offset,
"common_lock_depth");
if (ret < 0)
return -1; return -1;
if (fa->addr > fb->addr)
return 1;
return 0;
}
void parse_proc_kallsyms(char *file, unsigned int size __unused)
{
struct func_list {
struct func_list *next;
unsigned long long addr;
char *func;
char *mod;
} *list = NULL, *item;
char *line;
char *next = NULL;
char *addr_str;
char ch;
int ret __used;
int i;
line = strtok_r(file, "\n", &next);
while (line) {
item = malloc_or_die(sizeof(*item));
item->mod = NULL;
ret = sscanf(line, "%as %c %as\t[%as",
(float *)(void *)&addr_str, /* workaround gcc warning */
&ch,
(float *)(void *)&item->func,
(float *)(void *)&item->mod);
item->addr = strtoull(addr_str, NULL, 16);
free(addr_str);
/* truncate the extra ']' */
if (item->mod)
item->mod[strlen(item->mod) - 1] = 0;
return ret;
item->next = list;
list = item;
line = strtok_r(NULL, "\n", &next);
func_count++;
}
func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1));
i = 0;
while (list) {
func_list[i].func = list->func;
func_list[i].addr = list->addr;
func_list[i].mod = list->mod;
i++;
item = list;
list = list->next;
free(item);
}
qsort(func_list, func_count, sizeof(*func_list), func_cmp);
/*
* Add a special record at the end.
*/
func_list[func_count].func = NULL;
func_list[func_count].addr = 0;
func_list[func_count].mod = NULL;
} }
/* int common_flags(struct scripting_context *context)
* We are searching for a record in between, not an exact
* match.
*/
static int func_bcmp(const void *a, const void *b)
{ {
const struct func_map *fa = a; static int offset;
const struct func_map *fb = b; static int size;
int ret;
if ((fa->addr == fb->addr) ||
(fa->addr > fb->addr &&
fa->addr < (fb+1)->addr))
return 0;
if (fa->addr < fb->addr) ret = get_common_field(context, &size, &offset,
"common_flags");
if (ret < 0)
return -1; return -1;
return 1; return ret;
}
static struct func_map *find_func(unsigned long long addr)
{
struct func_map *func;
struct func_map key;
key.addr = addr;
func = bsearch(&key, func_list, func_count, sizeof(*func_list),
func_bcmp);
return func;
}
void print_funcs(void)
{
int i;
for (i = 0; i < (int)func_count; i++) {
printf("%016llx %s",
func_list[i].addr,
func_list[i].func);
if (func_list[i].mod)
printf(" [%s]\n", func_list[i].mod);
else
printf("\n");
}
} }
static struct printk_map { int common_pc(struct scripting_context *context)
unsigned long long addr;
char *printk;
} *printk_list;
static unsigned int printk_count;
static int printk_cmp(const void *a, const void *b)
{ {
const struct func_map *fa = a; static int offset;
const struct func_map *fb = b; static int size;
int ret;
if (fa->addr < fb->addr) ret = get_common_field(context, &size, &offset,
"common_preempt_count");
if (ret < 0)
return -1; return -1;
if (fa->addr > fb->addr)
return 1;
return 0; return ret;
} }
static struct printk_map *find_printk(unsigned long long addr) unsigned long long
raw_field_value(struct event_format *event, const char *name, void *data)
{ {
struct printk_map *printk; struct format_field *field;
struct printk_map key; unsigned long long val;
key.addr = addr; field = pevent_find_any_field(event, name);
if (!field)
return 0ULL;
printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list), pevent_read_number_field(field, data, &val);
printk_cmp);
return printk; return val;
} }
void parse_ftrace_printk(char *file, unsigned int size __unused) void *raw_field_ptr(struct event_format *event, const char *name, void *data)
{ {
struct printk_list { struct format_field *field;
struct printk_list *next;
unsigned long long addr;
char *printk;
} *list = NULL, *item;
char *line;
char *next = NULL;
char *addr_str;
int i;
line = strtok_r(file, "\n", &next);
while (line) {
addr_str = strsep(&line, ":");
if (!line) {
warning("error parsing print strings");
break;
}
item = malloc_or_die(sizeof(*item));
item->addr = strtoull(addr_str, NULL, 16);
/* fmt still has a space, skip it */
item->printk = strdup(line+1);
item->next = list;
list = item;
line = strtok_r(NULL, "\n", &next);
printk_count++;
}
printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1);
i = 0; field = pevent_find_any_field(event, name);
while (list) { if (!field)
printk_list[i].printk = list->printk; return NULL;
printk_list[i].addr = list->addr;
i++;
item = list;
list = list->next;
free(item);
}
qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp); if (field->flags & FIELD_IS_DYNAMIC) {
} int offset;
void print_printk(void) offset = *(int *)(data + field->offset);
{ offset &= 0xffff;
int i;
for (i = 0; i < (int)printk_count; i++) { return data + offset;
printf("%016llx %s\n",
printk_list[i].addr,
printk_list[i].printk);
} }
}
static struct event *alloc_event(void)
{
struct event *event;
event = malloc_or_die(sizeof(*event)); return data + field->offset;
memset(event, 0, sizeof(*event));
return event;
} }
enum event_type { int trace_parse_common_type(void *data)
EVENT_ERROR,
EVENT_NONE,
EVENT_SPACE,
EVENT_NEWLINE,
EVENT_OP,
EVENT_DELIM,
EVENT_ITEM,
EVENT_DQUOTE,
EVENT_SQUOTE,
};
static struct event *event_list;
static void add_event(struct event *event)
{ {
event->next = event_list; struct pevent_record record;
event_list = event;
}
static int event_item_type(enum event_type type) record.data = data;
{ return pevent_data_type(pevent, &record);
switch (type) {
case EVENT_ITEM ... EVENT_SQUOTE:
return 1;
case EVENT_ERROR ... EVENT_DELIM:
default:
return 0;
}
} }
static void free_arg(struct print_arg *arg) int trace_parse_common_pid(void *data)
{ {
if (!arg) struct pevent_record record;
return;
switch (arg->type) { record.data = data;
case PRINT_ATOM: return pevent_data_pid(pevent, &record);
if (arg->atom.atom)
free(arg->atom.atom);
break;
case PRINT_NULL:
case PRINT_FIELD ... PRINT_OP:
default:
/* todo */
break;
}
free(arg);
} }
static enum event_type get_type(int ch) unsigned long long read_size(void *ptr, int size)
{ {
if (ch == '\n') return pevent_read_number(pevent, ptr, size);
return EVENT_NEWLINE;
if (isspace(ch))
return EVENT_SPACE;
if (isalnum(ch) || ch == '_')
return EVENT_ITEM;
if (ch == '\'')
return EVENT_SQUOTE;
if (ch == '"')
return EVENT_DQUOTE;
if (!isprint(ch))
return EVENT_NONE;
if (ch == '(' || ch == ')' || ch == ',')
return EVENT_DELIM;
return EVENT_OP;
} }
static int __read_char(void) struct event_format *trace_find_event(int type)
{ {
if (input_buf_ptr >= input_buf_siz) return pevent_find_event(pevent, type);
return -1;
return input_buf[input_buf_ptr++];
} }
static int __peek_char(void)
void print_trace_event(int cpu, void *data, int size)
{ {
if (input_buf_ptr >= input_buf_siz) struct event_format *event;
return -1; struct pevent_record record;
struct trace_seq s;
int type;
return input_buf[input_buf_ptr]; type = trace_parse_common_type(data);
}
static enum event_type __read_token(char **tok) event = trace_find_event(type);
{ if (!event) {
char buf[BUFSIZ]; warning("ug! no event found for type %d", type);
int ch, last_ch, quote_ch, next_ch; return;
int i = 0;
int tok_size = 0;
enum event_type type;
*tok = NULL;
ch = __read_char();
if (ch < 0)
return EVENT_NONE;
type = get_type(ch);
if (type == EVENT_NONE)
return type;
buf[i++] = ch;
switch (type) {
case EVENT_NEWLINE:
case EVENT_DELIM:
*tok = malloc_or_die(2);
(*tok)[0] = ch;
(*tok)[1] = 0;
return type;
case EVENT_OP:
switch (ch) {
case '-':
next_ch = __peek_char();
if (next_ch == '>') {
buf[i++] = __read_char();
break;
}
/* fall through */
case '+':
case '|':
case '&':
case '>':
case '<':
last_ch = ch;
ch = __peek_char();
if (ch != last_ch)
goto test_equal;
buf[i++] = __read_char();
switch (last_ch) {
case '>':
case '<':
goto test_equal;
default:
break;
}
break;
case '!':
case '=':
goto test_equal;
default: /* what should we do instead? */
break;
}
buf[i] = 0;
*tok = strdup(buf);
return type;
test_equal:
ch = __peek_char();
if (ch == '=')
buf[i++] = __read_char();
break;
case EVENT_DQUOTE:
case EVENT_SQUOTE:
/* don't keep quotes */
i--;
quote_ch = ch;
last_ch = 0;
do {
if (i == (BUFSIZ - 1)) {
buf[i] = 0;
if (*tok) {
*tok = realloc(*tok, tok_size + BUFSIZ);
if (!*tok)
return EVENT_NONE;
strcat(*tok, buf);
} else
*tok = strdup(buf);
if (!*tok)
return EVENT_NONE;
tok_size += BUFSIZ;
i = 0;
}
last_ch = ch;
ch = __read_char();
buf[i++] = ch;
/* the '\' '\' will cancel itself */
if (ch == '\\' && last_ch == '\\')
last_ch = 0;
} while (ch != quote_ch || last_ch == '\\');
/* remove the last quote */
i--;
goto out;
case EVENT_ERROR ... EVENT_SPACE:
case EVENT_ITEM:
default:
break;
} }
while (get_type(__peek_char()) == type) { memset(&record, 0, sizeof(record));
if (i == (BUFSIZ - 1)) { record.cpu = cpu;
buf[i] = 0; record.size = size;
if (*tok) { record.data = data;
*tok = realloc(*tok, tok_size + BUFSIZ);
if (!*tok)
return EVENT_NONE;
strcat(*tok, buf);
} else
*tok = strdup(buf);
if (!*tok)
return EVENT_NONE;
tok_size += BUFSIZ;
i = 0;
}
ch = __read_char();
buf[i++] = ch;
}
out: trace_seq_init(&s);
buf[i] = 0; pevent_print_event(pevent, &s, &record);
if (*tok) { trace_seq_do_printf(&s);
*tok = realloc(*tok, tok_size + i); printf("\n");
if (!*tok)
return EVENT_NONE;
strcat(*tok, buf);
} else
*tok = strdup(buf);
if (!*tok)
return EVENT_NONE;
return type;
} }
static void free_token(char *tok) void print_event(int cpu, void *data, int size, unsigned long long nsecs,
char *comm)
{ {
if (tok) struct pevent_record record;
free(tok); struct trace_seq s;
} int pid;
static enum event_type read_token(char **tok) pevent->latency_format = latency_format;
{
enum event_type type;
for (;;) { record.ts = nsecs;
type = __read_token(tok); record.cpu = cpu;
if (type != EVENT_SPACE) record.size = size;
return type; record.data = data;
pid = pevent_data_pid(pevent, &record);
free_token(*tok); if (!pevent_pid_is_registered(pevent, pid))
} pevent_register_comm(pevent, comm, pid);
/* not reached */ trace_seq_init(&s);
return EVENT_NONE; pevent_print_event(pevent, &s, &record);
trace_seq_do_printf(&s);
printf("\n");
} }
/* no newline */ void parse_proc_kallsyms(char *file, unsigned int size __unused)
static enum event_type read_token_item(char **tok)
{ {
enum event_type type; unsigned long long addr;
char *func;
char *line;
char *next = NULL;
char *addr_str;
char *mod;
char ch;
for (;;) { line = strtok_r(file, "\n", &next);
type = __read_token(tok); while (line) {
if (type != EVENT_SPACE && type != EVENT_NEWLINE) mod = NULL;
return type; sscanf(line, "%as %c %as\t[%as",
(float *)(void *)&addr_str, /* workaround gcc warning */
&ch, (float *)(void *)&func, (float *)(void *)&mod);
addr = strtoull(addr_str, NULL, 16);
free(addr_str);
free_token(*tok); /* truncate the extra ']' */
} if (mod)
mod[strlen(mod) - 1] = 0;
/* not reached */ pevent_register_function(pevent, func, addr, mod);
return EVENT_NONE; free(func);
} free(mod);
static int test_type(enum event_type type, enum event_type expect) line = strtok_r(NULL, "\n", &next);
{
if (type != expect) {
warning("Error: expected type %d but read %d",
expect, type);
return -1;
} }
return 0;
} }
static int __test_type_token(enum event_type type, char *token, void parse_ftrace_printk(char *file, unsigned int size __unused)
enum event_type expect, const char *expect_tok,
bool warn)
{ {
if (type != expect) { unsigned long long addr;
if (warn) char *printk;
warning("Error: expected type %d but read %d", char *line;
expect, type); char *next = NULL;
return -1; char *addr_str;
} char *fmt;
if (strcmp(token, expect_tok) != 0) { line = strtok_r(file, "\n", &next);
if (warn) while (line) {
warning("Error: expected '%s' but read '%s'", addr_str = strtok_r(line, ":", &fmt);
expect_tok, token); if (!addr_str) {
return -1; warning("printk format with empty entry");
break;
}
addr = strtoull(addr_str, NULL, 16);
/* fmt still has a space, skip it */
printk = strdup(fmt+1);
line = strtok_r(NULL, "\n", &next);
pevent_register_print_string(pevent, printk, addr);
} }
return 0;
}
static int test_type_token(enum event_type type, char *token,
enum event_type expect, const char *expect_tok)
{
return __test_type_token(type, token, expect, expect_tok, true);
}
static int __read_expect_type(enum event_type expect, char **tok, int newline_ok)
{
enum event_type type;
if (newline_ok)
type = read_token(tok);
else
type = read_token_item(tok);
return test_type(type, expect);
}
static int read_expect_type(enum event_type expect, char **tok)
{
return __read_expect_type(expect, tok, 1);
}
static int __read_expected(enum event_type expect, const char *str,
int newline_ok, bool warn)
{
enum event_type type;
char *token;
int ret;
if (newline_ok)
type = read_token(&token);
else
type = read_token_item(&token);
ret = __test_type_token(type, token, expect, str, warn);
free_token(token);
return ret;
} }
static int read_expected(enum event_type expect, const char *str) int parse_ftrace_file(char *buf, unsigned long size)
{ {
return __read_expected(expect, str, 1, true); return pevent_parse_event(pevent, buf, size, "ftrace");
} }
static int read_expected_item(enum event_type expect, const char *str) int parse_event_file(char *buf, unsigned long size, char *sys)
{ {
return __read_expected(expect, str, 0, true); return pevent_parse_event(pevent, buf, size, sys);
} }
static char *event_read_name(void) struct event_format *trace_find_next_event(struct event_format *event)
{ {
char *token; static int idx;
if (read_expected(EVENT_ITEM, "name") < 0)
return NULL;
if (read_expected(EVENT_OP, ":") < 0) if (!pevent->events)
return NULL; return NULL;
if (read_expect_type(EVENT_ITEM, &token) < 0) if (!event) {
goto fail; idx = 0;
return pevent->events[0];
}
return token; if (idx < pevent->nr_events && event == pevent->events[idx]) {
idx++;
if (idx == pevent->nr_events)
return NULL;
return pevent->events[idx];
}
fail: for (idx = 1; idx < pevent->nr_events; idx++) {
free_token(token); if (event == pevent->events[idx - 1])
return pevent->events[idx];
}
return NULL; return NULL;
} }
static int event_read_id(void) struct flag {
{ const char *name;
char *token; unsigned long long value;
int id = -1; };
if (read_expected_item(EVENT_ITEM, "ID") < 0)
return -1;
if (read_expected(EVENT_OP, ":") < 0) static const struct flag flags[] = {
return -1; { "HI_SOFTIRQ", 0 },
{ "TIMER_SOFTIRQ", 1 },
{ "NET_TX_SOFTIRQ", 2 },
{ "NET_RX_SOFTIRQ", 3 },
{ "BLOCK_SOFTIRQ", 4 },
{ "BLOCK_IOPOLL_SOFTIRQ", 5 },
{ "TASKLET_SOFTIRQ", 6 },
{ "SCHED_SOFTIRQ", 7 },
{ "HRTIMER_SOFTIRQ", 8 },
{ "RCU_SOFTIRQ", 9 },
if (read_expect_type(EVENT_ITEM, &token) < 0) { "HRTIMER_NORESTART", 0 },
goto free; { "HRTIMER_RESTART", 1 },
};
id = strtoul(token, NULL, 0); unsigned long long eval_flag(const char *flag)
{
int i;
free: /*
free_token(token); * Some flags in the format files do not get converted.
return id; * If the flag is not numeric, see if it is something that
} * we already know about.
*/
if (isdigit(flag[0]))
return strtoull(flag, NULL, 0);
static int field_is_string(struct format_field *field) for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
{ if (strcmp(flags[i].name, flag) == 0)
if ((field->flags & FIELD_IS_ARRAY) && return flags[i].value;
(!strstr(field->type, "char") || !strstr(field->type, "u8") ||
!strstr(field->type, "s8")))
return 1;
return 0; return 0;
} }
static int field_is_dynamic(struct format_field *field)
{
if (!strncmp(field->type, "__data_loc", 10))
return 1;
return 0;
}
static int event_read_fields(struct event *event, struct format_field **fields)
{
struct format_field *field = NULL;
enum event_type type;
char *token;
char *last_token;
int count = 0;
do {
type = read_token(&token);
if (type == EVENT_NEWLINE) {
free_token(token);
return count;
}
count++;
if (test_type_token(type, token, EVENT_ITEM, "field"))
goto fail;
free_token(token);
type = read_token(&token);
/*
* The ftrace fields may still use the "special" name.
* Just ignore it.
*/
if (event->flags & EVENT_FL_ISFTRACE &&
type == EVENT_ITEM && strcmp(token, "special") == 0) {
free_token(token);
type = read_token(&token);
}
if (test_type_token(type, token, EVENT_OP, ":") < 0)
return -1;
if (read_expect_type(EVENT_ITEM, &token) < 0)
goto fail;
last_token = token;
field = malloc_or_die(sizeof(*field));
memset(field, 0, sizeof(*field));
/* read the rest of the type */
for (;;) {
type = read_token(&token);
if (type == EVENT_ITEM ||
(type == EVENT_OP && strcmp(token, "*") == 0) ||
/*
* Some of the ftrace fields are broken and have
* an illegal "." in them.
*/
(event->flags & EVENT_FL_ISFTRACE &&
type == EVENT_OP && strcmp(token, ".") == 0)) {
if (strcmp(token, "*") == 0)
field->flags |= FIELD_IS_POINTER;
if (field->type) {
field->type = realloc(field->type,
strlen(field->type) +
strlen(last_token) + 2);
strcat(field->type, " ");
strcat(field->type, last_token);
} else
field->type = last_token;
last_token = token;
continue;
}
break;
}
if (!field->type) {
die("no type found");
goto fail;
}
field->name = last_token;
if (test_type(type, EVENT_OP))
goto fail;
if (strcmp(token, "[") == 0) {
enum event_type last_type = type;
char *brackets = token;
int len;
field->flags |= FIELD_IS_ARRAY;
type = read_token(&token);
while (strcmp(token, "]") != 0) {
if (last_type == EVENT_ITEM &&
type == EVENT_ITEM)
len = 2;
else
len = 1;
last_type = type;
brackets = realloc(brackets,
strlen(brackets) +
strlen(token) + len);
if (len == 2)
strcat(brackets, " ");
strcat(brackets, token);
free_token(token);
type = read_token(&token);
if (type == EVENT_NONE) {
die("failed to find token");
goto fail;
}
}
free_token(token);
brackets = realloc(brackets, strlen(brackets) + 2);
strcat(brackets, "]");
/* add brackets to type */
type = read_token(&token);
/*
* If the next token is not an OP, then it is of
* the format: type [] item;
*/
if (type == EVENT_ITEM) {
field->type = realloc(field->type,
strlen(field->type) +
strlen(field->name) +
strlen(brackets) + 2);
strcat(field->type, " ");
strcat(field->type, field->name);
free_token(field->name);
strcat(field->type, brackets);
field->name = token;
type = read_token(&token);
} else {
field->type = realloc(field->type,
strlen(field->type) +
strlen(brackets) + 1);
strcat(field->type, brackets);
}
free(brackets);
}
if (field_is_string(field)) {
field->flags |= FIELD_IS_STRING;
if (field_is_dynamic(field))
field->flags |= FIELD_IS_DYNAMIC;
}
if (test_type_token(type, token, EVENT_OP, ";"))
goto fail;
free_token(token);
if (read_expected(EVENT_ITEM, "offset") < 0)
goto fail_expect;
if (read_expected(EVENT_OP, ":") < 0)
goto fail_expect;
if (read_expect_type(EVENT_ITEM, &token))
goto fail;
field->offset = strtoul(token, NULL, 0);
free_token(token);
if (read_expected(EVENT_OP, ";") < 0)
goto fail_expect;
if (read_expected(EVENT_ITEM, "size") < 0)
goto fail_expect;
if (read_expected(EVENT_OP, ":") < 0)
goto fail_expect;
if (read_expect_type(EVENT_ITEM, &token))
goto fail;
field->size = strtoul(token, NULL, 0);
free_token(token);
if (read_expected(EVENT_OP, ";") < 0)
goto fail_expect;
type = read_token(&token);
if (type != EVENT_NEWLINE) {
/* newer versions of the kernel have a "signed" type */
if (test_type_token(type, token, EVENT_ITEM, "signed"))
goto fail;
free_token(token);
if (read_expected(EVENT_OP, ":") < 0)
goto fail_expect;
if (read_expect_type(EVENT_ITEM, &token))
goto fail;
if (strtoul(token, NULL, 0))
field->flags |= FIELD_IS_SIGNED;
free_token(token);
if (read_expected(EVENT_OP, ";") < 0)
goto fail_expect;
if (read_expect_type(EVENT_NEWLINE, &token))
goto fail;
}
free_token(token);
*fields = field;
fields = &field->next;
} while (1);
return 0;
fail:
free_token(token);
fail_expect:
if (field)
free(field);
return -1;
}
static int event_read_format(struct event *event)
{
char *token;
int ret;
if (read_expected_item(EVENT_ITEM, "format") < 0)
return -1;
if (read_expected(EVENT_OP, ":") < 0)
return -1;
if (read_expect_type(EVENT_NEWLINE, &token))
goto fail;
free_token(token);
ret = event_read_fields(event, &event->format.common_fields);
if (ret < 0)
return ret;
event->format.nr_common = ret;
ret = event_read_fields(event, &event->format.fields);
if (ret < 0)
return ret;
event->format.nr_fields = ret;
return 0;
fail:
free_token(token);
return -1;
}
enum event_type
process_arg_token(struct event *event, struct print_arg *arg,
char **tok, enum event_type type);
static enum event_type
process_arg(struct event *event, struct print_arg *arg, char **tok)
{
enum event_type type;
char *token;
type = read_token(&token);
*tok = token;
return process_arg_token(event, arg, tok, type);
}
static enum event_type
process_cond(struct event *event, struct print_arg *top, char **tok)
{
struct print_arg *arg, *left, *right;
enum event_type type;
char *token = NULL;
arg = malloc_or_die(sizeof(*arg));
memset(arg, 0, sizeof(*arg));
left = malloc_or_die(sizeof(*left));
right = malloc_or_die(sizeof(*right));
arg->type = PRINT_OP;
arg->op.left = left;
arg->op.right = right;
*tok = NULL;
type = process_arg(event, left, &token);
if (test_type_token(type, token, EVENT_OP, ":"))
goto out_free;
arg->op.op = token;
type = process_arg(event, right, &token);
top->op.right = arg;
*tok = token;
return type;
out_free:
free_token(*tok);
free(right);
free(left);
free_arg(arg);
return EVENT_ERROR;
}
static enum event_type
process_array(struct event *event, struct print_arg *top, char **tok)
{
struct print_arg *arg;
enum event_type type;
char *token = NULL;
arg = malloc_or_die(sizeof(*arg));
memset(arg, 0, sizeof(*arg));
*tok = NULL;
type = process_arg(event, arg, &token);
if (test_type_token(type, token, EVENT_OP, "]"))
goto out_free;
top->op.right = arg;
free_token(token);
type = read_token_item(&token);
*tok = token;
return type;
out_free:
free_token(*tok);
free_arg(arg);
return EVENT_ERROR;
}
static int get_op_prio(char *op)
{
if (!op[1]) {
switch (op[0]) {
case '*':
case '/':
case '%':
return 6;
case '+':
case '-':
return 7;
/* '>>' and '<<' are 8 */
case '<':
case '>':
return 9;
/* '==' and '!=' are 10 */
case '&':
return 11;
case '^':
return 12;
case '|':
return 13;
case '?':
return 16;
default:
die("unknown op '%c'", op[0]);
return -1;
}
} else {
if (strcmp(op, "++") == 0 ||
strcmp(op, "--") == 0) {
return 3;
} else if (strcmp(op, ">>") == 0 ||
strcmp(op, "<<") == 0) {
return 8;
} else if (strcmp(op, ">=") == 0 ||
strcmp(op, "<=") == 0) {
return 9;
} else if (strcmp(op, "==") == 0 ||
strcmp(op, "!=") == 0) {
return 10;
} else if (strcmp(op, "&&") == 0) {
return 14;
} else if (strcmp(op, "||") == 0) {
return 15;
} else {
die("unknown op '%s'", op);
return -1;
}
}
}
static void set_op_prio(struct print_arg *arg)
{
/* single ops are the greatest */
if (!arg->op.left || arg->op.left->type == PRINT_NULL) {
arg->op.prio = 0;
return;
}
arg->op.prio = get_op_prio(arg->op.op);
}
static enum event_type
process_op(struct event *event, struct print_arg *arg, char **tok)
{
struct print_arg *left, *right = NULL;
enum event_type type;
char *token;
/* the op is passed in via tok */
token = *tok;
if (arg->type == PRINT_OP && !arg->op.left) {
/* handle single op */
if (token[1]) {
die("bad op token %s", token);
return EVENT_ERROR;
}
switch (token[0]) {
case '!':
case '+':
case '-':
break;
default:
die("bad op token %s", token);
return EVENT_ERROR;
}
/* make an empty left */
left = malloc_or_die(sizeof(*left));
left->type = PRINT_NULL;
arg->op.left = left;
right = malloc_or_die(sizeof(*right));
arg->op.right = right;
type = process_arg(event, right, tok);
} else if (strcmp(token, "?") == 0) {
left = malloc_or_die(sizeof(*left));
/* copy the top arg to the left */
*left = *arg;
arg->type = PRINT_OP;
arg->op.op = token;
arg->op.left = left;
arg->op.prio = 0;
type = process_cond(event, arg, tok);
} else if (strcmp(token, ">>") == 0 ||
strcmp(token, "<<") == 0 ||
strcmp(token, "&") == 0 ||
strcmp(token, "|") == 0 ||
strcmp(token, "&&") == 0 ||
strcmp(token, "||") == 0 ||
strcmp(token, "-") == 0 ||
strcmp(token, "+") == 0 ||
strcmp(token, "*") == 0 ||
strcmp(token, "^") == 0 ||
strcmp(token, "/") == 0 ||
strcmp(token, "<") == 0 ||
strcmp(token, ">") == 0 ||
strcmp(token, "==") == 0 ||
strcmp(token, "!=") == 0) {
left = malloc_or_die(sizeof(*left));
/* copy the top arg to the left */
*left = *arg;
arg->type = PRINT_OP;
arg->op.op = token;
arg->op.left = left;
set_op_prio(arg);
right = malloc_or_die(sizeof(*right));
type = read_token_item(&token);
*tok = token;
/* could just be a type pointer */
if ((strcmp(arg->op.op, "*") == 0) &&
type == EVENT_DELIM && (strcmp(token, ")") == 0)) {
if (left->type != PRINT_ATOM)
die("bad pointer type");
left->atom.atom = realloc(left->atom.atom,
sizeof(left->atom.atom) + 3);
strcat(left->atom.atom, " *");
*arg = *left;
free(arg);
return type;
}
type = process_arg_token(event, right, tok, type);
arg->op.right = right;
} else if (strcmp(token, "[") == 0) {
left = malloc_or_die(sizeof(*left));
*left = *arg;
arg->type = PRINT_OP;
arg->op.op = token;
arg->op.left = left;
arg->op.prio = 0;
type = process_array(event, arg, tok);
} else {
warning("unknown op '%s'", token);
event->flags |= EVENT_FL_FAILED;
/* the arg is now the left side */
return EVENT_NONE;
}
if (type == EVENT_OP) {
int prio;
/* higher prios need to be closer to the root */
prio = get_op_prio(*tok);
if (prio > arg->op.prio)
return process_op(event, arg, tok);
return process_op(event, right, tok);
}
return type;
}
static enum event_type
process_entry(struct event *event __unused, struct print_arg *arg,
char **tok)
{
enum event_type type;
char *field;
char *token;
if (read_expected(EVENT_OP, "->") < 0)
return EVENT_ERROR;
if (read_expect_type(EVENT_ITEM, &token) < 0)
goto fail;
field = token;
arg->type = PRINT_FIELD;
arg->field.name = field;
if (is_flag_field) {
arg->field.field = find_any_field(event, arg->field.name);
arg->field.field->flags |= FIELD_IS_FLAG;
is_flag_field = 0;
} else if (is_symbolic_field) {
arg->field.field = find_any_field(event, arg->field.name);
arg->field.field->flags |= FIELD_IS_SYMBOLIC;
is_symbolic_field = 0;
}
type = read_token(&token);
*tok = token;
return type;
fail:
free_token(token);
return EVENT_ERROR;
}
static char *arg_eval (struct print_arg *arg);
static long long arg_num_eval(struct print_arg *arg)
{
long long left, right;
long long val = 0;
switch (arg->type) {
case PRINT_ATOM:
val = strtoll(arg->atom.atom, NULL, 0);
break;
case PRINT_TYPE:
val = arg_num_eval(arg->typecast.item);
break;
case PRINT_OP:
switch (arg->op.op[0]) {
case '|':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
if (arg->op.op[1])
val = left || right;
else
val = left | right;
break;
case '&':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
if (arg->op.op[1])
val = left && right;
else
val = left & right;
break;
case '<':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
switch (arg->op.op[1]) {
case 0:
val = left < right;
break;
case '<':
val = left << right;
break;
case '=':
val = left <= right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case '>':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
switch (arg->op.op[1]) {
case 0:
val = left > right;
break;
case '>':
val = left >> right;
break;
case '=':
val = left >= right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case '=':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
if (arg->op.op[1] != '=')
die("unknown op '%s'", arg->op.op);
val = left == right;
break;
case '!':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
switch (arg->op.op[1]) {
case '=':
val = left != right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case '+':
left = arg_num_eval(arg->op.left);
right = arg_num_eval(arg->op.right);
val = left + right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case PRINT_NULL:
case PRINT_FIELD ... PRINT_SYMBOL:
case PRINT_STRING:
default:
die("invalid eval type %d", arg->type);
}
return val;
}
static char *arg_eval (struct print_arg *arg)
{
long long val;
static char buf[20];
switch (arg->type) {
case PRINT_ATOM:
return arg->atom.atom;
case PRINT_TYPE:
return arg_eval(arg->typecast.item);
case PRINT_OP:
val = arg_num_eval(arg);
sprintf(buf, "%lld", val);
return buf;
case PRINT_NULL:
case PRINT_FIELD ... PRINT_SYMBOL:
case PRINT_STRING:
default:
die("invalid eval type %d", arg->type);
break;
}
return NULL;
}
static enum event_type
process_fields(struct event *event, struct print_flag_sym **list, char **tok)
{
enum event_type type;
struct print_arg *arg = NULL;
struct print_flag_sym *field;
char *token = NULL;
char *value;
do {
free_token(token);
type = read_token_item(&token);
if (test_type_token(type, token, EVENT_OP, "{"))
break;
arg = malloc_or_die(sizeof(*arg));
free_token(token);
type = process_arg(event, arg, &token);
if (type == EVENT_OP)
type = process_op(event, arg, &token);
if (type == EVENT_ERROR)
goto out_free;
if (test_type_token(type, token, EVENT_DELIM, ","))
goto out_free;
field = malloc_or_die(sizeof(*field));
memset(field, 0, sizeof(*field));
value = arg_eval(arg);
field->value = strdup(value);
free_token(token);
type = process_arg(event, arg, &token);
if (test_type_token(type, token, EVENT_OP, "}"))
goto out_free;
value = arg_eval(arg);
field->str = strdup(value);
free_arg(arg);
arg = NULL;
*list = field;
list = &field->next;
free_token(token);
type = read_token_item(&token);
} while (type == EVENT_DELIM && strcmp(token, ",") == 0);
*tok = token;
return type;
out_free:
free_arg(arg);
free_token(token);
return EVENT_ERROR;
}
static enum event_type
process_flags(struct event *event, struct print_arg *arg, char **tok)
{
struct print_arg *field;
enum event_type type;
char *token;
memset(arg, 0, sizeof(*arg));
arg->type = PRINT_FLAGS;
if (read_expected_item(EVENT_DELIM, "(") < 0)
return EVENT_ERROR;
field = malloc_or_die(sizeof(*field));
type = process_arg(event, field, &token);
while (type == EVENT_OP)
type = process_op(event, field, &token);
if (test_type_token(type, token, EVENT_DELIM, ","))
goto out_free;
arg->flags.field = field;
type = read_token_item(&token);
if (event_item_type(type)) {
arg->flags.delim = token;
type = read_token_item(&token);
}
if (test_type_token(type, token, EVENT_DELIM, ","))
goto out_free;
type = process_fields(event, &arg->flags.flags, &token);
if (test_type_token(type, token, EVENT_DELIM, ")"))
goto out_free;
free_token(token);
type = read_token_item(tok);
return type;
out_free:
free_token(token);
return EVENT_ERROR;
}
static enum event_type
process_symbols(struct event *event, struct print_arg *arg, char **tok)
{
struct print_arg *field;
enum event_type type;
char *token;
memset(arg, 0, sizeof(*arg));
arg->type = PRINT_SYMBOL;
if (read_expected_item(EVENT_DELIM, "(") < 0)
return EVENT_ERROR;
field = malloc_or_die(sizeof(*field));
type = process_arg(event, field, &token);
if (test_type_token(type, token, EVENT_DELIM, ","))
goto out_free;
arg->symbol.field = field;
type = process_fields(event, &arg->symbol.symbols, &token);
if (test_type_token(type, token, EVENT_DELIM, ")"))
goto out_free;
free_token(token);
type = read_token_item(tok);
return type;
out_free:
free_token(token);
return EVENT_ERROR;
}
static enum event_type
process_paren(struct event *event, struct print_arg *arg, char **tok)
{
struct print_arg *item_arg;
enum event_type type;
char *token;
type = process_arg(event, arg, &token);
if (type == EVENT_ERROR)
return EVENT_ERROR;
if (type == EVENT_OP)
type = process_op(event, arg, &token);
if (type == EVENT_ERROR)
return EVENT_ERROR;
if (test_type_token(type, token, EVENT_DELIM, ")")) {
free_token(token);
return EVENT_ERROR;
}
free_token(token);
type = read_token_item(&token);
/*
* If the next token is an item or another open paren, then
* this was a typecast.
*/
if (event_item_type(type) ||
(type == EVENT_DELIM && strcmp(token, "(") == 0)) {
/* make this a typecast and contine */
/* prevous must be an atom */
if (arg->type != PRINT_ATOM)
die("previous needed to be PRINT_ATOM");
item_arg = malloc_or_die(sizeof(*item_arg));
arg->type = PRINT_TYPE;
arg->typecast.type = arg->atom.atom;
arg->typecast.item = item_arg;
type = process_arg_token(event, item_arg, &token, type);
}
*tok = token;
return type;
}
static enum event_type
process_str(struct event *event __unused, struct print_arg *arg, char **tok)
{
enum event_type type;
char *token;
if (read_expected(EVENT_DELIM, "(") < 0)
return EVENT_ERROR;
if (read_expect_type(EVENT_ITEM, &token) < 0)
goto fail;
arg->type = PRINT_STRING;
arg->string.string = token;
arg->string.offset = -1;
if (read_expected(EVENT_DELIM, ")") < 0)
return EVENT_ERROR;
type = read_token(&token);
*tok = token;
return type;
fail:
free_token(token);
return EVENT_ERROR;
}
enum event_type
process_arg_token(struct event *event, struct print_arg *arg,
char **tok, enum event_type type)
{
char *token;
char *atom;
token = *tok;
switch (type) {
case EVENT_ITEM:
if (strcmp(token, "REC") == 0) {
free_token(token);
type = process_entry(event, arg, &token);
} else if (strcmp(token, "__print_flags") == 0) {
free_token(token);
is_flag_field = 1;
type = process_flags(event, arg, &token);
} else if (strcmp(token, "__print_symbolic") == 0) {
free_token(token);
is_symbolic_field = 1;
type = process_symbols(event, arg, &token);
} else if (strcmp(token, "__get_str") == 0) {
free_token(token);
type = process_str(event, arg, &token);
} else {
atom = token;
/* test the next token */
type = read_token_item(&token);
/* atoms can be more than one token long */
while (type == EVENT_ITEM) {
atom = realloc(atom, strlen(atom) + strlen(token) + 2);
strcat(atom, " ");
strcat(atom, token);
free_token(token);
type = read_token_item(&token);
}
/* todo, test for function */
arg->type = PRINT_ATOM;
arg->atom.atom = atom;
}
break;
case EVENT_DQUOTE:
case EVENT_SQUOTE:
arg->type = PRINT_ATOM;
arg->atom.atom = token;
type = read_token_item(&token);
break;
case EVENT_DELIM:
if (strcmp(token, "(") == 0) {
free_token(token);
type = process_paren(event, arg, &token);
break;
}
case EVENT_OP:
/* handle single ops */
arg->type = PRINT_OP;
arg->op.op = token;
arg->op.left = NULL;
type = process_op(event, arg, &token);
break;
case EVENT_ERROR ... EVENT_NEWLINE:
default:
die("unexpected type %d", type);
}
*tok = token;
return type;
}
static int event_read_print_args(struct event *event, struct print_arg **list)
{
enum event_type type = EVENT_ERROR;
struct print_arg *arg;
char *token;
int args = 0;
do {
if (type == EVENT_NEWLINE) {
free_token(token);
type = read_token_item(&token);
continue;
}
arg = malloc_or_die(sizeof(*arg));
memset(arg, 0, sizeof(*arg));
type = process_arg(event, arg, &token);
if (type == EVENT_ERROR) {
free_arg(arg);
return -1;
}
*list = arg;
args++;
if (type == EVENT_OP) {
type = process_op(event, arg, &token);
list = &arg->next;
continue;
}
if (type == EVENT_DELIM && strcmp(token, ",") == 0) {
free_token(token);
*list = arg;
list = &arg->next;
continue;
}
break;
} while (type != EVENT_NONE);
if (type != EVENT_NONE)
free_token(token);
return args;
}
static int event_read_print(struct event *event)
{
enum event_type type;
char *token;
int ret;
if (read_expected_item(EVENT_ITEM, "print") < 0)
return -1;
if (read_expected(EVENT_ITEM, "fmt") < 0)
return -1;
if (read_expected(EVENT_OP, ":") < 0)
return -1;
if (read_expect_type(EVENT_DQUOTE, &token) < 0)
goto fail;
concat:
event->print_fmt.format = token;
event->print_fmt.args = NULL;
/* ok to have no arg */
type = read_token_item(&token);
if (type == EVENT_NONE)
return 0;
/* Handle concatination of print lines */
if (type == EVENT_DQUOTE) {
char *cat;
cat = malloc_or_die(strlen(event->print_fmt.format) +
strlen(token) + 1);
strcpy(cat, event->print_fmt.format);
strcat(cat, token);
free_token(token);
free_token(event->print_fmt.format);
event->print_fmt.format = NULL;
token = cat;
goto concat;
}
if (test_type_token(type, token, EVENT_DELIM, ","))
goto fail;
free_token(token);
ret = event_read_print_args(event, &event->print_fmt.args);
if (ret < 0)
return -1;
return ret;
fail:
free_token(token);
return -1;
}
static struct format_field *
find_common_field(struct event *event, const char *name)
{
struct format_field *format;
for (format = event->format.common_fields;
format; format = format->next) {
if (strcmp(format->name, name) == 0)
break;
}
return format;
}
static struct format_field *
find_field(struct event *event, const char *name)
{
struct format_field *format;
for (format = event->format.fields;
format; format = format->next) {
if (strcmp(format->name, name) == 0)
break;
}
return format;
}
static struct format_field *
find_any_field(struct event *event, const char *name)
{
struct format_field *format;
format = find_common_field(event, name);
if (format)
return format;
return find_field(event, name);
}
unsigned long long read_size(void *ptr, int size)
{
switch (size) {
case 1:
return *(unsigned char *)ptr;
case 2:
return data2host2(ptr);
case 4:
return data2host4(ptr);
case 8:
return data2host8(ptr);
default:
/* BUG! */
return 0;
}
}
unsigned long long
raw_field_value(struct event *event, const char *name, void *data)
{
struct format_field *field;
field = find_any_field(event, name);
if (!field)
return 0ULL;
return read_size(data + field->offset, field->size);
}
void *raw_field_ptr(struct event *event, const char *name, void *data)
{
struct format_field *field;
field = find_any_field(event, name);
if (!field)
return NULL;
if (field->flags & FIELD_IS_DYNAMIC) {
int offset;
offset = *(int *)(data + field->offset);
offset &= 0xffff;
return data + offset;
}
return data + field->offset;
}
static int get_common_info(const char *type, int *offset, int *size)
{
struct event *event;
struct format_field *field;
/*
* All events should have the same common elements.
* Pick any event to find where the type is;
*/
if (!event_list)
die("no event_list!");
event = event_list;
field = find_common_field(event, type);
if (!field)
die("field '%s' not found", type);
*offset = field->offset;
*size = field->size;
return 0;
}
static int __parse_common(void *data, int *size, int *offset,
const char *name)
{
int ret;
if (!*size) {
ret = get_common_info(name, offset, size);
if (ret < 0)
return ret;
}
return read_size(data + *offset, *size);
}
int trace_parse_common_type(void *data)
{
static int type_offset;
static int type_size;
return __parse_common(data, &type_size, &type_offset,
"common_type");
}
int trace_parse_common_pid(void *data)
{
static int pid_offset;
static int pid_size;
return __parse_common(data, &pid_size, &pid_offset,
"common_pid");
}
int parse_common_pc(void *data)
{
static int pc_offset;
static int pc_size;
return __parse_common(data, &pc_size, &pc_offset,
"common_preempt_count");
}
int parse_common_flags(void *data)
{
static int flags_offset;
static int flags_size;
return __parse_common(data, &flags_size, &flags_offset,
"common_flags");
}
int parse_common_lock_depth(void *data)
{
static int ld_offset;
static int ld_size;
int ret;
ret = __parse_common(data, &ld_size, &ld_offset,
"common_lock_depth");
if (ret < 0)
return -1;
return ret;
}
struct event *trace_find_event(int id)
{
struct event *event;
for (event = event_list; event; event = event->next) {
if (event->id == id)
break;
}
return event;
}
struct event *trace_find_next_event(struct event *event)
{
if (!event)
return event_list;
return event->next;
}
static unsigned long long eval_num_arg(void *data, int size,
struct event *event, struct print_arg *arg)
{
unsigned long long val = 0;
unsigned long long left, right;
struct print_arg *larg;
switch (arg->type) {
case PRINT_NULL:
/* ?? */
return 0;
case PRINT_ATOM:
return strtoull(arg->atom.atom, NULL, 0);
case PRINT_FIELD:
if (!arg->field.field) {
arg->field.field = find_any_field(event, arg->field.name);
if (!arg->field.field)
die("field %s not found", arg->field.name);
}
/* must be a number */
val = read_size(data + arg->field.field->offset,
arg->field.field->size);
break;
case PRINT_FLAGS:
case PRINT_SYMBOL:
break;
case PRINT_TYPE:
return eval_num_arg(data, size, event, arg->typecast.item);
case PRINT_STRING:
return 0;
break;
case PRINT_OP:
if (strcmp(arg->op.op, "[") == 0) {
/*
* Arrays are special, since we don't want
* to read the arg as is.
*/
if (arg->op.left->type != PRINT_FIELD)
goto default_op; /* oops, all bets off */
larg = arg->op.left;
if (!larg->field.field) {
larg->field.field =
find_any_field(event, larg->field.name);
if (!larg->field.field)
die("field %s not found", larg->field.name);
}
right = eval_num_arg(data, size, event, arg->op.right);
val = read_size(data + larg->field.field->offset +
right * long_size, long_size);
break;
}
default_op:
left = eval_num_arg(data, size, event, arg->op.left);
right = eval_num_arg(data, size, event, arg->op.right);
switch (arg->op.op[0]) {
case '|':
if (arg->op.op[1])
val = left || right;
else
val = left | right;
break;
case '&':
if (arg->op.op[1])
val = left && right;
else
val = left & right;
break;
case '<':
switch (arg->op.op[1]) {
case 0:
val = left < right;
break;
case '<':
val = left << right;
break;
case '=':
val = left <= right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case '>':
switch (arg->op.op[1]) {
case 0:
val = left > right;
break;
case '>':
val = left >> right;
break;
case '=':
val = left >= right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
case '=':
if (arg->op.op[1] != '=')
die("unknown op '%s'", arg->op.op);
val = left == right;
break;
case '-':
val = left - right;
break;
case '+':
val = left + right;
break;
default:
die("unknown op '%s'", arg->op.op);
}
break;
default: /* not sure what to do there */
return 0;
}
return val;
}
struct flag {
const char *name;
unsigned long long value;
};
static const struct flag flags[] = {
{ "HI_SOFTIRQ", 0 },
{ "TIMER_SOFTIRQ", 1 },
{ "NET_TX_SOFTIRQ", 2 },
{ "NET_RX_SOFTIRQ", 3 },
{ "BLOCK_SOFTIRQ", 4 },
{ "BLOCK_IOPOLL_SOFTIRQ", 5 },
{ "TASKLET_SOFTIRQ", 6 },
{ "SCHED_SOFTIRQ", 7 },
{ "HRTIMER_SOFTIRQ", 8 },
{ "RCU_SOFTIRQ", 9 },
{ "HRTIMER_NORESTART", 0 },
{ "HRTIMER_RESTART", 1 },
};
unsigned long long eval_flag(const char *flag)
{
int i;
/*
* Some flags in the format files do not get converted.
* If the flag is not numeric, see if it is something that
* we already know about.
*/
if (isdigit(flag[0]))
return strtoull(flag, NULL, 0);
for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++)
if (strcmp(flags[i].name, flag) == 0)
return flags[i].value;
return 0;
}
static void print_str_arg(void *data, int size,
struct event *event, struct print_arg *arg)
{
struct print_flag_sym *flag;
unsigned long long val, fval;
char *str;
int print;
switch (arg->type) {
case PRINT_NULL:
/* ?? */
return;
case PRINT_ATOM:
printf("%s", arg->atom.atom);
return;
case PRINT_FIELD:
if (!arg->field.field) {
arg->field.field = find_any_field(event, arg->field.name);
if (!arg->field.field)
die("field %s not found", arg->field.name);
}
str = malloc_or_die(arg->field.field->size + 1);
memcpy(str, data + arg->field.field->offset,
arg->field.field->size);
str[arg->field.field->size] = 0;
printf("%s", str);
free(str);
break;
case PRINT_FLAGS:
val = eval_num_arg(data, size, event, arg->flags.field);
print = 0;
for (flag = arg->flags.flags; flag; flag = flag->next) {
fval = eval_flag(flag->value);
if (!val && !fval) {
printf("%s", flag->str);
break;
}
if (fval && (val & fval) == fval) {
if (print && arg->flags.delim)
printf("%s", arg->flags.delim);
printf("%s", flag->str);
print = 1;
val &= ~fval;
}
}
break;
case PRINT_SYMBOL:
val = eval_num_arg(data, size, event, arg->symbol.field);
for (flag = arg->symbol.symbols; flag; flag = flag->next) {
fval = eval_flag(flag->value);
if (val == fval) {
printf("%s", flag->str);
break;
}
}
break;
case PRINT_TYPE:
break;
case PRINT_STRING: {
int str_offset;
if (arg->string.offset == -1) {
struct format_field *f;
f = find_any_field(event, arg->string.string);
arg->string.offset = f->offset;
}
str_offset = *(int *)(data + arg->string.offset);
str_offset &= 0xffff;
printf("%s", ((char *)data) + str_offset);
break;
}
case PRINT_OP:
/*
* The only op for string should be ? :
*/
if (arg->op.op[0] != '?')
return;
val = eval_num_arg(data, size, event, arg->op.left);
if (val)
print_str_arg(data, size, event, arg->op.right->op.left);
else
print_str_arg(data, size, event, arg->op.right->op.right);
break;
default:
/* well... */
break;
}
}
static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event)
{
static struct format_field *field, *ip_field;
struct print_arg *args, *arg, **next;
unsigned long long ip, val;
char *ptr;
void *bptr;
if (!field) {
field = find_field(event, "buf");
if (!field)
die("can't find buffer field for binary printk");
ip_field = find_field(event, "ip");
if (!ip_field)
die("can't find ip field for binary printk");
}
ip = read_size(data + ip_field->offset, ip_field->size);
/*
* The first arg is the IP pointer.
*/
args = malloc_or_die(sizeof(*args));
arg = args;
arg->next = NULL;
next = &arg->next;
arg->type = PRINT_ATOM;
arg->atom.atom = malloc_or_die(32);
sprintf(arg->atom.atom, "%lld", ip);
/* skip the first "%pf : " */
for (ptr = fmt + 6, bptr = data + field->offset;
bptr < data + size && *ptr; ptr++) {
int ls = 0;
if (*ptr == '%') {
process_again:
ptr++;
switch (*ptr) {
case '%':
break;
case 'l':
ls++;
goto process_again;
case 'L':
ls = 2;
goto process_again;
case '0' ... '9':
goto process_again;
case 'p':
ls = 1;
/* fall through */
case 'd':
case 'u':
case 'x':
case 'i':
/* the pointers are always 4 bytes aligned */
bptr = (void *)(((unsigned long)bptr + 3) &
~3);
switch (ls) {
case 0:
case 1:
ls = long_size;
break;
case 2:
ls = 8;
default:
break;
}
val = read_size(bptr, ls);
bptr += ls;
arg = malloc_or_die(sizeof(*arg));
arg->next = NULL;
arg->type = PRINT_ATOM;
arg->atom.atom = malloc_or_die(32);
sprintf(arg->atom.atom, "%lld", val);
*next = arg;
next = &arg->next;
break;
case 's':
arg = malloc_or_die(sizeof(*arg));
arg->next = NULL;
arg->type = PRINT_STRING;
arg->string.string = strdup(bptr);
bptr += strlen(bptr) + 1;
*next = arg;
next = &arg->next;
default:
break;
}
}
}
return args;
}
static void free_args(struct print_arg *args)
{
struct print_arg *next;
while (args) {
next = args->next;
if (args->type == PRINT_ATOM)
free(args->atom.atom);
else
free(args->string.string);
free(args);
args = next;
}
}
static char *get_bprint_format(void *data, int size __unused, struct event *event)
{
unsigned long long addr;
static struct format_field *field;
struct printk_map *printk;
char *format;
char *p;
if (!field) {
field = find_field(event, "fmt");
if (!field)
die("can't find format field for binary printk");
printf("field->offset = %d size=%d\n", field->offset, field->size);
}
addr = read_size(data + field->offset, field->size);
printk = find_printk(addr);
if (!printk) {
format = malloc_or_die(45);
sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n",
addr);
return format;
}
p = printk->printk;
/* Remove any quotes. */
if (*p == '"')
p++;
format = malloc_or_die(strlen(p) + 10);
sprintf(format, "%s : %s", "%pf", p);
/* remove ending quotes and new line since we will add one too */
p = format + strlen(format) - 1;
if (*p == '"')
*p = 0;
p -= 2;
if (strcmp(p, "\\n") == 0)
*p = 0;
return format;
}
static void pretty_print(void *data, int size, struct event *event)
{
struct print_fmt *print_fmt = &event->print_fmt;
struct print_arg *arg = print_fmt->args;
struct print_arg *args = NULL;
const char *ptr = print_fmt->format;
unsigned long long val;
struct func_map *func;
const char *saveptr;
char *bprint_fmt = NULL;
char format[32];
int show_func;
int len;
int ls;
if (event->flags & EVENT_FL_ISFUNC)
ptr = " %pF <-- %pF";
if (event->flags & EVENT_FL_ISBPRINT) {
bprint_fmt = get_bprint_format(data, size, event);
args = make_bprint_args(bprint_fmt, data, size, event);
arg = args;
ptr = bprint_fmt;
}
for (; *ptr; ptr++) {
ls = 0;
if (*ptr == '\\') {
ptr++;
switch (*ptr) {
case 'n':
printf("\n");
break;
case 't':
printf("\t");
break;
case 'r':
printf("\r");
break;
case '\\':
printf("\\");
break;
default:
printf("%c", *ptr);
break;
}
} else if (*ptr == '%') {
saveptr = ptr;
show_func = 0;
cont_process:
ptr++;
switch (*ptr) {
case '%':
printf("%%");
break;
case 'l':
ls++;
goto cont_process;
case 'L':
ls = 2;
goto cont_process;
case 'z':
case 'Z':
case '0' ... '9':
goto cont_process;
case 'p':
if (long_size == 4)
ls = 1;
else
ls = 2;
if (*(ptr+1) == 'F' ||
*(ptr+1) == 'f') {
ptr++;
show_func = *ptr;
}
/* fall through */
case 'd':
case 'i':
case 'x':
case 'X':
case 'u':
if (!arg)
die("no argument match");
len = ((unsigned long)ptr + 1) -
(unsigned long)saveptr;
/* should never happen */
if (len > 32)
die("bad format!");
memcpy(format, saveptr, len);
format[len] = 0;
val = eval_num_arg(data, size, event, arg);
arg = arg->next;
if (show_func) {
func = find_func(val);
if (func) {
printf("%s", func->func);
if (show_func == 'F')
printf("+0x%llx",
val - func->addr);
break;
}
}
switch (ls) {
case 0:
printf(format, (int)val);
break;
case 1:
printf(format, (long)val);
break;
case 2:
printf(format, (long long)val);
break;
default:
die("bad count (%d)", ls);
}
break;
case 's':
if (!arg)
die("no matching argument");
print_str_arg(data, size, event, arg);
arg = arg->next;
break;
default:
printf(">%c<", *ptr);
}
} else
printf("%c", *ptr);
}
if (args) {
free_args(args);
free(bprint_fmt);
}
}
static inline int log10_cpu(int nb)
{
if (nb / 100)
return 3;
if (nb / 10)
return 2;
return 1;
}
static void print_lat_fmt(void *data, int size __unused)
{
unsigned int lat_flags;
unsigned int pc;
int lock_depth;
int hardirq;
int softirq;
lat_flags = parse_common_flags(data);
pc = parse_common_pc(data);
lock_depth = parse_common_lock_depth(data);
hardirq = lat_flags & TRACE_FLAG_HARDIRQ;
softirq = lat_flags & TRACE_FLAG_SOFTIRQ;
printf("%c%c%c",
(lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
(lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
'X' : '.',
(lat_flags & TRACE_FLAG_NEED_RESCHED) ?
'N' : '.',
(hardirq && softirq) ? 'H' :
hardirq ? 'h' : softirq ? 's' : '.');
if (pc)
printf("%x", pc);
else
printf(".");
if (lock_depth < 0)
printf(". ");
else
printf("%d ", lock_depth);
}
#define TRACE_GRAPH_INDENT 2
static struct record *
get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
struct record *next)
{
struct format_field *field;
struct event *event;
unsigned long val;
int type;
int pid;
type = trace_parse_common_type(next->data);
event = trace_find_event(type);
if (!event)
return NULL;
if (!(event->flags & EVENT_FL_ISFUNCRET))
return NULL;
pid = trace_parse_common_pid(next->data);
field = find_field(event, "func");
if (!field)
die("function return does not have field func");
val = read_size(next->data + field->offset, field->size);
if (cur_pid != pid || cur_func != val)
return NULL;
/* this is a leaf, now advance the iterator */
return trace_read_data(cpu);
}
/* Signal a overhead of time execution to the output */
static void print_graph_overhead(unsigned long long duration)
{
/* Non nested entry or return */
if (duration == ~0ULL)
return (void)printf(" ");
/* Duration exceeded 100 msecs */
if (duration > 100000ULL)
return (void)printf("! ");
/* Duration exceeded 10 msecs */
if (duration > 10000ULL)
return (void)printf("+ ");
printf(" ");
}
static void print_graph_duration(unsigned long long duration)
{
unsigned long usecs = duration / 1000;
unsigned long nsecs_rem = duration % 1000;
/* log10(ULONG_MAX) + '\0' */
char msecs_str[21];
char nsecs_str[5];
int len;
int i;
sprintf(msecs_str, "%lu", usecs);
/* Print msecs */
len = printf("%lu", usecs);
/* Print nsecs (we don't want to exceed 7 numbers) */
if (len < 7) {
snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
len += printf(".%s", nsecs_str);
}
printf(" us ");
/* Print remaining spaces to fit the row's width */
for (i = len; i < 7; i++)
printf(" ");
printf("| ");
}
static void
print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec)
{
unsigned long long rettime, calltime;
unsigned long long duration, depth;
unsigned long long val;
struct format_field *field;
struct func_map *func;
struct event *ret_event;
int type;
int i;
type = trace_parse_common_type(ret_rec->data);
ret_event = trace_find_event(type);
field = find_field(ret_event, "rettime");
if (!field)
die("can't find rettime in return graph");
rettime = read_size(ret_rec->data + field->offset, field->size);
field = find_field(ret_event, "calltime");
if (!field)
die("can't find rettime in return graph");
calltime = read_size(ret_rec->data + field->offset, field->size);
duration = rettime - calltime;
/* Overhead */
print_graph_overhead(duration);
/* Duration */
print_graph_duration(duration);
field = find_field(event, "depth");
if (!field)
die("can't find depth in entry graph");
depth = read_size(data + field->offset, field->size);
/* Function */
for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
printf(" ");
field = find_field(event, "func");
if (!field)
die("can't find func in entry graph");
val = read_size(data + field->offset, field->size);
func = find_func(val);
if (func)
printf("%s();", func->func);
else
printf("%llx();", val);
}
static void print_graph_nested(struct event *event, void *data)
{
struct format_field *field;
unsigned long long depth;
unsigned long long val;
struct func_map *func;
int i;
/* No overhead */
print_graph_overhead(-1);
/* No time */
printf(" | ");
field = find_field(event, "depth");
if (!field)
die("can't find depth in entry graph");
depth = read_size(data + field->offset, field->size);
/* Function */
for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
printf(" ");
field = find_field(event, "func");
if (!field)
die("can't find func in entry graph");
val = read_size(data + field->offset, field->size);
func = find_func(val);
if (func)
printf("%s() {", func->func);
else
printf("%llx() {", val);
}
static void
pretty_print_func_ent(void *data, int size, struct event *event,
int cpu, int pid)
{
struct format_field *field;
struct record *rec;
void *copy_data;
unsigned long val;
if (latency_format) {
print_lat_fmt(data, size);
printf(" | ");
}
field = find_field(event, "func");
if (!field)
die("function entry does not have func field");
val = read_size(data + field->offset, field->size);
/*
* peek_data may unmap the data pointer. Copy it first.
*/
copy_data = malloc_or_die(size);
memcpy(copy_data, data, size);
data = copy_data;
rec = trace_peek_data(cpu);
if (rec) {
rec = get_return_for_leaf(cpu, pid, val, rec);
if (rec) {
print_graph_entry_leaf(event, data, rec);
goto out_free;
}
}
print_graph_nested(event, data);
out_free:
free(data);
}
static void
pretty_print_func_ret(void *data, int size __unused, struct event *event)
{
unsigned long long rettime, calltime;
unsigned long long duration, depth;
struct format_field *field;
int i;
if (latency_format) {
print_lat_fmt(data, size);
printf(" | ");
}
field = find_field(event, "rettime");
if (!field)
die("can't find rettime in return graph");
rettime = read_size(data + field->offset, field->size);
field = find_field(event, "calltime");
if (!field)
die("can't find calltime in return graph");
calltime = read_size(data + field->offset, field->size);
duration = rettime - calltime;
/* Overhead */
print_graph_overhead(duration);
/* Duration */
print_graph_duration(duration);
field = find_field(event, "depth");
if (!field)
die("can't find depth in entry graph");
depth = read_size(data + field->offset, field->size);
/* Function */
for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++)
printf(" ");
printf("}");
}
static void
pretty_print_func_graph(void *data, int size, struct event *event,
int cpu, int pid)
{
if (event->flags & EVENT_FL_ISFUNCENT)
pretty_print_func_ent(data, size, event, cpu, pid);
else if (event->flags & EVENT_FL_ISFUNCRET)
pretty_print_func_ret(data, size, event);
printf("\n");
}
void print_trace_event(int cpu, void *data, int size)
{
struct event *event;
int type;
int pid;
type = trace_parse_common_type(data);
event = trace_find_event(type);
if (!event) {
warning("ug! no event found for type %d", type);
return;
}
pid = trace_parse_common_pid(data);
if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET))
return pretty_print_func_graph(data, size, event, cpu, pid);
if (latency_format)
print_lat_fmt(data, size);
if (event->flags & EVENT_FL_FAILED) {
printf("EVENT '%s' FAILED TO PARSE\n",
event->name);
return;
}
pretty_print(data, size, event);
}
static void print_fields(struct print_flag_sym *field)
{
printf("{ %s, %s }", field->value, field->str);
if (field->next) {
printf(", ");
print_fields(field->next);
}
}
static void print_args(struct print_arg *args)
{
int print_paren = 1;
switch (args->type) {
case PRINT_NULL:
printf("null");
break;
case PRINT_ATOM:
printf("%s", args->atom.atom);
break;
case PRINT_FIELD:
printf("REC->%s", args->field.name);
break;
case PRINT_FLAGS:
printf("__print_flags(");
print_args(args->flags.field);
printf(", %s, ", args->flags.delim);
print_fields(args->flags.flags);
printf(")");
break;
case PRINT_SYMBOL:
printf("__print_symbolic(");
print_args(args->symbol.field);
printf(", ");
print_fields(args->symbol.symbols);
printf(")");
break;
case PRINT_STRING:
printf("__get_str(%s)", args->string.string);
break;
case PRINT_TYPE:
printf("(%s)", args->typecast.type);
print_args(args->typecast.item);
break;
case PRINT_OP:
if (strcmp(args->op.op, ":") == 0)
print_paren = 0;
if (print_paren)
printf("(");
print_args(args->op.left);
printf(" %s ", args->op.op);
print_args(args->op.right);
if (print_paren)
printf(")");
break;
default:
/* we should warn... */
return;
}
if (args->next) {
printf("\n");
print_args(args->next);
}
}
int parse_ftrace_file(char *buf, unsigned long size)
{
struct format_field *field;
struct print_arg *arg, **list;
struct event *event;
int ret;
init_input_buf(buf, size);
event = alloc_event();
if (!event)
return -ENOMEM;
event->flags |= EVENT_FL_ISFTRACE;
event->name = event_read_name();
if (!event->name)
die("failed to read ftrace event name");
if (strcmp(event->name, "function") == 0)
event->flags |= EVENT_FL_ISFUNC;
else if (strcmp(event->name, "funcgraph_entry") == 0)
event->flags |= EVENT_FL_ISFUNCENT;
else if (strcmp(event->name, "funcgraph_exit") == 0)
event->flags |= EVENT_FL_ISFUNCRET;
else if (strcmp(event->name, "bprint") == 0)
event->flags |= EVENT_FL_ISBPRINT;
event->id = event_read_id();
if (event->id < 0)
die("failed to read ftrace event id");
add_event(event);
ret = event_read_format(event);
if (ret < 0)
die("failed to read ftrace event format");
ret = event_read_print(event);
if (ret < 0)
die("failed to read ftrace event print fmt");
/* New ftrace handles args */
if (ret > 0)
return 0;
/*
* The arguments for ftrace files are parsed by the fields.
* Set up the fields as their arguments.
*/
list = &event->print_fmt.args;
for (field = event->format.fields; field; field = field->next) {
arg = malloc_or_die(sizeof(*arg));
memset(arg, 0, sizeof(*arg));
*list = arg;
list = &arg->next;
arg->type = PRINT_FIELD;
arg->field.name = field->name;
arg->field.field = field;
}
return 0;
}
int parse_event_file(char *buf, unsigned long size, char *sys)
{
struct event *event;
int ret;
init_input_buf(buf, size);
event = alloc_event();
if (!event)
return -ENOMEM;
event->name = event_read_name();
if (!event->name)
die("failed to read event name");
event->id = event_read_id();
if (event->id < 0)
die("failed to read event id");
ret = event_read_format(event);
if (ret < 0) {
warning("failed to read event format for %s", event->name);
goto event_failed;
}
ret = event_read_print(event);
if (ret < 0) {
warning("failed to read event print fmt for %s", event->name);
goto event_failed;
}
event->system = strdup(sys);
#define PRINT_ARGS 0
if (PRINT_ARGS && event->print_fmt.args)
print_args(event->print_fmt.args);
add_event(event);
return 0;
event_failed:
event->flags |= EVENT_FL_FAILED;
/* still add it even if it failed */
add_event(event);
return -1;
}
void parse_set_info(int nr_cpus, int long_sz)
{
cpus = nr_cpus;
long_size = long_sz;
}
int common_pc(struct scripting_context *context)
{
return parse_common_pc(context->event_data);
}
int common_flags(struct scripting_context *context)
{
return parse_common_flags(context->event_data);
}
int common_lock_depth(struct scripting_context *context)
{
return parse_common_lock_depth(context->event_data);
}
tools/perf/util/trace-event-read.c
View file @ 73787190
...@@ -52,6 +52,16 @@ static unsigned long page_size; ...@@ -52,6 +52,16 @@ static unsigned long page_size;
static ssize_t calc_data_size; static ssize_t calc_data_size;
static bool repipe; static bool repipe;
static void *malloc_or_die(int size)
{
void *ret;
ret = malloc(size);
if (!ret)
die("malloc");
return ret;
}
static int do_read(int fd, void *buf, int size) static int do_read(int fd, void *buf, int size)
{ {
int rsize = size; int rsize = size;
...@@ -109,7 +119,7 @@ static unsigned int read4(void) ...@@ -109,7 +119,7 @@ static unsigned int read4(void)
unsigned int data; unsigned int data;
read_or_die(&data, 4); read_or_die(&data, 4);
return __data2host4(data); return __data2host4(perf_pevent, data);
} }
static unsigned long long read8(void) static unsigned long long read8(void)
...@@ -117,7 +127,7 @@ static unsigned long long read8(void) ...@@ -117,7 +127,7 @@ static unsigned long long read8(void)
unsigned long long data; unsigned long long data;
read_or_die(&data, 8); read_or_die(&data, 8);
return __data2host8(data); return __data2host8(perf_pevent, data);
} }
static char *read_string(void) static char *read_string(void)
...@@ -282,7 +292,7 @@ struct cpu_data { ...@@ -282,7 +292,7 @@ struct cpu_data {
unsigned long long offset; unsigned long long offset;
unsigned long long size; unsigned long long size;
unsigned long long timestamp; unsigned long long timestamp;
struct record *next; struct pevent_record *next;
char *page; char *page;
int cpu; int cpu;
int index; int index;
...@@ -367,9 +377,9 @@ static int calc_index(void *ptr, int cpu) ...@@ -367,9 +377,9 @@ static int calc_index(void *ptr, int cpu)
return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page; return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
} }
struct record *trace_peek_data(int cpu) struct pevent_record *trace_peek_data(int cpu)
{ {
struct record *data; struct pevent_record *data;
void *page = cpu_data[cpu].page; void *page = cpu_data[cpu].page;
int idx = cpu_data[cpu].index; int idx = cpu_data[cpu].index;
void *ptr = page + idx; void *ptr = page + idx;
...@@ -389,15 +399,15 @@ struct record *trace_peek_data(int cpu) ...@@ -389,15 +399,15 @@ struct record *trace_peek_data(int cpu)
/* FIXME: handle header page */ /* FIXME: handle header page */
if (header_page_ts_size != 8) if (header_page_ts_size != 8)
die("expected a long long type for timestamp"); die("expected a long long type for timestamp");
cpu_data[cpu].timestamp = data2host8(ptr); cpu_data[cpu].timestamp = data2host8(perf_pevent, ptr);
ptr += 8; ptr += 8;
switch (header_page_size_size) { switch (header_page_size_size) {
case 4: case 4:
cpu_data[cpu].page_size = data2host4(ptr); cpu_data[cpu].page_size = data2host4(perf_pevent, ptr);
ptr += 4; ptr += 4;
break; break;
case 8: case 8:
cpu_data[cpu].page_size = data2host8(ptr); cpu_data[cpu].page_size = data2host8(perf_pevent, ptr);
ptr += 8; ptr += 8;
break; break;
default: default:
...@@ -414,7 +424,7 @@ struct record *trace_peek_data(int cpu) ...@@ -414,7 +424,7 @@ struct record *trace_peek_data(int cpu)
return trace_peek_data(cpu); return trace_peek_data(cpu);
} }
type_len_ts = data2host4(ptr); type_len_ts = data2host4(perf_pevent, ptr);
ptr += 4; ptr += 4;
type_len = type_len4host(type_len_ts); type_len = type_len4host(type_len_ts);
...@@ -424,14 +434,14 @@ struct record *trace_peek_data(int cpu) ...@@ -424,14 +434,14 @@ struct record *trace_peek_data(int cpu)
case RINGBUF_TYPE_PADDING: case RINGBUF_TYPE_PADDING:
if (!delta) if (!delta)
die("error, hit unexpected end of page"); die("error, hit unexpected end of page");
length = data2host4(ptr); length = data2host4(perf_pevent, ptr);
ptr += 4; ptr += 4;
length *= 4; length *= 4;
ptr += length; ptr += length;
goto read_again; goto read_again;
case RINGBUF_TYPE_TIME_EXTEND: case RINGBUF_TYPE_TIME_EXTEND:
extend = data2host4(ptr); extend = data2host4(perf_pevent, ptr);
ptr += 4; ptr += 4;
extend <<= TS_SHIFT; extend <<= TS_SHIFT;
extend += delta; extend += delta;
...@@ -442,7 +452,7 @@ struct record *trace_peek_data(int cpu) ...@@ -442,7 +452,7 @@ struct record *trace_peek_data(int cpu)
ptr += 12; ptr += 12;
break; break;
case 0: case 0:
length = data2host4(ptr); length = data2host4(perf_pevent, ptr);
ptr += 4; ptr += 4;
die("here! length=%d", length); die("here! length=%d", length);
break; break;
...@@ -467,9 +477,9 @@ struct record *trace_peek_data(int cpu) ...@@ -467,9 +477,9 @@ struct record *trace_peek_data(int cpu)
return data; return data;
} }
struct record *trace_read_data(int cpu) struct pevent_record *trace_read_data(int cpu)
{ {
struct record *data; struct pevent_record *data;
data = trace_peek_data(cpu); data = trace_peek_data(cpu);
cpu_data[cpu].next = NULL; cpu_data[cpu].next = NULL;
...@@ -509,6 +519,8 @@ ssize_t trace_report(int fd, bool __repipe) ...@@ -509,6 +519,8 @@ ssize_t trace_report(int fd, bool __repipe)
file_bigendian = buf[0]; file_bigendian = buf[0];
host_bigendian = bigendian(); host_bigendian = bigendian();
read_trace_init(file_bigendian, host_bigendian);
read_or_die(buf, 1); read_or_die(buf, 1);
long_size = buf[0]; long_size = buf[0];
...@@ -526,11 +538,11 @@ ssize_t trace_report(int fd, bool __repipe) ...@@ -526,11 +538,11 @@ ssize_t trace_report(int fd, bool __repipe)
repipe = false; repipe = false;
if (show_funcs) { if (show_funcs) {
print_funcs(); pevent_print_funcs(perf_pevent);
return size; return size;
} }
if (show_printk) { if (show_printk) {
print_printk(); pevent_print_printk(perf_pevent);
return size; return size;
} }
......
tools/perf/util/trace-event.h
View file @ 73787190
#ifndef __PERF_TRACE_EVENTS_H #ifndef _PERF_UTIL_TRACE_EVENT_H
#define __PERF_TRACE_EVENTS_H #define _PERF_UTIL_TRACE_EVENT_H
#include <stdbool.h>
#include "parse-events.h" #include "parse-events.h"
#include "event-parse.h"
#include "session.h"
struct machine; struct machine;
struct perf_sample; struct perf_sample;
union perf_event; union perf_event;
struct thread; struct thread;
#define __unused __attribute__((unused)) extern int header_page_size_size;
extern int header_page_ts_size;
extern int header_page_data_offset;
#ifndef PAGE_MASK extern bool latency_format;
#define PAGE_MASK (page_size - 1) extern struct pevent *perf_pevent;
#endif
enum { enum {
RINGBUF_TYPE_PADDING = 29, RINGBUF_TYPE_PADDING = 29,
...@@ -26,246 +27,37 @@ enum { ...@@ -26,246 +27,37 @@ enum {
#define TS_SHIFT 27 #define TS_SHIFT 27
#endif #endif
#define NSECS_PER_SEC 1000000000ULL int bigendian(void);
#define NSECS_PER_USEC 1000ULL
enum format_flags {
FIELD_IS_ARRAY = 1,
FIELD_IS_POINTER = 2,
FIELD_IS_SIGNED = 4,
FIELD_IS_STRING = 8,
FIELD_IS_DYNAMIC = 16,
FIELD_IS_FLAG = 32,
FIELD_IS_SYMBOLIC = 64,
};
struct format_field {
struct format_field *next;
char *type;
char *name;
int offset;
int size;
unsigned long flags;
};
struct format {
int nr_common;
int nr_fields;
struct format_field *common_fields;
struct format_field *fields;
};
struct print_arg_atom {
char *atom;
};
struct print_arg_string {
char *string;
int offset;
};
struct print_arg_field {
char *name;
struct format_field *field;
};
struct print_flag_sym {
struct print_flag_sym *next;
char *value;
char *str;
};
struct print_arg_typecast {
char *type;
struct print_arg *item;
};
struct print_arg_flags {
struct print_arg *field;
char *delim;
struct print_flag_sym *flags;
};
struct print_arg_symbol {
struct print_arg *field;
struct print_flag_sym *symbols;
};
struct print_arg;
struct print_arg_op {
char *op;
int prio;
struct print_arg *left;
struct print_arg *right;
};
struct print_arg_func {
char *name;
struct print_arg *args;
};
enum print_arg_type {
PRINT_NULL,
PRINT_ATOM,
PRINT_FIELD,
PRINT_FLAGS,
PRINT_SYMBOL,
PRINT_TYPE,
PRINT_STRING,
PRINT_OP,
};
struct print_arg {
struct print_arg *next;
enum print_arg_type type;
union {
struct print_arg_atom atom;
struct print_arg_field field;
struct print_arg_typecast typecast;
struct print_arg_flags flags;
struct print_arg_symbol symbol;
struct print_arg_func func;
struct print_arg_string string;
struct print_arg_op op;
};
};
struct print_fmt {
char *format;
struct print_arg *args;
};
struct event {
struct event *next;
char *name;
int id;
int flags;
struct format format;
struct print_fmt print_fmt;
char *system;
};
enum {
EVENT_FL_ISFTRACE = 0x01,
EVENT_FL_ISPRINT = 0x02,
EVENT_FL_ISBPRINT = 0x04,
EVENT_FL_ISFUNC = 0x08,
EVENT_FL_ISFUNCENT = 0x10,
EVENT_FL_ISFUNCRET = 0x20,
EVENT_FL_FAILED = 0x80000000
};
struct record {
unsigned long long ts;
int size;
void *data;
};
struct record *trace_peek_data(int cpu);
struct record *trace_read_data(int cpu);
void parse_set_info(int nr_cpus, int long_sz);
ssize_t trace_report(int fd, bool repipe);
void *malloc_or_die(unsigned int size);
void parse_cmdlines(char *file, int size); int read_trace_init(int file_bigendian, int host_bigendian);
void parse_proc_kallsyms(char *file, unsigned int size); void print_trace_event(int cpu, void *data, int size);
void parse_ftrace_printk(char *file, unsigned int size);
void print_funcs(void); void print_event(int cpu, void *data, int size, unsigned long long nsecs,
void print_printk(void); char *comm);
int parse_ftrace_file(char *buf, unsigned long size); int parse_ftrace_file(char *buf, unsigned long size);
int parse_event_file(char *buf, unsigned long size, char *sys); int parse_event_file(char *buf, unsigned long size, char *sys);
void print_trace_event(int cpu, void *data, int size);
extern int file_bigendian;
extern int host_bigendian;
int bigendian(void);
static inline unsigned short __data2host2(unsigned short data)
{
unsigned short swap;
if (host_bigendian == file_bigendian)
return data;
swap = ((data & 0xffULL) << 8) | struct pevent_record *trace_peek_data(int cpu);
((data & (0xffULL << 8)) >> 8); struct event_format *trace_find_event(int type);
return swap; unsigned long long
} raw_field_value(struct event_format *event, const char *name, void *data);
void *raw_field_ptr(struct event_format *event, const char *name, void *data);
static inline unsigned int __data2host4(unsigned int data)
{
unsigned int swap;
if (host_bigendian == file_bigendian)
return data;
swap = ((data & 0xffULL) << 24) |
((data & (0xffULL << 8)) << 8) |
((data & (0xffULL << 16)) >> 8) |
((data & (0xffULL << 24)) >> 24);
return swap;
}
static inline unsigned long long __data2host8(unsigned long long data)
{
unsigned long long swap;
if (host_bigendian == file_bigendian)
return data;
swap = ((data & 0xffULL) << 56) |
((data & (0xffULL << 8)) << 40) |
((data & (0xffULL << 16)) << 24) |
((data & (0xffULL << 24)) << 8) |
((data & (0xffULL << 32)) >> 8) |
((data & (0xffULL << 40)) >> 24) |
((data & (0xffULL << 48)) >> 40) |
((data & (0xffULL << 56)) >> 56);
return swap;
}
#define data2host2(ptr) __data2host2(*(unsigned short *)ptr) void parse_proc_kallsyms(char *file, unsigned int size __unused);
#define data2host4(ptr) __data2host4(*(unsigned int *)ptr) void parse_ftrace_printk(char *file, unsigned int size __unused);
#define data2host8(ptr) ({ \
unsigned long long __val; \
\
memcpy(&__val, (ptr), sizeof(unsigned long long)); \
__data2host8(__val); \
})
extern int header_page_ts_offset; ssize_t trace_report(int fd, bool repipe);
extern int header_page_ts_size;
extern int header_page_size_offset;
extern int header_page_size_size;
extern int header_page_data_offset;
extern int header_page_data_size;
extern bool latency_format;
int trace_parse_common_type(void *data); int trace_parse_common_type(void *data);
int trace_parse_common_pid(void *data); int trace_parse_common_pid(void *data);
int parse_common_pc(void *data);
int parse_common_flags(void *data); struct event_format *trace_find_next_event(struct event_format *event);
int parse_common_lock_depth(void *data);
struct event *trace_find_event(int id);
struct event *trace_find_next_event(struct event *event);
unsigned long long read_size(void *ptr, int size); unsigned long long read_size(void *ptr, int size);
unsigned long long
raw_field_value(struct event *event, const char *name, void *data);
void *raw_field_ptr(struct event *event, const char *name, void *data);
unsigned long long eval_flag(const char *flag); unsigned long long eval_flag(const char *flag);
struct pevent_record *trace_read_data(int cpu);
int read_tracing_data(int fd, struct list_head *pattrs); int read_tracing_data(int fd, struct list_head *pattrs);
struct tracing_data { struct tracing_data {
...@@ -280,15 +72,6 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs, ...@@ -280,15 +72,6 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
void tracing_data_put(struct tracing_data *tdata); void tracing_data_put(struct tracing_data *tdata);
/* taken from kernel/trace/trace.h */
enum trace_flag_type {
TRACE_FLAG_IRQS_OFF = 0x01,
TRACE_FLAG_IRQS_NOSUPPORT = 0x02,
TRACE_FLAG_NEED_RESCHED = 0x04,
TRACE_FLAG_HARDIRQ = 0x08,
TRACE_FLAG_SOFTIRQ = 0x10,
};
struct scripting_ops { struct scripting_ops {
const char *name; const char *name;
int (*start_script) (const char *script, int argc, const char **argv); int (*start_script) (const char *script, int argc, const char **argv);
...@@ -314,4 +97,4 @@ int common_pc(struct scripting_context *context); ...@@ -314,4 +97,4 @@ int common_pc(struct scripting_context *context);
int common_flags(struct scripting_context *context); int common_flags(struct scripting_context *context);
int common_lock_depth(struct scripting_context *context); int common_lock_depth(struct scripting_context *context);
#endif /* __PERF_TRACE_EVENTS_H */ #endif /* _PERF_UTIL_TRACE_EVENT_H */
tools/scripts/Makefile.include
View file @ 73787190
ifeq ("$(origin O)", "command line") ifeq ("$(origin O)", "command line")
OUTPUT := $(O)/ OUTPUT := $(O)/
COMMAND_O := O=$(O)
endif endif
ifneq ($(OUTPUT),) ifneq ($(OUTPUT),)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7