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