6cd62ccf |
1 | #include <stdio.h> |
2 | #include <asm/types.h> |
3 | #include <linux/byteorder/swab.h> |
fcdf0ec2 |
4 | #include <ltt/LTTTypes.h> |
6cd62ccf |
5 | #include "parser.h" |
6 | #include <ltt/event.h> |
7 | |
908f42fa |
8 | /***************************************************************************** |
9 | *Function name |
10 | * ltt_event_refresh_fields : refresh fields of an event |
11 | *Input params |
12 | * offsetRoot : offset from the root |
13 | * offsetParent : offset from the parrent |
14 | * fld : field |
15 | * evD : event data |
16 | *Return value |
17 | * int : size of the field |
18 | ****************************************************************************/ |
19 | |
20 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
21 | LttField * fld, void *evD) |
22 | { |
23 | int size, size1, element_number, i, offset1, offset2; |
24 | LttType * type = fld->field_type; |
25 | |
26 | if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY && |
27 | type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){ |
28 | size = fld->field_size; |
29 | }else if(type->type_class == LTT_ARRAY){ |
30 | element_number = (int) type->element_number; |
31 | if(fld->field_fixed == 0){// has string or sequence |
32 | size = 0; |
33 | for(i=0;i<element_number;i++){ |
34 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
35 | fld->child[0], evD+size); |
36 | } |
37 | }else size = fld->field_size; |
38 | }else if(type->type_class == LTT_SEQUENCE){ |
39 | size1 = fld->sequ_number_size; |
40 | element_number = getIntNumber(size1,evD); |
41 | type->element_number = element_number; |
42 | if(fld->element_size > 0){ |
43 | size = element_number * fld->element_size; |
44 | }else{//sequence has string or sequence |
45 | size = 0; |
46 | for(i=0;i<element_number;i++){ |
47 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
48 | fld->child[0], evD+size+size1); |
49 | } |
50 | size += size1; |
51 | } |
52 | }else if(type->type_class == LTT_STRING){ |
53 | size = strlen((char*)evD) + 1; //include end : '\0' |
54 | }else if(type->type_class == LTT_STRUCT){ |
55 | element_number = (int) type->element_number; |
56 | if(fld->field_fixed == 0){ |
57 | offset1 = offsetRoot; |
58 | offset2 = 0; |
59 | for(i=0;i<element_number;i++){ |
60 | size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2); |
61 | offset1 += size; |
62 | offset2 += size; |
63 | } |
64 | size = offset2; |
65 | }else size = fld->field_size; |
66 | } |
67 | |
68 | fld->offset_root = offsetRoot; |
69 | fld->offset_parent = offsetParent; |
70 | fld->fixed_root = (offsetRoot==-1) ? 0 : 1; |
71 | fld->fixed_parent = (offsetParent==-1) ? 0 : 1; |
72 | fld->field_size = size; |
73 | |
74 | return size; |
75 | } |
76 | |
6cd62ccf |
77 | /***************************************************************************** |
78 | *Function name |
963b5f2d |
79 | * ltt_event_eventtype_id: get event type id |
80 | * (base id + position of the event) |
6cd62ccf |
81 | *Input params |
963b5f2d |
82 | * e : an instance of an event type |
6cd62ccf |
83 | *Return value |
963b5f2d |
84 | * unsigned : event type id |
6cd62ccf |
85 | ****************************************************************************/ |
86 | |
963b5f2d |
87 | unsigned ltt_event_eventtype_id(LttEvent *e) |
6cd62ccf |
88 | { |
89 | return (unsigned) e->event_id; |
90 | } |
91 | |
92 | /***************************************************************************** |
93 | *Function name |
94 | * ltt_event_facility : get the facility of the event |
95 | *Input params |
96 | * e : an instance of an event type |
97 | *Return value |
963b5f2d |
98 | * LttFacility * : the facility of the event |
6cd62ccf |
99 | ****************************************************************************/ |
100 | |
963b5f2d |
101 | LttFacility *ltt_event_facility(LttEvent *e) |
6cd62ccf |
102 | { |
963b5f2d |
103 | LttTrace * trace = e->tracefile->trace; |
104 | unsigned id = e->event_id; |
105 | return ltt_trace_facility_by_id(trace,id); |
6cd62ccf |
106 | } |
107 | |
108 | /***************************************************************************** |
109 | *Function name |
110 | * ltt_event_eventtype : get the event type of the event |
111 | *Input params |
112 | * e : an instance of an event type |
113 | *Return value |
963b5f2d |
114 | * LttEventType * : the event type of the event |
6cd62ccf |
115 | ****************************************************************************/ |
116 | |
963b5f2d |
117 | LttEventType *ltt_event_eventtype(LttEvent *e) |
6cd62ccf |
118 | { |
963b5f2d |
119 | LttFacility* facility = ltt_event_facility(e); |
120 | if(!facility) return NULL; |
121 | return facility->events[e->event_id - facility->base_id]; |
6cd62ccf |
122 | } |
123 | |
124 | /***************************************************************************** |
125 | *Function name |
963b5f2d |
126 | * ltt_event_field : get the root field of the event |
6cd62ccf |
127 | *Input params |
963b5f2d |
128 | * e : an instance of an event type |
6cd62ccf |
129 | *Return value |
963b5f2d |
130 | * LttField * : the root field of the event |
6cd62ccf |
131 | ****************************************************************************/ |
132 | |
963b5f2d |
133 | LttField *ltt_event_field(LttEvent *e) |
6cd62ccf |
134 | { |
908f42fa |
135 | LttField * field; |
963b5f2d |
136 | LttEventType * event_type = ltt_event_eventtype(e); |
137 | if(!event_type) return NULL; |
908f42fa |
138 | field = event_type->root_field; |
a2331fa0 |
139 | if(!field) return NULL; |
908f42fa |
140 | |
141 | //check if the field need refresh |
142 | if(e->which_block != event_type->latest_block || |
143 | e->which_event != event_type->latest_event){ |
144 | |
145 | event_type->latest_block = e->which_block; |
146 | event_type->latest_event = e->which_event; |
147 | |
148 | if(field->field_fixed == 1)return field; |
149 | |
150 | //refresh the field |
151 | ltt_event_refresh_fields(0, 0, field, e->data); |
152 | } |
153 | return field; |
6cd62ccf |
154 | } |
155 | |
156 | /***************************************************************************** |
157 | *Function name |
963b5f2d |
158 | * ltt_event_time : get the time of the event |
6cd62ccf |
159 | *Input params |
160 | * e : an instance of an event type |
161 | *Return value |
963b5f2d |
162 | * LttTime : the time of the event |
6cd62ccf |
163 | ****************************************************************************/ |
164 | |
963b5f2d |
165 | LttTime ltt_event_time(LttEvent *e) |
6cd62ccf |
166 | { |
963b5f2d |
167 | return e->event_time; |
6cd62ccf |
168 | } |
169 | |
170 | /***************************************************************************** |
171 | *Function name |
963b5f2d |
172 | * ltt_event_time : get the cycle count of the event |
6cd62ccf |
173 | *Input params |
174 | * e : an instance of an event type |
175 | *Return value |
963b5f2d |
176 | * LttCycleCount : the cycle count of the event |
6cd62ccf |
177 | ****************************************************************************/ |
178 | |
963b5f2d |
179 | LttCycleCount ltt_event_cycle_count(LttEvent *e) |
6cd62ccf |
180 | { |
963b5f2d |
181 | return e->event_cycle_count; |
6cd62ccf |
182 | } |
183 | |
80da81ad |
184 | /***************************************************************************** |
185 | *Function name |
186 | * ltt_event_position : get the event's position |
187 | *Input params |
188 | * e : an instance of an event type |
189 | * ep : a pointer to event's position structure |
190 | ****************************************************************************/ |
191 | |
192 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
193 | { |
194 | ep->block_num = e->which_block; |
195 | ep->event_num = e->which_event; |
196 | ep->event_time = e->event_time; |
197 | ep->event_cycle_count = e->event_cycle_count; |
198 | ep->heart_beat_number = e->tracefile->cur_heart_beat_number; |
e4eced0f |
199 | ep->old_position = FALSE; |
80da81ad |
200 | ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ; |
e4eced0f |
201 | ep->tf = e->tracefile; |
80da81ad |
202 | } |
203 | |
204 | /***************************************************************************** |
205 | *Function name |
206 | * ltt_event_position_get : get the block number and index of the event |
207 | *Input params |
208 | * ep : a pointer to event's position structure |
209 | * block_number : the block number of the event |
210 | * index_in_block : the index of the event within the block |
211 | ****************************************************************************/ |
212 | |
213 | void ltt_event_position_get(LttEventPosition *ep, |
e4eced0f |
214 | unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf) |
80da81ad |
215 | { |
216 | *block_number = ep->block_num; |
217 | *index_in_block = ep->event_num; |
e4eced0f |
218 | *tf = ep->tf; |
80da81ad |
219 | } |
220 | |
221 | /***************************************************************************** |
222 | *Function name |
223 | * ltt_event_position_set : set the block number and index of the event |
224 | *Input params |
225 | * ep : a pointer to event's position structure |
226 | * block_number : the block number of the event |
227 | * index_in_block : the index of the event within the block |
228 | ****************************************************************************/ |
229 | |
230 | void ltt_event_position_set(LttEventPosition *ep, |
231 | unsigned block_number, unsigned index_in_block) |
232 | { |
233 | ep->block_num = block_number; |
e4eced0f |
234 | ep->event_num = index_in_block; |
80da81ad |
235 | } |
236 | |
6cd62ccf |
237 | /***************************************************************************** |
238 | *Function name |
963b5f2d |
239 | * ltt_event_cpu_i: get the cpu id where the event happens |
6cd62ccf |
240 | *Input params |
241 | * e : an instance of an event type |
242 | *Return value |
963b5f2d |
243 | * unsigned : the cpu id |
6cd62ccf |
244 | ****************************************************************************/ |
245 | |
963b5f2d |
246 | unsigned ltt_event_cpu_id(LttEvent *e) |
247 | { |
248 | return (unsigned)atoi(e->tracefile->name); |
6cd62ccf |
249 | } |
250 | |
251 | /***************************************************************************** |
252 | *Function name |
253 | * ltt_event_data : get the raw data for the event |
254 | *Input params |
255 | * e : an instance of an event type |
256 | *Return value |
257 | * void * : pointer to the raw data for the event |
258 | ****************************************************************************/ |
259 | |
963b5f2d |
260 | void *ltt_event_data(LttEvent *e) |
6cd62ccf |
261 | { |
262 | return e->data; |
263 | } |
264 | |
265 | /***************************************************************************** |
266 | *Function name |
267 | * ltt_event_field_element_number |
268 | * : The number of elements in a sequence field is specific |
269 | * to each event. This function returns the number of |
270 | * elements for an array or sequence field in an event. |
271 | *Input params |
908f42fa |
272 | * e : an instance of an event type |
6cd62ccf |
273 | * f : a field of the instance |
274 | *Return value |
275 | * unsigned : the number of elements for an array/sequence field |
276 | ****************************************************************************/ |
277 | |
963b5f2d |
278 | unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) |
6cd62ccf |
279 | { |
280 | if(f->field_type->type_class != LTT_ARRAY && |
281 | f->field_type->type_class != LTT_SEQUENCE) |
282 | return 0; |
908f42fa |
283 | |
284 | if(f->field_type->type_class == LTT_ARRAY) |
285 | return f->field_type->element_number; |
286 | return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root); |
6cd62ccf |
287 | } |
288 | |
289 | /***************************************************************************** |
290 | *Function name |
291 | * ltt_event_field_element_select |
292 | * : Set the currently selected element for a sequence or |
293 | * array field |
294 | *Input params |
908f42fa |
295 | * e : an instance of an event type |
6cd62ccf |
296 | * f : a field of the instance |
297 | * i : the ith element |
6cd62ccf |
298 | ****************************************************************************/ |
299 | |
963b5f2d |
300 | void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) |
6cd62ccf |
301 | { |
908f42fa |
302 | unsigned element_number; |
303 | LttField *fld; |
304 | int k, size; |
305 | void *evD; |
306 | |
307 | if(f->field_type->type_class != LTT_ARRAY && |
6cd62ccf |
308 | f->field_type->type_class != LTT_SEQUENCE) |
908f42fa |
309 | return ; |
310 | |
311 | element_number = ltt_event_field_element_number(e,f); |
89d4760c |
312 | if((element_number-1) < i || i < 0) return; |
908f42fa |
313 | |
314 | fld = f->child[0]; |
315 | |
316 | evD = e->data + f->offset_root; |
317 | size = 0; |
318 | for(k=0;k<i;k++){ |
319 | size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size); |
320 | } |
6cd62ccf |
321 | |
908f42fa |
322 | f->current_element = i - 1; |
6cd62ccf |
323 | } |
324 | |
325 | /***************************************************************************** |
326 | * These functions extract data from an event after architecture specific |
327 | * conversions |
328 | ****************************************************************************/ |
329 | |
963b5f2d |
330 | unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
331 | { |
963b5f2d |
332 | int revFlag = e->tracefile->trace->my_arch_endian == |
333 | e->tracefile->trace->system_description->endian ? 0:1; |
334 | LttTypeEnum t = f->field_type->type_class; |
6cd62ccf |
335 | |
c687f6c8 |
336 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
337 | g_error("The type of the field is not unsigned int\n"); |
338 | |
b7b36242 |
339 | if(f->field_size == 1){ |
340 | uint8_t x = *(uint8_t*)(e->data + f->offset_root); |
341 | return (unsigned int) x; |
342 | }else if(f->field_size == 2){ |
343 | uint16_t x = *(uint16_t*)(e->data + f->offset_root); |
344 | return (unsigned int) (revFlag ? BREV16(x): x); |
345 | }else if(f->field_size == 4){ |
346 | uint32_t x = *(uint32_t*)(e->data + f->offset_root); |
347 | return (unsigned int) (revFlag ? BREV32(x): x); |
348 | }else if(f->field_size == 8){ |
349 | uint64_t x = *(uint64_t*)(e->data + f->offset_root); |
350 | return (unsigned int) (revFlag ? BREV64(x): x); |
6cd62ccf |
351 | } |
352 | } |
353 | |
963b5f2d |
354 | int ltt_event_get_int(LttEvent *e, LttField *f) |
6cd62ccf |
355 | { |
963b5f2d |
356 | int revFlag = e->tracefile->trace->my_arch_endian == |
357 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
358 | |
359 | if(f->field_type->type_class != LTT_INT) |
360 | g_error("The type of the field is not int\n"); |
361 | |
b7b36242 |
362 | if(f->field_size == 1){ |
363 | int8_t x = *(int8_t*)(e->data + f->offset_root); |
364 | return (int) x; |
365 | }else if(f->field_size == 2){ |
366 | int16_t x = *(int16_t*)(e->data + f->offset_root); |
367 | return (int) (revFlag ? BREV16(x): x); |
368 | }else if(f->field_size == 4){ |
369 | int32_t x = *(int32_t*)(e->data + f->offset_root); |
370 | return (int) (revFlag ? BREV32(x): x); |
371 | }else if(f->field_size == 8){ |
372 | int64_t x = *(int64_t*)(e->data + f->offset_root); |
373 | return (int) (revFlag ? BREV64(x): x); |
6cd62ccf |
374 | } |
375 | } |
376 | |
963b5f2d |
377 | unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
378 | { |
963b5f2d |
379 | int revFlag = e->tracefile->trace->my_arch_endian == |
380 | e->tracefile->trace->system_description->endian ? 0:1; |
381 | LttTypeEnum t = f->field_type->type_class; |
6cd62ccf |
382 | |
c687f6c8 |
383 | if(t != LTT_UINT && t != LTT_ENUM) |
6cd62ccf |
384 | g_error("The type of the field is not unsigned long\n"); |
385 | |
b7b36242 |
386 | if(f->field_size == 1){ |
387 | uint8_t x = *(uint8_t*)(e->data + f->offset_root); |
388 | return (unsigned long) x; |
389 | }else if(f->field_size == 2){ |
390 | uint16_t x = *(uint16_t*)(e->data + f->offset_root); |
391 | return (unsigned long) (revFlag ? BREV16(x): x); |
392 | }else if(f->field_size == 4){ |
393 | uint32_t x = *(uint32_t*)(e->data + f->offset_root); |
394 | return (unsigned long) (revFlag ? BREV32(x): x); |
395 | }else if(f->field_size == 8){ |
396 | uint64_t x = *(uint64_t*)(e->data + f->offset_root); |
397 | return (unsigned long) (revFlag ? BREV64(x): x); |
6cd62ccf |
398 | } |
399 | } |
400 | |
963b5f2d |
401 | long int ltt_event_get_long_int(LttEvent *e, LttField *f) |
6cd62ccf |
402 | { |
963b5f2d |
403 | int revFlag = e->tracefile->trace->my_arch_endian == |
404 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
405 | |
406 | if( f->field_type->type_class != LTT_INT) |
407 | g_error("The type of the field is not long int\n"); |
408 | |
b7b36242 |
409 | if(f->field_size == 1){ |
410 | int8_t x = *(int8_t*)(e->data + f->offset_root); |
411 | return (long) x; |
412 | }else if(f->field_size == 2){ |
413 | int16_t x = *(int16_t*)(e->data + f->offset_root); |
414 | return (long) (revFlag ? BREV16(x): x); |
415 | }else if(f->field_size == 4){ |
416 | int32_t x = *(int32_t*)(e->data + f->offset_root); |
417 | return (long) (revFlag ? BREV32(x): x); |
418 | }else if(f->field_size == 8){ |
419 | int64_t x = *(int64_t*)(e->data + f->offset_root); |
420 | return (long) (revFlag ? BREV64(x): x); |
6cd62ccf |
421 | } |
422 | } |
423 | |
963b5f2d |
424 | float ltt_event_get_float(LttEvent *e, LttField *f) |
6cd62ccf |
425 | { |
963b5f2d |
426 | int revFlag = e->tracefile->trace->my_arch_endian == |
427 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
428 | |
429 | if(f->field_type->type_class != LTT_FLOAT || |
430 | (f->field_type->type_class == LTT_FLOAT && f->field_size != 4)) |
431 | g_error("The type of the field is not float\n"); |
432 | |
433 | if(revFlag == 0) return *(float *)(e->data + f->offset_root); |
434 | else{ |
435 | uint32_t aInt; |
436 | memcpy((void*)&aInt, e->data + f->offset_root, 4); |
437 | aInt = ___swab32(aInt); |
438 | return *((float*)&aInt); |
439 | } |
440 | } |
441 | |
963b5f2d |
442 | double ltt_event_get_double(LttEvent *e, LttField *f) |
6cd62ccf |
443 | { |
963b5f2d |
444 | int revFlag = e->tracefile->trace->my_arch_endian == |
445 | e->tracefile->trace->system_description->endian ? 0:1; |
6cd62ccf |
446 | |
447 | if(f->field_type->type_class != LTT_FLOAT || |
448 | (f->field_type->type_class == LTT_FLOAT && f->field_size != 8)) |
449 | g_error("The type of the field is not double\n"); |
450 | |
451 | if(revFlag == 0) return *(double *)(e->data + f->offset_root); |
452 | else{ |
453 | uint64_t aInt; |
454 | memcpy((void*)&aInt, e->data + f->offset_root, 8); |
455 | aInt = ___swab64(aInt); |
456 | return *((double *)&aInt); |
457 | } |
458 | } |
459 | |
460 | /***************************************************************************** |
461 | * The string obtained is only valid until the next read from |
908f42fa |
462 | * the same tracefile. |
6cd62ccf |
463 | ****************************************************************************/ |
464 | |
963b5f2d |
465 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
6cd62ccf |
466 | { |
467 | if(f->field_type->type_class != LTT_STRING) |
468 | g_error("The field contains no string\n"); |
469 | return (char*)g_strdup((char*)(e->data + f->offset_root)); |
470 | } |