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
,
83 lttv_simple_expression
*
84 lttv_simple_expression_new() {
89 * Assign a new tree for the current expression
91 * @return pointer of lttv_filter_tree
93 lttv_filter_tree
* lttv_filter_tree_new() {
94 lttv_filter_tree
* tree
;
96 tree
= g_new(lttv_filter_tree
,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(lttv_filter_tree
* tree
) {
111 if(tree
->left
== LTTV_TREE_LEAF
) g_free(tree
->l_child
.leaf
);
112 else if(tree
->left
== LTTV_TREE_NODE
) lttv_filter_tree_destroy(tree
->l_child
.t
);
114 if(tree
->right
== LTTV_TREE_LEAF
) g_free(tree
->r_child
.leaf
);
115 else if(tree
->right
== LTTV_TREE_NODE
) lttv_filter_tree_destroy(tree
->r_child
.t
);
122 lttv_filter_tree_add_node(GPtrArray
* stack
, lttv_filter_tree
* subtree
, lttv_logical_op op
) {
124 lttv_filter_tree
* t1
= NULL
;
125 lttv_filter_tree
* t2
= NULL
;;
127 t1
= (lttv_filter_tree
*)g_ptr_array_index(stack
,stack
->len
-1);
128 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
129 t2
= lttv_filter_tree_new();
131 if(subtree
!= NULL
) {
132 t2
->left
= LTTV_TREE_NODE
;
133 t2
->l_child
.t
= subtree
;
135 t1
->right
= LTTV_TREE_NODE
;
138 // a_simple_expression->value = a_field_component->str;
139 // a_field_component = g_string_new("");
140 t2
->left
= LTTV_TREE_LEAF
;
141 // t2->l_child.leaf = a_simple_expression;
142 // a_simple_expression = g_new(lttv_simple_expression,1);
143 t1
->right
= LTTV_TREE_NODE
;
150 * Parse through filtering field hierarchy as specified
151 * by user. This function compares each value to
152 * predetermined quarks
153 * @param fp The field path list
154 * @return success/failure of operation
157 parse_field_path(GPtrArray
* fp
) {
160 if(fp
->len
< 2) return FALSE
;
161 g_assert(f
=g_ptr_array_index(fp
,0)); //list_first(fp)->data;
163 if(g_quark_try_string(f
->str
) == LTTV_FILTER_EVENT
) {
164 f
=g_ptr_array_index(fp
,1);
165 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
166 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CATEGORY
) {}
167 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TIME
) {
168 // offset = &((LttEvent*)NULL)->event_time);
170 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TSC
) {
171 // offset = &((LttEvent*)NULL)->event_cycle_count);
173 else { /* core.xml specified options */
176 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACEFILE
) {
177 f
=g_ptr_array_index(fp
,1);
178 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
180 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACE
) {
181 f
=g_ptr_array_index(fp
,1);
182 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
185 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_STATE
) {
186 f
=g_ptr_array_index(fp
,1);
187 if(g_quark_try_string(f
->str
) == LTTV_FILTER_PID
) {}
188 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_PPID
) {}
189 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_C_TIME
) {}
190 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_I_TIME
) {}
191 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_NAME
) {}
192 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_MODE
) {}
193 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_SUBMODE
) {}
194 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_STATUS
) {}
195 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CPU
) {}
199 g_warning("Unrecognized field in filter string");
206 * Add an filtering option to the current tree
207 * @param expression Current expression to parse
208 * @return success/failure of operation
211 parse_simple_expression(GString
* expression
) {
221 * Creates a new lttv_filter
222 * @param expression filtering options string
223 * @param t pointer to the current LttvTrace
224 * @return the current lttv_filter or NULL if error
227 lttv_filter_new(char *expression
, LttvTraceState
*tcs
) {
229 g_print("filter::lttv_filter_new()\n"); /* debug */
233 p_nesting
=0, /* parenthesis nesting value */
234 b
=0; /* current breakpoint in expression string */
238 *tree
= lttv_filter_tree_new(), /* main tree */
239 *subtree
= NULL
, /* buffer for subtrees */
245 * each element of the list
246 * is a sub tree created
247 * by the use of parenthesis in the
248 * global expression. The final tree
249 * will be the one left at the root of
252 GPtrArray
*tree_stack
= g_ptr_array_new();
253 g_ptr_array_add( tree_stack
,(gpointer
) tree
);
255 /* temporary values */
256 GString
*a_field_component
= g_string_new("");
257 GPtrArray
*a_field_path
= NULL
;
259 lttv_simple_expression
* a_simple_expression
= g_new(lttv_simple_expression
,1);
262 * Parse entire expression and construct
263 * the binary tree. There are two steps
264 * in browsing that string
265 * 1. finding boolean ops " &,|,^,! " and parenthesis " {,(,[,],),} "
266 * 2. finding simple expressions
267 * - field path ( separated by dots )
268 * - op ( >, <, =, >=, <=, !=)
269 * - value ( integer, string ... )
270 * To spare computing time, the whole
271 * string is parsed in this loop for a
272 * O(n) complexity order.
274 * When encountering logical op &,|,^
275 * 1. parse the last value if any
276 * 2. create a new tree
277 * 3. add the expression (simple exp, or exp (subtree)) to the tree
278 * 4. concatenate this tree with the current tree on top of the stack
279 * When encountering math ops >,>=,<,<=,=,!=
280 * 1. add to op to the simple expression
281 * 2. concatenate last field component to field path
282 * When encountering concatening ops .
283 * 1. concatenate last field component to field path
284 * When encountering opening parenthesis (,{,[
285 * 1. create a new subtree on top of tree stack
286 * When encountering closing parenthesis ),},]
287 * 1. add the expression on right child of the current tree
288 * 2. the subtree is completed, allocate a new subtree
289 * 3. pop the tree value from the tree stack
292 a_field_path
= g_ptr_array_new();
293 g_ptr_array_set_size(a_field_path
,2); /* by default, recording 2 field expressions */
296 for(i
=0;i
<strlen(expression
);i
++) {
297 // g_print("%s\n",a_field_component->str);
298 g_print("%c ",expression
[i
]);
299 // g_print("switch:%c -->subtree:%p\n",expression[i],subtree);
300 switch(expression
[i
]) {
305 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
306 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
307 t2
= lttv_filter_tree_new();
308 t2
->node
= LTTV_LOGICAL_AND
;
309 if(subtree
!= NULL
) {
310 t2
->left
= LTTV_TREE_NODE
;
311 t2
->l_child
.t
= subtree
;
313 t1
->right
= LTTV_TREE_NODE
;
316 a_simple_expression
->value
= a_field_component
->str
;
317 a_field_component
= g_string_new("");
318 t2
->left
= LTTV_TREE_LEAF
;
319 t2
->l_child
.leaf
= a_simple_expression
;
320 a_simple_expression
= g_new(lttv_simple_expression
,1);
321 t1
->right
= LTTV_TREE_NODE
;
327 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
328 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
329 t2
= lttv_filter_tree_new();
330 t2
->node
= LTTV_LOGICAL_OR
;
331 if(subtree
!= NULL
) {
332 t2
->left
= LTTV_TREE_NODE
;
333 t2
->l_child
.t
= subtree
;
335 t1
->right
= LTTV_TREE_NODE
;
338 a_simple_expression
->value
= a_field_component
->str
;
339 a_field_component
= g_string_new("");
340 t2
->left
= LTTV_TREE_LEAF
;
341 t2
->l_child
.leaf
= a_simple_expression
;
342 a_simple_expression
= g_new(lttv_simple_expression
,1);
343 t1
->right
= LTTV_TREE_NODE
;
348 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
349 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
350 t2
= lttv_filter_tree_new();
351 t2
->node
= LTTV_LOGICAL_XOR
;
352 if(subtree
!= NULL
) {
353 t2
->left
= LTTV_TREE_NODE
;
354 t2
->l_child
.t
= subtree
;
356 t1
->right
= LTTV_TREE_NODE
;
359 a_simple_expression
->value
= a_field_component
->str
;
360 a_field_component
= g_string_new("");
361 t2
->left
= LTTV_TREE_LEAF
;
362 t2
->l_child
.leaf
= a_simple_expression
;
363 a_simple_expression
= g_new(lttv_simple_expression
,1);
364 t1
->right
= LTTV_TREE_NODE
;
368 case '!': /* not, or not equal (math op) */
369 if(expression
[i
+1] == '=') { /* != */
370 a_simple_expression
->op
= LTTV_FIELD_NE
;
372 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
373 a_field_component
= g_string_new("");
375 // g_print("%s\n",a_field_component);
376 // a_field_component = g_string_new("");
377 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
378 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
379 t2
= lttv_filter_tree_new();
380 t2
->node
= LTTV_LOGICAL_NOT
;
381 t1
->right
= LTTV_TREE_NODE
;
385 case '(': /* start of parenthesis */
388 p_nesting
++; /* incrementing parenthesis nesting value */
389 t1
= lttv_filter_tree_new();
390 g_ptr_array_add( tree_stack
,(gpointer
) t1
);
392 case ')': /* end of parenthesis */
395 p_nesting
--; /* decrementing parenthesis nesting value */
396 if(p_nesting
<0 || tree_stack
->len
<2) {
397 g_warning("Wrong filtering options, the string\n\"%s\"\n\
398 is not valid due to parenthesis incorrect use",expression
);
402 g_assert(tree_stack
->len
>0);
403 if(subtree
!= NULL
) {
404 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
405 while(t1
->right
!= LTTV_TREE_IDLE
&& t1
->right
!= LTTV_TREE_LEAF
) {
406 g_assert(t1
!=NULL
&& t1
->r_child
.t
!= NULL
);
409 t1
->right
= LTTV_TREE_NODE
;
410 t1
->r_child
.t
= subtree
;
411 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
412 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
414 a_simple_expression
->value
= a_field_component
->str
;
415 a_field_component
= g_string_new("");
416 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
417 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
418 t1
->right
= LTTV_TREE_LEAF
;
419 t1
->r_child
.leaf
= a_simple_expression
;
420 a_simple_expression
= g_new(lttv_simple_expression
,1);
421 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
422 g_assert(subtree
!= NULL
);
423 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
428 * mathematic operators
430 case '<': /* lower, lower or equal */
431 if(expression
[i
+1] == '=') { /* <= */
433 a_simple_expression
->op
= LTTV_FIELD_LE
;
434 } else a_simple_expression
->op
= LTTV_FIELD_LT
;
435 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
436 a_field_component
= g_string_new("");
438 case '>': /* higher, higher or equal */
439 if(expression
[i
+1] == '=') { /* >= */
441 a_simple_expression
->op
= LTTV_FIELD_GE
;
442 } else a_simple_expression
->op
= LTTV_FIELD_GT
;
443 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
444 a_field_component
= g_string_new("");
446 case '=': /* equal */
447 a_simple_expression
->op
= LTTV_FIELD_EQ
;
448 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
449 a_field_component
= g_string_new("");
452 * Field concatening caracter
455 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
456 a_field_component
= g_string_new("");
458 default: /* concatening current string */
459 g_string_append_c(a_field_component
,expression
[i
]);
463 g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree
,tree
,t1
,t2
);
464 g_print("stack size: %i\n",tree_stack
->len
);
467 * Preliminary check to see
468 * if tree was constructed correctly
471 g_warning("Wrong filtering options, the string\n\"%s\"\n\
472 is not valid due to parenthesis incorrect use",expression
);
476 if(tree_stack
->len
!= 1) /* only root tree should remain */
479 /* processing last element of expression */
480 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
481 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
482 if(subtree
!= NULL
) { /* add the subtree */
483 t1
->right
= LTTV_TREE_NODE
;
484 t1
->r_child
.t
= subtree
;
486 } else { /* add a leaf */
487 a_simple_expression
->value
= a_field_component
->str
;
488 a_field_component
= g_string_new("");
489 t1
->right
= LTTV_TREE_LEAF
;
490 t1
->r_child
.leaf
= a_simple_expression
;
491 a_simple_expression
= g_new(lttv_simple_expression
,1);
494 g_assert(tree
!= NULL
);
495 g_assert(subtree
== NULL
);
497 lttv_filter_tracefile(tree
,NULL
);
504 * Apply the filter to a specific trace
505 * @param filter the current filter applied
506 * @param tracefile the trace to apply the filter to
507 * @return success/failure of operation
510 lttv_filter_tracefile(lttv_filter_tree
*filter
, LttTracefile
*tracefile
) {
513 * Each tree is parsed in inorder.
514 * This way, it's possible to apply the left filter of the
515 * tree, then decide whether or not the right branch should
516 * be parsed depending on the linking logical operator
518 * As for the filtering structure, since we are trying
519 * to remove elements from the trace, it might be better
520 * managing an array of all items to be removed ..
523 g_print("node:%p lchild:%p rchild:%p\n",filter
,filter
->l_child
.t
,filter
->r_child
.t
);
524 g_print("node type%i\n",filter
->node
);
525 if(filter
->left
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->l_child
.t
,NULL
);
526 else if(filter
->left
== LTTV_TREE_LEAF
) {
527 g_assert(filter
->l_child
.leaf
->value
!= NULL
);
528 g_print("%p: left is qqch %i %s\n",filter
,filter
->l_child
.leaf
->op
,filter
->l_child
.leaf
->value
);
530 if(filter
->right
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->r_child
.t
,NULL
);
531 else if(filter
->right
== LTTV_TREE_LEAF
) {
532 g_assert(filter
->r_child
.leaf
->value
!= NULL
);
533 g_print("%p: right is qqch %i %s\n",filter
,filter
->r_child
.leaf
->op
,filter
->r_child
.leaf
->value
);
538 char *f_name, *e_name;
548 GString *fe_name = g_string_new("");
550 nb = ltt_trace_eventtype_number(tcs->parent.t);
551 g_print("NB:%i\n",nb);
552 for(i = 0 ; i < nb ; i++) {
553 et = ltt_trace_eventtype_get(tcs->parent.t, i);
554 e_name = ltt_eventtype_name(et);
555 f_name = ltt_facility_name(ltt_eventtype_facility(et));
556 g_string_printf(fe_name, "%s.%s", f_name, e_name);
557 g_print("facility:%s and event:%s\n",f_name,e_name);
563 lttv_filter_tracestate(lttv_filter_t
*filter
, LttvTraceState
*tracestate
) {
568 * Apply the filter to a specific event
569 * @param filter the current filter applied
570 * @param event the event to apply the filter to
571 * @return success/failure of operation
574 lttv_filter_event(lttv_filter_t
*filter
, LttEvent
*event
) {
579 * Initializes the filter module and specific values
581 static void module_init()
585 * Quarks initialization
586 * for hardcoded filtering options
588 * TODO: traceset has no yet been defined
592 LTTV_FILTER_EVENT
= g_quark_from_string("event");
593 LTTV_FILTER_TRACE
= g_quark_from_string("trace");
594 LTTV_FILTER_TRACESET
= g_quark_from_string("traceset");
595 LTTV_FILTER_STATE
= g_quark_from_string("state");
596 LTTV_FILTER_TRACEFILE
= g_quark_from_string("tracefile");
598 /* event.name, tracefile.name, trace.name */
599 LTTV_FILTER_NAME
= g_quark_from_string("name");
601 /* event sub fields */
602 LTTV_FILTER_CATEGORY
= g_quark_from_string("category");
603 LTTV_FILTER_TIME
= g_quark_from_string("time");
604 LTTV_FILTER_TSC
= g_quark_from_string("tsc");
606 /* state sub fields */
607 LTTV_FILTER_PID
= g_quark_from_string("pid");
608 LTTV_FILTER_PPID
= g_quark_from_string("ppid");
609 LTTV_FILTER_C_TIME
= g_quark_from_string("creation_time");
610 LTTV_FILTER_I_TIME
= g_quark_from_string("insertion_time");
611 LTTV_FILTER_P_NAME
= g_quark_from_string("process_name");
612 LTTV_FILTER_EX_MODE
= g_quark_from_string("execution_mode");
613 LTTV_FILTER_EX_SUBMODE
= g_quark_from_string("execution_submode");
614 LTTV_FILTER_P_STATUS
= g_quark_from_string("process_status");
615 LTTV_FILTER_CPU
= g_quark_from_string("cpu");
620 * Destroys the filter module and specific values
622 static void module_destroy()
627 LTTV_MODULE("filter", "Filters traceset and events", \
628 "Filters traceset and events specifically to user input", \
629 module_init
, module_destroy
)
This page took 0.044127 seconds and 4 git commands to generate.