3 #include <linux/byteorder/swab.h>
7 /*****************************************************************************
9 * ltt_event_refresh_fields : refresh fields of an event
11 * offsetRoot : offset from the root
12 * offsetParent : offset from the parrent
16 * int : size of the field
17 ****************************************************************************/
19 int ltt_event_refresh_fields(int offsetRoot
,int offsetParent
,
20 LttField
* fld
, void *evD
)
22 int size
, size1
, element_number
, i
, offset1
, offset2
;
23 LttType
* type
= fld
->field_type
;
25 if(type
->type_class
!= LTT_STRUCT
&& type
->type_class
!= LTT_ARRAY
&&
26 type
->type_class
!= LTT_SEQUENCE
&& type
->type_class
!= LTT_STRING
){
27 size
= fld
->field_size
;
28 }else if(type
->type_class
== LTT_ARRAY
){
29 element_number
= (int) type
->element_number
;
30 if(fld
->field_fixed
== 0){// has string or sequence
32 for(i
=0;i
<element_number
;i
++){
33 size
+= ltt_event_refresh_fields(offsetRoot
+size
,size
,
34 fld
->child
[0], evD
+size
);
36 }else size
= fld
->field_size
;
37 }else if(type
->type_class
== LTT_SEQUENCE
){
38 size1
= fld
->sequ_number_size
;
39 element_number
= getIntNumber(size1
,evD
);
40 type
->element_number
= element_number
;
41 if(fld
->element_size
> 0){
42 size
= element_number
* fld
->element_size
;
43 }else{//sequence has string or sequence
45 for(i
=0;i
<element_number
;i
++){
46 size
+= ltt_event_refresh_fields(offsetRoot
+size
+size1
,size
+size1
,
47 fld
->child
[0], evD
+size
+size1
);
51 }else if(type
->type_class
== LTT_STRING
){
52 size
= strlen((char*)evD
) + 1; //include end : '\0'
53 }else if(type
->type_class
== LTT_STRUCT
){
54 element_number
= (int) type
->element_number
;
55 if(fld
->field_fixed
== 0){
58 for(i
=0;i
<element_number
;i
++){
59 size
=ltt_event_refresh_fields(offset1
,offset2
,fld
->child
[i
],evD
+offset2
);
64 }else size
= fld
->field_size
;
67 fld
->offset_root
= offsetRoot
;
68 fld
->offset_parent
= offsetParent
;
69 fld
->fixed_root
= (offsetRoot
==-1) ? 0 : 1;
70 fld
->fixed_parent
= (offsetParent
==-1) ? 0 : 1;
71 fld
->field_size
= size
;
76 /*****************************************************************************
78 * ltt_event_eventtype_id: get event type id
79 * (base id + position of the event)
81 * e : an instance of an event type
83 * unsigned : event type id
84 ****************************************************************************/
86 unsigned ltt_event_eventtype_id(LttEvent
*e
)
88 return (unsigned) e
->event_id
;
91 /*****************************************************************************
93 * ltt_event_facility : get the facility of the event
95 * e : an instance of an event type
97 * LttFacility * : the facility of the event
98 ****************************************************************************/
100 LttFacility
*ltt_event_facility(LttEvent
*e
)
102 LttTrace
* trace
= e
->tracefile
->trace
;
103 unsigned id
= e
->event_id
;
104 return ltt_trace_facility_by_id(trace
,id
);
107 /*****************************************************************************
109 * ltt_event_eventtype : get the event type of the event
111 * e : an instance of an event type
113 * LttEventType * : the event type of the event
114 ****************************************************************************/
116 LttEventType
*ltt_event_eventtype(LttEvent
*e
)
118 LttFacility
* facility
= ltt_event_facility(e
);
119 if(!facility
) return NULL
;
120 return facility
->events
[e
->event_id
- facility
->base_id
];
123 /*****************************************************************************
125 * ltt_event_field : get the root field of the event
127 * e : an instance of an event type
129 * LttField * : the root field of the event
130 ****************************************************************************/
132 LttField
*ltt_event_field(LttEvent
*e
)
135 LttEventType
* event_type
= ltt_event_eventtype(e
);
136 if(!event_type
) return NULL
;
137 field
= event_type
->root_field
;
138 if(!field
) return NULL
;
140 //check if the field need refresh
141 if(e
->which_block
!= event_type
->latest_block
||
142 e
->which_event
!= event_type
->latest_event
){
144 event_type
->latest_block
= e
->which_block
;
145 event_type
->latest_event
= e
->which_event
;
147 if(field
->field_fixed
== 1)return field
;
150 ltt_event_refresh_fields(0, 0, field
, e
->data
);
155 /*****************************************************************************
157 * ltt_event_time : get the time of the event
159 * e : an instance of an event type
161 * LttTime : the time of the event
162 ****************************************************************************/
164 LttTime
ltt_event_time(LttEvent
*e
)
166 return e
->event_time
;
169 /*****************************************************************************
171 * ltt_event_time : get the cycle count of the event
173 * e : an instance of an event type
175 * LttCycleCount : the cycle count of the event
176 ****************************************************************************/
178 LttCycleCount
ltt_event_cycle_count(LttEvent
*e
)
180 return e
->event_cycle_count
;
183 /*****************************************************************************
185 * ltt_event_position : get the event's position
187 * e : an instance of an event type
188 * ep : a pointer to event's position structure
189 ****************************************************************************/
191 void ltt_event_position(LttEvent
*e
, LttEventPosition
*ep
)
193 ep
->block_num
= e
->which_block
;
194 ep
->event_num
= e
->which_event
;
195 ep
->event_time
= e
->event_time
;
196 ep
->event_cycle_count
= e
->event_cycle_count
;
197 ep
->heart_beat_number
= e
->tracefile
->cur_heart_beat_number
;
198 ep
->old_position
= FALSE
;
199 ep
->event_offset
= e
->data
- e
->tracefile
->buffer
- EVENT_HEADER_SIZE
;
200 ep
->tf
= e
->tracefile
;
203 /*****************************************************************************
205 * ltt_event_position_get : get the block number and index of the event
207 * ep : a pointer to event's position structure
208 * block_number : the block number of the event
209 * index_in_block : the index of the event within the block
210 ****************************************************************************/
212 void ltt_event_position_get(LttEventPosition
*ep
,
213 unsigned *block_number
, unsigned *index_in_block
, LttTracefile
** tf
)
215 *block_number
= ep
->block_num
;
216 *index_in_block
= ep
->event_num
;
220 /*****************************************************************************
222 * ltt_event_position_set : set the block number and index of the event
224 * ep : a pointer to event's position structure
225 * block_number : the block number of the event
226 * index_in_block : the index of the event within the block
227 ****************************************************************************/
229 void ltt_event_position_set(LttEventPosition
*ep
,
230 unsigned block_number
, unsigned index_in_block
)
232 ep
->block_num
= block_number
;
233 ep
->event_num
= index_in_block
;
236 /*****************************************************************************
238 * ltt_event_cpu_i: get the cpu id where the event happens
240 * e : an instance of an event type
242 * unsigned : the cpu id
243 ****************************************************************************/
245 unsigned ltt_event_cpu_id(LttEvent
*e
)
247 return (unsigned)atoi(e
->tracefile
->name
);
250 /*****************************************************************************
252 * ltt_event_data : get the raw data for the event
254 * e : an instance of an event type
256 * void * : pointer to the raw data for the event
257 ****************************************************************************/
259 void *ltt_event_data(LttEvent
*e
)
264 /*****************************************************************************
266 * ltt_event_field_element_number
267 * : The number of elements in a sequence field is specific
268 * to each event. This function returns the number of
269 * elements for an array or sequence field in an event.
271 * e : an instance of an event type
272 * f : a field of the instance
274 * unsigned : the number of elements for an array/sequence field
275 ****************************************************************************/
277 unsigned ltt_event_field_element_number(LttEvent
*e
, LttField
*f
)
279 if(f
->field_type
->type_class
!= LTT_ARRAY
&&
280 f
->field_type
->type_class
!= LTT_SEQUENCE
)
283 if(f
->field_type
->type_class
== LTT_ARRAY
)
284 return f
->field_type
->element_number
;
285 return (unsigned) getIntNumber(f
->sequ_number_size
, e
+ f
->offset_root
);
288 /*****************************************************************************
290 * ltt_event_field_element_select
291 * : Set the currently selected element for a sequence or
294 * e : an instance of an event type
295 * f : a field of the instance
296 * i : the ith element
297 ****************************************************************************/
299 void ltt_event_field_element_select(LttEvent
*e
, LttField
*f
, unsigned i
)
301 unsigned element_number
;
306 if(f
->field_type
->type_class
!= LTT_ARRAY
&&
307 f
->field_type
->type_class
!= LTT_SEQUENCE
)
310 element_number
= ltt_event_field_element_number(e
,f
);
311 if((element_number
-1) < i
|| i
< 0) return;
315 evD
= e
->data
+ f
->offset_root
;
318 size
+= ltt_event_refresh_fields(f
->offset_root
+size
,size
, fld
, evD
+size
);
321 f
->current_element
= i
- 1;
324 /*****************************************************************************
325 * These functions extract data from an event after architecture specific
327 ****************************************************************************/
329 unsigned ltt_event_get_unsigned(LttEvent
*e
, LttField
*f
)
331 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
332 e
->tracefile
->trace
->system_description
->endian
? 0:1;
333 LttTypeEnum t
= f
->field_type
->type_class
;
335 if(t
!= LTT_UINT
&& t
!= LTT_ENUM
)
336 g_error("The type of the field is not unsigned int\n");
338 if(f
->field_size
== 1){
339 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
340 return (unsigned int) x
;
341 }else if(f
->field_size
== 2){
342 guint16 x
= *(guint16
*)(e
->data
+ f
->offset_root
);
343 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
344 return (unsigned int) (revFlag
? GUINT16_FROM_BE(x
): x
);
346 return (unsigned int) (revFlag
? GUINT16_FROM_LE(x
): x
);
347 }else if(f
->field_size
== 4){
348 guint32 x
= *(guint32
*)(e
->data
+ f
->offset_root
);
349 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
350 return (unsigned int) (revFlag
? GUINT32_FROM_BE(x
): x
);
352 return (unsigned int) (revFlag
? GUINT32_FROM_LE(x
): x
);
353 }else if(f
->field_size
== 8){
354 guint64 x
= *(guint64
*)(e
->data
+ f
->offset_root
);
355 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
356 return (unsigned int) (revFlag
? GUINT64_FROM_BE(x
): x
);
358 return (unsigned int) (revFlag
? GUINT64_FROM_LE(x
): x
);
362 int ltt_event_get_int(LttEvent
*e
, LttField
*f
)
364 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
365 e
->tracefile
->trace
->system_description
->endian
? 0:1;
367 if(f
->field_type
->type_class
!= LTT_INT
)
368 g_error("The type of the field is not int\n");
370 if(f
->field_size
== 1){
371 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
373 }else if(f
->field_size
== 2){
374 gint16 x
= *(gint16
*)(e
->data
+ f
->offset_root
);
375 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
376 return (int) (revFlag
? GINT16_FROM_BE(x
): x
);
378 return (int) (revFlag
? GINT16_FROM_LE(x
): x
);
379 }else if(f
->field_size
== 4){
380 gint32 x
= *(gint32
*)(e
->data
+ f
->offset_root
);
381 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
382 return (int) (revFlag
? GINT32_FROM_BE(x
): x
);
384 return (int) (revFlag
? GINT32_FROM_LE(x
): x
);
385 }else if(f
->field_size
== 8){
386 gint64 x
= *(gint64
*)(e
->data
+ f
->offset_root
);
387 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
388 return (int) (revFlag
? GINT64_FROM_BE(x
): x
);
390 return (int) (revFlag
? GINT64_FROM_LE(x
): x
);
394 unsigned long ltt_event_get_long_unsigned(LttEvent
*e
, LttField
*f
)
396 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
397 e
->tracefile
->trace
->system_description
->endian
? 0:1;
398 LttTypeEnum t
= f
->field_type
->type_class
;
400 if(t
!= LTT_UINT
&& t
!= LTT_ENUM
)
401 g_error("The type of the field is not unsigned long\n");
403 if(f
->field_size
== 1){
404 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
405 return (unsigned long) x
;
406 }else if(f
->field_size
== 2){
407 guint16 x
= *(guint16
*)(e
->data
+ f
->offset_root
);
408 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
409 return (unsigned long) (revFlag
? GUINT16_FROM_BE(x
): x
);
411 return (unsigned long) (revFlag
? GUINT16_FROM_LE(x
): x
);
412 }else if(f
->field_size
== 4){
413 guint32 x
= *(guint32
*)(e
->data
+ f
->offset_root
);
414 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
415 return (unsigned long) (revFlag
? GUINT32_FROM_BE(x
): x
);
417 return (unsigned long) (revFlag
? GUINT32_FROM_LE(x
): x
);
418 }else if(f
->field_size
== 8){
419 guint64 x
= *(guint64
*)(e
->data
+ f
->offset_root
);
420 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
421 return (unsigned long) (revFlag
? GUINT64_FROM_BE(x
): x
);
423 return (unsigned long) (revFlag
? GUINT64_FROM_LE(x
): x
);
427 long int ltt_event_get_long_int(LttEvent
*e
, LttField
*f
)
429 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
430 e
->tracefile
->trace
->system_description
->endian
? 0:1;
432 if( f
->field_type
->type_class
!= LTT_INT
)
433 g_error("The type of the field is not long int\n");
435 if(f
->field_size
== 1){
436 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
438 }else if(f
->field_size
== 2){
439 gint16 x
= *(gint16
*)(e
->data
+ f
->offset_root
);
440 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
441 return (long) (revFlag
? GINT16_FROM_BE(x
): x
);
443 return (long) (revFlag
? GINT16_FROM_LE(x
): x
);
444 }else if(f
->field_size
== 4){
445 gint32 x
= *(gint32
*)(e
->data
+ f
->offset_root
);
446 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
447 return (long) (revFlag
? GINT32_FROM_BE(x
): x
);
449 return (long) (revFlag
? GINT32_FROM_LE(x
): x
);
450 }else if(f
->field_size
== 8){
451 gint64 x
= *(gint64
*)(e
->data
+ f
->offset_root
);
452 if(e
->tracefile
->trace
->my_arch_endian
== LTT_LITTLE_ENDIAN
)
453 return (long) (revFlag
? GINT64_FROM_BE(x
): x
);
455 return (long) (revFlag
? GINT64_FROM_LE(x
): x
);
459 float ltt_event_get_float(LttEvent
*e
, LttField
*f
)
461 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
462 e
->tracefile
->trace
->system_description
->endian
? 0:1;
464 if(f
->field_type
->type_class
!= LTT_FLOAT
||
465 (f
->field_type
->type_class
== LTT_FLOAT
&& f
->field_size
!= 4))
466 g_error("The type of the field is not float\n");
468 if(revFlag
== 0) return *(float *)(e
->data
+ f
->offset_root
);
471 memcpy((void*)&aInt
, e
->data
+ f
->offset_root
, 4);
472 aInt
= ___swab32(aInt
);
473 return *((float*)&aInt
);
477 double ltt_event_get_double(LttEvent
*e
, LttField
*f
)
479 int revFlag
= e
->tracefile
->trace
->my_arch_endian
==
480 e
->tracefile
->trace
->system_description
->endian
? 0:1;
482 if(f
->field_type
->type_class
!= LTT_FLOAT
||
483 (f
->field_type
->type_class
== LTT_FLOAT
&& f
->field_size
!= 8))
484 g_error("The type of the field is not double\n");
486 if(revFlag
== 0) return *(double *)(e
->data
+ f
->offset_root
);
489 memcpy((void*)&aInt
, e
->data
+ f
->offset_root
, 8);
490 aInt
= ___swab64(aInt
);
491 return *((double *)&aInt
);
495 /*****************************************************************************
496 * The string obtained is only valid until the next read from
497 * the same tracefile.
498 ****************************************************************************/
500 char *ltt_event_get_string(LttEvent
*e
, LttField
*f
)
502 if(f
->field_type
->type_class
!= LTT_STRING
)
503 g_error("The field contains no string\n");
504 return (char*)g_strdup((char*)(e
->data
+ f
->offset_root
));
This page took 0.044215 seconds and 4 git commands to generate.