* |->trace
* | |->name (String, converted to GQuark)
* |->state
- * |->pid (uint64)
- * |->ppid (uint64)
+ * |->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 (GQuark)
+ * |->cpu (guint)
* \endverbatim
*/
* - remove the idle expressions in the tree
*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
//#define TEST
#ifdef TEST
#include <time.h>
#endif
#include <lttv/filter.h>
+#include <ltt/trace.h>
+#include <ltt/type.h>
+#include <stdlib.h>
+#include <string.h>
/**
* @fn LttvSimpleExpression* lttv_simple_expression_new()
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
case LTTV_FILTER_TRACEFILE_NAME:
case LTTV_FILTER_STATE_P_NAME:
case LTTV_FILTER_EVENT_NAME:
- case LTTV_FILTER_STATE_CPU:
case LTTV_FILTER_STATE_EX_MODE:
case LTTV_FILTER_STATE_EX_SUBMODE:
case LTTV_FILTER_STATE_P_STATUS:
/*
* integer
*/
- case LTTV_FILTER_STATE_PID:
- case LTTV_FILTER_STATE_PPID:
case LTTV_FILTER_EVENT_TSC:
switch(op) {
case LTTV_FIELD_EQ:
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
gboolean is_double = FALSE;
LttTime t = ltt_time_zero;
GString* v;
- GQuark quark;
switch(se->field) {
/*
case LTTV_FILTER_TRACEFILE_NAME:
case LTTV_FILTER_STATE_P_NAME:
case LTTV_FILTER_EVENT_NAME:
- case LTTV_FILTER_STATE_CPU:
case LTTV_FILTER_STATE_EX_MODE:
case LTTV_FILTER_STATE_EX_SUBMODE:
case LTTV_FILTER_STATE_P_STATUS:
/*
* integer -- supposed to be uint64
*/
- case LTTV_FILTER_STATE_PID:
- case LTTV_FILTER_STATE_PPID:
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
*/
/* cannot specify number with more than one '.' */
if(is_double) return FALSE;
else is_double = TRUE;
- t.tv_sec = atoi(v);
+ t.tv_sec = atoi(v->str);
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);
- else t.tv_sec = atoi(v);
+ if(is_double) t.tv_nsec = atoi(v->str);
+ else t.tv_sec = atoi(v->str);
g_string_free(v,TRUE);
}
}
+/**
+ * @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)
*
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)
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_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r < v2.v_uint);
+}
/**
* @fn gboolean lttv_apply_op_lt_uint64(gpointer,LttvFieldValue)
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)
}
+/**
+ * @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_uint(const gpointer v1, LttvFieldValue v2) {
+ guint* r = (guint*) v1;
+ return (*r > v2.v_uint);
+}
+
/**
* @fn gboolean lttv_apply_op_gt_uint64(gpointer,LttvFieldValue)
*
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)
*/
LttvFilter*
lttv_filter_clone(const LttvFilter* filter) {
-
+
+ if(!filter) return NULL;
+
LttvFilter* newfilter = g_new(LttvFilter,1);
strcpy(newfilter->expression,filter->expression);
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);
}
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) {
const LttEvent* event,
const LttTracefile* tracefile,
const LttTrace* trace,
- const LttvProcessState* state,
const LttvTracefileContext* context
/*,...*/)
{
*/
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,context);
+ lresult = lttv_filter_tree_parse(t->l_child.t,event,tracefile,trace,context);
}
else if(t->left == LTTV_TREE_LEAF) {
lresult = lttv_filter_tree_parse_branch(t->l_child.leaf,event,tracefile,trace,state,context);
* Parse right branch
*/
if(t->right == LTTV_TREE_NODE) {
- rresult = lttv_filter_tree_parse(t->r_child.t,event,tracefile,trace,state,context);
+ 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);
case LTTV_FILTER_TRACE_NAME:
if(trace == NULL) return TRUE;
else {
- char* trace_name = ltt_trace_name(trace);
- GQuark quark = g_quark_from_string(trace_name);
+ GQuark quark = ltt_trace_name(trace);
return se->op((gpointer)&quark,v);
}
break;
case LTTV_FILTER_TRACEFILE_NAME:
if(tracefile == NULL) return TRUE;
else {
- char* tracefile_name = ltt_tracefile_name(tracefile);
- GQuark quark = g_quark_from_string(tracefile_name);
+ GQuark quark = ltt_tracefile_name(tracefile);
return se->op((gpointer)&quark,v);
}
break;
case LTTV_FILTER_STATE_CPU:
if(context == NULL) return TRUE;
else {
- /* FIXME: not sure of that one */
- GQuark quark = ((LttvTracefileState*)context)->cpu_name;
- return se->op((gpointer)&quark,v);
+ /* 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:
else {
LttEventType* et;
et = ltt_event_eventtype(event);
- char* event_name = ltt_eventtype_name(et);
- GQuark quark = g_quark_from_string(event_name);
+ GQuark quark = ltt_eventtype_name(et);
return se->op((gpointer)&quark,v);
}
break;
projects / lttv.git / blobdiff