54ecbf38 |
1 | /* This file is part of the Linux Trace Toolkit viewer |
2 | * Copyright (C) 2003-2004 Xiangxiu Yang |
3 | * |
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; |
7 | * |
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. |
12 | * |
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, |
16 | * MA 02111-1307, USA. |
17 | */ |
18 | |
19 | #ifdef HAVE_CONFIG_H |
20 | #include <config.h> |
21 | #endif |
22 | |
23 | #include <stdio.h> |
24 | #include <string.h> |
25 | #include <stdlib.h> |
26 | |
27 | #include <asm/types.h> |
28 | #include <linux/byteorder/swab.h> |
29 | |
30 | #include "parser.h" |
31 | #include <ltt/ltt.h> |
32 | #include "ltt-private.h" |
33 | #include <ltt/event.h> |
34 | #include <ltt/trace.h> |
35 | #include <ltt/ltt-types.h> |
36 | |
37 | |
38 | LttEvent *ltt_event_new() |
39 | { |
40 | return g_new(LttEvent, 1); |
41 | } |
42 | |
43 | void ltt_event_destroy(LttEvent *event) |
44 | { |
45 | g_free(event); |
46 | } |
47 | |
48 | |
49 | /***************************************************************************** |
50 | *Function name |
51 | * ltt_event_refresh_fields : refresh fields of an event |
52 | *Input params |
53 | * offsetRoot : offset from the root |
54 | * offsetParent : offset from the parent |
55 | * fld : field |
56 | * evD : event data |
57 | * reverse_byte_order : 1 or 0 |
58 | *Return value |
59 | * int : size of the field |
60 | ****************************************************************************/ |
61 | |
62 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
63 | LttField * fld, void *evD, gboolean reverse_byte_order) |
64 | { |
65 | int size, size1, element_number, i, offset1, offset2; |
66 | LttType * type = fld->field_type; |
67 | |
68 | switch(type->type_class) { |
69 | case LTT_ARRAY: |
70 | element_number = (int) type->element_number; |
71 | if(fld->field_fixed == 0){// has string or sequence |
72 | size = 0; |
73 | for(i=0;i<element_number;i++){ |
74 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
75 | fld->child[0], evD+size, reverse_byte_order); |
76 | } |
77 | }else size = fld->field_size; |
78 | break; |
79 | |
80 | case LTT_SEQUENCE: |
81 | size1 = fld->sequ_number_size; |
82 | element_number = getIntNumber(reverse_byte_order,size1,evD); |
83 | type->element_number = element_number; |
84 | if(fld->element_size > 0){ |
85 | size = element_number * fld->element_size; |
86 | }else{//sequence has string or sequence |
87 | size = 0; |
88 | for(i=0;i<element_number;i++){ |
89 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
90 | fld->child[0], evD+size+size1, reverse_byte_order); |
91 | } |
92 | size += size1; |
93 | } |
94 | break; |
95 | |
96 | case LTT_STRING: |
97 | size = strlen((gchar*)evD) + 1; //include end : '\0' |
98 | break; |
99 | |
100 | case LTT_STRUCT: |
101 | element_number = (int) type->element_number; |
102 | if(fld->field_fixed == 0){ |
103 | offset1 = offsetRoot; |
104 | offset2 = 0; |
105 | for(i=0;i<element_number;i++){ |
106 | size=ltt_event_refresh_fields(offset1,offset2, |
107 | fld->child[i],evD+offset2, reverse_byte_order); |
108 | offset1 += size; |
109 | offset2 += size; |
110 | } |
111 | size = offset2; |
112 | }else size = fld->field_size; |
113 | break; |
114 | |
115 | case LTT_UNION: |
116 | size = fld->field_size; |
117 | break; |
118 | |
119 | default: |
120 | size = fld->field_size; |
121 | } |
122 | |
123 | #if 0 |
124 | if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY && |
125 | type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){ |
126 | size = fld->field_size; |
127 | }else if(type->type_class == LTT_ARRAY){ |
128 | element_number = (int) type->element_number; |
129 | if(fld->field_fixed == 0){// has string or sequence |
130 | size = 0; |
131 | for(i=0;i<element_number;i++){ |
132 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
133 | fld->child[0], evD+size); |
134 | } |
135 | }else size = fld->field_size; |
136 | }else if(type->type_class == LTT_SEQUENCE){ |
137 | size1 = fld->sequ_number_size; |
138 | element_number = getIntNumber(size1,evD); |
139 | type->element_number = element_number; |
140 | if(fld->element_size > 0){ |
141 | size = element_number * fld->element_size; |
142 | }else{//sequence has string or sequence |
143 | size = 0; |
144 | for(i=0;i<element_number;i++){ |
145 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
146 | fld->child[0], evD+size+size1); |
147 | } |
148 | size += size1; |
149 | } |
150 | }else if(type->type_class == LTT_STRING){ |
151 | size = strlen((char*)evD) + 1; //include end : '\0' |
152 | }else if(type->type_class == LTT_STRUCT){ |
153 | element_number = (int) type->element_number; |
154 | if(fld->field_fixed == 0){ |
155 | offset1 = offsetRoot; |
156 | offset2 = 0; |
157 | for(i=0;i<element_number;i++){ |
158 | size=ltt_event_refresh_fields(offset1,offset2, |
159 | fld->child[i],evD+offset2); |
160 | offset1 += size; |
161 | offset2 += size; |
162 | } |
163 | size = offset2; |
164 | }else size = fld->field_size; |
165 | } |
166 | #endif //0 |
167 | fld->offset_root = offsetRoot; |
168 | fld->offset_parent = offsetParent; |
169 | fld->fixed_root = (offsetRoot==-1) ? 0 : 1; |
170 | fld->fixed_parent = (offsetParent==-1) ? 0 : 1; |
171 | fld->field_size = size; |
172 | |
173 | return size; |
174 | } |
175 | |
176 | /***************************************************************************** |
177 | *Function name |
178 | * ltt_event_eventtype_id: get event type id |
179 | * (base id + position of the event) |
180 | *Input params |
181 | * e : an instance of an event type |
182 | *Return value |
183 | * unsigned : event type id |
184 | ****************************************************************************/ |
185 | |
186 | unsigned ltt_event_eventtype_id(LttEvent *e) |
187 | { |
188 | return (unsigned) e->event_id; |
189 | } |
190 | |
191 | /***************************************************************************** |
192 | *Function name |
193 | * ltt_event_facility : get the facility of the event |
194 | *Input params |
195 | * e : an instance of an event type |
196 | *Return value |
197 | * LttFacility * : the facility of the event |
198 | ****************************************************************************/ |
199 | |
200 | LttFacility *ltt_event_facility(LttEvent *e) |
201 | { |
202 | LttTrace * trace = e->tracefile->trace; |
203 | unsigned id = e->event_id; |
204 | return ltt_trace_facility_by_id(trace,id); |
205 | } |
206 | |
207 | /***************************************************************************** |
208 | *Function name |
209 | * ltt_event_eventtype : get the event type of the event |
210 | *Input params |
211 | * e : an instance of an event type |
212 | *Return value |
213 | * LttEventType * : the event type of the event |
214 | ****************************************************************************/ |
215 | |
216 | LttEventType *ltt_event_eventtype(LttEvent *e) |
217 | { |
218 | LttFacility* facility = ltt_event_facility(e); |
219 | if(!facility) return NULL; |
220 | return facility->events[e->event_id - facility->base_id]; |
221 | } |
222 | |
223 | /***************************************************************************** |
224 | *Function name |
225 | * ltt_event_field : get the root field of the event |
226 | *Input params |
227 | * e : an instance of an event type |
228 | *Return value |
229 | * LttField * : the root field of the event |
230 | ****************************************************************************/ |
231 | |
232 | LttField *ltt_event_field(LttEvent *e) |
233 | { |
234 | LttField * field; |
235 | LttEventType * event_type = ltt_event_eventtype(e); |
236 | if(unlikely(!event_type)) return NULL; |
237 | field = event_type->root_field; |
238 | if(unlikely(!field)) return NULL; |
239 | |
240 | //check if the field need refresh |
241 | if(likely(e->which_block != event_type->latest_block || |
242 | e->which_event != event_type->latest_event)){ |
243 | |
244 | event_type->latest_block = e->which_block; |
245 | event_type->latest_event = e->which_event; |
246 | |
247 | if(unlikely(field->field_fixed != 1)) |
248 | ltt_event_refresh_fields(0, 0, field, e->data, |
249 | e->tracefile->trace->reverse_byte_order); |
250 | } |
251 | return field; |
252 | } |
253 | |
254 | /***************************************************************************** |
255 | *Function name |
256 | * ltt_event_time : get the time of the event |
257 | *Input params |
258 | * e : an instance of an event type |
259 | *Return value |
260 | * LttTime : the time of the event |
261 | ****************************************************************************/ |
262 | |
263 | LttTime ltt_event_time(LttEvent *e) |
264 | { |
265 | return e->event_time; |
266 | } |
267 | |
268 | /***************************************************************************** |
269 | *Function name |
270 | * ltt_event_time : get the cycle count of the event |
271 | *Input params |
272 | * e : an instance of an event type |
273 | *Return value |
274 | * LttCycleCount : the cycle count of the event |
275 | ****************************************************************************/ |
276 | |
277 | LttCycleCount ltt_event_cycle_count(LttEvent *e) |
278 | { |
279 | return e->event_cycle_count; |
280 | } |
281 | |
282 | /***************************************************************************** |
283 | *Function name |
284 | * ltt_event_position : get the event's position |
285 | *Input params |
286 | * e : an instance of an event type |
287 | * ep : a pointer to event's position structure |
288 | ****************************************************************************/ |
289 | |
290 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
291 | { |
292 | ep->block_num = e->which_block; |
293 | ep->event_num = e->which_event; |
294 | ep->event_time = e->event_time; |
295 | ep->event_cycle_count = e->event_cycle_count; |
296 | ep->heart_beat_number = e->tracefile->cur_heart_beat_number; |
297 | ep->old_position = TRUE; |
298 | ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ; |
299 | ep->tf = e->tracefile; |
300 | ep->overflow_nsec = e->overflow_nsec; |
301 | /* This is a workaround for fast position seek */ |
302 | ep->last_event_pos = e->last_event_pos; |
303 | ep->prev_block_end_time = e->prev_block_end_time; |
304 | ep->prev_event_time = e->prev_event_time; |
305 | ep->pre_cycle_count = e->pre_cycle_count; |
306 | ep->count = e->count; |
307 | ep->last_heartbeat = e->last_heartbeat; |
308 | |
309 | /* end of workaround */ |
310 | } |
311 | |
312 | LttEventPosition * ltt_event_position_new() |
313 | { |
314 | return g_new(LttEventPosition, 1); |
315 | } |
316 | |
317 | /***************************************************************************** |
318 | *Function name |
319 | * ltt_event_position_get : get the block number and index of the event |
320 | *Input params |
321 | * ep : a pointer to event's position structure |
322 | * block_number : the block number of the event |
323 | * index_in_block : the index of the event within the block |
324 | ****************************************************************************/ |
325 | |
326 | void ltt_event_position_get(LttEventPosition *ep, |
327 | unsigned *block_number, unsigned *index_in_block, LttTracefile ** tf) |
328 | { |
329 | *block_number = ep->block_num; |
330 | *index_in_block = ep->event_num; |
331 | *tf = ep->tf; |
332 | } |
333 | |
334 | /***************************************************************************** |
335 | *Function name |
336 | * ltt_event_position_set : set the block number and index of the event |
337 | * It does put the old_position gboolean to FALSE, as it is impossible |
338 | * to know the quick position to seek in the tracefile. |
339 | *Input params |
340 | * ep : a pointer to event's position structure |
341 | * block_number : the block number of the event |
342 | * index_in_block : the index of the event within the block |
343 | ****************************************************************************/ |
344 | |
345 | void ltt_event_position_set(LttEventPosition *ep, |
346 | unsigned block_number, unsigned index_in_block) |
347 | { |
348 | if(ep->block_num != block_number || ep->event_num != index_in_block) |
349 | ep->old_position = FALSE; |
350 | |
351 | ep->block_num = block_number; |
352 | ep->event_num = index_in_block; |
353 | |
354 | } |
355 | |
356 | /***************************************************************************** |
357 | * Function name |
358 | * ltt_event_position_compare : compare two positions |
359 | * A NULL value is infinite. |
360 | * Input params |
361 | * ep1 : a pointer to event's position structure |
362 | * ep2 : a pointer to event's position structure |
363 | * Return |
364 | * -1 is ep1 < ep2 |
365 | * 1 if ep1 > ep2 |
366 | * 0 if ep1 == ep2 |
367 | ****************************************************************************/ |
368 | |
369 | |
370 | gint ltt_event_position_compare(const LttEventPosition *ep1, |
371 | const LttEventPosition *ep2) |
372 | { |
373 | if(ep1->tf != ep2->tf) |
374 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
375 | if(ep1 == NULL && ep2 == NULL) |
376 | return 0; |
377 | if(ep1 != NULL && ep2 == NULL) |
378 | return -1; |
379 | if(ep1 == NULL && ep2 != NULL) |
380 | return 1; |
381 | |
382 | if(ep1->block_num < ep2->block_num) |
383 | return -1; |
384 | if(ep1->block_num > ep2->block_num) |
385 | return 1; |
386 | if(ep1->event_num < ep2->event_num) |
387 | return -1; |
388 | if(ep1->event_num > ep2->event_num) |
389 | return 1; |
390 | return 0; |
391 | } |
392 | |
393 | /***************************************************************************** |
394 | * Function name |
395 | * ltt_event_event_position_compare : compare two positions, one in event, |
396 | * other in position opaque structure. |
397 | * Input params |
398 | * event : a pointer to event structure |
399 | * ep : a pointer to event's position structure |
400 | * Return |
401 | * -1 is event < ep |
402 | * 1 if event > ep |
403 | * 0 if event == ep |
404 | ****************************************************************************/ |
405 | |
406 | gint ltt_event_event_position_compare(const LttEvent *event, |
407 | const LttEventPosition *ep) |
408 | { |
409 | if(event == NULL && ep == NULL) |
410 | return 0; |
411 | if(event != NULL && ep == NULL) |
412 | return -1; |
413 | if(event == NULL && ep != NULL) |
414 | return 1; |
415 | |
416 | g_assert(event->tracefile == ep->tf); |
417 | |
418 | if(event->which_block < ep->block_num) |
419 | return -1; |
420 | if(event->which_block > ep->block_num) |
421 | return 1; |
422 | if(event->which_event < ep->event_num) |
423 | return -1; |
424 | if(event->which_event > ep->event_num) |
425 | return 1; |
426 | return 0; |
427 | } |
428 | |
429 | /***************************************************************************** |
430 | * Function name |
431 | * ltt_event_position_copy : copy position |
432 | * Input params |
433 | * src : a pointer to event's position structure source |
434 | * dest : a pointer to event's position structure dest |
435 | * Return |
436 | * void |
437 | ****************************************************************************/ |
438 | void ltt_event_position_copy(LttEventPosition *dest, |
439 | const LttEventPosition *src) |
440 | { |
441 | if(src == NULL) |
442 | dest = NULL; |
443 | else |
444 | *dest = *src; |
445 | } |
446 | |
447 | |
448 | /***************************************************************************** |
449 | *Function name |
450 | * ltt_event_cpu_i: get the cpu id where the event happens |
451 | *Input params |
452 | * e : an instance of an event type |
453 | *Return value |
454 | * unsigned : the cpu id |
455 | ****************************************************************************/ |
456 | |
457 | unsigned ltt_event_cpu_id(LttEvent *e) |
458 | { |
459 | gchar * c1, * c2, * c3; |
460 | c1 = strrchr(e->tracefile->name,'\\'); |
461 | c2 = strrchr(e->tracefile->name,'/'); |
462 | if(c1 == NULL && c2 == NULL){ |
463 | return (unsigned)atoi(e->tracefile->name); |
464 | }else if(c1 == NULL){ |
465 | c2++; |
466 | return (unsigned)atoi(c2); |
467 | }else if(c2 == NULL){ |
468 | c1++; |
469 | return (unsigned)atoi(c1); |
470 | }else{ |
471 | c3 = (c1 > c2) ? c1 : c2; |
472 | c3++; |
473 | return (unsigned)atoi(c3); |
474 | } |
475 | } |
476 | |
477 | /***************************************************************************** |
478 | *Function name |
479 | * ltt_event_data : get the raw data for the event |
480 | *Input params |
481 | * e : an instance of an event type |
482 | *Return value |
483 | * void * : pointer to the raw data for the event |
484 | ****************************************************************************/ |
485 | |
486 | void *ltt_event_data(LttEvent *e) |
487 | { |
488 | return e->data; |
489 | } |
490 | |
491 | /***************************************************************************** |
492 | *Function name |
493 | * ltt_event_field_element_number |
494 | * : The number of elements in a sequence field is specific |
495 | * to each event. This function returns the number of |
496 | * elements for an array or sequence field in an event. |
497 | *Input params |
498 | * e : an instance of an event type |
499 | * f : a field of the instance |
500 | *Return value |
501 | * unsigned : the number of elements for an array/sequence field |
502 | ****************************************************************************/ |
503 | |
504 | unsigned ltt_event_field_element_number(LttEvent *e, LttField *f) |
505 | { |
506 | if(f->field_type->type_class != LTT_ARRAY && |
507 | f->field_type->type_class != LTT_SEQUENCE) |
508 | return 0; |
509 | |
510 | if(f->field_type->type_class == LTT_ARRAY) |
511 | return f->field_type->element_number; |
512 | return (unsigned) getIntNumber(e->tracefile->trace->reverse_byte_order, |
513 | f->sequ_number_size, e + f->offset_root); |
514 | } |
515 | |
516 | /***************************************************************************** |
517 | *Function name |
518 | * ltt_event_field_element_select |
519 | * : Set the currently selected element for a sequence or |
520 | * array field |
521 | *Input params |
522 | * e : an instance of an event type |
523 | * f : a field of the instance |
524 | * i : the ith element |
525 | ****************************************************************************/ |
526 | |
527 | void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i) |
528 | { |
529 | unsigned element_number; |
530 | LttField *fld; |
531 | unsigned int k; |
532 | int size; |
533 | void *evD; |
534 | |
535 | if(f->field_type->type_class != LTT_ARRAY && |
536 | f->field_type->type_class != LTT_SEQUENCE) |
537 | return ; |
538 | |
539 | element_number = ltt_event_field_element_number(e,f); |
540 | /* Sanity check for i : 1..n only, and must be lower or equal element_number |
541 | */ |
542 | if(element_number < i || i == 0) return; |
543 | |
544 | fld = f->child[0]; |
545 | |
546 | evD = e->data + f->offset_root; |
547 | size = 0; |
548 | for(k=0;k<i;k++){ |
549 | size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size, |
550 | e->tracefile->trace->reverse_byte_order); |
551 | } |
552 | f->current_element = i - 1; |
553 | } |
554 | |
555 | /***************************************************************************** |
556 | * These functions extract data from an event after architecture specific |
557 | * conversions |
558 | ****************************************************************************/ |
559 | |
560 | guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f) |
561 | { |
562 | //int revFlag = e->tracefile->trace->my_arch_endian == |
563 | // e->tracefile->trace->system_description->endian ? 0:1; |
564 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
565 | |
566 | LttTypeEnum t = f->field_type->type_class; |
567 | |
568 | g_assert(t == LTT_UINT || t == LTT_ENUM); |
569 | |
570 | if(f->field_size == 1){ |
571 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
572 | return (guint32) x; |
573 | }else if(f->field_size == 2){ |
574 | return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
575 | }else if(f->field_size == 4){ |
576 | return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
577 | } |
578 | #if 0 |
579 | else if(f->field_size == 8){ |
580 | guint64 x = *(guint64 *)(e->data + f->offset_root); |
581 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
582 | return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x); |
583 | else |
584 | return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x); |
585 | } |
586 | #endif //0 |
587 | g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size); |
588 | return 0; |
589 | } |
590 | |
591 | gint32 ltt_event_get_int(LttEvent *e, LttField *f) |
592 | { |
593 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
594 | //int revFlag = e->tracefile->trace->my_arch_endian == |
595 | // e->tracefile->trace->system_description->endian ? 0:1; |
596 | |
597 | g_assert(f->field_type->type_class == LTT_INT); |
598 | |
599 | if(f->field_size == 1){ |
600 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
601 | return (gint32) x; |
602 | }else if(f->field_size == 2){ |
603 | return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
604 | }else if(f->field_size == 4){ |
605 | return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
606 | } |
607 | #if 0 |
608 | else if(f->field_size == 8){ |
609 | gint64 x = *(gint64 *)(e->data + f->offset_root); |
610 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
611 | return (int) (revFlag ? GINT64_FROM_BE(x): x); |
612 | else |
613 | return (int) (revFlag ? GINT64_FROM_LE(x): x); |
614 | } |
615 | #endif //0 |
616 | g_critical("ltt_event_get_int : field size %i unknown", f->field_size); |
617 | return 0; |
618 | } |
619 | |
620 | guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
621 | { |
622 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
623 | //int revFlag = e->tracefile->trace->my_arch_endian == |
624 | // e->tracefile->trace->system_description->endian ? 0:1; |
625 | LttTypeEnum t = f->field_type->type_class; |
626 | |
627 | g_assert(t == LTT_UINT || t == LTT_ENUM); |
628 | |
629 | if(f->field_size == 1){ |
630 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
631 | return (guint64) x; |
632 | }else if(f->field_size == 2){ |
633 | return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
634 | }else if(f->field_size == 4){ |
635 | return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
636 | }else if(f->field_size == 8){ |
637 | return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root); |
638 | } |
639 | g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size); |
640 | return 0; |
641 | } |
642 | |
643 | gint64 ltt_event_get_long_int(LttEvent *e, LttField *f) |
644 | { |
645 | //int revFlag = e->tracefile->trace->my_arch_endian == |
646 | // e->tracefile->trace->system_description->endian ? 0:1; |
647 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
648 | |
649 | g_assert( f->field_type->type_class == LTT_INT); |
650 | |
651 | if(f->field_size == 1){ |
652 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
653 | return (gint64) x; |
654 | }else if(f->field_size == 2){ |
655 | return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
656 | }else if(f->field_size == 4){ |
657 | return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
658 | }else if(f->field_size == 8){ |
659 | return ltt_get_int64(reverse_byte_order, e->data + f->offset_root); |
660 | } |
661 | g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size); |
662 | return 0; |
663 | } |
664 | |
665 | float ltt_event_get_float(LttEvent *e, LttField *f) |
666 | { |
667 | //int revFlag = e->tracefile->trace->my_arch_endian == |
668 | // e->tracefile->trace->system_description->endian ? 0:1; |
669 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
670 | |
671 | g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4); |
672 | |
673 | if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root); |
674 | else{ |
675 | guint32 aInt; |
676 | memcpy((void*)&aInt, e->data + f->offset_root, 4); |
677 | aInt = ___swab32(aInt); |
678 | return ((float)aInt); |
679 | } |
680 | } |
681 | |
682 | double ltt_event_get_double(LttEvent *e, LttField *f) |
683 | { |
684 | gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order; |
685 | //int revFlag = e->tracefile->trace->my_arch_endian == |
686 | // e->tracefile->trace->system_description->endian ? 0:1; |
687 | |
688 | g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8); |
689 | |
690 | if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root); |
691 | else{ |
692 | guint64 aInt; |
693 | memcpy((void*)&aInt, e->data + f->offset_root, 8); |
694 | aInt = ___swab64(aInt); |
695 | return ((double)aInt); |
696 | } |
697 | } |
698 | |
699 | /***************************************************************************** |
700 | * The string obtained is only valid until the next read from |
701 | * the same tracefile. |
702 | ****************************************************************************/ |
703 | |
704 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
705 | { |
706 | g_assert(f->field_type->type_class == LTT_STRING); |
707 | |
708 | return (gchar*)g_strdup((gchar*)(e->data + f->offset_root)); |
709 | } |