6cd62ccf |
1 | #include <stdio.h> |
2 | #include <asm/types.h> |
3 | #include <linux/byteorder/swab.h> |
6cd62ccf |
4 | #include "parser.h" |
5 | #include <ltt/event.h> |
6 | |
908f42fa |
7 | /***************************************************************************** |
8 | *Function name |
9 | * ltt_event_refresh_fields : refresh fields of an event |
10 | *Input params |
11 | * offsetRoot : offset from the root |
12 | * offsetParent : offset from the parrent |
13 | * fld : field |
14 | * evD : event data |
15 | *Return value |
16 | * int : size of the field |
17 | ****************************************************************************/ |
18 | |
19 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
20 | LttField * fld, void *evD) |
21 | { |
22 | int size, size1, element_number, i, offset1, offset2; |
23 | LttType * type = fld->field_type; |
24 | |
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 |
31 | size = 0; |
32 | for(i=0;i<element_number;i++){ |
33 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
34 | fld->child[0], evD+size); |
35 | } |
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 |
44 | size = 0; |
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); |
48 | } |
49 | size += size1; |
50 | } |
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){ |
56 | offset1 = offsetRoot; |
57 | offset2 = 0; |
58 | for(i=0;i<element_number;i++){ |
59 | size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2); |
60 | offset1 += size; |
61 | offset2 += size; |
62 | } |
63 | size = offset2; |
64 | }else size = fld->field_size; |
65 | } |
66 | |
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; |
72 | |
73 | return size; |
74 | } |
75 | |
6cd62ccf |
76 | /***************************************************************************** |
77 | *Function name |
963b5f2d |
78 | * ltt_event_eventtype_id: get event type id |
79 | * (base id + position of the event) |
6cd62ccf |
80 | *Input params |
963b5f2d |
81 | * e : an instance of an event type |
6cd62ccf |
82 | *Return value |
963b5f2d |
83 | * unsigned : event type id |
6cd62ccf |
84 | ****************************************************************************/ |
85 | |
963b5f2d |
86 | unsigned ltt_event_eventtype_id(LttEvent *e) |
6cd62ccf |
87 | { |
88 | return (unsigned) e->event_id; |
89 | } |
90 | |
91 | /***************************************************************************** |
92 | *Function name |
93 | * ltt_event_facility : get the facility of the event |
94 | *Input params |
95 | * e : an instance of an event type |
96 | *Return value |
963b5f2d |
97 | * LttFacility * : the facility of the event |
6cd62ccf |
98 | ****************************************************************************/ |
99 | |
963b5f2d |
100 | LttFacility *ltt_event_facility(LttEvent *e) |
6cd62ccf |
101 | { |
963b5f2d |
102 | LttTrace * trace = e->tracefile->trace; |
103 | unsigned id = e->event_id; |
104 | return ltt_trace_facility_by_id(trace,id); |
6cd62ccf |
105 | } |
106 | |
107 | /***************************************************************************** |
108 | *Function name |
109 | * ltt_event_eventtype : get the event type of the event |
110 | *Input params |
111 | * e : an instance of an event type |
112 | *Return value |
963b5f2d |
113 | * LttEventType * : the event type of the event |
6cd62ccf |
114 | ****************************************************************************/ |
115 | |
963b5f2d |
116 | LttEventType *ltt_event_eventtype(LttEvent *e) |
6cd62ccf |
117 | { |
963b5f2d |
118 | LttFacility* facility = ltt_event_facility(e); |
119 | if(!facility) return NULL; |
120 | return facility->events[e->event_id - facility->base_id]; |
6cd62ccf |
121 | } |
122 | |
123 | /***************************************************************************** |
124 | *Function name |
963b5f2d |
125 | * ltt_event_field : get the root field of the event |
6cd62ccf |
126 | *Input params |
963b5f2d |
127 | * e : an instance of an event type |
6cd62ccf |
128 | *Return value |
963b5f2d |
129 | * LttField * : the root field of the event |
6cd62ccf |
130 | ****************************************************************************/ |
131 | |
963b5f2d |
132 | LttField *ltt_event_field(LttEvent *e) |
6cd62ccf |
133 | { |
908f42fa |
134 | LttField * field; |
963b5f2d |
135 | LttEventType * event_type = ltt_event_eventtype(e); |
136 | if(!event_type) return NULL; |
908f42fa |
137 | field = event_type->root_field; |
a2331fa0 |
138 | if(!field) return NULL; |
908f42fa |
139 | |
140 | //check if the field need refresh |
141 | if(e->which_block != event_type->latest_block || |
142 | e->which_event != event_type->latest_event){ |
143 | |
144 | event_type->latest_block = e->which_block; |
145 | event_type->latest_event = e->which_event; |
146 | |
147 | if(field->field_fixed == 1)return field; |
148 | |
149 | //refresh the field |
150 | ltt_event_refresh_fields(0, 0, field, e->data); |
151 | } |
152 | return field; |
6cd62ccf |
153 | } |
154 | |
155 | /***************************************************************************** |
156 | *Function name |
963b5f2d |
157 | * ltt_event_time : get the time of the event |
6cd62ccf |
158 | *Input params |
159 | * e : an instance of an event type |
160 | *Return value |
963b5f2d |
161 | * LttTime : the time of the event |
6cd62ccf |
162 | ****************************************************************************/ |
163 | |
963b5f2d |
164 | LttTime ltt_event_time(LttEvent *e) |
6cd62ccf |
165 | { |
963b5f2d |
166 | return e->event_time; |
6cd62ccf |
167 | } |
168 | |
169 | /***************************************************************************** |
170 | *Function name |
963b5f2d |
171 | * ltt_event_time : get the cycle count of the event |
6cd62ccf |
172 | *Input params |
173 | * e : an instance of an event type |
174 | *Return value |
963b5f2d |
175 | * LttCycleCount : the cycle count of the event |
6cd62ccf |
176 | ****************************************************************************/ |
177 | |
963b5f2d |
178 | LttCycleCount ltt_event_cycle_count(LttEvent *e) |
6cd62ccf |
179 | { |
963b5f2d |
180 | return e->event_cycle_count; |
6cd62ccf |
181 | } |
182 | |
80da81ad |
183 | /***************************************************************************** |
184 | *Function name |
185 | * ltt_event_position : get the event's position |
186 | *Input params |
187 | * e : an instance of an event type |
188 | * ep : a pointer to event's position structure |
189 | ****************************************************************************/ |
190 | |
191 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
192 | { |
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; |
e4eced0f |
198 | ep->old_position = FALSE; |
80da81ad |
199 | ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ; |
e4eced0f |
200 | ep->tf = e->tracefile; |
80da81ad |
201 | } |
202 | |
203 | /***************************************************************************** |
204 | *Function name |
205 | * ltt_event_position_get : get the block number and index of the event |
206 | *Input params |
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 | ****************************************************************************/ |
211 | |
212 | void ltt_event_position_get(LttEventPosition *ep, |
e4eced0f |
213 | unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf) |
80da81ad |
214 | { |
215 | *block_number = ep->block_num; |
216 | *index_in_block = ep->event_num; |
e4eced0f |
217 | *tf = ep->tf; |
80da81ad |
218 | } |
219 | |
220 | /***************************************************************************** |
221 | *Function name |
222 | * ltt_event_position_set : set the block number and index of the event |
223 | *Input params |
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 | ****************************************************************************/ |
228 | |
229 | void ltt_event_position_set(LttEventPosition *ep, |
230 | unsigned block_number, unsigned index_in_block) |
231 | { |
232 | ep->block_num = block_number; |
e4eced0f |
233 | ep->event_num = index_in_block; |
80da81ad |
234 | } |
235 | |
6cd62ccf |
236 | /***************************************************************************** |
237 | *Function name |
963b5f2d |
238 | * ltt_event_cpu_i: get the cpu id where the event happens |
6cd62ccf |
239 | *Input params |
240 | * e : an instance of an event type |
241 | *Return value |
963b5f2d |
242 | * unsigned : the cpu id |
6cd62ccf |
243 | ****************************************************************************/ |
244 | |
963b5f2d |
245 | unsigned ltt_event_cpu_id(LttEvent *e) |
246 | { |
247 | return (unsigned)atoi(e->tracefile->name); |
6cd62ccf |
248 | } |
249 | |
250 | /***************************************************************************** |
251 | *Function name |
252 | * ltt_event_data : get the raw data for the event |
253 | *Input params |
254 | * e : an instance of an event type |
255 | *Return value |
256 | * void * : pointer to the raw data for the event |
257 | ****************************************************************************/ |
258 | |
963b5f2d |
259 | void *ltt_event_data(LttEvent *e) |
6cd62ccf |
260 | { |
261 | return e->data; |
262 | } |
263 | |
264 | /***************************************************************************** |
265 | *Function name |
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. |
270 | *Input params |
908f42fa |
271 | * e : an instance of an event type |
6cd62ccf |
272 | * f : a field of the instance |
273 | *Return value |
274 | * unsigned : the number of elements for an array/sequence field |
275 | ****************************************************************************/ |
276 | |
963b5f2d |
277 | unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) |
6cd62ccf |
278 | { |
279 | if(f->field_type->type_class != LTT_ARRAY && |
280 | f->field_type->type_class != LTT_SEQUENCE) |
281 | return 0; |
908f42fa |
282 | |
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); |
6cd62ccf |
286 | } |
287 | |
288 | /***************************************************************************** |
289 | *Function name |
290 | * ltt_event_field_element_select |
291 | * : Set the currently selected element for a sequence or |
292 | * array field |
293 | *Input params |
908f42fa |
294 | * e : an instance of an event type |
6cd62ccf |
295 | * f : a field of the instance |
296 | * i : the ith element |
6cd62ccf |
297 | ****************************************************************************/ |
298 | |
963b5f2d |
299 | void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) |
6cd62ccf |
300 | { |
908f42fa |
301 | unsigned element_number; |
302 | LttField *fld; |
303 | int k, size; |
304 | void *evD; |
305 | |
306 | if(f->field_type->type_class != LTT_ARRAY && |
6cd62ccf |
307 | f->field_type->type_class != LTT_SEQUENCE) |
908f42fa |
308 | return ; |
309 | |
310 | element_number = ltt_event_field_element_number(e,f); |
89d4760c |
311 | if((element_number-1) < i || i < 0) return; |
908f42fa |
312 | |
313 | fld = f->child[0]; |
314 | |
315 | evD = e->data + f->offset_root; |
316 | size = 0; |
317 | for(k=0;k<i;k++){ |
318 | size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size); |
319 | } |
6cd62ccf |
320 | |
908f42fa |
321 | f->current_element = i - 1; |
6cd62ccf |
322 | } |
323 | |
324 | /***************************************************************************** |
325 | * These functions extract data from an event after architecture specific |
326 | * conversions |
327 | ****************************************************************************/ |
328 | |
963b5f2d |
329 | unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
330 | { |
963b5f2d |
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; |
6cd62ccf |
334 | |
c687f6c8 |
335 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
336 | g_error("The type of the field is not unsigned int\n"); |
337 | |
b7b36242 |
338 | if(f->field_size == 1){ |
cbd41522 |
339 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
b7b36242 |
340 | return (unsigned int) x; |
341 | }else if(f->field_size == 2){ |
cbd41522 |
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); |
345 | else |
346 | return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x); |
b7b36242 |
347 | }else if(f->field_size == 4){ |
cbd41522 |
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); |
351 | else |
352 | return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x); |
b7b36242 |
353 | }else if(f->field_size == 8){ |
cbd41522 |
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); |
357 | else |
358 | return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x); |
6cd62ccf |
359 | } |
360 | } |
361 | |
963b5f2d |
362 | int ltt_event_get_int(LttEvent *e, LttField *f) |
6cd62ccf |
363 | { |
963b5f2d |
364 | int revFlag = e->tracefile->trace->my_arch_endian == |
365 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
366 | |
367 | if(f->field_type->type_class != LTT_INT) |
368 | g_error("The type of the field is not int\n"); |
369 | |
b7b36242 |
370 | if(f->field_size == 1){ |
cbd41522 |
371 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
b7b36242 |
372 | return (int) x; |
373 | }else if(f->field_size == 2){ |
cbd41522 |
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); |
377 | else |
378 | return (int) (revFlag ? GINT16_FROM_LE(x): x); |
b7b36242 |
379 | }else if(f->field_size == 4){ |
cbd41522 |
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); |
383 | else |
384 | return (int) (revFlag ? GINT32_FROM_LE(x): x); |
b7b36242 |
385 | }else if(f->field_size == 8){ |
cbd41522 |
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); |
389 | else |
390 | return (int) (revFlag ? GINT64_FROM_LE(x): x); |
6cd62ccf |
391 | } |
392 | } |
393 | |
963b5f2d |
394 | unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
395 | { |
963b5f2d |
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; |
6cd62ccf |
399 | |
c687f6c8 |
400 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
401 | g_error("The type of the field is not unsigned long\n"); |
402 | |
b7b36242 |
403 | if(f->field_size == 1){ |
cbd41522 |
404 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
b7b36242 |
405 | return (unsigned long) x; |
406 | }else if(f->field_size == 2){ |
cbd41522 |
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); |
410 | else |
411 | return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x); |
b7b36242 |
412 | }else if(f->field_size == 4){ |
cbd41522 |
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); |
416 | else |
417 | return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x); |
b7b36242 |
418 | }else if(f->field_size == 8){ |
cbd41522 |
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); |
422 | else |
423 | return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x); |
6cd62ccf |
424 | } |
425 | } |
426 | |
963b5f2d |
427 | long int ltt_event_get_long_int(LttEvent *e, LttField *f) |
6cd62ccf |
428 | { |
963b5f2d |
429 | int revFlag = e->tracefile->trace->my_arch_endian == |
430 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
431 | |
432 | if( f->field_type->type_class != LTT_INT) |
433 | g_error("The type of the field is not long int\n"); |
434 | |
b7b36242 |
435 | if(f->field_size == 1){ |
cbd41522 |
436 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
b7b36242 |
437 | return (long) x; |
438 | }else if(f->field_size == 2){ |
cbd41522 |
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); |
442 | else |
443 | return (long) (revFlag ? GINT16_FROM_LE(x): x); |
b7b36242 |
444 | }else if(f->field_size == 4){ |
cbd41522 |
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); |
448 | else |
449 | return (long) (revFlag ? GINT32_FROM_LE(x): x); |
b7b36242 |
450 | }else if(f->field_size == 8){ |
cbd41522 |
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); |
454 | else |
455 | return (long) (revFlag ? GINT64_FROM_LE(x): x); |
6cd62ccf |
456 | } |
457 | } |
458 | |
963b5f2d |
459 | float ltt_event_get_float(LttEvent *e, LttField *f) |
6cd62ccf |
460 | { |
963b5f2d |
461 | int revFlag = e->tracefile->trace->my_arch_endian == |
462 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
463 | |
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"); |
467 | |
468 | if(revFlag == 0) return *(float *)(e->data + f->offset_root); |
469 | else{ |
cbd41522 |
470 | guint32 aInt; |
6cd62ccf |
471 | memcpy((void*)&aInt, e->data + f->offset_root, 4); |
472 | aInt = ___swab32(aInt); |
473 | return *((float*)&aInt); |
474 | } |
475 | } |
476 | |
963b5f2d |
477 | double ltt_event_get_double(LttEvent *e, LttField *f) |
6cd62ccf |
478 | { |
963b5f2d |
479 | int revFlag = e->tracefile->trace->my_arch_endian == |
480 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
481 | |
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"); |
485 | |
486 | if(revFlag == 0) return *(double *)(e->data + f->offset_root); |
487 | else{ |
cbd41522 |
488 | guint64 aInt; |
6cd62ccf |
489 | memcpy((void*)&aInt, e->data + f->offset_root, 8); |
490 | aInt = ___swab64(aInt); |
491 | return *((double *)&aInt); |
492 | } |
493 | } |
494 | |
495 | /***************************************************************************** |
496 | * The string obtained is only valid until the next read from |
908f42fa |
497 | * the same tracefile. |
6cd62ccf |
498 | ****************************************************************************/ |
499 | |
963b5f2d |
500 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
6cd62ccf |
501 | { |
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)); |
505 | } |