X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=a1cfc0dcbd6dc86e6196ba891c295073e5d199a4;hb=ad34d11603355415efdf377595143e232f64118f;hp=f2f978828887be8101a6f237c930d09643a4b49a;hpb=47aa6e5829423aabcb60f4f318ea862a36cedf9e;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index f2f97882..a1cfc0dc 100644 --- a/ltt/branches/poly/lttv/lttv/filter.c +++ b/ltt/branches/poly/lttv/lttv/filter.c @@ -1,5 +1,5 @@ /* This file is part of the Linux Trace Toolkit viewer - * Copyright (C) 2003-2005 Michel Dagenais + * Copyright (C) 2003-2005 Michel Dagenais and Simon Bouvier-Zappa * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License Version 2 as @@ -16,122 +16,107 @@ * MA 02111-1307, USA. */ -/* - read_token - - read_expression - ( read expr ) - simple expr [ op expr ] - - read_simple_expression - read_field_path [ rel value ] - - read_field_path - read_field_component [. field path] - - read_field_component - name [ \[ value \] ] - - data struct: - and/or(left/right) - not(child) - op(left/right) - path(component...) -> field - - consist in AND, OR and NOT nested expressions, forming a tree with - simple relations as leaves. The simple relations test is a field - in an event is equal, not equal, smaller, smaller or equal, larger, or - larger or equal to a specified value. -*/ - -/* - * YET TO BE ANSWERED - * - none yet +/*! \file lttv/lttv/filter.c + * \brief Defines the core filter of application + * + * consist in AND, OR and NOT nested expressions, forming a tree with + * simple relations as leaves. The simple relations test if a field + * in an event is equal, not equal, smaller, smaller or equal, larger, or + * larger or equal to a specified value. + * + * Fields specified in a simple expression can take following + * values + * + * \verbatim + * LttvTracefileContext{} + * |->event\ + * | |->name (String, converted to GQuark) + * | |->facility (String, converted to GQuark) + * | |->category (String, not yet implemented) + * | |->time (LttTime) + * | |->tsc (LttCycleCount --> uint64) + * | |->fields + * | |->"event name" + * | |->"field name" + * | |->"sub-field name" + * | |->... + * | |->"leaf-field name" (field type) + * |->tracefile + * | |->name (String, converted to GQuark) + * |->trace + * | |->name (String, converted to GQuark) + * |->state + * |->pid (guint) + * |->ppid (guint) + * |->creation_time (LttTime) + * |->insertion_time (LttTime) + * |->process_name (String, converted to GQuark) + * |->execution_mode (LttvExecutionMode) + * |->execution_submode (LttvExecutionSubmode) + * |->process_status (LttvProcessStatus) + * |->cpu (guint) + * \endverbatim */ /* - * TODO + * \todo * - refine switch of expression in multiple uses functions - * - remove the idle expressions in the tree **** - * - add the current simple expression to the tree + * - remove the idle expressions in the tree */ -#include +#ifdef HAVE_CONFIG_H +#include +#endif -/* -GQuark - LTTV_FILTER_TRACE, - LTTV_FILTER_TRACESET, - LTTV_FILTER_TRACEFILE, - LTTV_FILTER_STATE, - LTTV_FILTER_EVENT, - LTTV_FILTER_NAME, - LTTV_FILTER_CATEGORY, - LTTV_FILTER_TIME, - LTTV_FILTER_TSC, - LTTV_FILTER_PID, - LTTV_FILTER_PPID, - LTTV_FILTER_C_TIME, - LTTV_FILTER_I_TIME, - LTTV_FILTER_P_NAME, - LTTV_FILTER_EX_MODE, - LTTV_FILTER_EX_SUBMODE, - LTTV_FILTER_P_STATUS, - LTTV_FILTER_CPU; -*/ +//#define TEST +#ifdef TEST +#include +#include +#endif -LttvSimpleExpression* -lttv_simple_expression_new() { +#include +#include +#include +#include +#include +#include -} /** - * add a node to the current tree - * @param stack the tree stack - * @param subtree the subtree if available (pointer or NULL) - * @param op the logical operator that will form the node + * @fn LttvSimpleExpression* lttv_simple_expression_new() + * + * Constructor for LttvSimpleExpression + * @return pointer to new LttvSimpleExpression */ -void -lttv_filter_tree_add_node(GPtrArray* stack, LttvFilterTree* subtree, LttvLogicalOp op) { - - LttvFilterTree* t1 = NULL; - LttvFilterTree* t2 = NULL; - - t1 = (LttvFilterTree*)g_ptr_array_index(stack,stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; - t2 = lttv_filter_tree_new(); - t2->node = op; - if(subtree != NULL) { - t2->left = LTTV_TREE_NODE; - t2->l_child.t = subtree; - subtree = NULL; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - } else { -// a_simple_expression->value = a_field_component->str; -// a_field_component = g_string_new(""); - t2->left = LTTV_TREE_LEAF; -// t2->l_child.leaf = a_simple_expression; -// a_simple_expression = g_new(lttv_simple_expression,1); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - } - +LttvSimpleExpression* +lttv_simple_expression_new() { + + LttvSimpleExpression* se = g_new(LttvSimpleExpression,1); + + se->field = LTTV_FILTER_UNDEFINED; + se->op = NULL; + se->offset = 0; + + return se; } /** + * @fn gboolean lttv_simple_expression_assign_field(GPtrArray*,LttvSimpleExpression*) + * * Parse through filtering field hierarchy as specified * by user. This function compares each value to * predetermined quarks * @param fp The field path list + * @param se current simple expression * @return success/failure of operation */ gboolean -parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { +lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { GString* f = NULL; + if(fp->len < 2) return FALSE; - g_assert(f=g_ptr_array_index(fp,0)); //list_first(fp)->data; - + g_assert((f=g_ptr_array_remove_index(fp,0))); + /* * Parse through the specified * hardcoded fields. @@ -145,27 +130,31 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * subfields, it will be considered * as a dynamic field */ - if(g_strcasecmp(f->str,"trace") ) { + if(!g_strcasecmp(f->str,"trace") ) { /* * Possible values: * trace.name */ - f=g_ptr_array_index(fp,1); - if(g_strcasecmp(f->str,"name")) {} - else return FALSE; - } else if(g_strcasecmp(f->str,"traceset") ) { + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + if(!g_strcasecmp(f->str,"name")) { + se->field = LTTV_FILTER_TRACE_NAME; + } + } else if(!g_strcasecmp(f->str,"traceset") ) { /* * FIXME: not yet implemented ! */ - } else if(g_strcasecmp(f->str,"tracefile") ) { + } else if(!g_strcasecmp(f->str,"tracefile") ) { /* * Possible values: * tracefile.name */ - f=g_ptr_array_index(fp,1); - if(g_strcasecmp(f->str,"name")) {} - else return FALSE; - } else if(g_strcasecmp(f->str,"state") ) { + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + if(!g_strcasecmp(f->str,"name")) { + se->field = LTTV_FILTER_TRACEFILE_NAME; + } + } else if(!g_strcasecmp(f->str,"state") ) { /* * Possible values: * state.pid @@ -178,312 +167,1017 @@ parse_field_path(GPtrArray* fp, LttvSimpleExpression* se) { * state.process_status * state.cpu */ - f=g_ptr_array_index(fp,1); - if(g_strcasecmp(f->str,"pid") ) {} - else if(g_strcasecmp(f->str,"ppid") ) {} - else if(g_strcasecmp(f->str,"creation_time") ) {} - else if(g_strcasecmp(f->str,"insertion_time") ) {} - else if(g_strcasecmp(f->str,"process_name") ) {} - else if(g_strcasecmp(f->str,"execution_mode") ) {} - else if(g_strcasecmp(f->str,"execution_submode") ) {} - else if(g_strcasecmp(f->str,"process_status") ) {} - else if(g_strcasecmp(f->str,"cpu") ) {} - else return FALSE; - } else if(g_strcasecmp(f->str,"event") ) { - f=g_ptr_array_index(fp,1); - if(g_strcasecmp(f->str,"name") ) {} - else if(g_strcasecmp(f->str,"category") ) {} - else if(g_strcasecmp(f->str,"time") ) { - // offset = &((LttEvent*)NULL)->event_time); + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + if(!g_strcasecmp(f->str,"pid") ) { + se->field = LTTV_FILTER_STATE_PID; + } + else if(!g_strcasecmp(f->str,"ppid") ) { + se->field = LTTV_FILTER_STATE_PPID; + } + else if(!g_strcasecmp(f->str,"creation_time") ) { + se->field = LTTV_FILTER_STATE_CT; + } + else if(!g_strcasecmp(f->str,"insertion_time") ) { + se->field = LTTV_FILTER_STATE_IT; + } + else if(!g_strcasecmp(f->str,"process_name") ) { + se->field = LTTV_FILTER_STATE_P_NAME; + } + else if(!g_strcasecmp(f->str,"execution_mode") ) { + se->field = LTTV_FILTER_STATE_EX_MODE; + } + else if(!g_strcasecmp(f->str,"execution_submode") ) { + se->field = LTTV_FILTER_STATE_EX_SUBMODE; + } + else if(!g_strcasecmp(f->str,"process_status") ) { + se->field = LTTV_FILTER_STATE_P_STATUS; + } + else if(!g_strcasecmp(f->str,"cpu") ) { + se->field = LTTV_FILTER_STATE_CPU; + } + } else if(!g_strcasecmp(f->str,"event") ) { + /* + * Possible values: + * event.name + * event.category + * event.time + * event.tsc + */ + g_string_free(f,TRUE); + f=g_ptr_array_remove_index(fp,0); + if(!g_strcasecmp(f->str,"name") ) { + se->field = LTTV_FILTER_EVENT_NAME; + } + else if(!g_strcasecmp(f->str,"facility") ) { + se->field = LTTV_FILTER_EVENT_FACILITY; + } + else if(!g_strcasecmp(f->str,"category") ) { + /* + * FIXME: Category not yet functional in lttv + */ + se->field = LTTV_FILTER_EVENT_CATEGORY; + } + else if(!g_strcasecmp(f->str,"time") ) { + se->field = LTTV_FILTER_EVENT_TIME; } - else if(g_strcasecmp(f->str,"tsc") ) { - // offset = &((LttEvent*)NULL)->event_cycle_count); + else if(!g_strcasecmp(f->str,"tsc") ) { + se->field = LTTV_FILTER_EVENT_TSC; } else { /* core.xml specified options */ - + se->field = LTTV_FILTER_EVENT_FIELD; } } else { g_warning("Unrecognized field in filter string"); - return FALSE; } + /* free memory for last string */ + g_string_free(f,TRUE); + + /* array should be empty */ + g_assert(fp->len == 0); + + if(se->field == LTTV_FILTER_UNDEFINED) { + g_warning("The specified field was not recognized !"); + return FALSE; + } return TRUE; } /** - * Add an filtering option to the current tree - * @param expression Current expression to parse - * @return success/failure of operation + * @fn gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression*,LttvExpressionOp) + * + * Sets the function pointer for the current + * Simple Expression + * @param se current simple expression + * @param op current operator + * @return success/failure of operation */ -gboolean -parse_simple_expression(GString* expression) { - - unsigned i; +gboolean +lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { + + switch(se->field) { + /* + * string + */ + case LTTV_FILTER_TRACE_NAME: + case LTTV_FILTER_TRACEFILE_NAME: + case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: + case LTTV_FILTER_STATE_EX_MODE: + case LTTV_FILTER_STATE_EX_SUBMODE: + case LTTV_FILTER_STATE_P_STATUS: + switch(op) { + case LTTV_FIELD_EQ: + se->op = lttv_apply_op_eq_quark; + break; + case LTTV_FIELD_NE: + se->op = lttv_apply_op_ne_quark; + break; + default: + g_warning("Error encountered in operator assignment = or != expected"); + return FALSE; + } + break; + /* + * integer + */ + case LTTV_FILTER_EVENT_TSC: + switch(op) { + case LTTV_FIELD_EQ: + se->op = lttv_apply_op_eq_uint64; + break; + case LTTV_FIELD_NE: + se->op = lttv_apply_op_ne_uint64; + break; + case LTTV_FIELD_LT: + se->op = lttv_apply_op_lt_uint64; + break; + case LTTV_FIELD_LE: + se->op = lttv_apply_op_le_uint64; + break; + case LTTV_FIELD_GT: + se->op = lttv_apply_op_gt_uint64; + break; + case LTTV_FIELD_GE: + se->op = lttv_apply_op_ge_uint64; + break; + default: + g_warning("Error encountered in operator assignment"); + return FALSE; + } + break; + /* + * unsigned integers + */ + case LTTV_FILTER_STATE_CPU: + case LTTV_FILTER_STATE_PID: + case LTTV_FILTER_STATE_PPID: + switch(op) { + case LTTV_FIELD_EQ: + se->op = lttv_apply_op_eq_uint; + break; + case LTTV_FIELD_NE: + se->op = lttv_apply_op_ne_uint; + break; + case LTTV_FIELD_LT: + se->op = lttv_apply_op_lt_uint; + break; + case LTTV_FIELD_LE: + se->op = lttv_apply_op_le_uint; + break; + case LTTV_FIELD_GT: + se->op = lttv_apply_op_gt_uint; + break; + case LTTV_FIELD_GE: + se->op = lttv_apply_op_ge_uint; + break; + default: + g_warning("Error encountered in operator assignment"); + return FALSE; + } + break; + + /* + * Enums + * Entered as string, converted to enum + * + * can only be compared with 'equal' or 'not equal' operators + * + * unsigned int of 16 bits are used here since enums + * should not go over 2^16-1 values + */ +// case /*NOTHING*/: +// switch(op) { +// case LTTV_FIELD_EQ: +// se->op = lttv_apply_op_eq_uint16; +// break; +// case LTTV_FIELD_NE: +// se->op = lttv_apply_op_ne_uint16; +// break; +// default: +// g_warning("Error encountered in operator assignment = or != expected"); +// return FALSE; +// } +// break; + /* + * Ltttime + */ + case LTTV_FILTER_STATE_CT: + case LTTV_FILTER_STATE_IT: + case LTTV_FILTER_EVENT_TIME: + switch(op) { + case LTTV_FIELD_EQ: + se->op = lttv_apply_op_eq_ltttime; + break; + case LTTV_FIELD_NE: + se->op = lttv_apply_op_ne_ltttime; + break; + case LTTV_FIELD_LT: + se->op = lttv_apply_op_lt_ltttime; + break; + case LTTV_FIELD_LE: + se->op = lttv_apply_op_le_ltttime; + break; + case LTTV_FIELD_GT: + se->op = lttv_apply_op_gt_ltttime; + break; + case LTTV_FIELD_GE: + se->op = lttv_apply_op_ge_ltttime; + break; + default: + g_warning("Error encountered in operator assignment"); + return FALSE; + } + break; + default: + g_warning("Error encountered in operator assignation ! Field type:%i",se->field); + return FALSE; + } + + return TRUE; + +} + +/** + * @fn gboolean lttv_simple_expression_assign_value(LttvSimpleExpression*,char*) + * + * Assign the value field to the current LttvSimpleExpression + * @param se pointer to the current LttvSimpleExpression + * @param value string value for simple expression + */ +gboolean +lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { + unsigned i; + gboolean is_double = FALSE; + LttTime t = ltt_time_zero; + GString* v; + + switch(se->field) { + /* + * Strings + * entered as strings, converted to Quarks + */ + case LTTV_FILTER_TRACE_NAME: + case LTTV_FILTER_TRACEFILE_NAME: + case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: + case LTTV_FILTER_STATE_EX_MODE: + case LTTV_FILTER_STATE_EX_SUBMODE: + case LTTV_FILTER_STATE_P_STATUS: + // se->value.v_string = value; + se->value.v_uint32 = g_quark_from_string(value); + g_free(value); + break; + /* + * integer -- supposed to be uint64 + */ + case LTTV_FILTER_EVENT_TSC: + se->value.v_uint64 = atoi(value); + g_free(value); + break; + /* + * unsigned integers + */ + case LTTV_FILTER_STATE_PID: + case LTTV_FILTER_STATE_PPID: + case LTTV_FILTER_STATE_CPU: + se->value.v_uint = atoi(value); + g_free(value); + break; + /* + * LttTime + */ + case LTTV_FILTER_STATE_CT: + case LTTV_FILTER_STATE_IT: + case LTTV_FILTER_EVENT_TIME: + //se->value.v_double = atof(value); + /* + * parsing logic could be optimised, + * but as for now, simpler this way + */ + v = g_string_new(""); + for(i=0;istr); + g_string_free(v,TRUE); + v = g_string_new(""); + } else g_string_append_c(v,value[i]); + } + /* number can be integer or double */ + if(is_double) t.tv_nsec = atoi(v->str); + else t.tv_sec = atoi(v->str); + + g_string_free(v,TRUE); + + se->value.v_ltttime = t; + g_free(value); + break; + default: + g_warning("Error encountered in value assignation ! Field type = %i",se->field); + g_free(value); + return FALSE; + } + return TRUE; + +} + +/** + * @fn void lttv_simple_expression_destroy(LttvSimpleExpression*) + * + * Disallocate memory for the current + * simple expression + * @param se pointer to the current LttvSimpleExpression + */ +void +lttv_simple_expression_destroy(LttvSimpleExpression* se) { + + // g_free(se->value); +// switch(se->field) { +// case LTTV_FILTER_TRACE_NAME: +// case LTTV_FILTER_TRACEFILE_NAME: +// case LTTV_FILTER_STATE_P_NAME: +// case LTTV_FILTER_EVENT_NAME: +// g_free(se->value.v_string); +// break; +// } + g_free(se); + +} + +/** + * @fn gint lttv_struct_type(gint) + * + * Finds the structure type depending + * on the fields in parameters + * @params ft Field of the current structure + * @return LttvStructType enum or -1 for error + */ +gint +lttv_struct_type(gint ft) { + + switch(ft) { + case LTTV_FILTER_TRACE_NAME: + return LTTV_FILTER_TRACE; + break; + case LTTV_FILTER_TRACEFILE_NAME: + return LTTV_FILTER_TRACEFILE; + break; + case LTTV_FILTER_STATE_PID: + case LTTV_FILTER_STATE_PPID: + case LTTV_FILTER_STATE_CT: + case LTTV_FILTER_STATE_IT: + case LTTV_FILTER_STATE_P_NAME: + case LTTV_FILTER_STATE_EX_MODE: + case LTTV_FILTER_STATE_EX_SUBMODE: + case LTTV_FILTER_STATE_P_STATUS: + case LTTV_FILTER_STATE_CPU: + return LTTV_FILTER_STATE; + break; + case LTTV_FILTER_EVENT_NAME: + case LTTV_FILTER_EVENT_FACILITY: + case LTTV_FILTER_EVENT_CATEGORY: + case LTTV_FILTER_EVENT_TIME: + case LTTV_FILTER_EVENT_TSC: + case LTTV_FILTER_EVENT_FIELD: + return LTTV_FILTER_EVENT; + break; + default: + return -1; + } +} + +/** + * @fn gboolean lttv_apply_op_eq_uint(gpointer,LttvFieldValue) + * + * Applies the 'equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_eq_uint(const gpointer v1, LttvFieldValue v2) { + + guint* r = (guint*) v1; + return (*r == v2.v_uint); + +} + +/** + * @fn gboolean lttv_apply_op_eq_uint64(gpointer,LttvFieldValue) + * + * Applies the 'equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_eq_uint64(const gpointer v1, LttvFieldValue v2) { + + guint64* r = (guint64*) v1; + return (*r == v2.v_uint64); +} +/** + * @fn gboolean lttv_apply_op_eq_uint32(gpointer,LttvFieldValue) + * + * Applies the 'equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_eq_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r == v2.v_uint32); } /** + * @fn gboolean lttv_apply_op_eq_uint16(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_eq_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r == v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_eq_double(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_eq_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r == v2.v_double); +} /** + * @fn gboolean lttv_apply_op_eq_string(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) { + char* r = (char*) v1; + return (!g_strcasecmp(r,v2.v_string)); +} /** + * @fn gboolean lttv_apply_op_eq_quark(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_double(double v1, double v2) {} +gboolean lttv_apply_op_eq_quark(const gpointer v1, LttvFieldValue v2) { + GQuark* r = (GQuark*) v1; +// g_print("v1:%i v2:%i\n",*r,v2.v_uint32); + return (*r == v2.v_uint32); +} /** + * @fn gboolean lttv_apply_op_eq_ltttime(gpointer,LttvFieldValue) + * * Applies the 'equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_string(char* v1, char* v2) {} +gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ltt_time_compare(*r, v2.v_ltttime)==0?1:0; +} + +/** + * @fn gboolean lttv_apply_op_ne_uint(gpointer,LttvFieldValue) + * + * Applies the 'not equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ne_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r != v2.v_uint); +} + +/** + * @fn gboolean lttv_apply_op_ne_uint64(gpointer,LttvFieldValue) + * + * Applies the 'not equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ne_uint64(const gpointer v1, LttvFieldValue v2) { + guint64* r = (guint64*) v1; + return (*r != v2.v_uint64); +} + +/** + * @fn gboolean lttv_apply_op_ne_uint32(gpointer,LttvFieldValue) + * + * Applies the 'not equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ne_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r != v2.v_uint32); +} /** + * @fn gboolean lttv_apply_op_ne_uint16(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_ne_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r != v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_ne_double(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_ne_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r != v2.v_double); +} /** + * @fn gboolean lttv_apply_op_ne_string(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_ne_string(const gpointer v1, LttvFieldValue v2) { + char* r = (char*) v1; + return (g_strcasecmp(r,v2.v_string)); +} /** + * @fn gboolean lttv_apply_op_ne_quark(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_double(double v1, double v2) {} +gboolean lttv_apply_op_ne_quark(const gpointer v1, LttvFieldValue v2) { + GQuark* r = (GQuark*) v1; + return (*r != v2.v_uint32); +} + /** + * @fn gboolean lttv_apply_op_ne_ltttime(gpointer,LttvFieldValue) + * * Applies the 'not equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_string(char* v1, char* v2) {} +gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; + return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0; +} /** + * @fn gboolean lttv_apply_op_lt_uint(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_lt_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r < v2.v_uint); +} /** + * @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_lt_uint64(const gpointer v1, LttvFieldValue v2) { + guint64* r = (guint64*) v1; + return (*r < v2.v_uint64); +} /** + * @fn gboolean lttv_apply_op_lt_uint32(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_lt_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r < v2.v_uint32); +} /** + * @fn gboolean lttv_apply_op_lt_uint16(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_double(double v1, double v2) {} +gboolean lttv_apply_op_lt_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r < v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_lt_double(gpointer,LttvFieldValue) + * * Applies the 'lower than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_lt_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r < v2.v_double); +} /** + * @fn gboolean lttv_apply_op_lt_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'lower than' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_lt_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; +// return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec < v2.v_ltttime.tv_nsec))); + return ltt_time_compare(*r, v2.v_ltttime)==-1?1:0; +} + +/** + * @fn gboolean lttv_apply_op_le_uint(gpointer,LttvFieldValue) + * + * Applies the 'lower or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_le_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r <= v2.v_uint); +} + +/** + * @fn gboolean lttv_apply_op_le_uint64(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_le_uint64(const gpointer v1, LttvFieldValue v2) { + guint64* r = (guint64*) v1; + return (*r <= v2.v_uint64); +} /** + * @fn gboolean lttv_apply_op_le_uint32(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_le_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r <= v2.v_uint32); +} /** + * @fn gboolean lttv_apply_op_le_uint16(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_double(double v1, double v2) {} +gboolean lttv_apply_op_le_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r <= v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_le_double(gpointer,LttvFieldValue) + * * Applies the 'lower or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_le_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r <= v2.v_double); +} /** + * @fn gboolean lttv_apply_op_le_ltttime(gpointer,LttvFieldValue) + * + * Applies the 'lower or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_le_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; +// return ((r->tv_sec < v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec <= v2.v_ltttime.tv_nsec))); + return ltt_time_compare(*r, v2.v_ltttime)<1?1:0; +} + + +/** + * @fn gboolean lttv_apply_op_gt_uint(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_gt_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r > v2.v_uint); +} /** + * @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_gt_uint64(const gpointer v1, LttvFieldValue v2) { + guint64* r = (guint64*) v1; + return (*r > v2.v_uint64); +} + +/** + * @fn gboolean lttv_apply_op_gt_uint32(gpointer,LttvFieldValue) + * + * Applies the 'greater than' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_gt_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r > v2.v_uint32); +} + +/** + * @fn gboolean lttv_apply_op_gt_uint16(gpointer,LttvFieldValue) + * + * Applies the 'greater than' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_gt_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r > v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_gt_double(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_double(double v1, double v2) {} +gboolean lttv_apply_op_gt_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r > v2.v_double); +} /** + * @fn gboolean lttv_apply_op_gt_ltttime(gpointer,LttvFieldValue) + * * Applies the 'greater than' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint64(guint64 v1, guint64 v2) {} +gboolean lttv_apply_op_gt_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; +// return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec > v2.v_ltttime.tv_nsec))); + return ltt_time_compare(*r, v2.v_ltttime)==1?1:0; +} + +/** + * @fn gboolean lttv_apply_op_ge_uint(gpointer,LttvFieldValue) + * + * Applies the 'greater or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ge_uint(const gpointer v1, LttvFieldValue v2) { + guint* r = (guint*) v1; + return (*r >= v2.v_uint); +} + +/** + * @fn gboolean lttv_apply_op_ge_uint64(gpointer,LttvFieldValue) + * + * Applies the 'greater or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ge_uint64(const gpointer v1, LttvFieldValue v2) { + guint64* r = (guint64*) v1; + return (*r >= v2.v_uint64); +} + +/** + * @fn gboolean lttv_apply_op_ge_uint32(gpointer,LttvFieldValue) + * + * Applies the 'greater or equal' operator to the + * specified structure and value + * @param v1 left member of comparison + * @param v2 right member of comparison + * @return success/failure of operation + */ +gboolean lttv_apply_op_ge_uint32(const gpointer v1, LttvFieldValue v2) { + guint32* r = (guint32*) v1; + return (*r >= v2.v_uint32); +} /** + * @fn gboolean lttv_apply_op_ge_uint16(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint32(guint32 v1, guint32 v2) {} +gboolean lttv_apply_op_ge_uint16(const gpointer v1, LttvFieldValue v2) { + guint16* r = (guint16*) v1; + return (*r >= v2.v_uint16); +} /** + * @fn gboolean lttv_apply_op_ge_double(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint16(guint16 v1, guint16 v2) {} +gboolean lttv_apply_op_ge_double(const gpointer v1, LttvFieldValue v2) { + double* r = (double*) v1; + return (*r >= v2.v_double); +} /** + * @fn gboolean lttv_apply_op_ge_ltttime(gpointer,LttvFieldValue) + * * Applies the 'greater or equal' operator to the * specified structure and value * @param v1 left member of comparison * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_double(double v1, double v2) {} +gboolean lttv_apply_op_ge_ltttime(const gpointer v1, LttvFieldValue v2) { + LttTime* r = (LttTime*) v1; +// return ((r->tv_sec > v2.v_ltttime.tv_sec) || ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec >= v2.v_ltttime.tv_nsec))); + return ltt_time_compare(*r, v2.v_ltttime)>-1?1:0; +} + /** - * Makes a copy of the current filter tree - * @param tree pointer to the current tree - * @return new copy of the filter tree + * Makes a copy of the current filter tree + * @param tree pointer to the current tree + * @return new copy of the filter tree */ LttvFilterTree* -lttv_filter_tree_clone(LttvFilterTree* tree) { +lttv_filter_tree_clone(const LttvFilterTree* tree) { - + LttvFilterTree* newtree = lttv_filter_tree_new(); + newtree->node = tree->node; + + newtree->left = tree->left; + if(newtree->left == LTTV_TREE_NODE) { + newtree->l_child.t = lttv_filter_tree_clone(tree->l_child.t); + } else if(newtree->left == LTTV_TREE_LEAF) { + newtree->l_child.leaf = lttv_simple_expression_new(); + newtree->l_child.leaf->field = tree->l_child.leaf->field; + newtree->l_child.leaf->offset = tree->l_child.leaf->offset; + newtree->l_child.leaf->op = tree->l_child.leaf->op; + /* FIXME: special case for string copy ! */ + newtree->l_child.leaf->value = tree->l_child.leaf->value; + } + + newtree->right = tree->right; + if(newtree->right == LTTV_TREE_NODE) { + newtree->r_child.t = lttv_filter_tree_clone(tree->r_child.t); + } else if(newtree->right == LTTV_TREE_LEAF) { + newtree->r_child.leaf = lttv_simple_expression_new(); + newtree->r_child.leaf->field = tree->r_child.leaf->field; + newtree->r_child.leaf->offset = tree->r_child.leaf->offset; + newtree->r_child.leaf->op = tree->r_child.leaf->op; + newtree->r_child.leaf->value = tree->r_child.leaf->value; + } + + return newtree; + } /** - * Makes a copy of the current filter - * @param filter pointer to the current filter - * @return new copy of the filter + * Makes a copy of the current filter + * @param filter pointer to the current filter + * @return new copy of the filter */ LttvFilter* -lttv_filter_clone(LttvFilter* filter) { +lttv_filter_clone(const LttvFilter* filter) { + + if(!filter) return NULL; - LttvFilter* newfilter = g_new(LttvFilter,1); - // newfilter->expression = g_new(char,1) strcpy(newfilter->expression,filter->expression); newfilter->head = lttv_filter_tree_clone(filter->head); @@ -494,28 +1188,58 @@ lttv_filter_clone(LttvFilter* filter) { /** - * Creates a new lttv_filter - * @param expression filtering options string - * @param t pointer to the current LttvTrace - * @return the current lttv_filter or NULL if error + * @fn LttvFilter* lttv_filter_new() + * + * Creates a new LttvFilter + * @return the current LttvFilter or NULL if error */ LttvFilter* -lttv_filter_new(char *expression, LttvTraceState *tcs) { +lttv_filter_new() { - g_print("filter::lttv_filter_new()\n"); /* debug */ + LttvFilter* filter = g_new(LttvFilter,1); + filter->expression = NULL; + filter->head = NULL; - unsigned + return filter; + +} + +/** + * @fn gboolean lttv_filter_update(LttvFilter*) + * + * Updates the current LttvFilter by building + * its tree based upon the expression string + * @param filter pointer to the current LttvFilter + * @return Failure/Success of operation + */ +gboolean +lttv_filter_update(LttvFilter* filter) { + +// g_print("filter::lttv_filter_new()\n"); /* debug */ + + if(filter->expression == NULL) return FALSE; + + int i, p_nesting=0, /* parenthesis nesting value */ - b=0; /* current breakpoint in expression string */ - + not=0; + /* trees */ LttvFilterTree *tree = lttv_filter_tree_new(), /* main tree */ *subtree = NULL, /* buffer for subtrees */ *t1, /* buffer #1 */ - *t2; /* buffer #2 */ + *t2, /* buffer #2 */ + *t3; /* buffer #3 */ + /* + * the filter + * If the tree already exists, + * destroy it and build a new one + */ + if(filter->head != NULL) lttv_filter_tree_destroy(filter->head); + filter->head = NULL; /* will be assigned at the end */ + /* * Tree Stack * each element of the list @@ -530,9 +1254,10 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { /* temporary values */ GString *a_field_component = g_string_new(""); - GPtrArray *a_field_path = NULL; - - LttvSimpleExpression* a_simple_expression = g_new(LttvSimpleExpression,1); + GPtrArray *a_field_path = g_ptr_array_new(); + + /* simple expression buffer */ + LttvSimpleExpression* a_simple_expression = lttv_simple_expression_new(); /* * Parse entire expression and construct @@ -564,139 +1289,188 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * 2. the subtree is completed, allocate a new subtree * 3. pop the tree value from the tree stack */ + +#ifdef TEST + struct timeval starttime; + struct timeval endtime; + gettimeofday(&starttime, NULL); +#endif - a_field_path = g_ptr_array_new(); - g_ptr_array_set_size(a_field_path,2); /* by default, recording 2 field expressions */ - - - for(i=0;istr); - g_print("%c ",expression[i]); -// g_print("switch:%c -->subtree:%p\n",expression[i],subtree); - switch(expression[i]) { + for(i=0;iexpression);i++) { + // debug +// g_print("%c\n ",filter->expression[i]); + + switch(filter->expression[i]) { /* * logical operators */ case '&': /* and */ + + /* get current tree in tree stack */ t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + + /* get current node at absolute right */ + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_AND; - if(subtree != NULL) { + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + if(not) { /* add not operator to tree */ + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t2->left = LTTV_TREE_NODE; + t2->l_child.t = t3; + t2 = t3; + not = 0; + } + if(subtree != NULL) { /* append subtree to current tree */ t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; subtree = NULL; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - } else { - a_simple_expression->value = a_field_component->str; + } else { /* append a simple expression */ + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; - a_simple_expression = g_new(LttvSimpleExpression,1); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + a_simple_expression = lttv_simple_expression_new(); } - break; + case '|': /* or */ - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_OR; - if(subtree != NULL) { + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + if(not) { // add not operator to tree + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t2->left = LTTV_TREE_NODE; + t2->l_child.t = t3; + t2 = t3; + not = 0; + } + if(subtree != NULL) { /* append subtree to current tree */ t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; subtree = NULL; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - } else { - a_simple_expression->value = a_field_component->str; + } else { /* append a simple expression */ + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; - a_simple_expression = g_new(LttvSimpleExpression,1); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + a_simple_expression = lttv_simple_expression_new(); } break; + case '^': /* xor */ - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + + t1 = (LttvFilterTree*)g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_XOR; - if(subtree != NULL) { + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t2; + if(not) { // add not operator to tree + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t2->left = LTTV_TREE_NODE; + t2->l_child.t = t3; + t2 = t3; + not = 0; + } + if(subtree != NULL) { /* append subtree to current tree */ t2->left = LTTV_TREE_NODE; t2->l_child.t = subtree; subtree = NULL; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - } else { - a_simple_expression->value = a_field_component->str; + } else { /* append a simple expression */ + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); t2->left = LTTV_TREE_LEAF; t2->l_child.leaf = a_simple_expression; - a_simple_expression = g_new(LttvSimpleExpression,1); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + a_simple_expression = lttv_simple_expression_new(); } break; + case '!': /* not, or not equal (math op) */ - if(expression[i+1] == '=') { /* != */ - a_simple_expression->op = LTTV_FIELD_NE; - i++; + + if(filter->expression[i+1] == '=') { /* != */ g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE); + i++; } else { /* ! */ - // g_print("%s\n",a_field_component); - // a_field_component = g_string_new(""); - t1 = (LttvFilter*)g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; - t2 = lttv_filter_tree_new(); - t2->node = LTTV_LOGICAL_NOT; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + not=1; } break; + case '(': /* start of parenthesis */ case '[': case '{': + p_nesting++; /* incrementing parenthesis nesting value */ t1 = lttv_filter_tree_new(); + if(not) { /* add not operator to tree */ + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t3; + not = 0; + } g_ptr_array_add( tree_stack,(gpointer) t1 ); break; + case ')': /* end of parenthesis */ case ']': case '}': + p_nesting--; /* decrementing parenthesis nesting value */ if(p_nesting<0 || tree_stack->len<2) { g_warning("Wrong filtering options, the string\n\"%s\"\n\ - is not valid due to parenthesis incorrect use",expression); - return NULL; + is not valid due to parenthesis incorrect use",filter->expression); + return FALSE; } - + + /* there must at least be the root tree left in the array */ g_assert(tree_stack->len>0); - if(subtree != NULL) { - t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE && t1->right != LTTV_TREE_LEAF) { - g_assert(t1!=NULL && t1->r_child.t != NULL); - t1 = t1->r_child.t; - } + + t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); + while(t1->right != LTTV_TREE_IDLE) { + t1 = t1->r_child.t; + } + if(not) { // add not operator to tree + g_print("ici"); + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t3; + t1 = t3; + not = 0; + } + if(subtree != NULL) { /* append subtree to current tree */ t1->right = LTTV_TREE_NODE; t1->r_child.t = subtree; subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); g_ptr_array_remove_index(tree_stack,tree_stack->len-1); - } else { - a_simple_expression->value = a_field_component->str; + } else { /* assign subtree as current tree */ + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); a_field_component = g_string_new(""); - t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; - a_simple_expression = g_new(LttvSimpleExpression,1); - subtree = g_ptr_array_index(tree_stack,tree_stack->len-1); - g_assert(subtree != NULL); - g_ptr_array_remove_index(tree_stack,tree_stack->len-1); + a_simple_expression = lttv_simple_expression_new(); + subtree = g_ptr_array_remove_index(tree_stack,tree_stack->len-1); } break; @@ -704,239 +1478,549 @@ lttv_filter_new(char *expression, LttvTraceState *tcs) { * mathematic operators */ case '<': /* lower, lower or equal */ - if(expression[i+1] == '=') { /* <= */ - i++; - a_simple_expression->op = LTTV_FIELD_LE; - } else a_simple_expression->op = LTTV_FIELD_LT; + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); - break; - case '>': /* higher, higher or equal */ - if(expression[i+1] == '=') { /* >= */ + if(filter->expression[i+1] == '=') { /* <= */ i++; - a_simple_expression->op = LTTV_FIELD_GE; - } else a_simple_expression->op = LTTV_FIELD_GT; - g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LE); + } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_LT); + break; + + case '>': /* higher, higher or equal */ + + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); - break; + if(filter->expression[i+1] == '=') { /* >= */ + i++; + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GE); + } else lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_GT); + break; + case '=': /* equal */ - a_simple_expression->op = LTTV_FIELD_EQ; + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + lttv_simple_expression_assign_field(a_field_path,a_simple_expression); a_field_component = g_string_new(""); + lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_EQ); break; + /* * Field concatening caracter */ case '.': /* dot */ - g_ptr_array_add( a_field_path,(gpointer) a_field_component ); - a_field_component = g_string_new(""); + + /* + * divide field expression into elements + * in a_field_path array. + * + * A dot can also be present in double values + */ + if(a_simple_expression->field == LTTV_FILTER_UNDEFINED) { + g_ptr_array_add( a_field_path,(gpointer) a_field_component ); + a_field_component = g_string_new(""); + } + break; + case ' ': /* ignore */ + case '\n': /* ignore */ break; default: /* concatening current string */ - g_string_append_c(a_field_component,expression[i]); + g_string_append_c(a_field_component,filter->expression[i]); } } - g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree,tree,t1,t2); - g_print("stack size: %i\n",tree_stack->len); - /* * Preliminary check to see * if tree was constructed correctly */ if( p_nesting>0 ) { g_warning("Wrong filtering options, the string\n\"%s\"\n\ - is not valid due to parenthesis incorrect use",expression); - return NULL; + is not valid due to parenthesis incorrect use",filter->expression); + return FALSE; } if(tree_stack->len != 1) /* only root tree should remain */ - return NULL; + return FALSE; - /* processing last element of expression */ + /* + * processing last element of expression + */ t1 = g_ptr_array_index(tree_stack,tree_stack->len-1); - while(t1->right != LTTV_TREE_IDLE) t1 = t1->r_child.t; + while(t1->right != LTTV_TREE_IDLE) { + g_assert(t1->right == LTTV_TREE_NODE); + t1 = t1->r_child.t; + } + if(not) { // add not operator to tree + t3 = lttv_filter_tree_new(); + t3->node = LTTV_LOGICAL_NOT; + t1->right = LTTV_TREE_NODE; + t1->r_child.t = t3; + t1 = t3; + not = 0; + } if(subtree != NULL) { /* add the subtree */ t1->right = LTTV_TREE_NODE; t1->r_child.t = subtree; subtree = NULL; } else { /* add a leaf */ - a_simple_expression->value = a_field_component->str; - a_field_component = g_string_new(""); + lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); + a_field_component = NULL; t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; - /* - * FIXME: is it really necessary to reallocate - * LttvSimpleExpression at this point ?? - */ - a_simple_expression = g_new(LttvSimpleExpression,1); + a_simple_expression = NULL; } - g_assert(tree != NULL); - g_assert(subtree == NULL); - lttv_filter_tracefile(tree,NULL); + /* free the pointer array */ + g_assert(a_field_path->len == 0); + g_ptr_array_free(a_field_path,TRUE); + + /* free the tree stack -- but keep the root tree */ + filter->head = g_ptr_array_remove_index(tree_stack,0); + g_ptr_array_free(tree_stack,TRUE); - return tree; + /* free the field buffer if allocated */ + if(a_field_component != NULL) g_string_free(a_field_component,TRUE); + + /* free the simple expression buffer if allocated */ + if(a_simple_expression != NULL) lttv_simple_expression_destroy(a_simple_expression); + + g_assert(filter->head != NULL); /* tree should exist */ + g_assert(subtree == NULL); /* remaining subtree should be included in main tree */ + +#ifdef TEST + gettimeofday(&endtime, NULL); + + /* Calcul du temps de l'algorithme */ + double time1 = starttime.tv_sec + (starttime.tv_usec/1000000.0); + double time2 = endtime.tv_sec + (endtime.tv_usec/1000000.0); +// g_print("Tree build took %.10f ms for strlen of %i\n",(time2-time1)*1000,strlen(filter->expression)); + g_print("%.10f %i\n",(time2-time1)*1000,strlen(filter->expression)); +#endif + + /* debug */ + g_debug("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n"); + lttv_print_tree(filter->head,0) ; + g_debug("+++++++++++++++ END PRINT ++++++++++++++++++\n"); + /* success */ + return TRUE; + } +/** + * @fn void lttv_filter_destroy(LttvFilter*) + * + * Destroy the current LttvFilter + * @param filter pointer to the current LttvFilter + */ void lttv_filter_destroy(LttvFilter* filter) { + + if(!filter) return; + if(filter->expression) + g_free(filter->expression); + if(filter->head) + lttv_filter_tree_destroy(filter->head); + g_free(filter); + } /** + * @fn LttvFilterTree* lttv_filter_tree_new() + * * Assign a new tree for the current expression * or sub expression * @return pointer of LttvFilterTree */ -LttvFilterTree* lttv_filter_tree_new() { +LttvFilterTree* +lttv_filter_tree_new() { LttvFilterTree* tree; - tree = g_new(LttvFilter,1); + tree = g_new(LttvFilterTree,1); tree->node = 0; //g_new(lttv_expression,1); -// tree->node->type = LTTV_UNDEFINED_EXPRESSION; tree->left = LTTV_TREE_IDLE; tree->right = LTTV_TREE_IDLE; - + tree->r_child.t = NULL; + tree->l_child.t = NULL; + return tree; } /** + * @fn void lttv_filter_append_expression(LttvFilter*,char*) + * + * Append a new expression to the expression + * defined in the current filter + * @param filter pointer to the current LttvFilter + * @param expression string that must be appended + * @return Success/Failure of operation + */ +gboolean +lttv_filter_append_expression(LttvFilter* filter, const char *expression) { + + if(expression == NULL) return FALSE; + if(filter == NULL) return FALSE; + if(expression[0] == '\0') return FALSE; /* Empty expression */ + + GString* s = g_string_new(""); + if(filter->expression != NULL) { + g_string_append(s,filter->expression); + g_string_append_c(s,'&'); + } + g_string_append(s,expression); + + g_free(filter->expression); + filter->expression = g_string_free(s,FALSE); + + /* TRUE if construction of tree proceeded without errors */ + return lttv_filter_update(filter); + +} + +/** + * @fn void lttv_filter_clear_expression(LttvFilter*) + * + * Clear the filter expression from the + * current filter and sets its pointer to NULL + * @param filter pointer to the current LttvFilter + */ +void +lttv_filter_clear_expression(LttvFilter* filter) { + + if(filter->expression != NULL) { + g_free(filter->expression); + filter->expression = NULL; + } + +} + +/** + * @fn void lttv_filter_tree_destroy(LttvFilterTree*) + * * Destroys the tree and his sub-trees * @param tree Tree which must be destroyed */ -void lttv_filter_tree_destroy(LttvFilterTree* tree) { - +void +lttv_filter_tree_destroy(LttvFilterTree* tree) { + if(tree == NULL) return; - if(tree->left == LTTV_TREE_LEAF) g_free(tree->l_child.leaf); + if(tree->left == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->l_child.leaf); else if(tree->left == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->l_child.t); - if(tree->right == LTTV_TREE_LEAF) g_free(tree->r_child.leaf); + if(tree->right == LTTV_TREE_LEAF) lttv_simple_expression_destroy(tree->r_child.leaf); else if(tree->right == LTTV_TREE_NODE) lttv_filter_tree_destroy(tree->r_child.t); - g_free(tree->node); +// g_free(tree->node); g_free(tree); } - /** - * Apply the filter to a specific trace - * @param filter the current filter applied - * @param tracefile the trace to apply the filter to - * @return success/failure of operation + * Global parsing function for the current + * LttvFilterTree + * @param t pointer to the current LttvFilterTree + * @param event current LttEvent, NULL if not used + * @param tracefile current LttTracefile, NULL if not used + * @param trace current LttTrace, NULL if not used + * @param state current LttvProcessState, NULL if not used + * @param context current LttvTracefileContext, NULL if not used + * @return response of filter */ gboolean -lttv_filter_tracefile(LttvFilter *filter, LttTracefile *tracefile) { +lttv_filter_tree_parse( + const LttvFilterTree* t, + const LttEvent* event, + const LttTracefile* tracefile, + const LttTrace* trace, + const LttvTracefileContext* context + /*,...*/) +{ - LttvFilterTree* t = filter->head; - - /* + /* * Each tree is parsed in inorder. * This way, it's possible to apply the left filter of the * tree, then decide whether or not the right branch should * be parsed depending on the linking logical operator * - * As for the filtering structure, since we are trying - * to remove elements from the trace, it might be better - * managing an array of all items to be removed .. + * Each node consists in a + * 1. logical operator + * 2. left child ( node or simple expression ) + * 3. right child ( node or simple expression ) + * + * When the child is a simple expression, we must + * before all determine if the expression refers to + * a structure which is whithin observation ( not NULL ). + * -If so, the expression is evaluated. + * -If not, the result is set to TRUE since this particular + * operation does not interfere with the lttv structure + * + * The result of each simple expression will directly + * affect the next branch. This way, depending on + * the linking logical operator, the parser will decide + * to explore or not the next branch. + * 1. AND OPERATOR + * -If result of left branch is 0 / FALSE + * then don't explore right branch and return 0; + * -If result of left branch is 1 / TRUE then explore + * 2. OR OPERATOR + * -If result of left branch is 1 / TRUE + * then don't explore right branch and return 1; + * -If result of left branch is 0 / FALSE then explore + * 3. XOR OPERATOR + * -Result of left branch will not affect exploration of + * right branch */ + + gboolean lresult = FALSE, rresult = FALSE; + + LttvProcessState* state; - g_print("node:%p lchild:%p rchild:%p\n",t,t->l_child.t,t->r_child.t); - g_print("node type%i\n",t->node); - if(t->left == LTTV_TREE_NODE) lttv_filter_tracefile(t->l_child.t,NULL); - else if(t->left == LTTV_TREE_LEAF) { - g_assert(t->l_child.leaf->value != NULL); - g_print("%p: left is qqch %i %s\n",t,t->l_child.leaf->op,t->l_child.leaf->value); + guint cpu = ltt_tracefile_num(context->tf); + LttvTraceState *ts = (LttvTraceState*)context->t_context; + state = ts->running_process[cpu]; + + /* + * Parse left branch + */ + if(t->left == LTTV_TREE_NODE) { + lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,context); } - if(t->right == LTTV_TREE_NODE) lttv_filter_tracefile(t->r_child.t,NULL); - else if(t->right == LTTV_TREE_LEAF) { - g_assert(t->r_child.leaf->value != NULL); - g_print("%p: right is qqch %i %s\n",t,t->r_child.leaf->op,t->r_child.leaf->value); + else if(t->left == LTTV_TREE_LEAF) { + lresult = lttv_filter_tree_parse_branch(t->l_child.leaf,event,tracefile,trace,state,context); } - - /* test */ -/* int i, nb; - char *f_name, *e_name; - - char* field = "cpu"; - LttvTraceHook h; - - LttEventType *et; - - LttType *t; + /* + * Parse linking operator + * make a cutoff if possible + */ + if((t->node & LTTV_LOGICAL_OR) && lresult == TRUE) return TRUE; + if((t->node & LTTV_LOGICAL_AND) && lresult == FALSE) return FALSE; - GString *fe_name = g_string_new(""); + /* + * Parse right branch + */ + if(t->right == LTTV_TREE_NODE) { + rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,context); + } + else if(t->right == LTTV_TREE_LEAF) { + rresult = lttv_filter_tree_parse_branch(t->r_child.leaf,event,tracefile,trace,state,context); + } - nb = ltt_trace_eventtype_number(tcs->parent.t); - g_print("NB:%i\n",nb); - for(i = 0 ; i < nb ; i++) { - et = ltt_trace_eventtype_get(tcs->parent.t, i); - e_name = ltt_eventtype_name(et); - f_name = ltt_facility_name(ltt_eventtype_facility(et)); - g_string_printf(fe_name, "%s.%s", f_name, e_name); - g_print("facility:%s and event:%s\n",f_name,e_name); + + /* + * Apply and return the + * logical link between the + * two operation + */ + switch(t->node) { + case LTTV_LOGICAL_OR: return (lresult | rresult); + case LTTV_LOGICAL_AND: return (lresult & rresult); + case LTTV_LOGICAL_NOT: + return (t->left==LTTV_TREE_LEAF)?!lresult:((t->right==LTTV_TREE_LEAF)?!rresult:TRUE); + case LTTV_LOGICAL_XOR: return (lresult ^ rresult); + case 0: return (rresult); + default: + /* + * This case should never be + * parsed, if so, this subtree + * is cancelled ! + */ + return TRUE; } - */ + } -gboolean -lttv_filter_tracestate(LttvFilter *filter, LttvTraceState *tracestate) { +/** + * This function parses a particular branch of the tree + * @param se pointer to the current LttvSimpleExpression + * @param event current LttEvent, NULL if not used + * @param tracefile current LttTracefile, NULL if not used + * @param trace current LttTrace, NULL if not used + * @param state current LttvProcessState, NULL if not used + * @param context current LttvTracefileContext, NULL if not used + * @return response of filter + */ +gboolean +lttv_filter_tree_parse_branch( + const LttvSimpleExpression* se, + const LttEvent* event, + const LttTracefile* tracefile, + const LttTrace* trace, + const LttvProcessState* state, + const LttvTracefileContext* context) { + + LttvFieldValue v; + v = se->value; + switch(se->field) { + case LTTV_FILTER_TRACE_NAME: + if(trace == NULL) return TRUE; + else { + GQuark quark = ltt_trace_name(trace); + return se->op((gpointer)&quark,v); + } + break; + case LTTV_FILTER_TRACEFILE_NAME: + if(tracefile == NULL) return TRUE; + else { + GQuark quark = ltt_tracefile_name(tracefile); + return se->op((gpointer)&quark,v); + } + break; + case LTTV_FILTER_STATE_PID: + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->pid,v); + break; + case LTTV_FILTER_STATE_PPID: + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->ppid,v); + break; + case LTTV_FILTER_STATE_CT: + if(state == NULL) return TRUE; + else { + return se->op((gpointer)&state->creation_time,v); + } + break; + case LTTV_FILTER_STATE_IT: + if(state == NULL) return TRUE; + else { + return se->op((gpointer)&state->insertion_time,v); + } + break; + case LTTV_FILTER_STATE_P_NAME: + /* + * All 'unnamed' for the moment + */ + if(state == NULL) return TRUE; + else { + GQuark quark = state->name; + return se->op((gpointer)&quark,v); + } + break; + case LTTV_FILTER_STATE_EX_MODE: + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->t,v); + break; + case LTTV_FILTER_STATE_EX_SUBMODE: + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->n,v); + break; + case LTTV_FILTER_STATE_P_STATUS: + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->s,v); + break; + case LTTV_FILTER_STATE_CPU: + if(context == NULL) return TRUE; + else { + /* FIXME: not sure of that one Mathieu : fixed.*/ + // GQuark quark = ((LttvTracefileState*)context)->cpu_name; + // return se->op((gpointer)&quark,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->cpu,v); + } + break; + case LTTV_FILTER_EVENT_NAME: + if(event == NULL) return TRUE; + else { + LttEventType* et; + et = ltt_event_eventtype(event); + GQuark quark = ltt_eventtype_name(et); + return se->op((gpointer)&quark,v); + } + break; + case LTTV_FILTER_EVENT_FACILITY: + if(event == NULL) return TRUE; + else { + LttFacility* fac; + fac = ltt_event_facility(event); + GQuark quark = ltt_facility_name(fac); + return se->op((gpointer)&quark,v); + } + break; + case LTTV_FILTER_EVENT_CATEGORY: + /* + * TODO: Not yet implemented + */ + return TRUE; + break; + case LTTV_FILTER_EVENT_TIME: + if(event == NULL) return TRUE; + else { + LttTime time = ltt_event_time(event); + return se->op((gpointer)&time,v); + } + break; + case LTTV_FILTER_EVENT_TSC: + if(event == NULL) return TRUE; + else { + LttCycleCount count = ltt_event_cycle_count(event); + return se->op((gpointer)&count,v); + } + break; + case LTTV_FILTER_EVENT_FIELD: + /* + * TODO: Use the offset to + * find the dynamic field + * in the event struct + */ + return TRUE; + default: + /* + * This case should never be + * parsed, if so, the whole + * filtering is cancelled + */ + g_warning("Error while parsing the filter tree"); + return TRUE; + } + /* should never get here */ + return TRUE; + } + + /** - * Apply the filter to a specific event - * @param filter the current filter applied - * @param event the event to apply the filter to - * @return success/failure of operation + * Debug function. Prints tree memory allocation. + * @param t the pointer to the current LttvFilterTree */ -gboolean -lttv_filter_event(LttvFilter *filter, LttEvent *event) { +void +lttv_print_tree(const LttvFilterTree* t, const int count) { + + g_debug("node:%p lchild:%p rchild:%p depth:%i\n",t, //t->l_child.t,t->r_child.t); + (t->left==LTTV_TREE_NODE)?t->l_child.t:NULL, + (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL, + count); + g_debug("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE")))); + g_debug("|-> left branch %p is a %s\n",t->l_child.t,(t->left==LTTV_TREE_NODE)?"NODE":((t->left==LTTV_TREE_LEAF)?"LEAF":"IDLE")); + if(t->left == LTTV_TREE_LEAF) { + g_debug("| |-> field type number: %i\n",t->l_child.leaf->field); + g_debug("| |-> offset is: %i\n",t->l_child.leaf->offset); + g_debug("| |-> operator function is: %p\n",t->l_child.leaf->op); + } + g_debug("|-> right branch %p is a %s\n",t->r_child.t,(t->right==LTTV_TREE_NODE)?"NODE":((t->right==LTTV_TREE_LEAF)?"LEAF":"IDLE")); + if(t->right == LTTV_TREE_LEAF) { + g_debug("| |-> field type number: %i\n",t->r_child.leaf->field); + g_debug("| |-> offset is: %i\n",t->r_child.leaf->offset); + g_debug("| |-> operator function is: %p\n",t->r_child.leaf->op); + } + if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t,count+1); + if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t,count+1); } /** + * @fn static void module_init() + * * Initializes the filter module and specific values */ static void module_init() { - /* - * Quarks initialization - * for hardcoded filtering options - * - * TODO: traceset has no yet been defined - */ - - /* top fields */ -// LTTV_FILTER_EVENT = g_quark_from_string("event"); -// LTTV_FILTER_TRACE = g_quark_from_string("trace"); -// LTTV_FILTER_TRACESET = g_quark_from_string("traceset"); -// LTTV_FILTER_STATE = g_quark_from_string("state"); -// LTTV_FILTER_TRACEFILE = g_quark_from_string("tracefile"); - - /* event.name, tracefile.name, trace.name */ -// LTTV_FILTER_NAME = g_quark_from_string("name"); - - /* event sub fields */ -// LTTV_FILTER_CATEGORY = g_quark_from_string("category"); -// LTTV_FILTER_TIME = g_quark_from_string("time"); -// LTTV_FILTER_TSC = g_quark_from_string("tsc"); - - /* state sub fields */ -// LTTV_FILTER_PID = g_quark_from_string("pid"); -// LTTV_FILTER_PPID = g_quark_from_string("ppid"); -// LTTV_FILTER_C_TIME = g_quark_from_string("creation_time"); -// LTTV_FILTER_I_TIME = g_quark_from_string("insertion_time"); -// LTTV_FILTER_P_NAME = g_quark_from_string("process_name"); -// LTTV_FILTER_EX_MODE = g_quark_from_string("execution_mode"); -// LTTV_FILTER_EX_SUBMODE = g_quark_from_string("execution_submode"); -// LTTV_FILTER_P_STATUS = g_quark_from_string("process_status"); -// LTTV_FILTER_CPU = g_quark_from_string("cpu"); - } /** @@ -944,6 +2028,7 @@ static void module_init() */ static void module_destroy() { + }