/* set the offset of the fields belonging to the event,
need the information of the archecture */
void set_fields_offsets(LttTracefile *tf, LttEventType *event_type);
-size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
+//size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
/* get the size of the field type according to
* The facility size information. */
enum field_status *fixed_root, enum field_status *fixed_parent,
LttField *field);
-
-static inline size_t get_field_type_size(LttTracefile *tf,
- LttEventType *event_type,
- off_t offset_root, off_t offset_parent,
- LttField *field, void *data);
-
-
/* map a fixed size or a block information from the file (fd) */
static gint map_block(LttTracefile * tf, guint block_num);
/* go to the next event */
static int ltt_seek_next_event(LttTracefile *tf);
+void ltt_update_event_size(LttTracefile *tf);
+
#if 0
/* Functions to parse system.xml file (using glib xml parser) */
static void parser_start_element (GMarkupParseContext __UNUSED__ *context,
des->description = g_strdup(text);
}
#endif //0
-static inline LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
+LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
guint num)
{
g_assert(num < t->facilities_by_num->len);
tf->block_size = header->buf_size;
tf->num_blocks = tf->file_size / tf->block_size;
- vfree(tf->buffer.head);
+ munmap(tf->buffer.head, sizeof(struct ltt_block_start_header));
tf->buffer.head = NULL;
//read the first block
}
+GData *ltt_trace_get_tracefiles_groups(LttTrace *trace)
+{
+ return trace->tracefiles;
+}
+
+
+void compute_tracefile_group(GArray *group,
+ struct compute_tracefile_group_args args)
+{
+ int i;
+ LttTracefile *tf;
+
+ for(i=0; i<group->len; i++) {
+ tf = &g_array_index (group, LttTracefile, i);
+ if(tf->cpu_online)
+ args.func(tf, args.func_args);
+ }
+}
+
+
void ltt_tracefile_group_destroy(gpointer data)
{
GArray *group = (GArray *)data;
fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id);
fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->pointer_size);
- fac->size_t_size = ltt_get_uin32(LTT_GET_BO(tf),
+ fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->size_t_size);
fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->alignment);
fac->trace = tf->trace;
fac->exists = 1;
- fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name, fac->name);
+ fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
+ fac->name);
if(fac_ids == NULL) {
fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
g_datalist_id_set_data_full(&tf->trace->facilities_by_name,
fac->name = g_quark_from_string(fac_name);
fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->checksum);
- fac->id = ltt_get_uint8(LTT_GET_BO(tf), &fac_load_data->id);
+ fac->id = fac_load_data->id;
fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->pointer_size);
- fac->size_t_size = ltt_get_uin32(LTT_GET_BO(tf),
+ fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->size_t_size);
fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
&fac_load_data->alignment);
return time;
}
+
+/* Get the current event of the tracefile : valid until the next read */
+LttEvent *ltt_tracefile_get_event(LttTracefile *tf)
+{
+ return &tf->event;
+}
+
+
+
/*****************************************************************************
*Function name
* ltt_tracefile_read : Read the next event in the tracefile
LttEvent *event;
event = &tf->event;
- pos = event->offset;
+ pos = tf->buffer.head + event->offset;
/* Read event header */
pos += sizeof(guint32);
}
- event->facility_id = ltt_get_uint8(LTT_GET_BO(tf),
- pos);
+ event->facility_id = *(guint8*)pos;
pos += sizeof(guint8);
- event->event_id = ltt_get_uint8(LTT_GET_BO(tf),
- pos);
+ event->event_id = *(guint8*)pos;
pos += sizeof(guint8);
event->data = pos;
+ /* get the data size and update the event fields with the current
+ * information */
+ ltt_update_event_size(tf);
+
return 0;
}
* it means that the event read must get the first event. */
tf->event.tracefile = tf;
tf->event.block = block_num;
- tf->event.offset = tf->buffer.head;
+ tf->event.offset = 0;
return 0;
}
-ssize_t ltt_get_event_size(LttTracefile *tf)
+/* It will update the fields offsets too */
+void ltt_update_event_size(LttTracefile *tf)
{
ssize_t size = 0;
/* Specific handling of core events : necessary to read the facility control
* tracefile. */
- if(unlikely(tf->event.facility_id == LTT_FACILITY_CORE)) {
- switch((enum ltt_core_events)tf->event.event_id) {
- case LTT_EVENT_FACILITY_LOAD:
- size = sizeof(struct LttFacilityLoad);
- break;
- case LTT_EVENT_FACILITY_UNLOAD:
- size = sizeof(struct LttFacilityUnload);
- break;
- case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
- size = sizeof(struct LttStateDumpFacilityLoad);
- break;
- case LTT_EVENT_HEARTBEAT:
- size = sizeof(TimeHeartbeat);
- break;
- default:
- g_warning("Error in getting event size : tracefile %s, "
- "unknown event id %hhu in core facility.",
- g_quark_to_string(tf->name),
- tf->event.event_id);
- goto event_id_error;
+ LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
+ tf->event.facility_id);
- }
+ if(unlikely(f == NULL)) {
+ if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) {
+ switch((enum ltt_core_events)tf->event.event_id) {
+ case LTT_EVENT_FACILITY_LOAD:
+ size = sizeof(struct LttFacilityLoad);
+ break;
+ case LTT_EVENT_FACILITY_UNLOAD:
+ size = sizeof(struct LttFacilityUnload);
+ break;
+ case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
+ size = sizeof(struct LttStateDumpFacilityLoad);
+ break;
+ case LTT_EVENT_HEARTBEAT:
+ size = sizeof(TimeHeartbeat);
+ break;
+ default:
+ g_warning("Error in getting event size : tracefile %s, "
+ "unknown event id %hhu in core facility.",
+ g_quark_to_string(tf->name),
+ tf->event.event_id);
+ goto event_id_error;
+ }
+ }
} else {
- LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
- tf->event.facility_id);
LttEventType *event_type =
ltt_facility_eventtype_get(f, tf->event.event_id);
- size = get_fields_offsets(tf, event_type, tf->event.data);
+ size = get_field_type_size(tf, event_type,
+ 0, 0, event_type->root_field, tf->event.data);
}
-
- return size;
+ tf->event.data_size = size;
+
+ return;
+
event_id_error:
- return -1;
+ tf->event.data_size = 0;
}
ssize_t event_size;
/* seek over the buffer header if we are at the buffer start */
- if(tf->event.offset == tf->buffer.head) {
+ if(tf->event.offset == 0) {
tf->event.offset += sizeof(struct ltt_block_start_header);
goto found;
}
- if(tf->event.offset == tf->buffer.head + tf->buffer.lost_size) {
+ if(tf->event.offset == tf->buffer.lost_size) {
ret = ERANGE;
goto found;
}
pos = tf->event.data;
- event_size = ltt_get_event_size(tf);
- if(event_size < 0) goto error;
+ if(tf->event.data_size < 0) goto error;
- pos += (size_t)event_size;
+ pos += (size_t)tf->event.data_size;
- tf->event.offset = pos;
+ tf->event.offset = pos - tf->buffer.head;
found:
return ret;
/*****************************************************************************
*Function name
- * get_field_type_size : set the fixed and dynamic sizes of the field type
- * from the data read.
+ * check_fields_compatibility : Check for compatibility between two fields :
+ * do they use the same inner structure ?
*Input params
- * tf : tracefile
- * event_type : event type
- * offset_root : offset from the root
- * offset_parent : offset from the parent
- * field : field
- * data : a pointer to the event data.
- *Returns the field type size.
+ * event_type1 : event type
+ * event_type2 : event type
+ * field1 : field
+ * field2 : field
+ *Returns : 0 if identical
+ * 1 if not.
****************************************************************************/
-size_t get_field_type_size(LttTracefile *tf, LttEventType *event_type,
- off_t offset_root, off_t offset_parent,
- LttField *field, void *data)
+gint check_fields_compatibility(LttEventType *event_type1,
+ LttEventType *event_type2,
+ LttField *field1, LttField *field2)
{
- size_t size = 0;
+ guint different = 0;
+ enum field_status local_fixed_root, local_fixed_parent;
guint i;
- LttType *type;
+ LttType *type1;
+ LttType *type2;
- g_assert(field->fixed_root != FIELD_UNKNOWN);
- g_assert(field->fixed_parent != FIELD_UNKNOWN);
- g_assert(field->fixed_size != FIELD_UNKNOWN);
-
- field->offset_root = offset_root;
- field->offset_parent = offset_parent;
+ if(field1 == NULL) {
+ if(field2 == NULL) goto end;
+ else {
+ different = 1;
+ goto end;
+ }
+ } else if(field2 == NULL) {
+ different = 1;
+ goto end;
+ }
- type = field->field_type;
+ g_assert(field1->fixed_root != FIELD_UNKNOWN);
+ g_assert(field2->fixed_root != FIELD_UNKNOWN);
+ g_assert(field1->fixed_parent != FIELD_UNKNOWN);
+ g_assert(field2->fixed_parent != FIELD_UNKNOWN);
+ g_assert(field1->fixed_size != FIELD_UNKNOWN);
+ g_assert(field2->fixed_size != FIELD_UNKNOWN);
- switch(type->type_class) {
+ type1 = field1->field_type;
+ type2 = field2->field_type;
+
+ size_t current_root_offset;
+ size_t current_offset;
+ enum field_status current_child_status, final_child_status;
+ size_t max_size;
+
+ if(type1->type_class != type2->type_class) {
+ different = 1;
+ goto end;
+ }
+ if(type1->element_name != type2->element_name) {
+ different = 1;
+ goto end;
+ }
+
+ switch(type1->type_class) {
case LTT_INT:
case LTT_UINT:
case LTT_FLOAT:
- case LTT_ENUM:
case LTT_POINTER:
case LTT_LONG:
case LTT_ULONG:
case LTT_SIZE_T:
case LTT_SSIZE_T:
case LTT_OFF_T:
- g_assert(field->fixed_size == FIELD_FIXED);
- size = field->field_size;
+ if(field1->field_size != field2->field_size) {
+ different = 1;
+ goto end;
+ }
+ break;
+ case LTT_ENUM:
+ if(type1->element_number != type2->element_number) {
+ different = 1;
+ goto end;
+ }
+ for(i=0;i<type1->element_number;i++) {
+ if(type1->enum_strings[i] != type2->enum_strings[i]) {
+ different = 1;
+ goto end;
+ }
+ }
break;
case LTT_SEQUENCE:
- {
- gint seqnum = ltt_get_uint(LTT_GET_BO(tf),
- field->sequ_number_size,
- data + offset_root);
-
- if(field->child[0]->fixed_size == FIELD_FIXED) {
- size = field->sequ_number_size +
- (seqnum * get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data));
- } else {
- size += field->sequ_number_size;
- for(i=0;i<seqnum;i++) {
- size_t child_size;
- child_size = get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data);
- offset_root += child_size;
- offset_parent += child_size;
- size += child_size;
- }
+ /* Two elements : size and child */
+ g_assert(type1->element_number != type2->element_number);
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- field->field_size = size;
}
break;
case LTT_STRING:
- size = strlen((char*)(data+offset_root)) + 1;// length + \0
- field->field_size = size;
break;
case LTT_ARRAY:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- for(i=0;i<field->field_type->element_number;i++) {
- size_t child_size;
- child_size = get_field_type_size(tf, event_type,
- offset_root, offset_parent,
- field->child[0], data);
- offset_root += child_size;
- offset_parent += child_size;
- size += child_size;
- }
- field->field_size = size;
+ if(field1->field_size != field2->field_size) {
+ different = 1;
+ goto end;
}
- break;
- case LTT_STRUCT:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- size_t current_root_offset = offset_root;
- size_t current_offset = 0;
- size_t child_size = 0;
- for(i=0;i<type->element_number;i++) {
- child_size = get_field_type_size(tf,
- event_type, current_root_offset, current_offset,
- field->child[i], data);
- current_offset += child_size;
- current_root_offset += child_size;
-
+ /* Two elements : size and child */
+ g_assert(type1->element_number != type2->element_number);
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- size = current_offset;
- field->field_size = size;
}
break;
+ case LTT_STRUCT:
case LTT_UNION:
- if(field->fixed_size == FIELD_FIXED)
- size = field->field_size;
- else {
- size_t current_root_offset = field->offset_root;
- size_t current_offset = 0;
- for(i=0;i<type->element_number;i++) {
- size = get_field_type_size(tf, event_type,
- current_root_offset, current_offset,
- field->child[i], data);
- size = max(size, field->child[i]->field_size);
+ if(type1->element_number != type2->element_number) {
+ different = 1;
+ break;
+ }
+ for(i=0;i<type1->element_number;i++) {
+ if(check_fields_compatibility(event_type1, event_type2,
+ field1->child[0], field2->child[0])) {
+ different = 1;
+ goto end;
}
- field->field_size = size;
}
break;
}
-
- return size;
+end:
+ return different;
}
+
#if 0
/*****************************************************************************
*Function name
/*****************************************************************************
*Function name
- * get_int : get an integer number
+ * ltt_get_int : get an integer number
*Input params
* reverse_byte_order: must we reverse the byte order ?
* size : the size of the integer
* gint64 : a 64 bits integer
****************************************************************************/
-gint64 get_int(gboolean reverse_byte_order, gint size, void *data)
+gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data)
{
gint64 val;
/*****************************************************************************
*Function name
- * get_uint : get an unsigned integer number
+ * ltt_get_uint : get an unsigned integer number
*Input params
* reverse_byte_order: must we reverse the byte order ?
* size : the size of the integer
* guint64 : a 64 bits unsigned integer
****************************************************************************/
-guint64 get_uint(gboolean reverse_byte_order, gint size, void *data)
+guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data)
{
guint64 val;
projects / lttv.git / blobdiff