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
;
377 if(unlikely(f
->field_type
.network
)) {
378 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
380 reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
383 switch(f
->field_size
) {
386 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
391 return (guint32
)ltt_get_uint16(reverse_byte_order
, e
->data
+ f
->offset_root
);
394 return (guint32
)ltt_get_uint32(reverse_byte_order
, e
->data
+ f
->offset_root
);
398 g_critical("ltt_event_get_unsigned : field size %i unknown", f
->field_size
);
404 gint32
ltt_event_get_int(LttEvent
*e
, LttField
*f
)
406 gboolean reverse_byte_order
;
407 if(unlikely(f
->field_type
.network
)) {
408 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
410 reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
413 switch(f
->field_size
) {
416 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
421 return (gint32
)ltt_get_int16(reverse_byte_order
, e
->data
+ f
->offset_root
);
424 return (gint32
)ltt_get_int32(reverse_byte_order
, e
->data
+ f
->offset_root
);
428 g_critical("ltt_event_get_int : field size %i unknown", f
->field_size
);
434 guint64
ltt_event_get_long_unsigned(LttEvent
*e
, LttField
*f
)
436 gboolean reverse_byte_order
;
437 if(unlikely(f
->field_type
.network
)) {
438 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
440 reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
443 switch(f
->field_size
) {
446 guint8 x
= *(guint8
*)(e
->data
+ f
->offset_root
);
451 return (guint64
)ltt_get_uint16(reverse_byte_order
, e
->data
+ f
->offset_root
);
454 return (guint64
)ltt_get_uint32(reverse_byte_order
, e
->data
+ f
->offset_root
);
457 return ltt_get_uint64(reverse_byte_order
, e
->data
+ f
->offset_root
);
460 g_critical("ltt_event_get_long_unsigned : field size %i unknown", f
->field_size
);
466 gint64
ltt_event_get_long_int(LttEvent
*e
, LttField
*f
)
468 gboolean reverse_byte_order
;
469 if(unlikely(f
->field_type
.network
)) {
470 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
472 reverse_byte_order
= LTT_GET_BO(e
->tracefile
);
475 switch(f
->field_size
) {
478 gint8 x
= *(gint8
*)(e
->data
+ f
->offset_root
);
483 return (gint64
)ltt_get_int16(reverse_byte_order
, e
->data
+ f
->offset_root
);
486 return (gint64
)ltt_get_int32(reverse_byte_order
, e
->data
+ f
->offset_root
);
489 return ltt_get_int64(reverse_byte_order
, e
->data
+ f
->offset_root
);
492 g_critical("ltt_event_get_long_int : field size %i unknown", f
->field_size
);
498 float ltt_event_get_float(LttEvent
*e
, LttField
*f
)
500 gboolean reverse_byte_order
;
501 if(unlikely(f
->field_type
.network
)) {
502 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
504 g_assert(LTT_HAS_FLOAT(e
->tracefile
));
505 reverse_byte_order
= LTT_GET_FLOAT_BO(e
->tracefile
);
508 g_assert(f
->field_type
.type_class
== LTT_FLOAT
&& f
->field_size
== 4);
510 if(reverse_byte_order
== 0) return *(float *)(e
->data
+ f
->offset_root
);
512 void *ptr
= e
->data
+ f
->offset_root
;
513 guint32 value
= bswap_32(*(guint32
*)ptr
);
514 return *(float*)&value
;
518 double ltt_event_get_double(LttEvent
*e
, LttField
*f
)
520 gboolean reverse_byte_order
;
521 if(unlikely(f
->field_type
.network
)) {
522 reverse_byte_order
= (g_ntohs(0x1) != 0x1);
524 g_assert(LTT_HAS_FLOAT(e
->tracefile
));
525 reverse_byte_order
= LTT_GET_FLOAT_BO(e
->tracefile
);
528 if(f
->field_size
== 4)
529 return ltt_event_get_float(e
, f
);
531 g_assert(f
->field_type
.type_class
== LTT_FLOAT
&& f
->field_size
== 8);
533 if(reverse_byte_order
== 0) return *(double *)(e
->data
+ f
->offset_root
);
535 void *ptr
= e
->data
+ f
->offset_root
;
536 guint64 value
= bswap_64(*(guint64
*)ptr
);
537 return *(double*)&value
;
541 /*****************************************************************************
542 * The string obtained is only valid until the next read from
543 * the same tracefile.
544 ****************************************************************************/
545 char *ltt_event_get_string(LttEvent
*e
, LttField
*f
)
547 g_assert(f
->field_type
.type_class
== LTT_STRING
);
549 return (gchar
*)g_strdup((gchar
*)(e
->data
+ f
->offset_root
));
552 /*****************************************************************************
554 * compute_fields_offsets : set the precomputable offset of the fields
558 * offset : pointer to the current offset, must be incremented
559 ****************************************************************************/
562 void compute_fields_offsets(LttTracefile
*tf
,
563 LttFacility
*fac
, LttField
*field
, off_t
*offset
, void *root
)
565 LttType
*type
= &field
->field_type
;
567 switch(type
->type_class
) {
584 if(field
->fixed_root
== FIELD_VARIABLE
) {
585 /* Align offset on type size */
586 *offset
+= ltt_align(*offset
, get_alignment(field
),
588 /* remember offset */
589 field
->offset_root
= *offset
;
590 /* Increment offset */
591 *offset
+= field
->field_size
;
593 //g_debug("type before offset : %llu %llu %u\n", *offset,
594 // field->offset_root,
595 // field->field_size);
596 *offset
= field
->offset_root
;
597 *offset
+= field
->field_size
;
598 //g_debug("type after offset : %llu\n", *offset);
602 if(field
->fixed_root
== FIELD_VARIABLE
) {
603 field
->offset_root
= *offset
;
605 *offset
+= strlen((gchar
*)(root
+*offset
)) + 1;
606 /* Realign the data */
607 *offset
+= ltt_align(*offset
, fac
->pointer_size
,
611 g_assert(type
->fields
->len
== 1);
614 LttField
*child
= &g_array_index(type
->fields
, LttField
, 0);
615 if(field
->fixed_root
== FIELD_VARIABLE
) {
616 *offset
+= ltt_align(*offset
, get_alignment(field
),
618 /* remember offset */
619 field
->offset_root
= *offset
;
620 field
->array_offset
= *offset
;
623 if(field
->field_size
!= 0) {
624 /* Increment offset */
625 /* field_size is the array size in bytes */
626 *offset
= field
->offset_root
+ field
->field_size
;
629 *offset
= field
->array_offset
;
630 field
->dynamic_offsets
= g_array_set_size(field
->dynamic_offsets
,
632 for(i
=0; i
<type
->size
; i
++) {
633 g_array_append_val(field
->dynamic_offsets
, *offset
);
634 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
637 // local_offset = field->array_offset;
638 // /* Set the offset at position 0 */
639 // compute_fields_offsets(tf, fac, child, &local_offset, root);
643 g_assert(type
->fields
->len
== 2);
649 if(field
->fixed_root
== FIELD_VARIABLE
) {
650 *offset
+= ltt_align(*offset
, get_alignment(field
),
652 /* remember offset */
653 field
->offset_root
= *offset
;
655 child
= &g_array_index(type
->fields
, LttField
, 0);
656 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
657 child
= &g_array_index(type
->fields
, LttField
, 1);
658 *offset
+= ltt_align(*offset
, get_alignment(child
),
660 field
->array_offset
= *offset
;
663 child
= &g_array_index(type
->fields
, LttField
, 1);
665 *offset
= field
->array_offset
;
666 field
->dynamic_offsets
= g_array_set_size(field
->dynamic_offsets
,
668 num_elem
= ltt_event_field_element_number(&tf
->event
, field
);
669 for(i
=0; i
<num_elem
; i
++) {
670 g_array_append_val(field
->dynamic_offsets
, *offset
);
671 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
673 g_assert(num_elem
== field
->dynamic_offsets
->len
);
675 /* Realign the data */
676 *offset
+= ltt_align(*offset
, fac
->pointer_size
,
679 // local_offset = field->array_offset;
680 // /* Set the offset at position 0 */
681 // compute_fields_offsets(tf, fac, child, &local_offset, root);
689 if(field
->fixed_root
== FIELD_VARIABLE
) {
690 *offset
+= ltt_align(*offset
, get_alignment(fac
, field
),
692 /* remember offset */
693 field
->offset_root
= *offset
;
695 *offset
= field
->offset_root
;
697 for(i
=0; i
<type
->fields
->len
; i
++) {
698 child
= &g_array_index(type
->fields
, LttField
, i
);
699 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
708 if(field
->fixed_root
== FIELD_VARIABLE
) {
709 *offset
+= ltt_align(*offset
, get_alignment(field
),
711 /* remember offset */
712 field
->offset_root
= *offset
;
714 for(i
=0; i
<type
->fields
->len
; i
++) {
715 *offset
= field
->offset_root
;
716 child
= &g_array_index(type
->fields
, LttField
, i
);
717 compute_fields_offsets(tf
, fac
, child
, offset
, root
);
719 *offset
= field
->offset_root
+ field
->field_size
;
724 g_error("compute_fields_offsets : unknown type");
730 /*****************************************************************************
732 * compute_offsets : set the dynamically computable offsets of an event type
737 ****************************************************************************/
738 void compute_offsets(LttTracefile
*tf
, LttFacility
*fac
,
739 LttEventType
*event
, off_t
*offset
, void *root
)
743 /* compute all variable offsets */
744 for(i
=0; i
<event
->fields
->len
; i
++) {
745 //g_debug("computing offset %u of %u\n", i, event->fields->len-1);
746 LttField
*field
= &g_array_index(event
->fields
, LttField
, i
);
747 compute_fields_offsets(tf
, fac
, field
, offset
, root
);