1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2005 Michel Dagenais
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 consist in AND, OR and NOT nested expressions, forming a tree with
21 simple relations as leaves. The simple relations test is a field
22 in an event is equal, not equal, smaller, smaller or equal, larger, or
23 larger or equal to a specified value.
28 * - the exists an other lttv_filter which conflicts with this one
33 * - refine switch of expression in multiple uses functions
34 * - remove the idle expressions in the tree ****
35 * - add the current simple expression to the tree
38 #include <lttv/filter.h>
45 simple expr [ op expr ]
47 read_simple_expression
48 read_field_path [ rel value ]
51 read_field_component [. field path]
60 path(component...) -> field
66 LTTV_FILTER_TRACEFILE
,
79 LTTV_FILTER_EX_SUBMODE
,
84 lttv_simple_expression_new() {
89 * Assign a new tree for the current expression
91 * @return pointer of LttvFilter
93 LttvFilter
* lttv_filter_tree_new() {
96 tree
= g_new(LttvFilter
,1);
97 tree
->node
= 0; //g_new(lttv_expression,1);
98 // tree->node->type = LTTV_UNDEFINED_EXPRESSION;
99 tree
->left
= LTTV_TREE_IDLE
;
100 tree
->right
= LTTV_TREE_IDLE
;
106 * Destroys the tree and his sub-trees
107 * @param tree Tree which must be destroyed
109 void lttv_filter_tree_destroy(LttvFilter
* tree
) {
111 if(tree
== NULL
) return;
113 if(tree
->left
== LTTV_TREE_LEAF
) g_free(tree
->l_child
.leaf
);
114 else if(tree
->left
== LTTV_TREE_NODE
) lttv_filter_tree_destroy(tree
->l_child
.t
);
116 if(tree
->right
== LTTV_TREE_LEAF
) g_free(tree
->r_child
.leaf
);
117 else if(tree
->right
== LTTV_TREE_NODE
) lttv_filter_tree_destroy(tree
->r_child
.t
);
124 lttv_filter_clone(LttvFilter
* tree
) {
126 if(tree
== NULL
) return NULL
;
128 LttvFilter
* newtree
= lttv_filter_tree_new();
131 * TODO : Copy tree into new tree
139 lttv_filter_tree_add_node(GPtrArray
* stack
, LttvFilter
* subtree
, LttvLogicalOp op
) {
141 LttvFilter
* t1
= NULL
;
142 LttvFilter
* t2
= NULL
;
144 t1
= (LttvFilter
*)g_ptr_array_index(stack
,stack
->len
-1);
145 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
146 t2
= lttv_filter_tree_new();
148 if(subtree
!= NULL
) {
149 t2
->left
= LTTV_TREE_NODE
;
150 t2
->l_child
.t
= subtree
;
152 t1
->right
= LTTV_TREE_NODE
;
155 // a_simple_expression->value = a_field_component->str;
156 // a_field_component = g_string_new("");
157 t2
->left
= LTTV_TREE_LEAF
;
158 // t2->l_child.leaf = a_simple_expression;
159 // a_simple_expression = g_new(lttv_simple_expression,1);
160 t1
->right
= LTTV_TREE_NODE
;
167 * Parse through filtering field hierarchy as specified
168 * by user. This function compares each value to
169 * predetermined quarks
170 * @param fp The field path list
171 * @return success/failure of operation
174 parse_field_path(GPtrArray
* fp
) {
177 if(fp
->len
< 2) return FALSE
;
178 g_assert(f
=g_ptr_array_index(fp
,0)); //list_first(fp)->data;
180 if(g_quark_try_string(f
->str
) == LTTV_FILTER_EVENT
) {
181 f
=g_ptr_array_index(fp
,1);
182 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
183 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CATEGORY
) {}
184 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TIME
) {
185 // offset = &((LttEvent*)NULL)->event_time);
187 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TSC
) {
188 // offset = &((LttEvent*)NULL)->event_cycle_count);
190 else { /* core.xml specified options */
193 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACEFILE
) {
194 f
=g_ptr_array_index(fp
,1);
195 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
197 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACE
) {
198 f
=g_ptr_array_index(fp
,1);
199 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
202 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_STATE
) {
203 f
=g_ptr_array_index(fp
,1);
204 if(g_quark_try_string(f
->str
) == LTTV_FILTER_PID
) {}
205 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_PPID
) {}
206 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_C_TIME
) {}
207 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_I_TIME
) {}
208 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_NAME
) {}
209 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_MODE
) {}
210 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_SUBMODE
) {}
211 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_STATUS
) {}
212 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CPU
) {}
216 g_warning("Unrecognized field in filter string");
223 * Add an filtering option to the current tree
224 * @param expression Current expression to parse
225 * @return success/failure of operation
228 parse_simple_expression(GString
* expression
) {
238 * Creates a new lttv_filter
239 * @param expression filtering options string
240 * @param t pointer to the current LttvTrace
241 * @return the current lttv_filter or NULL if error
244 lttv_filter_new(char *expression
, LttvTraceState
*tcs
) {
246 g_print("filter::lttv_filter_new()\n"); /* debug */
250 p_nesting
=0, /* parenthesis nesting value */
251 b
=0; /* current breakpoint in expression string */
255 *tree
= lttv_filter_tree_new(), /* main tree */
256 *subtree
= NULL
, /* buffer for subtrees */
262 * each element of the list
263 * is a sub tree created
264 * by the use of parenthesis in the
265 * global expression. The final tree
266 * will be the one left at the root of
269 GPtrArray
*tree_stack
= g_ptr_array_new();
270 g_ptr_array_add( tree_stack
,(gpointer
) tree
);
272 /* temporary values */
273 GString
*a_field_component
= g_string_new("");
274 GPtrArray
*a_field_path
= NULL
;
276 LttvSimpleExpression
* a_simple_expression
= g_new(LttvSimpleExpression
,1);
279 * Parse entire expression and construct
280 * the binary tree. There are two steps
281 * in browsing that string
282 * 1. finding boolean ops " &,|,^,! " and parenthesis " {,(,[,],),} "
283 * 2. finding simple expressions
284 * - field path ( separated by dots )
285 * - op ( >, <, =, >=, <=, !=)
286 * - value ( integer, string ... )
287 * To spare computing time, the whole
288 * string is parsed in this loop for a
289 * O(n) complexity order.
291 * When encountering logical op &,|,^
292 * 1. parse the last value if any
293 * 2. create a new tree
294 * 3. add the expression (simple exp, or exp (subtree)) to the tree
295 * 4. concatenate this tree with the current tree on top of the stack
296 * When encountering math ops >,>=,<,<=,=,!=
297 * 1. add to op to the simple expression
298 * 2. concatenate last field component to field path
299 * When encountering concatening ops .
300 * 1. concatenate last field component to field path
301 * When encountering opening parenthesis (,{,[
302 * 1. create a new subtree on top of tree stack
303 * When encountering closing parenthesis ),},]
304 * 1. add the expression on right child of the current tree
305 * 2. the subtree is completed, allocate a new subtree
306 * 3. pop the tree value from the tree stack
309 a_field_path
= g_ptr_array_new();
310 g_ptr_array_set_size(a_field_path
,2); /* by default, recording 2 field expressions */
313 for(i
=0;i
<strlen(expression
);i
++) {
314 // g_print("%s\n",a_field_component->str);
315 g_print("%c ",expression
[i
]);
316 // g_print("switch:%c -->subtree:%p\n",expression[i],subtree);
317 switch(expression
[i
]) {
322 t1
= (LttvFilter
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
323 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
324 t2
= lttv_filter_tree_new();
325 t2
->node
= LTTV_LOGICAL_AND
;
326 if(subtree
!= NULL
) {
327 t2
->left
= LTTV_TREE_NODE
;
328 t2
->l_child
.t
= subtree
;
330 t1
->right
= LTTV_TREE_NODE
;
333 a_simple_expression
->value
= a_field_component
->str
;
334 a_field_component
= g_string_new("");
335 t2
->left
= LTTV_TREE_LEAF
;
336 t2
->l_child
.leaf
= a_simple_expression
;
337 a_simple_expression
= g_new(LttvSimpleExpression
,1);
338 t1
->right
= LTTV_TREE_NODE
;
344 t1
= (LttvFilter
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
345 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
346 t2
= lttv_filter_tree_new();
347 t2
->node
= LTTV_LOGICAL_OR
;
348 if(subtree
!= NULL
) {
349 t2
->left
= LTTV_TREE_NODE
;
350 t2
->l_child
.t
= subtree
;
352 t1
->right
= LTTV_TREE_NODE
;
355 a_simple_expression
->value
= a_field_component
->str
;
356 a_field_component
= g_string_new("");
357 t2
->left
= LTTV_TREE_LEAF
;
358 t2
->l_child
.leaf
= a_simple_expression
;
359 a_simple_expression
= g_new(LttvSimpleExpression
,1);
360 t1
->right
= LTTV_TREE_NODE
;
365 t1
= (LttvFilter
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
366 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
367 t2
= lttv_filter_tree_new();
368 t2
->node
= LTTV_LOGICAL_XOR
;
369 if(subtree
!= NULL
) {
370 t2
->left
= LTTV_TREE_NODE
;
371 t2
->l_child
.t
= subtree
;
373 t1
->right
= LTTV_TREE_NODE
;
376 a_simple_expression
->value
= a_field_component
->str
;
377 a_field_component
= g_string_new("");
378 t2
->left
= LTTV_TREE_LEAF
;
379 t2
->l_child
.leaf
= a_simple_expression
;
380 a_simple_expression
= g_new(LttvSimpleExpression
,1);
381 t1
->right
= LTTV_TREE_NODE
;
385 case '!': /* not, or not equal (math op) */
386 if(expression
[i
+1] == '=') { /* != */
387 a_simple_expression
->op
= LTTV_FIELD_NE
;
389 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
390 a_field_component
= g_string_new("");
392 // g_print("%s\n",a_field_component);
393 // a_field_component = g_string_new("");
394 t1
= (LttvFilter
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
395 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
396 t2
= lttv_filter_tree_new();
397 t2
->node
= LTTV_LOGICAL_NOT
;
398 t1
->right
= LTTV_TREE_NODE
;
402 case '(': /* start of parenthesis */
405 p_nesting
++; /* incrementing parenthesis nesting value */
406 t1
= lttv_filter_tree_new();
407 g_ptr_array_add( tree_stack
,(gpointer
) t1
);
409 case ')': /* end of parenthesis */
412 p_nesting
--; /* decrementing parenthesis nesting value */
413 if(p_nesting
<0 || tree_stack
->len
<2) {
414 g_warning("Wrong filtering options, the string\n\"%s\"\n\
415 is not valid due to parenthesis incorrect use",expression
);
419 g_assert(tree_stack
->len
>0);
420 if(subtree
!= NULL
) {
421 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
422 while(t1
->right
!= LTTV_TREE_IDLE
&& t1
->right
!= LTTV_TREE_LEAF
) {
423 g_assert(t1
!=NULL
&& t1
->r_child
.t
!= NULL
);
426 t1
->right
= LTTV_TREE_NODE
;
427 t1
->r_child
.t
= subtree
;
428 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
429 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
431 a_simple_expression
->value
= a_field_component
->str
;
432 a_field_component
= g_string_new("");
433 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
434 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
435 t1
->right
= LTTV_TREE_LEAF
;
436 t1
->r_child
.leaf
= a_simple_expression
;
437 a_simple_expression
= g_new(LttvSimpleExpression
,1);
438 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
439 g_assert(subtree
!= NULL
);
440 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
445 * mathematic operators
447 case '<': /* lower, lower or equal */
448 if(expression
[i
+1] == '=') { /* <= */
450 a_simple_expression
->op
= LTTV_FIELD_LE
;
451 } else a_simple_expression
->op
= LTTV_FIELD_LT
;
452 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
453 a_field_component
= g_string_new("");
455 case '>': /* higher, higher or equal */
456 if(expression
[i
+1] == '=') { /* >= */
458 a_simple_expression
->op
= LTTV_FIELD_GE
;
459 } else a_simple_expression
->op
= LTTV_FIELD_GT
;
460 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
461 a_field_component
= g_string_new("");
463 case '=': /* equal */
464 a_simple_expression
->op
= LTTV_FIELD_EQ
;
465 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
466 a_field_component
= g_string_new("");
469 * Field concatening caracter
472 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
473 a_field_component
= g_string_new("");
475 default: /* concatening current string */
476 g_string_append_c(a_field_component
,expression
[i
]);
480 g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree
,tree
,t1
,t2
);
481 g_print("stack size: %i\n",tree_stack
->len
);
484 * Preliminary check to see
485 * if tree was constructed correctly
488 g_warning("Wrong filtering options, the string\n\"%s\"\n\
489 is not valid due to parenthesis incorrect use",expression
);
493 if(tree_stack
->len
!= 1) /* only root tree should remain */
496 /* processing last element of expression */
497 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
498 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
499 if(subtree
!= NULL
) { /* add the subtree */
500 t1
->right
= LTTV_TREE_NODE
;
501 t1
->r_child
.t
= subtree
;
503 } else { /* add a leaf */
504 a_simple_expression
->value
= a_field_component
->str
;
505 a_field_component
= g_string_new("");
506 t1
->right
= LTTV_TREE_LEAF
;
507 t1
->r_child
.leaf
= a_simple_expression
;
509 * FIXME: is it really necessary to reallocate
510 * LttvSimpleExpression at this point ??
512 a_simple_expression
= g_new(LttvSimpleExpression
,1);
515 g_assert(tree
!= NULL
);
516 g_assert(subtree
== NULL
);
518 lttv_filter_tracefile(tree
,NULL
);
525 lttv_filter_destroy(LttvFilter
* filter
) {
530 * Apply the filter to a specific trace
531 * @param filter the current filter applied
532 * @param tracefile the trace to apply the filter to
533 * @return success/failure of operation
536 lttv_filter_tracefile(LttvFilter
*filter
, LttTracefile
*tracefile
) {
539 * Each tree is parsed in inorder.
540 * This way, it's possible to apply the left filter of the
541 * tree, then decide whether or not the right branch should
542 * be parsed depending on the linking logical operator
544 * As for the filtering structure, since we are trying
545 * to remove elements from the trace, it might be better
546 * managing an array of all items to be removed ..
549 g_print("node:%p lchild:%p rchild:%p\n",filter
,filter
->l_child
.t
,filter
->r_child
.t
);
550 g_print("node type%i\n",filter
->node
);
551 if(filter
->left
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->l_child
.t
,NULL
);
552 else if(filter
->left
== LTTV_TREE_LEAF
) {
553 g_assert(filter
->l_child
.leaf
->value
!= NULL
);
554 g_print("%p: left is qqch %i %s\n",filter
,filter
->l_child
.leaf
->op
,filter
->l_child
.leaf
->value
);
556 if(filter
->right
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->r_child
.t
,NULL
);
557 else if(filter
->right
== LTTV_TREE_LEAF
) {
558 g_assert(filter
->r_child
.leaf
->value
!= NULL
);
559 g_print("%p: right is qqch %i %s\n",filter
,filter
->r_child
.leaf
->op
,filter
->r_child
.leaf
->value
);
564 char *f_name, *e_name;
574 GString *fe_name = g_string_new("");
576 nb = ltt_trace_eventtype_number(tcs->parent.t);
577 g_print("NB:%i\n",nb);
578 for(i = 0 ; i < nb ; i++) {
579 et = ltt_trace_eventtype_get(tcs->parent.t, i);
580 e_name = ltt_eventtype_name(et);
581 f_name = ltt_facility_name(ltt_eventtype_facility(et));
582 g_string_printf(fe_name, "%s.%s", f_name, e_name);
583 g_print("facility:%s and event:%s\n",f_name,e_name);
589 lttv_filter_tracestate(LttvFilter
*filter
, LttvTraceState
*tracestate
) {
594 * Apply the filter to a specific event
595 * @param filter the current filter applied
596 * @param event the event to apply the filter to
597 * @return success/failure of operation
600 lttv_filter_event(LttvFilter
*filter
, LttEvent
*event
) {
605 * Initializes the filter module and specific values
607 static void module_init()
611 * Quarks initialization
612 * for hardcoded filtering options
614 * TODO: traceset has no yet been defined
618 LTTV_FILTER_EVENT
= g_quark_from_string("event");
619 LTTV_FILTER_TRACE
= g_quark_from_string("trace");
620 LTTV_FILTER_TRACESET
= g_quark_from_string("traceset");
621 LTTV_FILTER_STATE
= g_quark_from_string("state");
622 LTTV_FILTER_TRACEFILE
= g_quark_from_string("tracefile");
624 /* event.name, tracefile.name, trace.name */
625 LTTV_FILTER_NAME
= g_quark_from_string("name");
627 /* event sub fields */
628 LTTV_FILTER_CATEGORY
= g_quark_from_string("category");
629 LTTV_FILTER_TIME
= g_quark_from_string("time");
630 LTTV_FILTER_TSC
= g_quark_from_string("tsc");
632 /* state sub fields */
633 LTTV_FILTER_PID
= g_quark_from_string("pid");
634 LTTV_FILTER_PPID
= g_quark_from_string("ppid");
635 LTTV_FILTER_C_TIME
= g_quark_from_string("creation_time");
636 LTTV_FILTER_I_TIME
= g_quark_from_string("insertion_time");
637 LTTV_FILTER_P_NAME
= g_quark_from_string("process_name");
638 LTTV_FILTER_EX_MODE
= g_quark_from_string("execution_mode");
639 LTTV_FILTER_EX_SUBMODE
= g_quark_from_string("execution_submode");
640 LTTV_FILTER_P_STATUS
= g_quark_from_string("process_status");
641 LTTV_FILTER_CPU
= g_quark_from_string("cpu");
646 * Destroys the filter module and specific values
648 static void module_destroy()
653 LTTV_MODULE("filter", "Filters traceset and events", \
654 "Filters traceset and events specifically to user input", \
655 module_init
, module_destroy
)
This page took 0.042175 seconds and 4 git commands to generate.