X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Flttv%2Ffilter.c;h=a837317d7913beda14ed4f718aff0c2558c17c37;hb=6e0d58d62e75ecf147ebadb1e23b927d772e9a3a;hp=91a3edb0cfac90205fcc7ea8193c7bc490179366;hpb=7145a0733484cc976ab46a4595d4e1a41dd6970c;p=lttv.git diff --git a/ltt/branches/poly/lttv/lttv/filter.c b/ltt/branches/poly/lttv/lttv/filter.c index 91a3edb0..a837317d 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,108 +16,68 @@ * 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) + * | |->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 (uint64) + * |->ppid (uint64) + * |->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 - * * clear the field_path array after use + * - 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; -*/ - -/** - * @fn void lttv_filter_tree_add_node(GPtrArray*,LttvFilterTree*,LttvLogicalOp) - * - * add a node to the current tree - * FIXME: Might be used to lower coding in lttv_filter_new switch expression - * @param stack the tree stack - * @param subtree the subtree if available (pointer or NULL) - * @param op the logical operator that will form the node - */ -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 = (LttvFilterTree*)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; - } - -} +//#define TEST +#ifdef TEST +#include +#include +#endif +#include +#include +#include +#include +#include /** * @fn LttvSimpleExpression* lttv_simple_expression_new() @@ -133,13 +93,12 @@ lttv_simple_expression_new() { se->field = LTTV_FILTER_UNDEFINED; se->op = NULL; se->offset = 0; -// se->value.v_uint64 = 0; return se; } /** - * @fn gboolean lttv_simple_expression_add_field(GPtrArray*,LttvSimpleExpression*) + * @fn gboolean lttv_simple_expression_assign_field(GPtrArray*,LttvSimpleExpression*) * * Parse through filtering field hierarchy as specified * by user. This function compares each value to @@ -154,7 +113,7 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { GString* f = NULL; if(fp->len < 2) return FALSE; - g_assert(f=g_ptr_array_remove_index(fp,0)); + g_assert((f=g_ptr_array_remove_index(fp,0))); /* * Parse through the specified @@ -273,7 +232,6 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { /* array should be empty */ g_assert(fp->len == 0); - g_print("field: %i\n",se->field); if(se->field == LTTV_FILTER_UNDEFINED) { g_warning("The specified field was not recognized !"); return FALSE; @@ -287,15 +245,12 @@ lttv_simple_expression_assign_field(GPtrArray* fp, LttvSimpleExpression* se) { * Sets the function pointer for the current * Simple Expression * @param se current simple expression + * @param op current operator * @return success/failure of operation */ -gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { +gboolean +lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvExpressionOp op) { -// g_print("se->field = %i\n",se->field); -// g_print("se->offset = %i\n",se->offset); -// g_print("se->op = %p\n",se->op); -// g_print("se->value = %s\n",se->value); - switch(se->field) { /* * string @@ -304,12 +259,15 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx case LTTV_FILTER_TRACEFILE_NAME: case LTTV_FILTER_STATE_P_NAME: case LTTV_FILTER_EVENT_NAME: + 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_string; + se->op = lttv_apply_op_eq_quark; break; case LTTV_FIELD_NE: - se->op = lttv_apply_op_ne_string; + se->op = lttv_apply_op_ne_quark; break; default: g_warning("Error encountered in operator assignment = or != expected"); @@ -319,11 +277,7 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx /* * integer */ - case LTTV_FILTER_STATE_PID: - case LTTV_FILTER_STATE_PPID: - case LTTV_FILTER_STATE_EX_MODE: - case LTTV_FILTER_STATE_EX_SUBMODE: - case LTTV_FILTER_STATE_P_STATUS: + case LTTV_FILTER_EVENT_TSC: switch(op) { case LTTV_FIELD_EQ: se->op = lttv_apply_op_eq_uint64; @@ -348,13 +302,65 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx return FALSE; } break; + /* + * 32 bits 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_uint32; + break; + case LTTV_FIELD_NE: + se->op = lttv_apply_op_ne_uint32; + break; + case LTTV_FIELD_LT: + se->op = lttv_apply_op_lt_uint32; + break; + case LTTV_FIELD_LE: + se->op = lttv_apply_op_le_uint32; + break; + case LTTV_FIELD_GT: + se->op = lttv_apply_op_gt_uint32; + break; + case LTTV_FIELD_GE: + se->op = lttv_apply_op_ge_uint32; + 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: - case LTTV_FILTER_EVENT_TSC: switch(op) { case LTTV_FIELD_EQ: se->op = lttv_apply_op_eq_ltttime; @@ -389,35 +395,50 @@ gboolean lttv_simple_expression_assign_operator(LttvSimpleExpression* se, LttvEx } /** - * @fn void lttv_simple_expression_assign_value(LttvSimpleExpression*,char*) + * @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) { +gboolean +lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* value) { -// g_print("se->value:%s\n",value); + unsigned i; + gboolean is_double = FALSE; + LttTime t = ltt_time_zero; + GString* v; switch(se->field) { /* - * string + * 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: - se->value.v_string = value; + 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 + * integer -- supposed to be uint64 + */ + case LTTV_FILTER_EVENT_TSC: + se->value.v_uint64 = atoi(value); + g_free(value); + break; + /* + * 32 bits integer */ case LTTV_FILTER_STATE_PID: case LTTV_FILTER_STATE_PPID: - case LTTV_FILTER_STATE_EX_MODE: - case LTTV_FILTER_STATE_EX_SUBMODE: - case LTTV_FILTER_STATE_P_STATUS: - se->value.v_uint64 = atoi(value); + case LTTV_FILTER_STATE_CPU: + se->value.v_uint32 = atoi(value); g_free(value); break; /* @@ -426,13 +447,34 @@ gboolean lttv_simple_expression_assign_value(LttvSimpleExpression* se, char* val case LTTV_FILTER_STATE_CT: case LTTV_FILTER_STATE_IT: case LTTV_FILTER_EVENT_TIME: - case LTTV_FILTER_EVENT_TSC: //se->value.v_double = atof(value); - se->value.v_ltttime = ltt_time_from_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; } @@ -451,14 +493,14 @@ 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; - } +// 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); } @@ -513,7 +555,7 @@ lttv_struct_type(gint ft) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r == v2.v_uint64); @@ -529,7 +571,7 @@ gboolean lttv_apply_op_eq_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r == v2.v_uint32); } @@ -543,7 +585,7 @@ gboolean lttv_apply_op_eq_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_uint16(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_uint16(const gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; return (*r == v2.v_uint16); } @@ -557,7 +599,7 @@ gboolean lttv_apply_op_eq_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r == v2.v_double); } @@ -571,12 +613,26 @@ gboolean lttv_apply_op_eq_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_string(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_string(const gpointer v1, LttvFieldValue v2) { char* r = (char*) v1; - g_print("v1:%s = v2:%s\n",r,v2.v_string); 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_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) * @@ -586,9 +642,9 @@ gboolean lttv_apply_op_eq_string(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_eq_ltttime(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_eq_ltttime(const gpointer v1, LttvFieldValue v2) { LttTime* r = (LttTime*) v1; - return ((r->tv_sec == v2.v_ltttime.tv_sec) && (r->tv_nsec == v2.v_ltttime.tv_nsec)); + return ltt_time_compare(*r, v2.v_ltttime)==0?1:0; } @@ -601,7 +657,7 @@ gboolean lttv_apply_op_eq_ltttime(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ne_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r != v2.v_uint64); } @@ -615,7 +671,7 @@ gboolean lttv_apply_op_ne_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ne_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r != v2.v_uint32); } @@ -629,7 +685,7 @@ gboolean lttv_apply_op_ne_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_uint16(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ne_uint16(const gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; return (*r != v2.v_uint16); } @@ -643,7 +699,7 @@ gboolean lttv_apply_op_ne_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ne_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r != v2.v_double); } @@ -657,11 +713,26 @@ gboolean lttv_apply_op_ne_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_string(gpointer v1, LttvFieldValue 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_quark(const gpointer v1, LttvFieldValue v2) { + GQuark* r = (GQuark*) v1; + return (*r != v2.v_uint32); +} + + /** * @fn gboolean lttv_apply_op_ne_ltttime(gpointer,LttvFieldValue) * @@ -671,9 +742,9 @@ gboolean lttv_apply_op_ne_string(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ne_ltttime(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ne_ltttime(const gpointer v1, LttvFieldValue v2) { LttTime* r = (LttTime*) v1; - return ((r->tv_sec != v2.v_ltttime.tv_sec) || (r->tv_nsec != v2.v_ltttime.tv_nsec)); + return ltt_time_compare(*r, v2.v_ltttime)!=0?1:0; } @@ -686,7 +757,7 @@ gboolean lttv_apply_op_ne_ltttime(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_lt_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r < v2.v_uint64); } @@ -700,7 +771,7 @@ gboolean lttv_apply_op_lt_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_lt_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r < v2.v_uint32); } @@ -714,7 +785,7 @@ gboolean lttv_apply_op_lt_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_uint16(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_lt_uint16(const gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; return (*r < v2.v_uint16); } @@ -728,7 +799,7 @@ gboolean lttv_apply_op_lt_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_lt_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r < v2.v_double); } @@ -742,9 +813,10 @@ gboolean lttv_apply_op_lt_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_lt_ltttime(gpointer v1, LttvFieldValue v2) { +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 ((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; } @@ -757,7 +829,7 @@ gboolean lttv_apply_op_lt_ltttime(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_le_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r <= v2.v_uint64); } @@ -771,7 +843,7 @@ gboolean lttv_apply_op_le_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_le_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r <= v2.v_uint32); } @@ -785,7 +857,7 @@ gboolean lttv_apply_op_le_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_uint16(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_le_uint16(const gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; return (*r <= v2.v_uint16); } @@ -799,7 +871,7 @@ gboolean lttv_apply_op_le_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_le_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r <= v2.v_double); } @@ -813,9 +885,10 @@ gboolean lttv_apply_op_le_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_le_ltttime(gpointer v1, LttvFieldValue v2) { +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 ((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; } @@ -828,7 +901,7 @@ gboolean lttv_apply_op_le_ltttime(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_gt_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r > v2.v_uint64); } @@ -842,7 +915,7 @@ gboolean lttv_apply_op_gt_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_gt_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r > v2.v_uint32); } @@ -856,7 +929,7 @@ gboolean lttv_apply_op_gt_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_uint16(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_gt_uint16(const gpointer v1, LttvFieldValue v2) { guint16* r = (guint16*) v1; return (*r > v2.v_uint16); } @@ -870,7 +943,7 @@ gboolean lttv_apply_op_gt_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_gt_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r > v2.v_double); } @@ -884,9 +957,10 @@ gboolean lttv_apply_op_gt_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_gt_ltttime(gpointer v1, LttvFieldValue 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 ((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; } @@ -899,7 +973,7 @@ gboolean lttv_apply_op_gt_ltttime(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint64(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ge_uint64(const gpointer v1, LttvFieldValue v2) { guint64* r = (guint64*) v1; return (*r >= v2.v_uint64); } @@ -913,7 +987,7 @@ gboolean lttv_apply_op_ge_uint64(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint32(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ge_uint32(const gpointer v1, LttvFieldValue v2) { guint32* r = (guint32*) v1; return (*r >= v2.v_uint32); } @@ -927,13 +1001,13 @@ gboolean lttv_apply_op_ge_uint32(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_uint16(gpointer v1, LttvFieldValue 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) + * @fn gboolean lttv_apply_op_ge_double(gpointer,LttvFieldValue) * * Applies the 'greater or equal' operator to the * specified structure and value @@ -941,7 +1015,7 @@ gboolean lttv_apply_op_ge_uint16(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_double(gpointer v1, LttvFieldValue v2) { +gboolean lttv_apply_op_ge_double(const gpointer v1, LttvFieldValue v2) { double* r = (double*) v1; return (*r >= v2.v_double); } @@ -955,22 +1029,21 @@ gboolean lttv_apply_op_ge_double(gpointer v1, LttvFieldValue v2) { * @param v2 right member of comparison * @return success/failure of operation */ -gboolean lttv_apply_op_ge_ltttime(gpointer v1, LttvFieldValue 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 ((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 LttvFilterTree* lttv_filter_tree_clone(LttvFilterTree*) - * * 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(); @@ -1004,19 +1077,17 @@ lttv_filter_tree_clone(LttvFilterTree* tree) { } /** - * @fn LttvFilter* lttv_filter_clone(LttvFilter*) - * * 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); @@ -1029,10 +1100,8 @@ lttv_filter_clone(LttvFilter* filter) { /** * @fn LttvFilter* lttv_filter_new() * - * 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 + * Creates a new LttvFilter + * @return the current LttvFilter or NULL if error */ LttvFilter* lttv_filter_new() { @@ -1040,6 +1109,8 @@ lttv_filter_new() { LttvFilter* filter = g_new(LttvFilter,1); filter->expression = NULL; filter->head = NULL; + + return filter; } @@ -1054,20 +1125,22 @@ lttv_filter_new() { gboolean lttv_filter_update(LttvFilter* filter) { - g_print("filter::lttv_filter_new()\n"); /* debug */ +// g_print("filter::lttv_filter_new()\n"); /* debug */ if(filter->expression == NULL) return FALSE; int i, - p_nesting=0; /* parenthesis nesting value */ - + p_nesting=0, /* parenthesis nesting value */ + 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 @@ -1126,41 +1199,53 @@ lttv_filter_update(LttvFilter* filter) { * 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 -// g_print("expression: %s\n",filter->expression); -// g_print("strlen(expression): %i\n",strlen(filter->expression)); for(i=0;iexpression);i++) { // debug - g_print("%c ",filter->expression[i]); +// 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); + + /* 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; + 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 { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); - // a_simple_expression->value = 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 = lttv_simple_expression_new(); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; - g_print("t1:%p t1->child:%p\n",t1,t1->r_child.t); } break; @@ -1173,21 +1258,26 @@ lttv_filter_update(LttvFilter* filter) { } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_OR; - if(subtree != NULL) { /* append subtree to current tree */ + 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 { /* append a simple expression */ + } else { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); - //a_simple_expression->value = 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 = lttv_simple_expression_new(); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; } break; @@ -1200,21 +1290,26 @@ lttv_filter_update(LttvFilter* filter) { } t2 = lttv_filter_tree_new(); t2->node = LTTV_LOGICAL_XOR; + 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 { /* append a simple expression */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); - //a_simple_expression->value = 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 = lttv_simple_expression_new(); - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; } break; @@ -1227,15 +1322,7 @@ lttv_filter_update(LttvFilter* filter) { lttv_simple_expression_assign_operator(a_simple_expression,LTTV_FIELD_NE); i++; } else { /* ! */ - 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_NOT; - t1->right = LTTV_TREE_NODE; - t1->r_child.t = t2; + not=1; } break; @@ -1245,6 +1332,13 @@ lttv_filter_update(LttvFilter* filter) { 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; @@ -1261,28 +1355,28 @@ lttv_filter_update(LttvFilter* filter) { /* there must at least be the root tree left in the array */ g_assert(tree_stack->len>0); - + + 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 = 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; - } 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 { /* assign subtree as current tree */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); - //a_simple_expression->value = 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) { - g_print("while right:%i %p->child:%p\n",t1->right,t1,t1->r_child.t); - g_assert(t1->right == LTTV_TREE_NODE); - g_assert(t1->r_child.t != NULL); - t1 = t1->r_child.t; - } t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; a_simple_expression = lttv_simple_expression_new(); @@ -1331,24 +1425,22 @@ lttv_filter_update(LttvFilter* filter) { /* * divide field expression into elements * in a_field_path array. + * + * A dot can also be present in double values */ - /* FIXME: check for 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 ' ': - case '\n': + case ' ': /* ignore */ + case '\n': /* ignore */ break; default: /* concatening current string */ 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 @@ -1362,19 +1454,28 @@ lttv_filter_update(LttvFilter* filter) { if(tree_stack->len != 1) /* only root tree should remain */ 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) { 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 */ lttv_simple_expression_assign_value(a_simple_expression,g_string_free(a_field_component,FALSE)); - //a_simple_expression->value = g_string_free(a_field_component,FALSE); a_field_component = NULL; t1->right = LTTV_TREE_LEAF; t1->r_child.leaf = a_simple_expression; @@ -1387,7 +1488,6 @@ lttv_filter_update(LttvFilter* filter) { g_ptr_array_free(a_field_path,TRUE); /* free the tree stack -- but keep the root tree */ - // g_ptr_array_free(tree_stack,FALSE); filter->head = g_ptr_array_remove_index(tree_stack,0); g_ptr_array_free(tree_stack,TRUE); @@ -1399,10 +1499,20 @@ lttv_filter_update(LttvFilter* filter) { 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_print("+++++++++++++++ BEGIN PRINT ++++++++++++++++\n"); - lttv_print_tree(filter->head) ; + lttv_print_tree(filter->head,0) ; g_print("+++++++++++++++ END PRINT ++++++++++++++++++\n"); /* success */ @@ -1419,8 +1529,12 @@ lttv_filter_update(LttvFilter* filter) { void lttv_filter_destroy(LttvFilter* filter) { - g_free(filter->expression); - lttv_filter_tree_destroy(filter->head); + if(!filter) return; + + if(filter->expression) + g_free(filter->expression); + if(filter->head) + lttv_filter_tree_destroy(filter->head); g_free(filter); } @@ -1455,18 +1569,24 @@ lttv_filter_tree_new() { * @param expression string that must be appended * @return Success/Failure of operation */ -gboolean lttv_filter_append_expression(LttvFilter* filter, char *expression) { +gboolean +lttv_filter_append_expression(LttvFilter* filter, const char *expression) { if(expression == NULL) return FALSE; - if(filter == NULL) { - filter = lttv_filter_new(); - filter->expression = expression; - } else if(filter->expression == NULL) { - filter->expression = expression; - } else { - filter->expression = g_strconcat(filter->expression,"&",expression); - } + 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); } @@ -1478,7 +1598,8 @@ gboolean lttv_filter_append_expression(LttvFilter* filter, char *expression) { * current filter and sets its pointer to NULL * @param filter pointer to the current LttvFilter */ -void lttv_filter_clear_expression(LttvFilter* filter) { +void +lttv_filter_clear_expression(LttvFilter* filter) { if(filter->expression != NULL) { g_free(filter->expression); @@ -1509,23 +1630,23 @@ lttv_filter_tree_destroy(LttvFilterTree* tree) { } /** - * @fn gboolean lttv_filter_tree_parse(LttvFilterTree*,LttEvent,LttTracefile,LttTrace,LttvProcessState) - * * Global parsing function for the current * LttvFilterTree - * @param tree pointer to 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_tree_parse( - LttvFilterTree* t, - LttEvent* event, - LttTracefile* tracefile, - LttTrace* trace, - LttvProcessState* state + const LttvFilterTree* t, + const LttEvent* event, + const LttTracefile* tracefile, + const LttTrace* trace, + const LttvTracefileContext* context /*,...*/) { @@ -1563,122 +1684,25 @@ lttv_filter_tree_parse( * -Result of left branch will not affect exploration of * right branch */ - g_print("filter::lttv_parse_tree(...)\n"); gboolean lresult = FALSE, rresult = FALSE; + + LttvProcessState* state; + + 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,state); + if(t->left == LTTV_TREE_NODE) { + lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,context); + } else if(t->left == LTTV_TREE_LEAF) { - //g_print("%p: left is %i %p %s\n",t,t->l_child.leaf->field,t->l_child.leaf->op,t->l_child.leaf->value); - LttvFieldValue v; - v = t->l_child.leaf->value; - switch(t->l_child.leaf->field) { - - case LTTV_FILTER_TRACE_NAME: - if(trace == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)ltt_trace_name(trace),v); - break; - case LTTV_FILTER_TRACEFILE_NAME: - if(tracefile == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)ltt_tracefile_name(tracefile),v); - break; - case LTTV_FILTER_STATE_PID: - if(state == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)&state->pid,v); - break; - case LTTV_FILTER_STATE_PPID: - if(state == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)&state->ppid,v); - break; - case LTTV_FILTER_STATE_CT: - if(state == NULL) lresult = TRUE; - else { -// double val = ltt_time_to_double(state->creation_time); - lresult = t->l_child.leaf->op((gpointer)&state->creation_time,v); - } - break; - case LTTV_FILTER_STATE_IT: - if(state == NULL) lresult = TRUE; - else { -// double val = ltt_time_to_double(state->insertion_time); - lresult = t->l_child.leaf->op((gpointer)&state->insertion_time,v); - } - break; - case LTTV_FILTER_STATE_P_NAME: - /* - * FIXME: Yet to be done ( I think ? ) - */ - lresult = TRUE; - break; - case LTTV_FILTER_STATE_EX_MODE: - if(state == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)&state->state->t,v); - break; - case LTTV_FILTER_STATE_EX_SUBMODE: - if(state == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)&state->state->n,v); - break; - case LTTV_FILTER_STATE_P_STATUS: - if(state == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)&state->state->s,v); - break; - case LTTV_FILTER_STATE_CPU: - /* - * FIXME: What is the comparison value ? - */ - lresult = TRUE; - break; - case LTTV_FILTER_EVENT_NAME: - if(event == NULL) lresult = TRUE; - else lresult = t->l_child.leaf->op((gpointer)ltt_event_eventtype(event),v); - break; - - case LTTV_FILTER_EVENT_CATEGORY: - /* - * FIXME: Not yet implemented - */ - lresult = TRUE; - break; - case LTTV_FILTER_EVENT_TIME: -// if(event == NULL) lresult = TRUE; -// else { -// double val = ltt_time_to_double(event->event_time); -// lresult = t->l_child.leaf->op((gpointer)&val,v); -// } - lresult = TRUE; - break; - case LTTV_FILTER_EVENT_TSC: -// if(event == NULL) lresult = TRUE; -// else { -// double val = ltt_time_to_double(event->event_time); -// lresult = t->l_child.leaf->op((gpointer)&val,v); -// } - /* - * FIXME: Where is event.tsc - */ - lresult = TRUE; - break; - case LTTV_FILTER_EVENT_FIELD: - /* - * TODO: Use the offset to - * find the dynamic field - * in the event struct - */ - lresult = 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; - } + lresult = lttv_filter_tree_parse_branch(t->l_child.leaf,event,tracefile,trace,state,context); } - + /* * Parse linking operator * make a cutoff if possible @@ -1689,96 +1713,154 @@ lttv_filter_tree_parse( /* * Parse right branch */ - if(t->right == LTTV_TREE_NODE) rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,state); + 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) { - //g_print("%p: right is %i %p %s\n",t,t->r_child.leaf->field,t->r_child.leaf->op,t->r_child.leaf->value); + rresult = lttv_filter_tree_parse_branch(t->r_child.leaf,event,tracefile,trace,state,context); + } + + + /* + * 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; + } + +} + +/** + * 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 = t->r_child.leaf->value; - switch(t->r_child.leaf->field) { - + v = se->value; + switch(se->field) { case LTTV_FILTER_TRACE_NAME: - if(trace == NULL) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)ltt_trace_name(trace),v); + 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) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)ltt_tracefile_name(tracefile),v); + 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) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)&state->pid,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->pid,v); break; case LTTV_FILTER_STATE_PPID: - if(state == NULL) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)&state->ppid,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->ppid,v); break; case LTTV_FILTER_STATE_CT: - if(state == NULL) rresult = TRUE; + if(state == NULL) return TRUE; else { - // double val = ltt_time_to_double(state->creation_time); - rresult = t->r_child.leaf->op((gpointer)&state->creation_time,v); + return se->op((gpointer)&state->creation_time,v); } break; case LTTV_FILTER_STATE_IT: - if(state == NULL) rresult = TRUE; + if(state == NULL) return TRUE; else { -// double val = ltt_time_to_double(state->insertion_time); - rresult = t->r_child.leaf->op((gpointer)&state->insertion_time,v); + return se->op((gpointer)&state->insertion_time,v); } break; case LTTV_FILTER_STATE_P_NAME: /* - * FIXME: Yet to be done ( I think ? ) + * All 'unnamed' for the moment */ - rresult = TRUE; + 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) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)&state->state->t,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->t,v); break; case LTTV_FILTER_STATE_EX_SUBMODE: - if(state == NULL) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)&state->state->n,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->n,v); break; case LTTV_FILTER_STATE_P_STATUS: - if(state == NULL) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)&state->state->s,v); + if(state == NULL) return TRUE; + else return se->op((gpointer)&state->state->s,v); break; case LTTV_FILTER_STATE_CPU: - /* - * FIXME: What is the comparison value ? - */ - rresult = TRUE; + 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) rresult = TRUE; - else rresult = t->r_child.leaf->op((gpointer)ltt_event_eventtype(event),v); + 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_CATEGORY: /* - * FIXME: Not yet implemented + * TODO: Not yet implemented */ - rresult = TRUE; + return TRUE; break; case LTTV_FILTER_EVENT_TIME: -// if(event == NULL) rresult = TRUE; -// else { -// double val = ltt_time_to_double(event->event_time); -// rresult = t->r_child.leaf->op((gpointer)&event->event_time,v); -// } - rresult = TRUE; + 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) rresult = TRUE; -// else { -// double val = ltt_time_to_double(event->event_time); -// rresult = t->r_child.leaf->op((gpointer)&val,v); -// } - /* - * FIXME: Where is event.tsc - */ - rresult = TRUE; + 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: /* @@ -1786,104 +1868,51 @@ lttv_filter_tree_parse( * find the dynamic field * in the event struct */ - rresult = TRUE; + return TRUE; default: /* * This case should never be - * parsed, if so, this subtree - * is cancelled ! + * parsed, if so, the whole + * filtering is cancelled */ g_warning("Error while parsing the filter tree"); return TRUE; } - } - - /* - * 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 (!rresult); - 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; - } - + + /* should never get here */ + return TRUE; + } + + /** - * @fn void lttv_print_tree(LttvFilterTree*) - * - * Debug + * Debug function. Prints tree memory allocation. * @param t the pointer to the current LttvFilterTree */ void -lttv_print_tree(LttvFilterTree* t) { +lttv_print_tree(const LttvFilterTree* t, const int count) { - g_print("node:%p lchild:%p rchild:%p\n",t, //t->l_child.t,t->r_child.t); + g_print("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); - g_print("node type: %i / [left] %i / [right] %i\n",t->node,t->left,t->right); - if(t->left == LTTV_TREE_NODE) lttv_print_tree(t->l_child.t); - else if(t->left == LTTV_TREE_LEAF) { -// g_assert(t->l_child.leaf->value != NULL); - g_print("%p: left is %i %p value\n",t,t->l_child.leaf->field,t->l_child.leaf->op); + (t->right==LTTV_TREE_NODE)?t->r_child.t:NULL, + count); + g_print("logic operator: %s\n",(t->node&1)?"OR":((t->node&2)?"AND":((t->node&4)?"NOT":((t->node&8)?"XOR":"IDLE")))); + g_print("|-> 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_print("| |-> field type number: %i\n",t->l_child.leaf->field); + g_print("| |-> offset is: %i\n",t->l_child.leaf->offset); + g_print("| |-> operator function is: %p\n",t->l_child.leaf->op); } - if(t->right == LTTV_TREE_NODE) lttv_print_tree(t->r_child.t); - else if(t->right == LTTV_TREE_LEAF) { -// g_assert(t->r_child.leaf->value != NULL); - g_print("%p: right is %i %p value\n",t,t->r_child.leaf->field,t->r_child.leaf->op); + g_print("|-> 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_print("| |-> field type number: %i\n",t->r_child.leaf->field); + g_print("| |-> offset is: %i\n",t->r_child.leaf->offset); + g_print("| |-> operator function is: %p\n",t->r_child.leaf->op); } - -} - -/** - * @fn gboolean lttv_filter_tracefile(LttvFilter*, LttTracefile*) - * - * 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 - */ -gboolean -lttv_filter_tracefile(LttvFilter *filter, LttTracefile *tracefile) { - - return lttv_filter_tree_parse(filter->head,NULL,tracefile,NULL,NULL); - -} - -/** - * @fn gboolean lttv_filter_tracestate(LttvFilter*,LttvTraceState*) - * - * Parse the current tracestate - * @param filter pointer to the current LttvFilter - * @param tracestate pointer to the current tracestate - */ -gboolean -lttv_filter_tracestate(LttvFilter *filter, LttvTraceState *tracestate) { - -} - -/** - * @fn gboolean lttv_filter_event(LttvFilter*,LttEvent*) - * - * 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 - */ -gboolean -lttv_filter_event(LttvFilter *filter, LttEvent *event) { + 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); } /** @@ -1897,7 +1926,7 @@ static void module_init() } /** - * @fn Destroys the filter module and specific values + * Destroys the filter module and specific values */ static void module_destroy() {