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_clone(lttv_filter
* tree
) {
124 lttv_filter
* newtree
= lttv_filter_tree_new();
127 * TODO : Copy tree into new tree
135 lttv_filter_tree_add_node(GPtrArray
* stack
, lttv_filter_tree
* subtree
, lttv_logical_op op
) {
137 lttv_filter_tree
* t1
= NULL
;
138 lttv_filter_tree
* t2
= NULL
;;
140 t1
= (lttv_filter_tree
*)g_ptr_array_index(stack
,stack
->len
-1);
141 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
142 t2
= lttv_filter_tree_new();
144 if(subtree
!= NULL
) {
145 t2
->left
= LTTV_TREE_NODE
;
146 t2
->l_child
.t
= subtree
;
148 t1
->right
= LTTV_TREE_NODE
;
151 // a_simple_expression->value = a_field_component->str;
152 // a_field_component = g_string_new("");
153 t2
->left
= LTTV_TREE_LEAF
;
154 // t2->l_child.leaf = a_simple_expression;
155 // a_simple_expression = g_new(lttv_simple_expression,1);
156 t1
->right
= LTTV_TREE_NODE
;
163 * Parse through filtering field hierarchy as specified
164 * by user. This function compares each value to
165 * predetermined quarks
166 * @param fp The field path list
167 * @return success/failure of operation
170 parse_field_path(GPtrArray
* fp
) {
173 if(fp
->len
< 2) return FALSE
;
174 g_assert(f
=g_ptr_array_index(fp
,0)); //list_first(fp)->data;
176 if(g_quark_try_string(f
->str
) == LTTV_FILTER_EVENT
) {
177 f
=g_ptr_array_index(fp
,1);
178 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
179 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CATEGORY
) {}
180 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TIME
) {
181 // offset = &((LttEvent*)NULL)->event_time);
183 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TSC
) {
184 // offset = &((LttEvent*)NULL)->event_cycle_count);
186 else { /* core.xml specified options */
189 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACEFILE
) {
190 f
=g_ptr_array_index(fp
,1);
191 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
193 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_TRACE
) {
194 f
=g_ptr_array_index(fp
,1);
195 if(g_quark_try_string(f
->str
) == LTTV_FILTER_NAME
) {}
198 } else if(g_quark_try_string(f
->str
) == LTTV_FILTER_STATE
) {
199 f
=g_ptr_array_index(fp
,1);
200 if(g_quark_try_string(f
->str
) == LTTV_FILTER_PID
) {}
201 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_PPID
) {}
202 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_C_TIME
) {}
203 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_I_TIME
) {}
204 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_NAME
) {}
205 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_MODE
) {}
206 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_EX_SUBMODE
) {}
207 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_P_STATUS
) {}
208 else if(g_quark_try_string(f
->str
) == LTTV_FILTER_CPU
) {}
212 g_warning("Unrecognized field in filter string");
219 * Add an filtering option to the current tree
220 * @param expression Current expression to parse
221 * @return success/failure of operation
224 parse_simple_expression(GString
* expression
) {
234 * Creates a new lttv_filter
235 * @param expression filtering options string
236 * @param t pointer to the current LttvTrace
237 * @return the current lttv_filter or NULL if error
240 lttv_filter_new(char *expression
, LttvTraceState
*tcs
) {
242 g_print("filter::lttv_filter_new()\n"); /* debug */
246 p_nesting
=0, /* parenthesis nesting value */
247 b
=0; /* current breakpoint in expression string */
251 *tree
= lttv_filter_tree_new(), /* main tree */
252 *subtree
= NULL
, /* buffer for subtrees */
258 * each element of the list
259 * is a sub tree created
260 * by the use of parenthesis in the
261 * global expression. The final tree
262 * will be the one left at the root of
265 GPtrArray
*tree_stack
= g_ptr_array_new();
266 g_ptr_array_add( tree_stack
,(gpointer
) tree
);
268 /* temporary values */
269 GString
*a_field_component
= g_string_new("");
270 GPtrArray
*a_field_path
= NULL
;
272 lttv_simple_expression
* a_simple_expression
= g_new(lttv_simple_expression
,1);
275 * Parse entire expression and construct
276 * the binary tree. There are two steps
277 * in browsing that string
278 * 1. finding boolean ops " &,|,^,! " and parenthesis " {,(,[,],),} "
279 * 2. finding simple expressions
280 * - field path ( separated by dots )
281 * - op ( >, <, =, >=, <=, !=)
282 * - value ( integer, string ... )
283 * To spare computing time, the whole
284 * string is parsed in this loop for a
285 * O(n) complexity order.
287 * When encountering logical op &,|,^
288 * 1. parse the last value if any
289 * 2. create a new tree
290 * 3. add the expression (simple exp, or exp (subtree)) to the tree
291 * 4. concatenate this tree with the current tree on top of the stack
292 * When encountering math ops >,>=,<,<=,=,!=
293 * 1. add to op to the simple expression
294 * 2. concatenate last field component to field path
295 * When encountering concatening ops .
296 * 1. concatenate last field component to field path
297 * When encountering opening parenthesis (,{,[
298 * 1. create a new subtree on top of tree stack
299 * When encountering closing parenthesis ),},]
300 * 1. add the expression on right child of the current tree
301 * 2. the subtree is completed, allocate a new subtree
302 * 3. pop the tree value from the tree stack
305 a_field_path
= g_ptr_array_new();
306 g_ptr_array_set_size(a_field_path
,2); /* by default, recording 2 field expressions */
309 for(i
=0;i
<strlen(expression
);i
++) {
310 // g_print("%s\n",a_field_component->str);
311 g_print("%c ",expression
[i
]);
312 // g_print("switch:%c -->subtree:%p\n",expression[i],subtree);
313 switch(expression
[i
]) {
318 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
319 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
320 t2
= lttv_filter_tree_new();
321 t2
->node
= LTTV_LOGICAL_AND
;
322 if(subtree
!= NULL
) {
323 t2
->left
= LTTV_TREE_NODE
;
324 t2
->l_child
.t
= subtree
;
326 t1
->right
= LTTV_TREE_NODE
;
329 a_simple_expression
->value
= a_field_component
->str
;
330 a_field_component
= g_string_new("");
331 t2
->left
= LTTV_TREE_LEAF
;
332 t2
->l_child
.leaf
= a_simple_expression
;
333 a_simple_expression
= g_new(lttv_simple_expression
,1);
334 t1
->right
= LTTV_TREE_NODE
;
340 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
341 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
342 t2
= lttv_filter_tree_new();
343 t2
->node
= LTTV_LOGICAL_OR
;
344 if(subtree
!= NULL
) {
345 t2
->left
= LTTV_TREE_NODE
;
346 t2
->l_child
.t
= subtree
;
348 t1
->right
= LTTV_TREE_NODE
;
351 a_simple_expression
->value
= a_field_component
->str
;
352 a_field_component
= g_string_new("");
353 t2
->left
= LTTV_TREE_LEAF
;
354 t2
->l_child
.leaf
= a_simple_expression
;
355 a_simple_expression
= g_new(lttv_simple_expression
,1);
356 t1
->right
= LTTV_TREE_NODE
;
361 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
362 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
363 t2
= lttv_filter_tree_new();
364 t2
->node
= LTTV_LOGICAL_XOR
;
365 if(subtree
!= NULL
) {
366 t2
->left
= LTTV_TREE_NODE
;
367 t2
->l_child
.t
= subtree
;
369 t1
->right
= LTTV_TREE_NODE
;
372 a_simple_expression
->value
= a_field_component
->str
;
373 a_field_component
= g_string_new("");
374 t2
->left
= LTTV_TREE_LEAF
;
375 t2
->l_child
.leaf
= a_simple_expression
;
376 a_simple_expression
= g_new(lttv_simple_expression
,1);
377 t1
->right
= LTTV_TREE_NODE
;
381 case '!': /* not, or not equal (math op) */
382 if(expression
[i
+1] == '=') { /* != */
383 a_simple_expression
->op
= LTTV_FIELD_NE
;
385 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
386 a_field_component
= g_string_new("");
388 // g_print("%s\n",a_field_component);
389 // a_field_component = g_string_new("");
390 t1
= (lttv_filter_tree
*)g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
391 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
392 t2
= lttv_filter_tree_new();
393 t2
->node
= LTTV_LOGICAL_NOT
;
394 t1
->right
= LTTV_TREE_NODE
;
398 case '(': /* start of parenthesis */
401 p_nesting
++; /* incrementing parenthesis nesting value */
402 t1
= lttv_filter_tree_new();
403 g_ptr_array_add( tree_stack
,(gpointer
) t1
);
405 case ')': /* end of parenthesis */
408 p_nesting
--; /* decrementing parenthesis nesting value */
409 if(p_nesting
<0 || tree_stack
->len
<2) {
410 g_warning("Wrong filtering options, the string\n\"%s\"\n\
411 is not valid due to parenthesis incorrect use",expression
);
415 g_assert(tree_stack
->len
>0);
416 if(subtree
!= NULL
) {
417 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
418 while(t1
->right
!= LTTV_TREE_IDLE
&& t1
->right
!= LTTV_TREE_LEAF
) {
419 g_assert(t1
!=NULL
&& t1
->r_child
.t
!= NULL
);
422 t1
->right
= LTTV_TREE_NODE
;
423 t1
->r_child
.t
= subtree
;
424 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
425 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
427 a_simple_expression
->value
= a_field_component
->str
;
428 a_field_component
= g_string_new("");
429 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
430 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
431 t1
->right
= LTTV_TREE_LEAF
;
432 t1
->r_child
.leaf
= a_simple_expression
;
433 a_simple_expression
= g_new(lttv_simple_expression
,1);
434 subtree
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
435 g_assert(subtree
!= NULL
);
436 g_ptr_array_remove_index(tree_stack
,tree_stack
->len
-1);
441 * mathematic operators
443 case '<': /* lower, lower or equal */
444 if(expression
[i
+1] == '=') { /* <= */
446 a_simple_expression
->op
= LTTV_FIELD_LE
;
447 } else a_simple_expression
->op
= LTTV_FIELD_LT
;
448 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
449 a_field_component
= g_string_new("");
451 case '>': /* higher, higher or equal */
452 if(expression
[i
+1] == '=') { /* >= */
454 a_simple_expression
->op
= LTTV_FIELD_GE
;
455 } else a_simple_expression
->op
= LTTV_FIELD_GT
;
456 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
457 a_field_component
= g_string_new("");
459 case '=': /* equal */
460 a_simple_expression
->op
= LTTV_FIELD_EQ
;
461 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
462 a_field_component
= g_string_new("");
465 * Field concatening caracter
468 g_ptr_array_add( a_field_path
,(gpointer
) a_field_component
);
469 a_field_component
= g_string_new("");
471 default: /* concatening current string */
472 g_string_append_c(a_field_component
,expression
[i
]);
476 g_print("subtree:%p, tree:%p, t1:%p, t2:%p\n",subtree
,tree
,t1
,t2
);
477 g_print("stack size: %i\n",tree_stack
->len
);
480 * Preliminary check to see
481 * if tree was constructed correctly
484 g_warning("Wrong filtering options, the string\n\"%s\"\n\
485 is not valid due to parenthesis incorrect use",expression
);
489 if(tree_stack
->len
!= 1) /* only root tree should remain */
492 /* processing last element of expression */
493 t1
= g_ptr_array_index(tree_stack
,tree_stack
->len
-1);
494 while(t1
->right
!= LTTV_TREE_IDLE
) t1
= t1
->r_child
.t
;
495 if(subtree
!= NULL
) { /* add the subtree */
496 t1
->right
= LTTV_TREE_NODE
;
497 t1
->r_child
.t
= subtree
;
499 } else { /* add a leaf */
500 a_simple_expression
->value
= a_field_component
->str
;
501 a_field_component
= g_string_new("");
502 t1
->right
= LTTV_TREE_LEAF
;
503 t1
->r_child
.leaf
= a_simple_expression
;
504 a_simple_expression
= g_new(lttv_simple_expression
,1);
507 g_assert(tree
!= NULL
);
508 g_assert(subtree
== NULL
);
510 lttv_filter_tracefile(tree
,NULL
);
517 lttv_filter_destroy(lttv_filter
* filter
) {
522 * Apply the filter to a specific trace
523 * @param filter the current filter applied
524 * @param tracefile the trace to apply the filter to
525 * @return success/failure of operation
528 lttv_filter_tracefile(lttv_filter_tree
*filter
, LttTracefile
*tracefile
) {
531 * Each tree is parsed in inorder.
532 * This way, it's possible to apply the left filter of the
533 * tree, then decide whether or not the right branch should
534 * be parsed depending on the linking logical operator
536 * As for the filtering structure, since we are trying
537 * to remove elements from the trace, it might be better
538 * managing an array of all items to be removed ..
541 g_print("node:%p lchild:%p rchild:%p\n",filter
,filter
->l_child
.t
,filter
->r_child
.t
);
542 g_print("node type%i\n",filter
->node
);
543 if(filter
->left
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->l_child
.t
,NULL
);
544 else if(filter
->left
== LTTV_TREE_LEAF
) {
545 g_assert(filter
->l_child
.leaf
->value
!= NULL
);
546 g_print("%p: left is qqch %i %s\n",filter
,filter
->l_child
.leaf
->op
,filter
->l_child
.leaf
->value
);
548 if(filter
->right
== LTTV_TREE_NODE
) lttv_filter_tracefile(filter
->r_child
.t
,NULL
);
549 else if(filter
->right
== LTTV_TREE_LEAF
) {
550 g_assert(filter
->r_child
.leaf
->value
!= NULL
);
551 g_print("%p: right is qqch %i %s\n",filter
,filter
->r_child
.leaf
->op
,filter
->r_child
.leaf
->value
);
556 char *f_name, *e_name;
566 GString *fe_name = g_string_new("");
568 nb = ltt_trace_eventtype_number(tcs->parent.t);
569 g_print("NB:%i\n",nb);
570 for(i = 0 ; i < nb ; i++) {
571 et = ltt_trace_eventtype_get(tcs->parent.t, i);
572 e_name = ltt_eventtype_name(et);
573 f_name = ltt_facility_name(ltt_eventtype_facility(et));
574 g_string_printf(fe_name, "%s.%s", f_name, e_name);
575 g_print("facility:%s and event:%s\n",f_name,e_name);
581 lttv_filter_tracestate(lttv_filter_t
*filter
, LttvTraceState
*tracestate
) {
586 * Apply the filter to a specific event
587 * @param filter the current filter applied
588 * @param event the event to apply the filter to
589 * @return success/failure of operation
592 lttv_filter_event(lttv_filter_t
*filter
, LttEvent
*event
) {
597 * Initializes the filter module and specific values
599 static void module_init()
603 * Quarks initialization
604 * for hardcoded filtering options
606 * TODO: traceset has no yet been defined
610 LTTV_FILTER_EVENT
= g_quark_from_string("event");
611 LTTV_FILTER_TRACE
= g_quark_from_string("trace");
612 LTTV_FILTER_TRACESET
= g_quark_from_string("traceset");
613 LTTV_FILTER_STATE
= g_quark_from_string("state");
614 LTTV_FILTER_TRACEFILE
= g_quark_from_string("tracefile");
616 /* event.name, tracefile.name, trace.name */
617 LTTV_FILTER_NAME
= g_quark_from_string("name");
619 /* event sub fields */
620 LTTV_FILTER_CATEGORY
= g_quark_from_string("category");
621 LTTV_FILTER_TIME
= g_quark_from_string("time");
622 LTTV_FILTER_TSC
= g_quark_from_string("tsc");
624 /* state sub fields */
625 LTTV_FILTER_PID
= g_quark_from_string("pid");
626 LTTV_FILTER_PPID
= g_quark_from_string("ppid");
627 LTTV_FILTER_C_TIME
= g_quark_from_string("creation_time");
628 LTTV_FILTER_I_TIME
= g_quark_from_string("insertion_time");
629 LTTV_FILTER_P_NAME
= g_quark_from_string("process_name");
630 LTTV_FILTER_EX_MODE
= g_quark_from_string("execution_mode");
631 LTTV_FILTER_EX_SUBMODE
= g_quark_from_string("execution_submode");
632 LTTV_FILTER_P_STATUS
= g_quark_from_string("process_status");
633 LTTV_FILTER_CPU
= g_quark_from_string("cpu");
638 * Destroys the filter module and specific values
640 static void module_destroy()
645 LTTV_MODULE("filter", "Filters traceset and events", \
646 "Filters traceset and events specifically to user input", \
647 module_init
, module_destroy
)
This page took 0.043579 seconds and 5 git commands to generate.