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