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