*/
#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
#include <asm/types.h>
#include <linux/byteorder/swab.h>
#include "ltt-private.h"
#include <ltt/event.h>
#include <ltt/trace.h>
+#include <ltt/ltt-types.h>
LttEvent *ltt_event_new()
* offsetParent : offset from the parent
* fld : field
* evD : event data
+ * reverse_byte_order : 1 or 0
*Return value
* int : size of the field
****************************************************************************/
int ltt_event_refresh_fields(int offsetRoot,int offsetParent,
- LttField * fld, void *evD)
+ LttField * fld, void *evD, gboolean reverse_byte_order)
{
int size, size1, element_number, i, offset1, offset2;
LttType * type = fld->field_type;
+ switch(type->type_class) {
+ case LTT_ARRAY:
+ element_number = (int) type->element_number;
+ if(fld->field_fixed == 0){// has string or sequence
+ size = 0;
+ for(i=0;i<element_number;i++){
+ size += ltt_event_refresh_fields(offsetRoot+size,size,
+ fld->child[0], evD+size, reverse_byte_order);
+ }
+ }else size = fld->field_size;
+ break;
+
+ case LTT_SEQUENCE:
+ size1 = fld->sequ_number_size;
+ element_number = getIntNumber(reverse_byte_order,size1,evD);
+ type->element_number = element_number;
+ if(fld->element_size > 0){
+ size = element_number * fld->element_size;
+ }else{//sequence has string or sequence
+ size = 0;
+ for(i=0;i<element_number;i++){
+ size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
+ fld->child[0], evD+size+size1, reverse_byte_order);
+ }
+ size += size1;
+ }
+ break;
+
+ case LTT_STRING:
+ size = strlen((gchar*)evD) + 1; //include end : '\0'
+ break;
+
+ case LTT_STRUCT:
+ element_number = (int) type->element_number;
+ if(fld->field_fixed == 0){
+ offset1 = offsetRoot;
+ offset2 = 0;
+ for(i=0;i<element_number;i++){
+ size=ltt_event_refresh_fields(offset1,offset2,
+ fld->child[i],evD+offset2, reverse_byte_order);
+ offset1 += size;
+ offset2 += size;
+ }
+ size = offset2;
+ }else size = fld->field_size;
+ break;
+
+ case LTT_UNION:
+ size = fld->field_size;
+ break;
+
+ default:
+ size = fld->field_size;
+ }
+
+#if 0
if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
size = fld->field_size;
if(fld->field_fixed == 0){// has string or sequence
size = 0;
for(i=0;i<element_number;i++){
- size += ltt_event_refresh_fields(offsetRoot+size,size,
+ size += ltt_event_refresh_fields(offsetRoot+size,size,
fld->child[0], evD+size);
- }
+ }
}else size = fld->field_size;
}else if(type->type_class == LTT_SEQUENCE){
size1 = fld->sequ_number_size;
}else{//sequence has string or sequence
size = 0;
for(i=0;i<element_number;i++){
- size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
- fld->child[0], evD+size+size1);
+ size += ltt_event_refresh_fields(offsetRoot+size+size1,size+size1,
+ fld->child[0], evD+size+size1);
}
size += size1;
}
offset1 = offsetRoot;
offset2 = 0;
for(i=0;i<element_number;i++){
- size=ltt_event_refresh_fields(offset1,offset2,fld->child[i],evD+offset2);
- offset1 += size;
- offset2 += size;
+ size=ltt_event_refresh_fields(offset1,offset2,
+ fld->child[i],evD+offset2);
+ offset1 += size;
+ offset2 += size;
}
size = offset2;
}else size = fld->field_size;
}
-
+#endif //0
fld->offset_root = offsetRoot;
fld->offset_parent = offsetParent;
fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
{
LttField * field;
LttEventType * event_type = ltt_event_eventtype(e);
- if(!event_type) return NULL;
+ if(unlikely(!event_type)) return NULL;
field = event_type->root_field;
- if(!field) return NULL;
+ if(unlikely(!field)) return NULL;
//check if the field need refresh
- if(e->which_block != event_type->latest_block ||
- e->which_event != event_type->latest_event){
+ if(likely(e->which_block != event_type->latest_block ||
+ e->which_event != event_type->latest_event)){
event_type->latest_block = e->which_block;
event_type->latest_event = e->which_event;
- if(field->field_fixed == 1)return field;
-
- //refresh the field
- ltt_event_refresh_fields(0, 0, field, e->data);
+ if(unlikely(field->field_fixed != 1))
+ ltt_event_refresh_fields(0, 0, field, e->data,
+ e->tracefile->trace->reverse_byte_order);
}
return field;
}
ep->old_position = TRUE;
ep->event_offset = e->data - e->tracefile->buffer - EVENT_HEADER_SIZE ;
ep->tf = e->tracefile;
-
+ ep->overflow_nsec = e->overflow_nsec;
/* This is a workaround for fast position seek */
ep->last_event_pos = e->last_event_pos;
ep->prev_block_end_time = e->prev_block_end_time;
ep->prev_event_time = e->prev_event_time;
ep->pre_cycle_count = e->pre_cycle_count;
ep->count = e->count;
+ ep->last_heartbeat = e->last_heartbeat;
+
/* end of workaround */
}
/*****************************************************************************
*Function name
* ltt_event_position_set : set the block number and index of the event
+ * It does put the old_position gboolean to FALSE, as it is impossible
+ * to know the quick position to seek in the tracefile.
*Input params
* ep : a pointer to event's position structure
* block_number : the block number of the event
void ltt_event_position_set(LttEventPosition *ep,
unsigned block_number, unsigned index_in_block)
{
+ if(ep->block_num != block_number || ep->event_num != index_in_block)
+ ep->old_position = FALSE;
+
ep->block_num = block_number;
- ep->event_num = index_in_block;
+ ep->event_num = index_in_block;
+
}
/*****************************************************************************
unsigned ltt_event_cpu_id(LttEvent *e)
{
- char * c1, * c2, * c3;
+ gchar * c1, * c2, * c3;
c1 = strrchr(e->tracefile->name,'\\');
c2 = strrchr(e->tracefile->name,'/');
if(c1 == NULL && c2 == NULL){
if(f->field_type->type_class == LTT_ARRAY)
return f->field_type->element_number;
- return (unsigned) getIntNumber(f->sequ_number_size, e + f->offset_root);
+ return (unsigned) getIntNumber(e->tracefile->trace->reverse_byte_order,
+ f->sequ_number_size, e + f->offset_root);
}
/*****************************************************************************
{
unsigned element_number;
LttField *fld;
- int k, size;
+ unsigned int k;
+ int size;
void *evD;
if(f->field_type->type_class != LTT_ARRAY &&
return ;
element_number = ltt_event_field_element_number(e,f);
- if((element_number-1) < i || i < 0) return;
+ /* Sanity check for i : 1..n only, and must be lower or equal element_number
+ */
+ if(element_number < i || i == 0) return;
fld = f->child[0];
evD = e->data + f->offset_root;
size = 0;
for(k=0;k<i;k++){
- size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size);
+ size += ltt_event_refresh_fields(f->offset_root+size,size, fld, evD+size,
+ e->tracefile->trace->reverse_byte_order);
}
-
f->current_element = i - 1;
}
* conversions
****************************************************************************/
-unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
+guint32 ltt_event_get_unsigned(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
+
LttTypeEnum t = f->field_type->type_class;
g_assert(t == LTT_UINT || t == LTT_ENUM);
if(f->field_size == 1){
guint8 x = *(guint8 *)(e->data + f->offset_root);
- return (unsigned int) x;
+ return (guint32) x;
}else if(f->field_size == 2){
- guint16 x = *(guint16 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (unsigned int) (revFlag ? GUINT16_FROM_BE(x): x);
- else
- return (unsigned int) (revFlag ? GUINT16_FROM_LE(x): x);
+ return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 4){
- guint32 x = *(guint32 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (unsigned int) (revFlag ? GUINT32_FROM_BE(x): x);
- else
- return (unsigned int) (revFlag ? GUINT32_FROM_LE(x): x);
- }else if(f->field_size == 8){
+ return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
+ }
+#if 0
+ else if(f->field_size == 8){
guint64 x = *(guint64 *)(e->data + f->offset_root);
if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
return (unsigned int) (revFlag ? GUINT64_FROM_BE(x): x);
else
return (unsigned int) (revFlag ? GUINT64_FROM_LE(x): x);
}
+#endif //0
+ g_critical("ltt_event_get_unsigned : field size %i unknown", f->field_size);
+ return 0;
}
-int ltt_event_get_int(LttEvent *e, LttField *f)
+gint32 ltt_event_get_int(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
g_assert(f->field_type->type_class == LTT_INT);
if(f->field_size == 1){
gint8 x = *(gint8 *)(e->data + f->offset_root);
- return (int) x;
+ return (gint32) x;
}else if(f->field_size == 2){
- gint16 x = *(gint16 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (int) (revFlag ? GINT16_FROM_BE(x): x);
- else
- return (int) (revFlag ? GINT16_FROM_LE(x): x);
+ return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 4){
- gint32 x = *(gint32 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (int) (revFlag ? GINT32_FROM_BE(x): x);
- else
- return (int) (revFlag ? GINT32_FROM_LE(x): x);
- }else if(f->field_size == 8){
+ return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
+ }
+#if 0
+ else if(f->field_size == 8){
gint64 x = *(gint64 *)(e->data + f->offset_root);
if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
return (int) (revFlag ? GINT64_FROM_BE(x): x);
else
return (int) (revFlag ? GINT64_FROM_LE(x): x);
}
+#endif //0
+ g_critical("ltt_event_get_int : field size %i unknown", f->field_size);
+ return 0;
}
-unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
+guint64 ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
LttTypeEnum t = f->field_type->type_class;
g_assert(t == LTT_UINT || t == LTT_ENUM);
if(f->field_size == 1){
guint8 x = *(guint8 *)(e->data + f->offset_root);
- return (unsigned long) x;
+ return (guint64) x;
}else if(f->field_size == 2){
- guint16 x = *(guint16 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (unsigned long) (revFlag ? GUINT16_FROM_BE(x): x);
- else
- return (unsigned long) (revFlag ? GUINT16_FROM_LE(x): x);
+ return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 4){
- guint32 x = *(guint32 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (unsigned long) (revFlag ? GUINT32_FROM_BE(x): x);
- else
- return (unsigned long) (revFlag ? GUINT32_FROM_LE(x): x);
+ return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 8){
- guint64 x = *(guint64 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (unsigned long) (revFlag ? GUINT64_FROM_BE(x): x);
- else
- return (unsigned long) (revFlag ? GUINT64_FROM_LE(x): x);
+ return ltt_get_uint64(reverse_byte_order, e->data + f->offset_root);
}
+ g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->field_size);
+ return 0;
}
-long int ltt_event_get_long_int(LttEvent *e, LttField *f)
+gint64 ltt_event_get_long_int(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
g_assert( f->field_type->type_class == LTT_INT);
if(f->field_size == 1){
gint8 x = *(gint8 *)(e->data + f->offset_root);
- return (long) x;
+ return (gint64) x;
}else if(f->field_size == 2){
- gint16 x = *(gint16 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (long) (revFlag ? GINT16_FROM_BE(x): x);
- else
- return (long) (revFlag ? GINT16_FROM_LE(x): x);
+ return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 4){
- gint32 x = *(gint32 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (long) (revFlag ? GINT32_FROM_BE(x): x);
- else
- return (long) (revFlag ? GINT32_FROM_LE(x): x);
+ return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset_root);
}else if(f->field_size == 8){
- gint64 x = *(gint64 *)(e->data + f->offset_root);
- if(e->tracefile->trace->my_arch_endian == LTT_LITTLE_ENDIAN)
- return (long) (revFlag ? GINT64_FROM_BE(x): x);
- else
- return (long) (revFlag ? GINT64_FROM_LE(x): x);
+ return ltt_get_int64(reverse_byte_order, e->data + f->offset_root);
}
+ g_critical("ltt_event_get_long_int : field size %i unknown", f->field_size);
+ return 0;
}
float ltt_event_get_float(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 4);
- if(revFlag == 0) return *(float *)(e->data + f->offset_root);
+ if(reverse_byte_order == 0) return *(float *)(e->data + f->offset_root);
else{
guint32 aInt;
memcpy((void*)&aInt, e->data + f->offset_root, 4);
aInt = ___swab32(aInt);
- return *((float*)&aInt);
+ return ((float)aInt);
}
}
double ltt_event_get_double(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->trace->my_arch_endian ==
- e->tracefile->trace->system_description->endian ? 0:1;
+ gboolean reverse_byte_order = e->tracefile->trace->reverse_byte_order;
+ //int revFlag = e->tracefile->trace->my_arch_endian ==
+ // e->tracefile->trace->system_description->endian ? 0:1;
g_assert(f->field_type->type_class == LTT_FLOAT && f->field_size == 8);
- if(revFlag == 0) return *(double *)(e->data + f->offset_root);
+ if(reverse_byte_order == 0) return *(double *)(e->data + f->offset_root);
else{
guint64 aInt;
memcpy((void*)&aInt, e->data + f->offset_root, 8);
aInt = ___swab64(aInt);
- return *((double *)&aInt);
+ return ((double)aInt);
}
}
{
g_assert(f->field_type->type_class == LTT_STRING);
- return (char*)g_strdup((char*)(e->data + f->offset_root));
+ return (gchar*)g_strdup((gchar*)(e->data + f->offset_root));
}
projects / lttv.git / blobdiff