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