1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Xiangxiu Yang
3 * 2006 Mathieu Desnoyers
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.
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.
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.
29 #include <asm/types.h>
34 #include "ltt-private.h"
35 #include <ltt/event.h>
36 #include <ltt/trace.h>
37 #include <ltt/ltt-types.h>
41 void compute_fields_offsets(LttTracefile
*tf
,
42 LttFacility
*fac
, LttField
*field
, off_t
*offset
, void *root
);
45 LttEvent
*ltt_event_new()
47 return g_new(LttEvent
, 1);
50 void ltt_event_destroy(LttEvent
*event
)
56 /*****************************************************************************
58 * ltt_event_eventtype_id: get event type id
59 * (base id + position of the event)
61 * e : an instance of an event type
63 * unsigned : event type id
64 ****************************************************************************/
66 unsigned ltt_event_eventtype_id(const LttEvent
*e
)
68 return (unsigned) e
->event_id
;
71 /*****************************************************************************
73 * ltt_event_facility : get the facility of the event
75 * e : an instance of an event type
77 * LttFacility * : the facility of the event
78 ****************************************************************************/
80 LttFacility
*ltt_event_facility(const LttEvent
*e
)
82 LttTrace
* trace
= e
->tracefile
->trace
;
83 unsigned id
= e
->facility_id
;
84 LttFacility
*facility
= ltt_trace_facility_by_id(trace
,id
);
86 g_assert(facility
->exists
);
91 /*****************************************************************************
93 * ltt_event_facility_id : get the facility id of the event
95 * e : an instance of an event type
97 * unsigned : the facility of the event
98 ****************************************************************************/
100 unsigned ltt_event_facility_id(const LttEvent
*e
)
102 return e
->facility_id
;
105 /*****************************************************************************
107 * ltt_event_eventtype : get the event type of the event
109 * e : an instance of an event type
111 * LttEventType * : the event type of the event
112 ****************************************************************************/
114 LttEventType
*ltt_event_eventtype(const LttEvent
*e
)
116 LttFacility
* facility
= ltt_event_facility(e
);
117 if(!facility
) return NULL
;
118 return &g_array_index(facility
->events
, LttEventType
, e
->event_id
);
122 /*****************************************************************************
124 * ltt_event_time : get the time of the event
126 * e : an instance of an event type
128 * LttTime : the time of the event
129 ****************************************************************************/
131 LttTime
ltt_event_time(const LttEvent
*e
)
133 return e
->event_time
;
136 /*****************************************************************************
138 * ltt_event_time : get the cycle count of the event
140 * e : an instance of an event type
142 * LttCycleCount : the cycle count of the event
143 ****************************************************************************/
145 LttCycleCount
ltt_event_cycle_count(const LttEvent
*e
)
152 /*****************************************************************************
154 * ltt_event_position_get : get the event position data
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
162 ****************************************************************************/
163 void ltt_event_position_get(LttEventPosition
*ep
, LttTracefile
**tf
,
164 guint
*block
, guint
*offset
, guint64
*tsc
)
168 *offset
= ep
->offset
;
173 /*****************************************************************************
175 * ltt_event_position : get the event's position
177 * e : an instance of an event type
178 * ep : a pointer to event's position structure
179 ****************************************************************************/
181 void ltt_event_position(LttEvent
*e
, LttEventPosition
*ep
)
183 ep
->tracefile
= e
->tracefile
;
184 ep
->block
= e
->block
;
185 ep
->offset
= e
->offset
;
189 LttEventPosition
* ltt_event_position_new()
191 return g_new(LttEventPosition
, 1);
195 /*****************************************************************************
197 * ltt_event_position_compare : compare two positions
198 * A NULL value is infinite.
200 * ep1 : a pointer to event's position structure
201 * ep2 : a pointer to event's position structure
206 ****************************************************************************/
209 gint
ltt_event_position_compare(const LttEventPosition
*ep1
,
210 const LttEventPosition
*ep2
)
212 if(ep1
== NULL
&& ep2
== NULL
)
214 if(ep1
!= NULL
&& ep2
== NULL
)
216 if(ep1
== NULL
&& ep2
!= NULL
)
219 if(ep1
->tracefile
!= ep2
->tracefile
)
220 g_error("ltt_event_position_compare on different tracefiles makes no sense");
222 if(ep1
->block
< ep2
->block
)
224 if(ep1
->block
> ep2
->block
)
226 if(ep1
->offset
< ep2
->offset
)
228 if(ep1
->offset
> ep2
->offset
)
233 /*****************************************************************************
235 * ltt_event_position_copy : copy position
237 * src : a pointer to event's position structure source
238 * dest : a pointer to event's position structure dest
241 ****************************************************************************/
242 void ltt_event_position_copy(LttEventPosition
*dest
,
243 const LttEventPosition
*src
)
253 LttTracefile
*ltt_event_position_tracefile(LttEventPosition
*ep
)
255 return ep
->tracefile
;
258 /*****************************************************************************
260 * ltt_event_cpu_i: get the cpu id where the event happens
262 * e : an instance of an event type
264 * unsigned : the cpu id
265 ****************************************************************************/
267 unsigned ltt_event_cpu_id(LttEvent
*e
)
269 return e
->tracefile
->cpu_num
;
272 /*****************************************************************************
274 * ltt_event_data : get the raw data for the event
276 * e : an instance of an event type
278 * void * : pointer to the raw data for the event
279 ****************************************************************************/
281 void *ltt_event_data(LttEvent
*e
)
286 /*****************************************************************************
288 * ltt_event_field_element_number
289 * : The number of elements in a sequence field is specific
290 * to each event. This function returns the number of
291 * elements for an array or sequence field in an event.
293 * e : an instance of an event type
294 * f : a field of the instance
296 * unsigned : the number of elements for an array/sequence field
297 ****************************************************************************/
298 guint64
ltt_event_field_element_number(LttEvent
*e
, LttField
*f
)
300 if(f
->field_type
.type_class
!= LTT_ARRAY
&&
301 f
->field_type
.type_class
!= LTT_SEQUENCE
)
304 if(f
->field_type
.type_class
== LTT_ARRAY
)
305 return f
->field_type
.size
;
306 return ltt_event_get_long_unsigned(e
, &g_array_index(f
->field_type
.fields
,
310 /*****************************************************************************
312 * ltt_event_field_element_select
313 * : Set the currently selected element for a sequence or
315 * O(1) because of offset array.
317 * e : an instance of an event type
318 * f : a field of the instance
319 * i : the ith element (0, ...)
320 *returns : the child field, at the right index, updated.
321 ****************************************************************************/
322 LttField
*ltt_event_field_element_select(LttEvent
*e
, LttField
*f
, gulong i
)
324 gulong element_number
;
328 LttEventType
*event_type
;
331 if(f
->field_type
.type_class
!= LTT_ARRAY
&&
332 f
->field_type
.type_class
!= LTT_SEQUENCE
)
335 element_number
= ltt_event_field_element_number(e
,f
);
336 event_type
= ltt_event_eventtype(e
);
337 /* Sanity check for i : 0..n-1 only, and must be lower or equal element_number
339 if(i
>= element_number
) return NULL
;
341 if(f
->field_type
.type_class
== LTT_ARRAY
) {
342 field
= &g_array_index(f
->field_type
.fields
, LttField
, 0);
344 field
= &g_array_index(f
->field_type
.fields
, LttField
, 1);
347 if(field
->field_size
!= 0) {
348 if(f
->array_offset
+ (i
* field
->field_size
) == field
->offset_root
)
349 return field
; /* fixed length child, already at the right offset */
351 new_offset
= f
->array_offset
+ (i
* field
->field_size
);
353 /* Var. len. child */
354 new_offset
= g_array_index(f
->dynamic_offsets
, off_t
, i
);
356 compute_fields_offsets(e
->tracefile
,
357 ltt_event_facility(e
), field
, &new_offset
, e
->data
);
363 off_t
ltt_event_field_offset(LttEvent
*e
, LttField
*f
)
365 return f
->offset_root
;
370 /*****************************************************************************
371 * These functions extract data from an event after architecture specific
373 ****************************************************************************/
374 guint32
ltt_event_get_unsigned(LttEvent
*e
, LttField
*f
)
376 gboolean reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
378 switch(f
->field_size
) {
381 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
386 return (guint32
)ltt_get_uint16(reverse_byte_order
, e
->data
+ f
->offset_root
);
389 return (guint32
)ltt_get_uint32(reverse_byte_order
, e
->data
+ f
->offset_root
);
393 g_critical("ltt_event_get_unsigned : field size %i unknown", f
->field_size
);
399 gint32
ltt_event_get_int(LttEvent
*e
, LttField
*f
)
401 gboolean reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
403 switch(f
->field_size
) {
406 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
411 return (gint32
)ltt_get_int16(reverse_byte_order
, e
->data
+ f
->offset_root
);
414 return (gint32
)ltt_get_int32(reverse_byte_order
, e
->data
+ f
->offset_root
);
418 g_critical("ltt_event_get_int : field size %i unknown", f
->field_size
);
424 guint64
ltt_event_get_long_unsigned(LttEvent
*e
, LttField
*f
)
426 gboolean reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
428 switch(f
->field_size
) {
431 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
436 return (guint64
)ltt_get_uint16(reverse_byte_order
, e
->data
+ f
->offset_root
);
439 return (guint64
)ltt_get_uint32(reverse_byte_order
, e
->data
+ f
->offset_root
);
442 return ltt_get_uint64(reverse_byte_order
, e
->data
+ f
->offset_root
);
445 g_critical("ltt_event_get_long_unsigned : field size %i unknown", f
->field_size
);
451 gint64
ltt_event_get_long_int(LttEvent
*e
, LttField
*f
)
453 gboolean reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
455 switch(f
->field_size
) {
458 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
463 return (gint64
)ltt_get_int16(reverse_byte_order
, e
->data
+ f
->offset_root
);
466 return (gint64
)ltt_get_int32(reverse_byte_order
, e
->data
+ f
->offset_root
);
469 return ltt_get_int64(reverse_byte_order
, e
->data
+ f
->offset_root
);
472 g_critical("ltt_event_get_long_int : field size %i unknown", f
->field_size
);
478 float ltt_event_get_float(LttEvent
*e
, LttField
*f
)
480 g_assert(LTT_HAS_FLOAT(e
->tracefile
));
481 gboolean reverse_byte_order
= LTT_GET_FLOAT_BO(e
->tracefile
);
483 g_assert(f
->field_type
.type_class
== LTT_FLOAT
&& f
->field_size
== 4);
485 if(reverse_byte_order
== 0) return *(float *)(e
->data
+ f
->offset_root
);
487 void *ptr
= e
->data
+ f
->offset_root
;
488 guint32 value
= bswap_32(*(guint32
*)ptr
);
489 return *(float*)&value
;
493 double ltt_event_get_double(LttEvent
*e
, LttField
*f
)
495 g_assert(LTT_HAS_FLOAT(e
->tracefile
));
496 gboolean reverse_byte_order
= LTT_GET_FLOAT_BO(e
->tracefile
);
498 if(f
->field_size
== 4)
499 return ltt_event_get_float(e
, f
);
501 g_assert(f
->field_type
.type_class
== LTT_FLOAT
&& f
->field_size
== 8);
503 if(reverse_byte_order
== 0) return *(double *)(e
->data
+ f
->offset_root
);
505 void *ptr
= e
->data
+ f
->offset_root
;
506 guint64 value
= bswap_64(*(guint64
*)ptr
);
507 return *(double*)&value
;
511 /*****************************************************************************
512 * The string obtained is only valid until the next read from
513 * the same tracefile.
514 ****************************************************************************/
515 char *ltt_event_get_string(LttEvent
*e
, LttField
*f
)
517 g_assert(f
->field_type
.type_class
== LTT_STRING
);
519 return (gchar
*)g_strdup((gchar
*)(e
->data
+ f
->offset_root
));
522 /*****************************************************************************
524 * compute_fields_offsets : set the precomputable offset of the fields
528 * offset : pointer to the current offset, must be incremented
529 ****************************************************************************/
532 void compute_fields_offsets(LttTracefile
*tf
,
533 LttFacility
*fac
, LttField
*field
, off_t
*offset
, void *root
)
535 LttType
*type
= &field
->field_type
;
537 switch(type
->type_class
) {
554 if(field
->fixed_root
== FIELD_VARIABLE
) {
555 /* Align offset on type size */
556 *offset
+= ltt_align(*offset
, get_alignment(field
),
558 /* remember offset */
559 field
->offset_root
= *offset
;
560 /* Increment offset */
561 *offset
+= field
->field_size
;
563 //g_debug("type before offset : %llu %llu %u\n", *offset,
564 // field->offset_root,
565 // field->field_size);
566 *offset
= field
->offset_root
;
567 *offset
+= field
->field_size
;
568 //g_debug("type after offset : %llu\n", *offset);
572 if(field
->fixed_root
== FIELD_VARIABLE
) {
573 field
->offset_root
= *offset
;
575 *offset
+= strlen((gchar
*)(root
+*offset
)) + 1;
576 /* Realign the data */
577 *offset
+= ltt_align(*offset
, fac
->pointer_size
,
581 g_assert(type
->fields
->len
== 1);
584 LttField
*child
= &g_array_index(type
->fields
, LttField
, 0);
585 if(field
->fixed_root
== FIELD_VARIABLE
) {
586 *offset
+= ltt_align(*offset
, get_alignment(field
),
588 /* remember offset */
589 field
->offset_root
= *offset
;
590 field
->array_offset
= *offset
;
593 if(field
->field_size
!= 0) {
594 /* Increment offset */
595 /* field_size is the array size in bytes */
596 *offset
= field
->offset_root
+ field
->field_size
;
599 *offset
= field
->array_offset
;
600 field
->dynamic_offsets
= g_array_set_size(field
->dynamic_offsets
,
602 for(i
=0; i
<type
->size
; i
++) {
603 g_array_append_val(field
->dynamic_offsets
, *offset
);
604 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
607 // local_offset = field->array_offset;
608 // /* Set the offset at position 0 */
609 // compute_fields_offsets(tf, fac, child, &local_offset, root);
613 g_assert(type
->fields
->len
== 2);
619 if(field
->fixed_root
== FIELD_VARIABLE
) {
620 *offset
+= ltt_align(*offset
, get_alignment(field
),
622 /* remember offset */
623 field
->offset_root
= *offset
;
625 child
= &g_array_index(type
->fields
, LttField
, 0);
626 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
627 child
= &g_array_index(type
->fields
, LttField
, 1);
628 *offset
+= ltt_align(*offset
, get_alignment(child
),
630 field
->array_offset
= *offset
;
633 child
= &g_array_index(type
->fields
, LttField
, 1);
635 *offset
= field
->array_offset
;
636 field
->dynamic_offsets
= g_array_set_size(field
->dynamic_offsets
,
638 num_elem
= ltt_event_field_element_number(&tf
->event
, field
);
639 for(i
=0; i
<num_elem
; i
++) {
640 g_array_append_val(field
->dynamic_offsets
, *offset
);
641 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
643 g_assert(num_elem
== field
->dynamic_offsets
->len
);
645 /* Realign the data */
646 *offset
+= ltt_align(*offset
, fac
->pointer_size
,
649 // local_offset = field->array_offset;
650 // /* Set the offset at position 0 */
651 // compute_fields_offsets(tf, fac, child, &local_offset, root);
659 if(field
->fixed_root
== FIELD_VARIABLE
) {
660 *offset
+= ltt_align(*offset
, get_alignment(fac
, field
),
662 /* remember offset */
663 field
->offset_root
= *offset
;
665 *offset
= field
->offset_root
;
667 for(i
=0; i
<type
->fields
->len
; i
++) {
668 child
= &g_array_index(type
->fields
, LttField
, i
);
669 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
678 if(field
->fixed_root
== FIELD_VARIABLE
) {
679 *offset
+= ltt_align(*offset
, get_alignment(field
),
681 /* remember offset */
682 field
->offset_root
= *offset
;
684 for(i
=0; i
<type
->fields
->len
; i
++) {
685 *offset
= field
->offset_root
;
686 child
= &g_array_index(type
->fields
, LttField
, i
);
687 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
689 *offset
= field
->offset_root
+ field
->field_size
;
694 g_error("compute_fields_offsets : unknown type");
700 /*****************************************************************************
702 * compute_offsets : set the dynamically computable offsets of an event type
707 ****************************************************************************/
708 void compute_offsets(LttTracefile
*tf
, LttFacility
*fac
,
709 LttEventType
*event
, off_t
*offset
, void *root
)
713 /* compute all variable offsets */
714 for(i
=0; i
<event
->fields
->len
; i
++) {
715 //g_debug("computing offset %u of %u\n", i, event->fields->len-1);
716 LttField
*field
= &g_array_index(event
->fields
, LttField
, i
);
717 compute_fields_offsets(tf
, fac
, field
, offset
, root
);