449cb9d7 |
1 | /* This file is part of the Linux Trace Toolkit viewer |
2 | * Copyright (C) 2003-2004 Xiangxiu Yang |
1b44b0b5 |
3 | * 2006 Mathieu Desnoyers |
449cb9d7 |
4 | * |
1b44b0b5 |
5 | * This library is free software; you can redistribute it and/or |
6 | * modify it under the terms of the GNU Lesser General Public |
7 | * License Version 2.1 as published by the Free Software Foundation. |
449cb9d7 |
8 | * |
1b44b0b5 |
9 | * This library is distributed in the hope that it will be useful, |
449cb9d7 |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
1b44b0b5 |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | * Lesser General Public License for more details. |
449cb9d7 |
13 | * |
1b44b0b5 |
14 | * You should have received a copy of the GNU Lesser General Public |
15 | * License along with this library; if not, write to the |
16 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
17 | * Boston, MA 02111-1307, USA. |
449cb9d7 |
18 | */ |
19 | |
4e4d11b3 |
20 | #ifdef HAVE_CONFIG_H |
21 | #include <config.h> |
22 | #endif |
23 | |
6cd62ccf |
24 | #include <stdio.h> |
8d1e6362 |
25 | #include <string.h> |
26 | #include <stdlib.h> |
3aee1200 |
27 | #include <glib.h> |
8d1e6362 |
28 | |
6cd62ccf |
29 | #include <asm/types.h> |
d4214418 |
30 | #include <byteswap.h> |
a5dcde2f |
31 | |
6cd62ccf |
32 | #include "parser.h" |
a5dcde2f |
33 | #include <ltt/ltt.h> |
34 | #include "ltt-private.h" |
6cd62ccf |
35 | #include <ltt/event.h> |
a5dcde2f |
36 | #include <ltt/trace.h> |
0f7f40c1 |
37 | #include <ltt/ltt-types.h> |
6cd62ccf |
38 | |
2312de30 |
39 | |
40 | |
743e50fd |
41 | void compute_fields_offsets(LttTracefile *tf, |
42 | LttFacility *fac, LttField *field, off_t *offset, void *root); |
2312de30 |
43 | |
44 | |
c02ea99f |
45 | LttEvent *ltt_event_new() |
46 | { |
47 | return g_new(LttEvent, 1); |
48 | } |
49 | |
50 | void ltt_event_destroy(LttEvent *event) |
51 | { |
52 | g_free(event); |
53 | } |
54 | |
55 | |
3aee1200 |
56 | #if 0 |
57 | /* Use get_field_type_size instead */ |
908f42fa |
58 | /***************************************************************************** |
59 | *Function name |
60 | * ltt_event_refresh_fields : refresh fields of an event |
61 | *Input params |
62 | * offsetRoot : offset from the root |
18206708 |
63 | * offsetParent : offset from the parent |
908f42fa |
64 | * fld : field |
65 | * evD : event data |
0f7f40c1 |
66 | * reverse_byte_order : 1 or 0 |
908f42fa |
67 | *Return value |
68 | * int : size of the field |
69 | ****************************************************************************/ |
70 | |
71 | int ltt_event_refresh_fields(int offsetRoot,int offsetParent, |
0f7f40c1 |
72 | LttField * fld, void *evD, gboolean reverse_byte_order) |
908f42fa |
73 | { |
74 | int size, size1, element_number, i, offset1, offset2; |
75 | LttType * type = fld->field_type; |
76 | |
cf74a6f1 |
77 | switch(type->type_class) { |
78 | case LTT_ARRAY: |
79 | element_number = (int) type->element_number; |
80 | if(fld->field_fixed == 0){// has string or sequence |
81 | size = 0; |
82 | for(i=0;i<element_number;i++){ |
83 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
0f7f40c1 |
84 | fld->child[0], evD+size, reverse_byte_order); |
cf74a6f1 |
85 | } |
86 | }else size = fld->field_size; |
87 | break; |
88 | |
89 | case LTT_SEQUENCE: |
90 | size1 = fld->sequ_number_size; |
0f7f40c1 |
91 | element_number = getIntNumber(reverse_byte_order,size1,evD); |
cf74a6f1 |
92 | type->element_number = element_number; |
93 | if(fld->element_size > 0){ |
94 | size = element_number * fld->element_size; |
95 | }else{//sequence has string or sequence |
96 | size = 0; |
97 | for(i=0;i<element_number;i++){ |
98 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
0f7f40c1 |
99 | fld->child[0], evD+size+size1, reverse_byte_order); |
cf74a6f1 |
100 | } |
101 | size += size1; |
102 | } |
103 | break; |
104 | |
105 | case LTT_STRING: |
45e14832 |
106 | size = strlen((gchar*)evD) + 1; //include end : '\0' |
cf74a6f1 |
107 | break; |
108 | |
109 | case LTT_STRUCT: |
110 | element_number = (int) type->element_number; |
111 | if(fld->field_fixed == 0){ |
112 | offset1 = offsetRoot; |
113 | offset2 = 0; |
114 | for(i=0;i<element_number;i++){ |
115 | size=ltt_event_refresh_fields(offset1,offset2, |
0f7f40c1 |
116 | fld->child[i],evD+offset2, reverse_byte_order); |
cf74a6f1 |
117 | offset1 += size; |
118 | offset2 += size; |
119 | } |
120 | size = offset2; |
121 | }else size = fld->field_size; |
122 | break; |
e52d9126 |
123 | |
124 | case LTT_UNION: |
125 | size = fld->field_size; |
126 | break; |
cf74a6f1 |
127 | |
128 | default: |
129 | size = fld->field_size; |
130 | } |
131 | |
132 | #if 0 |
908f42fa |
133 | if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY && |
134 | type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){ |
135 | size = fld->field_size; |
136 | }else if(type->type_class == LTT_ARRAY){ |
137 | element_number = (int) type->element_number; |
138 | if(fld->field_fixed == 0){// has string or sequence |
139 | size = 0; |
140 | for(i=0;i<element_number;i++){ |
cf74a6f1 |
141 | size += ltt_event_refresh_fields(offsetRoot+size,size, |
908f42fa |
142 | fld->child[0], evD+size); |
cf74a6f1 |
143 | } |
908f42fa |
144 | }else size = fld->field_size; |
145 | }else if(type->type_class == LTT_SEQUENCE){ |
146 | size1 = fld->sequ_number_size; |
147 | element_number = getIntNumber(size1,evD); |
148 | type->element_number = element_number; |
149 | if(fld->element_size > 0){ |
150 | size = element_number * fld->element_size; |
151 | }else{//sequence has string or sequence |
152 | size = 0; |
153 | for(i=0;i<element_number;i++){ |
cf74a6f1 |
154 | size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1, |
155 | fld->child[0], evD+size+size1); |
908f42fa |
156 | } |
157 | size += size1; |
158 | } |
159 | }else if(type->type_class == LTT_STRING){ |
160 | size = strlen((char*)evD) + 1; //include end : '\0' |
161 | }else if(type->type_class == LTT_STRUCT){ |
162 | element_number = (int) type->element_number; |
163 | if(fld->field_fixed == 0){ |
164 | offset1 = offsetRoot; |
165 | offset2 = 0; |
166 | for(i=0;i<element_number;i++){ |
cf74a6f1 |
167 | size=ltt_event_refresh_fields(offset1,offset2, |
168 | fld->child[i],evD+offset2); |
169 | offset1 += size; |
170 | offset2 += size; |
908f42fa |
171 | } |
172 | size = offset2; |
173 | }else size = fld->field_size; |
174 | } |
cf74a6f1 |
175 | #endif //0 |
908f42fa |
176 | fld->offset_root = offsetRoot; |
177 | fld->offset_parent = offsetParent; |
178 | fld->fixed_root = (offsetRoot==-1) ? 0 : 1; |
179 | fld->fixed_parent = (offsetParent==-1) ? 0 : 1; |
180 | fld->field_size = size; |
181 | |
182 | return size; |
183 | } |
3aee1200 |
184 | #endif //0 |
185 | |
908f42fa |
186 | |
6cd62ccf |
187 | /***************************************************************************** |
188 | *Function name |
963b5f2d |
189 | * ltt_event_eventtype_id: get event type id |
190 | * (base id + position of the event) |
6cd62ccf |
191 | *Input params |
963b5f2d |
192 | * e : an instance of an event type |
6cd62ccf |
193 | *Return value |
963b5f2d |
194 | * unsigned : event type id |
6cd62ccf |
195 | ****************************************************************************/ |
196 | |
eed2ef37 |
197 | unsigned ltt_event_eventtype_id(const LttEvent *e) |
6cd62ccf |
198 | { |
199 | return (unsigned) e->event_id; |
200 | } |
201 | |
202 | /***************************************************************************** |
203 | *Function name |
204 | * ltt_event_facility : get the facility of the event |
205 | *Input params |
206 | * e : an instance of an event type |
207 | *Return value |
963b5f2d |
208 | * LttFacility * : the facility of the event |
6cd62ccf |
209 | ****************************************************************************/ |
210 | |
eed2ef37 |
211 | LttFacility *ltt_event_facility(const LttEvent *e) |
6cd62ccf |
212 | { |
963b5f2d |
213 | LttTrace * trace = e->tracefile->trace; |
27304273 |
214 | unsigned id = e->facility_id; |
215 | LttFacility *facility = ltt_trace_facility_by_id(trace,id); |
216 | |
217 | g_assert(facility->exists); |
218 | |
219 | return facility; |
6cd62ccf |
220 | } |
221 | |
eed2ef37 |
222 | /***************************************************************************** |
223 | *Function name |
224 | * ltt_event_facility_id : get the facility id of the event |
225 | *Input params |
226 | * e : an instance of an event type |
227 | *Return value |
228 | * unsigned : the facility of the event |
229 | ****************************************************************************/ |
230 | |
231 | unsigned ltt_event_facility_id(const LttEvent *e) |
232 | { |
233 | return e->facility_id; |
234 | } |
235 | |
6cd62ccf |
236 | /***************************************************************************** |
237 | *Function name |
238 | * ltt_event_eventtype : get the event type of the event |
239 | *Input params |
240 | * e : an instance of an event type |
241 | *Return value |
963b5f2d |
242 | * LttEventType * : the event type of the event |
6cd62ccf |
243 | ****************************************************************************/ |
244 | |
eed2ef37 |
245 | LttEventType *ltt_event_eventtype(const LttEvent *e) |
6cd62ccf |
246 | { |
963b5f2d |
247 | LttFacility* facility = ltt_event_facility(e); |
248 | if(!facility) return NULL; |
3aee1200 |
249 | return &g_array_index(facility->events, LttEventType, e->event_id); |
6cd62ccf |
250 | } |
251 | |
6cd62ccf |
252 | |
253 | /***************************************************************************** |
254 | *Function name |
963b5f2d |
255 | * ltt_event_time : get the time of the event |
6cd62ccf |
256 | *Input params |
257 | * e : an instance of an event type |
258 | *Return value |
963b5f2d |
259 | * LttTime : the time of the event |
6cd62ccf |
260 | ****************************************************************************/ |
261 | |
eed2ef37 |
262 | LttTime ltt_event_time(const LttEvent *e) |
6cd62ccf |
263 | { |
963b5f2d |
264 | return e->event_time; |
6cd62ccf |
265 | } |
266 | |
267 | /***************************************************************************** |
268 | *Function name |
963b5f2d |
269 | * ltt_event_time : get the cycle count of the event |
6cd62ccf |
270 | *Input params |
271 | * e : an instance of an event type |
272 | *Return value |
963b5f2d |
273 | * LttCycleCount : the cycle count of the event |
6cd62ccf |
274 | ****************************************************************************/ |
275 | |
eed2ef37 |
276 | LttCycleCount ltt_event_cycle_count(const LttEvent *e) |
6cd62ccf |
277 | { |
3aee1200 |
278 | return e->tsc; |
6cd62ccf |
279 | } |
280 | |
eed2ef37 |
281 | |
282 | |
283 | /***************************************************************************** |
284 | *Function name |
285 | * ltt_event_position_get : get the event position data |
286 | *Input params |
287 | * e : an instance of an event type |
288 | * ep : a pointer to event's position structure |
289 | * tf : tracefile pointer |
290 | * block : current block |
291 | * offset : current offset |
292 | * tsc : current tsc |
293 | ****************************************************************************/ |
294 | void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf, |
295 | guint *block, guint *offset, guint64 *tsc) |
296 | { |
297 | *tf = ep->tracefile; |
298 | *block = ep->block; |
299 | *offset = ep->offset; |
300 | *tsc = ep->tsc; |
301 | } |
302 | |
303 | |
80da81ad |
304 | /***************************************************************************** |
305 | *Function name |
306 | * ltt_event_position : get the event's position |
307 | *Input params |
308 | * e : an instance of an event type |
309 | * ep : a pointer to event's position structure |
310 | ****************************************************************************/ |
311 | |
312 | void ltt_event_position(LttEvent *e, LttEventPosition *ep) |
313 | { |
3aee1200 |
314 | ep->tracefile = e->tracefile; |
315 | ep->block = e->block; |
316 | ep->offset = e->offset; |
317 | ep->tsc = e->tsc; |
80da81ad |
318 | } |
319 | |
a5dcde2f |
320 | LttEventPosition * ltt_event_position_new() |
321 | { |
322 | return g_new(LttEventPosition, 1); |
323 | } |
324 | |
80da81ad |
325 | |
96da5c0d |
326 | /***************************************************************************** |
327 | * Function name |
328 | * ltt_event_position_compare : compare two positions |
a00149f6 |
329 | * A NULL value is infinite. |
96da5c0d |
330 | * Input params |
331 | * ep1 : a pointer to event's position structure |
332 | * ep2 : a pointer to event's position structure |
333 | * Return |
334 | * -1 is ep1 < ep2 |
335 | * 1 if ep1 > ep2 |
336 | * 0 if ep1 == ep2 |
337 | ****************************************************************************/ |
338 | |
339 | |
340 | gint ltt_event_position_compare(const LttEventPosition *ep1, |
341 | const LttEventPosition *ep2) |
342 | { |
a00149f6 |
343 | if(ep1 == NULL && ep2 == NULL) |
344 | return 0; |
345 | if(ep1 != NULL && ep2 == NULL) |
346 | return -1; |
347 | if(ep1 == NULL && ep2 != NULL) |
348 | return 1; |
96da5c0d |
349 | |
3aee1200 |
350 | if(ep1->tracefile != ep2->tracefile) |
351 | g_error("ltt_event_position_compare on different tracefiles makes no sense"); |
352 | |
353 | if(ep1->block < ep2->block) |
96da5c0d |
354 | return -1; |
3aee1200 |
355 | if(ep1->block > ep2->block) |
96da5c0d |
356 | return 1; |
3aee1200 |
357 | if(ep1->offset < ep2->offset) |
96da5c0d |
358 | return -1; |
3aee1200 |
359 | if(ep1->offset > ep2->offset) |
96da5c0d |
360 | return 1; |
361 | return 0; |
362 | } |
363 | |
2a74fbf4 |
364 | /***************************************************************************** |
365 | * Function name |
366 | * ltt_event_position_copy : copy position |
367 | * Input params |
368 | * src : a pointer to event's position structure source |
369 | * dest : a pointer to event's position structure dest |
370 | * Return |
371 | * void |
372 | ****************************************************************************/ |
373 | void ltt_event_position_copy(LttEventPosition *dest, |
374 | const LttEventPosition *src) |
375 | { |
a00149f6 |
376 | if(src == NULL) |
377 | dest = NULL; |
378 | else |
379 | *dest = *src; |
2a74fbf4 |
380 | } |
96da5c0d |
381 | |
382 | |
27304273 |
383 | |
384 | LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep) |
385 | { |
386 | return ep->tracefile; |
387 | } |
388 | |
6cd62ccf |
389 | /***************************************************************************** |
390 | *Function name |
963b5f2d |
391 | * ltt_event_cpu_i: get the cpu id where the event happens |
6cd62ccf |
392 | *Input params |
393 | * e : an instance of an event type |
394 | *Return value |
963b5f2d |
395 | * unsigned : the cpu id |
6cd62ccf |
396 | ****************************************************************************/ |
397 | |
963b5f2d |
398 | unsigned ltt_event_cpu_id(LttEvent *e) |
3aee1200 |
399 | { |
400 | return e->tracefile->cpu_num; |
6cd62ccf |
401 | } |
402 | |
403 | /***************************************************************************** |
404 | *Function name |
405 | * ltt_event_data : get the raw data for the event |
406 | *Input params |
407 | * e : an instance of an event type |
408 | *Return value |
409 | * void * : pointer to the raw data for the event |
410 | ****************************************************************************/ |
411 | |
963b5f2d |
412 | void *ltt_event_data(LttEvent *e) |
6cd62ccf |
413 | { |
414 | return e->data; |
415 | } |
416 | |
417 | /***************************************************************************** |
418 | *Function name |
419 | * ltt_event_field_element_number |
420 | * : The number of elements in a sequence field is specific |
421 | * to each event. This function returns the number of |
422 | * elements for an array or sequence field in an event. |
423 | *Input params |
908f42fa |
424 | * e : an instance of an event type |
6cd62ccf |
425 | * f : a field of the instance |
426 | *Return value |
427 | * unsigned : the number of elements for an array/sequence field |
428 | ****************************************************************************/ |
3aee1200 |
429 | guint64 ltt_event_field_element_number(LttEvent *e, LttField *f) |
6cd62ccf |
430 | { |
2312de30 |
431 | if(f->field_type.type_class != LTT_ARRAY && |
432 | f->field_type.type_class != LTT_SEQUENCE) |
6cd62ccf |
433 | return 0; |
908f42fa |
434 | |
2312de30 |
435 | if(f->field_type.type_class == LTT_ARRAY) |
436 | return f->field_type.size; |
437 | return ltt_event_get_long_unsigned(e, &g_array_index(f->field_type.fields, |
438 | LttField, 0)); |
6cd62ccf |
439 | } |
440 | |
441 | /***************************************************************************** |
442 | *Function name |
443 | * ltt_event_field_element_select |
444 | * : Set the currently selected element for a sequence or |
445 | * array field |
f104d082 |
446 | * O(1) because of offset array. |
6cd62ccf |
447 | *Input params |
908f42fa |
448 | * e : an instance of an event type |
6cd62ccf |
449 | * f : a field of the instance |
3aee1200 |
450 | * i : the ith element (0, ...) |
f104d082 |
451 | *returns : the child field, at the right index, updated. |
6cd62ccf |
452 | ****************************************************************************/ |
f104d082 |
453 | LttField *ltt_event_field_element_select(LttEvent *e, LttField *f, gulong i) |
6cd62ccf |
454 | { |
f104d082 |
455 | gulong element_number; |
3aee1200 |
456 | LttField *field; |
8d1e6362 |
457 | unsigned int k; |
3aee1200 |
458 | size_t size; |
459 | LttEventType *event_type; |
f104d082 |
460 | off_t new_offset; |
908f42fa |
461 | |
2312de30 |
462 | if(f->field_type.type_class != LTT_ARRAY && |
463 | f->field_type.type_class != LTT_SEQUENCE) |
743e50fd |
464 | return NULL; |
908f42fa |
465 | |
466 | element_number = ltt_event_field_element_number(e,f); |
3aee1200 |
467 | event_type = ltt_event_eventtype(e); |
468 | /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number |
8d1e6362 |
469 | */ |
743e50fd |
470 | if(i >= element_number) return NULL; |
f104d082 |
471 | |
2312de30 |
472 | if(f->field_type.type_class == LTT_ARRAY) { |
473 | field = &g_array_index(f->field_type.fields, LttField, 0); |
f104d082 |
474 | } else { |
2312de30 |
475 | field = &g_array_index(f->field_type.fields, LttField, 1); |
f104d082 |
476 | } |
3aee1200 |
477 | |
f104d082 |
478 | if(field->field_size != 0) { |
479 | if(f->array_offset + (i * field->field_size) == field->offset_root) |
743e50fd |
480 | return field; /* fixed length child, already at the right offset */ |
f104d082 |
481 | else |
482 | new_offset = f->array_offset + (i * field->field_size); |
3aee1200 |
483 | } else { |
f104d082 |
484 | /* Var. len. child */ |
485 | new_offset = g_array_index(f->dynamic_offsets, off_t, i); |
908f42fa |
486 | } |
743e50fd |
487 | compute_fields_offsets(e->tracefile, |
488 | ltt_event_facility(e), field, &new_offset, e->data); |
f104d082 |
489 | |
490 | return field; |
6cd62ccf |
491 | } |
492 | |
f2923fb2 |
493 | |
494 | off_t ltt_event_field_offset(LttEvent *e, LttField *f) |
495 | { |
496 | return f->offset_root; |
497 | } |
498 | |
499 | |
500 | |
6cd62ccf |
501 | /***************************************************************************** |
502 | * These functions extract data from an event after architecture specific |
503 | * conversions |
504 | ****************************************************************************/ |
63c35f6c |
505 | guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
506 | { |
3aee1200 |
507 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
0f7f40c1 |
508 | |
2312de30 |
509 | LttTypeEnum t = f->field_type.type_class; |
6cd62ccf |
510 | |
b7b36242 |
511 | if(f->field_size == 1){ |
cbd41522 |
512 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
63c35f6c |
513 | return (guint32) x; |
b7b36242 |
514 | }else if(f->field_size == 2){ |
0f7f40c1 |
515 | return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
516 | }else if(f->field_size == 4){ |
0f7f40c1 |
517 | return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
63c35f6c |
518 | } |
519 | #if 0 |
520 | else if(f->field_size == 8){ |
cbd41522 |
521 | guint64 x = *(guint64 *)(e->data + f->offset_root); |
522 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
523 | return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x); |
524 | else |
525 | return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x); |
6cd62ccf |
526 | } |
63c35f6c |
527 | #endif //0 |
8d1e6362 |
528 | g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size); |
529 | return 0; |
6cd62ccf |
530 | } |
531 | |
63c35f6c |
532 | gint32 ltt_event_get_int(LttEvent *e, LttField *f) |
6cd62ccf |
533 | { |
3aee1200 |
534 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
6cd62ccf |
535 | |
b7b36242 |
536 | if(f->field_size == 1){ |
cbd41522 |
537 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
63c35f6c |
538 | return (gint32) x; |
b7b36242 |
539 | }else if(f->field_size == 2){ |
0f7f40c1 |
540 | return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
541 | }else if(f->field_size == 4){ |
0f7f40c1 |
542 | return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
63c35f6c |
543 | } |
544 | #if 0 |
545 | else if(f->field_size == 8){ |
cbd41522 |
546 | gint64 x = *(gint64 *)(e->data + f->offset_root); |
547 | if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN) |
548 | return (int) (revFlag ? GINT64_FROM_BE(x): x); |
549 | else |
550 | return (int) (revFlag ? GINT64_FROM_LE(x): x); |
6cd62ccf |
551 | } |
63c35f6c |
552 | #endif //0 |
8d1e6362 |
553 | g_critical("ltt_event_get_int : field size %i unknown", f->field_size); |
554 | return 0; |
6cd62ccf |
555 | } |
556 | |
63c35f6c |
557 | guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f) |
6cd62ccf |
558 | { |
3aee1200 |
559 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
560 | |
2312de30 |
561 | LttTypeEnum t = f->field_type.type_class; |
6cd62ccf |
562 | |
b7b36242 |
563 | if(f->field_size == 1){ |
cbd41522 |
564 | guint8 x = *(guint8 *)(e->data + f->offset_root); |
63c35f6c |
565 | return (guint64) x; |
b7b36242 |
566 | }else if(f->field_size == 2){ |
0f7f40c1 |
567 | return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
568 | }else if(f->field_size == 4){ |
0f7f40c1 |
569 | return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
570 | }else if(f->field_size == 8){ |
0f7f40c1 |
571 | return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root); |
6cd62ccf |
572 | } |
8d1e6362 |
573 | g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size); |
574 | return 0; |
6cd62ccf |
575 | } |
576 | |
63c35f6c |
577 | gint64 ltt_event_get_long_int(LttEvent *e, LttField *f) |
6cd62ccf |
578 | { |
0f7f40c1 |
579 | //int revFlag = e->tracefile->trace->my_arch_endian == |
580 | // e->tracefile->trace->system_description->endian ? 0:1; |
3aee1200 |
581 | gboolean reverse_byte_order = LTT_GET_BO(e->tracefile); |
6cd62ccf |
582 | |
b7b36242 |
583 | if(f->field_size == 1){ |
cbd41522 |
584 | gint8 x = *(gint8 *)(e->data + f->offset_root); |
63c35f6c |
585 | return (gint64) x; |
b7b36242 |
586 | }else if(f->field_size == 2){ |
0f7f40c1 |
587 | return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
588 | }else if(f->field_size == 4){ |
0f7f40c1 |
589 | return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root); |
b7b36242 |
590 | }else if(f->field_size == 8){ |
0f7f40c1 |
591 | return ltt_get_int64(reverse_byte_order, e->data + f->offset_root); |
6cd62ccf |
592 | } |
8d1e6362 |
593 | g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size); |
594 | return 0; |
6cd62ccf |
595 | } |
596 | |
963b5f2d |
597 | float ltt_event_get_float(LttEvent *e, LttField *f) |
6cd62ccf |
598 | { |
3b10b765 |
599 | g_assert(LTT_HAS_FLOAT(e->tracefile)); |
600 | gboolean reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile); |
6cd62ccf |
601 | |
2312de30 |
602 | g_assert(f->field_type.type_class == LTT_FLOAT && f->field_size == 4); |
6cd62ccf |
603 | |
0f7f40c1 |
604 | if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root); |
6cd62ccf |
605 | else{ |
d4214418 |
606 | void *ptr = e->data + f->offset_root; |
fadf7e8b |
607 | guint32 value = bswap_32(*(guint32*)ptr); |
608 | return *(float*)&value; |
6cd62ccf |
609 | } |
610 | } |
611 | |
963b5f2d |
612 | double ltt_event_get_double(LttEvent *e, LttField *f) |
6cd62ccf |
613 | { |
3b10b765 |
614 | g_assert(LTT_HAS_FLOAT(e->tracefile)); |
615 | gboolean reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile); |
6cd62ccf |
616 | |
2312de30 |
617 | if(f->field_size == 4) |
618 | return ltt_event_get_float(e, f); |
619 | |
620 | g_assert(f->field_type.type_class == LTT_FLOAT && f->field_size == 8); |
6cd62ccf |
621 | |
0f7f40c1 |
622 | if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root); |
3b10b765 |
623 | else { |
d4214418 |
624 | void *ptr = e->data + f->offset_root; |
fadf7e8b |
625 | guint64 value = bswap_64(*(guint64*)ptr); |
626 | return *(double*)&value; |
6cd62ccf |
627 | } |
628 | } |
629 | |
630 | /***************************************************************************** |
631 | * The string obtained is only valid until the next read from |
908f42fa |
632 | * the same tracefile. |
6cd62ccf |
633 | ****************************************************************************/ |
963b5f2d |
634 | char *ltt_event_get_string(LttEvent *e, LttField *f) |
6cd62ccf |
635 | { |
2312de30 |
636 | g_assert(f->field_type.type_class == LTT_STRING); |
2a74fbf4 |
637 | |
45e14832 |
638 | return (gchar*)g_strdup((gchar*)(e->data + f->offset_root)); |
6cd62ccf |
639 | } |
eed2ef37 |
640 | |
641 | |
642 | /***************************************************************************** |
643 | *Function name |
644 | * get_field_type_size : set the fixed and dynamic sizes of the field type |
645 | * from the data read. |
646 | *Input params |
647 | * tf : tracefile |
648 | * event_type : event type |
649 | * offset_root : offset from the root |
650 | * offset_parent : offset from the parent |
651 | * field : field |
652 | * data : a pointer to the event data. |
653 | *Returns the field type size. |
654 | ****************************************************************************/ |
f104d082 |
655 | // TODO |
656 | // Change this function so it uses a *to offset value incrementation, just like |
657 | // genevent-new instead of returning a size. What is of interest here is the |
658 | // offset needed to read each field. |
659 | // |
660 | // Precomputed ones can be returned directly. Otherwise, the field is flagged |
661 | // "VARIABLE OFFSET" and must be computed dynamically. The dynamic processing |
662 | // of an offset takes the last known fixed offset, and then dynamically |
663 | // calculates all variable field offsets from it. |
664 | // |
665 | // After a VARIABLE SIZE element, all fields have a variable offset. |
666 | // Also, is an array or a sequence has variable length child, we must pass |
667 | // through all of them, saving the offsets in the dynamic_offsets array. |
668 | |
669 | #if 0 |
eed2ef37 |
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; |
f104d082 |
677 | off_t align; |
eed2ef37 |
678 | |
679 | g_assert(field->fixed_root != FIELD_UNKNOWN); |
680 | g_assert(field->fixed_parent != FIELD_UNKNOWN); |
681 | g_assert(field->fixed_size != FIELD_UNKNOWN); |
682 | |
683 | field->offset_root = offset_root; |
684 | field->offset_parent = offset_parent; |
685 | |
686 | type = field->field_type; |
687 | |
688 | switch(type->type_class) { |
689 | case LTT_INT: |
690 | case LTT_UINT: |
691 | case LTT_FLOAT: |
692 | case LTT_ENUM: |
693 | case LTT_POINTER: |
694 | case LTT_LONG: |
695 | case LTT_ULONG: |
696 | case LTT_SIZE_T: |
697 | case LTT_SSIZE_T: |
698 | case LTT_OFF_T: |
699 | g_assert(field->fixed_size == FIELD_FIXED); |
f104d082 |
700 | size = field->field_size; |
701 | align = ltt_align(field->offset_root, |
743e50fd |
702 | size, event_type->facility->alignment); |
f104d082 |
703 | field->offset_root += align; |
704 | field->offset_parent += align; |
705 | size += align; |
eed2ef37 |
706 | break; |
707 | case LTT_SEQUENCE: |
708 | { |
f104d082 |
709 | /* FIXME : check the type of sequence identifier */ |
eed2ef37 |
710 | gint seqnum = ltt_get_uint(LTT_GET_BO(tf), |
711 | field->sequ_number_size, |
712 | data + offset_root); |
713 | |
714 | if(field->child[0]->fixed_size == FIELD_FIXED) { |
715 | size = field->sequ_number_size + |
716 | (seqnum * get_field_type_size(tf, event_type, |
717 | offset_root, offset_parent, |
718 | field->child[0], data)); |
719 | } else { |
720 | size += field->sequ_number_size; |
721 | for(i=0;i<seqnum;i++) { |
722 | size_t child_size; |
723 | child_size = get_field_type_size(tf, event_type, |
724 | offset_root, offset_parent, |
725 | field->child[0], data); |
726 | offset_root += child_size; |
727 | offset_parent += child_size; |
728 | size += child_size; |
729 | } |
730 | } |
731 | field->field_size = size; |
732 | } |
733 | break; |
734 | case LTT_STRING: |
735 | size = strlen((char*)(data+offset_root)) + 1;// length + \0 |
736 | field->field_size = size; |
737 | break; |
738 | case LTT_ARRAY: |
739 | if(field->fixed_size == FIELD_FIXED) |
740 | size = field->field_size; |
741 | else { |
742 | for(i=0;i<field->field_type->element_number;i++) { |
743 | size_t child_size; |
744 | child_size = get_field_type_size(tf, event_type, |
745 | offset_root, offset_parent, |
746 | field->child[0], data); |
747 | offset_root += child_size; |
748 | offset_parent += child_size; |
749 | size += child_size; |
750 | } |
751 | field->field_size = size; |
752 | } |
753 | break; |
754 | case LTT_STRUCT: |
755 | if(field->fixed_size == FIELD_FIXED) |
756 | size = field->field_size; |
757 | else { |
758 | size_t current_root_offset = offset_root; |
759 | size_t current_offset = 0; |
760 | size_t child_size = 0; |
761 | for(i=0;i<type->element_number;i++) { |
762 | child_size = get_field_type_size(tf, |
763 | event_type, current_root_offset, current_offset, |
764 | field->child[i], data); |
765 | current_offset += child_size; |
766 | current_root_offset += child_size; |
767 | |
768 | } |
769 | size = current_offset; |
770 | field->field_size = size; |
771 | } |
772 | break; |
773 | case LTT_UNION: |
774 | if(field->fixed_size == FIELD_FIXED) |
775 | size = field->field_size; |
776 | else { |
777 | size_t current_root_offset = field->offset_root; |
778 | size_t current_offset = 0; |
779 | for(i=0;i<type->element_number;i++) { |
780 | size = get_field_type_size(tf, event_type, |
781 | current_root_offset, current_offset, |
782 | field->child[i], data); |
783 | size = max(size, field->child[i]->field_size); |
784 | } |
785 | field->field_size = size; |
786 | } |
787 | break; |
788 | } |
789 | |
790 | return size; |
791 | } |
f104d082 |
792 | #endif //0 |
793 | |
794 | |
795 | |
796 | |
797 | |
798 | /***************************************************************************** |
799 | *Function name |
800 | * compute_fields_offsets : set the precomputable offset of the fields |
801 | *Input params |
743e50fd |
802 | * fac : facility |
f104d082 |
803 | * field : the field |
804 | * offset : pointer to the current offset, must be incremented |
805 | ****************************************************************************/ |
806 | |
807 | |
743e50fd |
808 | void compute_fields_offsets(LttTracefile *tf, |
809 | LttFacility *fac, LttField *field, off_t *offset, void *root) |
f104d082 |
810 | { |
2312de30 |
811 | LttType *type = &field->field_type; |
f104d082 |
812 | |
813 | switch(type->type_class) { |
814 | case LTT_INT_FIXED: |
815 | case LTT_UINT_FIXED: |
816 | case LTT_POINTER: |
817 | case LTT_CHAR: |
818 | case LTT_UCHAR: |
819 | case LTT_SHORT: |
820 | case LTT_USHORT: |
821 | case LTT_INT: |
822 | case LTT_UINT: |
823 | case LTT_LONG: |
824 | case LTT_ULONG: |
825 | case LTT_SIZE_T: |
826 | case LTT_SSIZE_T: |
827 | case LTT_OFF_T: |
828 | case LTT_FLOAT: |
829 | case LTT_ENUM: |
830 | if(field->fixed_root == FIELD_VARIABLE) { |
831 | /* Align offset on type size */ |
743e50fd |
832 | *offset += ltt_align(*offset, get_alignment(field), |
833 | fac->alignment); |
f104d082 |
834 | /* remember offset */ |
835 | field->offset_root = *offset; |
836 | /* Increment offset */ |
837 | *offset += field->field_size; |
743e50fd |
838 | } else { |
839 | //g_debug("type before offset : %llu %llu %u\n", *offset, |
840 | // field->offset_root, |
841 | // field->field_size); |
842 | *offset = field->offset_root; |
843 | *offset += field->field_size; |
844 | //g_debug("type after offset : %llu\n", *offset); |
f104d082 |
845 | } |
f104d082 |
846 | break; |
847 | case LTT_STRING: |
848 | if(field->fixed_root == FIELD_VARIABLE) { |
849 | field->offset_root = *offset; |
850 | } |
851 | *offset += strlen((gchar*)(root+*offset)) + 1; |
743e50fd |
852 | /* Realign the data */ |
853 | *offset += ltt_align(*offset, fac->pointer_size, |
854 | fac->alignment); |
f104d082 |
855 | break; |
856 | case LTT_ARRAY: |
857 | g_assert(type->fields->len == 1); |
858 | { |
859 | off_t local_offset; |
860 | LttField *child = &g_array_index(type->fields, LttField, 0); |
861 | if(field->fixed_root == FIELD_VARIABLE) { |
743e50fd |
862 | *offset += ltt_align(*offset, get_alignment(field), |
863 | fac->alignment); |
f104d082 |
864 | /* remember offset */ |
865 | field->offset_root = *offset; |
866 | field->array_offset = *offset; |
867 | } |
868 | |
869 | if(field->field_size != 0) { |
870 | /* Increment offset */ |
871 | /* field_size is the array size in bytes */ |
872 | *offset = field->offset_root + field->field_size; |
873 | } else { |
874 | guint i; |
875 | *offset = field->array_offset; |
876 | field->dynamic_offsets = g_array_set_size(field->dynamic_offsets, |
877 | 0); |
878 | for(i=0; i<type->size; i++) { |
879 | g_array_append_val(field->dynamic_offsets, *offset); |
743e50fd |
880 | compute_fields_offsets(tf, fac, child, offset, root); |
f104d082 |
881 | } |
882 | } |
883 | // local_offset = field->array_offset; |
884 | // /* Set the offset at position 0 */ |
743e50fd |
885 | // compute_fields_offsets(tf, fac, child, &local_offset, root); |
2312de30 |
886 | } |
887 | break; |
f104d082 |
888 | case LTT_SEQUENCE: |
889 | g_assert(type->fields->len == 2); |
890 | { |
891 | off_t local_offset; |
892 | LttField *child; |
893 | guint i; |
743e50fd |
894 | guint num_elem; |
f104d082 |
895 | if(field->fixed_root == FIELD_VARIABLE) { |
743e50fd |
896 | *offset += ltt_align(*offset, get_alignment(field), |
897 | fac->alignment); |
f104d082 |
898 | /* remember offset */ |
899 | field->offset_root = *offset; |
900 | |
901 | child = &g_array_index(type->fields, LttField, 0); |
743e50fd |
902 | compute_fields_offsets(tf, fac, child, offset, root); |
f104d082 |
903 | child = &g_array_index(type->fields, LttField, 1); |
743e50fd |
904 | *offset += ltt_align(*offset, get_alignment(child), |
905 | fac->alignment); |
f104d082 |
906 | field->array_offset = *offset; |
907 | |
908 | } else { |
909 | child = &g_array_index(type->fields, LttField, 1); |
910 | } |
911 | *offset = field->array_offset; |
912 | field->dynamic_offsets = g_array_set_size(field->dynamic_offsets, |
913 | 0); |
743e50fd |
914 | num_elem = ltt_event_field_element_number(&tf->event, field); |
915 | for(i=0; i<num_elem; i++) { |
f104d082 |
916 | g_array_append_val(field->dynamic_offsets, *offset); |
743e50fd |
917 | compute_fields_offsets(tf, fac, child, offset, root); |
f104d082 |
918 | } |
743e50fd |
919 | g_assert(num_elem == field->dynamic_offsets->len); |
920 | |
921 | /* Realign the data */ |
922 | *offset += ltt_align(*offset, fac->pointer_size, |
923 | fac->alignment); |
924 | |
f104d082 |
925 | // local_offset = field->array_offset; |
926 | // /* Set the offset at position 0 */ |
743e50fd |
927 | // compute_fields_offsets(tf, fac, child, &local_offset, root); |
f104d082 |
928 | } |
929 | break; |
930 | case LTT_STRUCT: |
931 | { |
932 | LttField *child; |
933 | guint i; |
934 | gint ret=0; |
935 | if(field->fixed_root == FIELD_VARIABLE) { |
743e50fd |
936 | *offset += ltt_align(*offset, get_alignment(fac, field), |
937 | fac->alignment); |
f104d082 |
938 | /* remember offset */ |
939 | field->offset_root = *offset; |
940 | } else { |
941 | *offset = field->offset_root; |
942 | } |
943 | for(i=0; i<type->fields->len; i++) { |
944 | child = &g_array_index(type->fields, LttField, i); |
743e50fd |
945 | compute_fields_offsets(tf, fac, child, offset, root); |
f104d082 |
946 | } |
947 | } |
948 | break; |
949 | case LTT_UNION: |
950 | { |
951 | LttField *child; |
952 | guint i; |
953 | gint ret=0; |
954 | if(field->fixed_root == FIELD_VARIABLE) { |
743e50fd |
955 | *offset += ltt_align(*offset, get_alignment(field), |
956 | fac->alignment); |
f104d082 |
957 | /* remember offset */ |
958 | field->offset_root = *offset; |
959 | } |
960 | for(i=0; i<type->fields->len; i++) { |
961 | *offset = field->offset_root; |
962 | child = &g_array_index(type->fields, LttField, i); |
743e50fd |
963 | compute_fields_offsets(tf, fac, child, offset, root); |
f104d082 |
964 | } |
965 | *offset = field->offset_root + field->field_size; |
966 | } |
967 | break; |
968 | case LTT_NONE: |
969 | default: |
970 | g_error("compute_fields_offsets : unknown type"); |
971 | } |
972 | |
973 | } |
eed2ef37 |
974 | |
975 | |
f104d082 |
976 | /***************************************************************************** |
977 | *Function name |
978 | * compute_offsets : set the dynamically computable offsets of an event type |
979 | *Input params |
980 | * tf : tracefile |
981 | * event : event type |
982 | * |
983 | ****************************************************************************/ |
743e50fd |
984 | void compute_offsets(LttTracefile *tf, LttFacility *fac, |
985 | LttEventType *event, off_t *offset, void *root) |
f104d082 |
986 | { |
987 | guint i; |
f104d082 |
988 | |
989 | /* compute all variable offsets */ |
990 | for(i=0; i<event->fields->len; i++) { |
743e50fd |
991 | //g_debug("computing offset %u of %u\n", i, event->fields->len-1); |
f104d082 |
992 | LttField *field = &g_array_index(event->fields, LttField, i); |
743e50fd |
993 | compute_fields_offsets(tf, fac, field, offset, root); |
f104d082 |
994 | } |
995 | |
996 | } |
997 | |