-#ifndef TRACEFILE_H
-#define TRACEFILE_H
+#ifndef TRACE_H
+#define TRACE_H
#include <ltt/ltt.h>
/* The characteristics of the system on which the trace was obtained
is described in a LttSystemDescription structure. */
-typedef struct _LttSystemDescription {
+struct _LttSystemDescription {
char *description;
char *node_name;
- char *domainname;
+ char *domain_name;
unsigned nb_cpu;
LttArchSize size;
LttArchEndian endian;
unsigned ltt_block_size;
LttTime trace_start;
LttTime trace_end;
-} LttSystemDescription;
+};
-LttSystemDescription *ltt_trace_system_description(LttTrace *t)
+LttSystemDescription *ltt_trace_system_description(LttTrace *t);
/* Functions to discover the facilities in the trace. Once the number
#ifndef TYPE_H
#define TYPE_H
-#include <ltt/ltt.h>
-
/* Different types allowed */
LTT_SEQUENCE, LTT_STRUCT, LTT_UNION
} LttTypeEnum;
+#include <ltt/ltt.h>
+
/* All event types, data types and fields belong to their trace and
are released at the same time. */
LttTypeEnum ltt_type_class(LttType *t);
-unsigned ltt_type_size(LttTracefile *tf, LttType *t);
+unsigned ltt_type_size(LttTrace *trace, LttType *t);
/* The type of nested elements for arrays and sequences. */
#include <stdio.h>
#include <asm/types.h>
#include <linux/byteorder/swab.h>
-
#include <ltt/LTTTypes.h>
#include "parser.h"
#include <ltt/event.h>
/*****************************************************************************
*Function name
- * ltt_facility_eventtype_id: get event type id
- * (base id + position of the event)
+ * ltt_event_eventtype_id: get event type id
+ * (base id + position of the event)
*Input params
- * e : an instance of an event type
+ * e : an instance of an event type
*Return value
- * unsigned : event type id
+ * unsigned : event type id
****************************************************************************/
-unsigned ltt_event_eventtype_id(ltt_event *e)
+unsigned ltt_event_eventtype_id(LttEvent *e)
{
return (unsigned) e->event_id;
}
*Input params
* e : an instance of an event type
*Return value
- * ltt_facility * : the facility of the event
+ * LttFacility * : the facility of the event
****************************************************************************/
-ltt_facility *ltt_event_facility(ltt_event *e)
+LttFacility *ltt_event_facility(LttEvent *e)
{
- ltt_eventtype * evT;
- ptr_wrap * ptr;
- ptr = (ptr_wrap*)g_ptr_array_index(e->tracefile->eventtype_event_id,
- (gint)(e->event_id));
- evT = (ltt_eventtype*)(ptr->ptr);
-
- if(!evT) return NULL;
- return evT->facility;
+ LttTrace * trace = e->tracefile->trace;
+ unsigned id = e->event_id;
+ return ltt_trace_facility_by_id(trace,id);
}
/*****************************************************************************
*Input params
* e : an instance of an event type
*Return value
- * ltt_eventtype * : the event type of the event
+ * LttEventType * : the event type of the event
****************************************************************************/
-ltt_eventtype *ltt_event_eventtype(ltt_event *e)
+LttEventType *ltt_event_eventtype(LttEvent *e)
{
- ptr_wrap * ptr;
- ptr = (ptr_wrap*)g_ptr_array_index(e->tracefile->eventtype_event_id,
- (gint)(e->event_id));
- return (ltt_eventtype*)(ptr->ptr);
+ LttFacility* facility = ltt_event_facility(e);
+ if(!facility) return NULL;
+ return facility->events[e->event_id - facility->base_id];
}
/*****************************************************************************
*Function name
- * ltt_event_time : get the time of the event
+ * ltt_event_field : get the root field of the event
*Input params
- * e : an instance of an event type
+ * e : an instance of an event type
*Return value
- * ltt_time : the time of the event
+ * LttField * : the root field of the event
****************************************************************************/
-ltt_time ltt_event_time(ltt_event *e)
+LttField *ltt_event_field(LttEvent *e)
{
- return getEventTime(e->tracefile);
+ LttEventType * event_type = ltt_event_eventtype(e);
+ if(!event_type) return NULL;
+ return event_type->root_field;
}
/*****************************************************************************
*Function name
- * ltt_event_time : get the cycle count of the event
+ * ltt_event_time : get the time of the event
*Input params
* e : an instance of an event type
*Return value
- * ltt_time : the cycle count of the event
+ * LttTime : the time of the event
****************************************************************************/
-ltt_cycle_count ltt_event_cycle_count(ltt_event *e)
+LttTime ltt_event_time(LttEvent *e)
{
- return e->cycle_count;
+ return e->event_time;
}
/*****************************************************************************
*Function name
- * ltt_event_cpu_i: get the cpu id where the event happens
+ * ltt_event_time : get the cycle count of the event
*Input params
* e : an instance of an event type
*Return value
- * unsigned : the cpu id
+ * LttCycleCount : the cycle count of the event
****************************************************************************/
-unsigned ltt_event_cpu_id(ltt_event *e)
+LttCycleCount ltt_event_cycle_count(LttEvent *e)
{
- return e->tracefile->trace_header->cpu_id;
+ return e->event_cycle_count;
}
/*****************************************************************************
*Function name
- * ltt_event_cpu_i: get the name of the system where the event happens
+ * ltt_event_cpu_i: get the cpu id where the event happens
*Input params
* e : an instance of an event type
*Return value
- * char * : the name of the system
+ * unsigned : the cpu id
****************************************************************************/
-char *ltt_event_system_name(ltt_event *e)
-{
- return e->tracefile->trace_header->system_name;
+unsigned ltt_event_cpu_id(LttEvent *e)
+{
+ return (unsigned)atoi(e->tracefile->name);
}
/*****************************************************************************
* void * : pointer to the raw data for the event
****************************************************************************/
-void *ltt_event_data(ltt_event *e)
+void *ltt_event_data(LttEvent *e)
{
return e->data;
}
* unsigned : the number of elements for an array/sequence field
****************************************************************************/
-unsigned ltt_event_field_element_number(ltt_event *e, ltt_field *f)
+unsigned ltt_event_field_element_number(LttEvent *e, LttField *f)
{
if(f->field_type->type_class != LTT_ARRAY &&
f->field_type->type_class != LTT_SEQUENCE)
* e : an instance of an event type ????
* f : a field of the instance
* i : the ith element
- *Return value
- * int : ???? error number
****************************************************************************/
-int ltt_event_field_element_select(ltt_event *e, ltt_field *f, unsigned i)
+void ltt_event_field_element_select(LttEvent *e, LttField *f, unsigned i)
{
if(f->field_type->type_class != LTT_ARRAY &&
f->field_type->type_class != LTT_SEQUENCE)
- return -1; //?????
+ return ;
- if(f->field_type->element_number < i || i == 0) return -1; //????
+ if(f->field_type->element_number < i || i == 0) return;
f->current_element = i - 1;
- return 0;
}
/*****************************************************************************
* conversions
****************************************************************************/
-unsigned ltt_event_get_unsigned(ltt_event *e, ltt_field *f)
+unsigned ltt_event_get_unsigned(LttEvent *e, LttField *f)
{
- ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
- ltt_type_enum t = f->field_type->type_class;
+ LttArchSize rSize = e->tracefile->trace->system_description->size;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
+ LttTypeEnum t = f->field_type->type_class;
if(t != LTT_UINT || t != LTT_ENUM)
g_error("The type of the field is not unsigned int\n");
}
}
-int ltt_event_get_int(ltt_event *e, ltt_field *f)
+int ltt_event_get_int(LttEvent *e, LttField *f)
{
- ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
+ LttArchSize rSize = e->tracefile->trace->system_description->size;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
if(f->field_type->type_class != LTT_INT)
g_error("The type of the field is not int\n");
}
}
-unsigned long ltt_event_get_long_unsigned(ltt_event *e, ltt_field *f)
+unsigned long ltt_event_get_long_unsigned(LttEvent *e, LttField *f)
{
- ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
- ltt_type_enum t = f->field_type->type_class;
+ LttArchSize rSize = e->tracefile->trace->system_description->size;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
+ LttTypeEnum t = f->field_type->type_class;
if(t != LTT_UINT || t != LTT_ENUM)
g_error("The type of the field is not unsigned long\n");
}
}
-long int ltt_event_get_long_int(ltt_event *e, ltt_field *f)
+long int ltt_event_get_long_int(LttEvent *e, LttField *f)
{
- ltt_arch_size rSize = e->tracefile->trace_header->arch_size;
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
+ LttArchSize rSize = e->tracefile->trace->system_description->size;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
if( f->field_type->type_class != LTT_INT)
g_error("The type of the field is not long int\n");
}
}
-float ltt_event_get_float(ltt_event *e, ltt_field *f)
+float ltt_event_get_float(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
if(f->field_type->type_class != LTT_FLOAT ||
(f->field_type->type_class == LTT_FLOAT && f->field_size != 4))
}
}
-double ltt_event_get_double(ltt_event *e, ltt_field *f)
+double ltt_event_get_double(LttEvent *e, LttField *f)
{
- int revFlag = e->tracefile->my_arch_endian ==
- e->tracefile->trace_header->arch_endian ? 0:1;
+ int revFlag = e->tracefile->trace->my_arch_endian ==
+ e->tracefile->trace->system_description->endian ? 0:1;
if(f->field_type->type_class != LTT_FLOAT ||
(f->field_type->type_class == LTT_FLOAT && f->field_size != 8))
* the same tracefile. ????
****************************************************************************/
-char *ltt_event_get_string(ltt_event *e, ltt_field *f)
+char *ltt_event_get_string(LttEvent *e, LttField *f)
{
if(f->field_type->type_class != LTT_STRING)
g_error("The field contains no string\n");
/* search for the (named) type in the table, if it does not exist
create a new one */
-ltt_type * lookup_named_type(ltt_facility *fac, type_descriptor * td);
+LttType * lookup_named_type(LttFacility *fac, type_descriptor * td);
/* construct directed acyclic graph for types, and tree for fields */
-void constructTypeAndFields(ltt_facility * fac,type_descriptor * td,
- ltt_field * fld);
+void constructTypeAndFields(LttFacility * fac,type_descriptor * td,
+ LttField * fld);
/* generate the facility according to the events belongin to it */
-void generateFacility(ltt_facility * facility, char * pathname,
- ltt_checksum checksum, sequence * events);
+void generateFacility(LttFacility * f, facility * fac,
+ LttChecksum checksum);
/* functions to release the memory occupied by a facility */
-void freeFacility(ltt_facility * facility);
-void freeEventtype(ltt_eventtype * evType);
+void freeFacility(LttFacility * facility);
+void freeEventtype(LttEventType * evType);
void freeAllNamedTypes(table * named_types);
void freeAllUnamedTypes(sequence * unnamed_types);
void freeAllFields(sequence * all_fields);
-void freeLttType(ltt_type * type);
-void freeLttField(ltt_field * fld);
+void freeLttType(LttType * type);
+void freeLttField(LttField * fld);
/*****************************************************************************
*Function name
- * ltt_facility_open : open a facility
+ * ltt_facility_open : open facilities
*Input params
+ * t : the trace containing the facilities
* pathname : the path name of the facility
- * c : checksum of the facility registered in kernal
- *Return value
- * ltt_facility* : return a ltt_facility
****************************************************************************/
-ltt_facility * ltt_facility_open(char * pathname, ltt_checksum c)
+void ltt_facility_open(LttTrace * t, char * pathname)
{
char *token;
parse_file in;
char buffer[BUFFER_SIZE];
- ltt_checksum checksum;
- event *ev;
- sequence events;
- table namedTypes;
- sequence unnamedTypes;
- ltt_facility * aFacility = NULL;
-
- sequence_init(&events);
- table_init(&namedTypes);
- sequence_init(&unnamedTypes);
+ facility * fac;
+ LttFacility * f;
+ LttChecksum checksum;
in.buffer = buffer;
in.lineno = 0;
in.error = error_callback;
- in.name = appendString(pathname,".event");
+ in.name = pathname;
in.fp = fopen(in.name, "r");
- if(!in.fp )g_error("cannot open input file: %s\n", in.name);
-
+ if(!in.fp ) in.error(&in,"cannot open input file");
+
while(1){
token = getToken(&in);
if(in.type == ENDFILE) break;
- if(strcmp("event",token) == 0) {
- ev = g_new(event,1);
- sequence_push(&events,ev);
- parseEvent(&in,ev, &unnamedTypes, &namedTypes);
- }
- else if(strcmp("type",token) == 0) {
- parseTypeDefinition(&in, &unnamedTypes, &namedTypes);
+ if(strcmp(token, "<")) in.error(&in,"not a facility file");
+ token = getName(&in);
+
+ if(strcmp("facility",token) == 0) {
+ fac = g_new(facility, 1);
+ fac->name = NULL;
+ fac->description = NULL;
+ sequence_init(&(fac->events));
+ table_init(&(fac->named_types));
+ sequence_init(&(fac->unnamed_types));
+
+ parseFacility(&in, fac);
+
+ //check if any namedType is not defined
+ checkNamedTypesImplemented(&fac->named_types);
+
+ generateChecksum(fac->name, &checksum, &fac->events);
+
+ f = g_new(LttFacility,1);
+ generateFacility(f, fac, checksum);
+
+ t->facility_number++;
+ g_ptr_array_add(t->facilities,f);
+
+ free(fac->name);
+ free(fac->description);
+ freeEvents(&fac->events);
+ sequence_dispose(&fac->events);
+ freeNamedType(&fac->named_types);
+ table_dispose(&fac->named_types);
+ freeTypes(&fac->unnamed_types);
+ sequence_dispose(&fac->unnamed_types);
+ free(fac);
}
- else g_error("event or type token expected\n");
+ else in.error(&in,"facility token was expected");
}
-
fclose(in.fp);
-
- checkNamedTypesImplemented(&namedTypes);
-
- generateChecksum(pathname, &checksum, &events);
-
- //yxx disable during the test
- aFacility = g_new(ltt_facility,1);
- generateFacility(aFacility, pathname, checksum, &events);
-/*
- if(checksum == c){
- aFacility = g_new(ltt_facility,1);
- generateFacility(aFacility, pathname, checksum, &events);
- }else{
- g_error("local facility is different from the one registered in the kernel");
- }
-*/
-
- free(in.name);
- freeEvents(&events);
- sequence_dispose(&events);
- freeNamedType(&namedTypes);
- table_dispose(&namedTypes);
- freeTypes(&unnamedTypes);
- sequence_dispose(&unnamedTypes);
-
- return aFacility;
}
*Function name
* generateFacility : generate facility, internal function
*Input params
- * facility : facilty structure
- * facName : facility name
+ * facility : LttFacilty structure
+ * fac : facility structure
* checksum : checksum of the facility
- * events : sequence of events belonging to the facility
****************************************************************************/
-void generateFacility(ltt_facility * facility, char * pathname,
- ltt_checksum checksum, sequence * events)
+void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum)
{
- char * facilityName;
+ char * facilityName = fac->name;
+ sequence * events = &fac->events;
int i;
- ltt_eventtype * evType;
- ltt_field * field;
- ltt_type * type;
-
- //get the facility name (strip any leading directory)
- facilityName = strrchr(pathname,'/');
- if(facilityName) facilityName++;
- else facilityName = pathname;
+ LttEventType * evType;
+ LttField * field;
+ LttType * type;
- facility->name = g_strdup(facilityName);
- facility->event_number = events->position;
- facility->checksum = checksum;
- facility->usage_count = 0;
+ f->name = g_strdup(facilityName);
+ f->event_number = events->position;
+ f->checksum = checksum;
//initialize inner structures
- facility->events = g_new(ltt_eventtype*,facility->event_number);
- sequence_init(&(facility->all_fields));
- sequence_init(&(facility->all_unnamed_types));
- table_init(&(facility->all_named_types));
+ f->events = g_new(LttEventType*,f->event_number);
+ sequence_init(&(f->all_fields));
+ sequence_init(&(f->all_unnamed_types));
+ table_init(&(f->all_named_types));
//for each event, construct field tree and type graph
for(i=0;i<events->position;i++){
- evType = g_new(ltt_eventtype,1);
- facility->events[i] = evType;
+ evType = g_new(LttEventType,1);
+ f->events[i] = evType;
evType->name = g_strdup(((event*)(events->array[i]))->name);
evType->description=g_strdup(((event*)(events->array[i]))->description);
- field = g_new(ltt_field, 1);
- sequence_push(&(facility->all_fields), field);
+ field = g_new(LttField, 1);
+ sequence_push(&(f->all_fields), field);
evType->root_field = field;
- evType->facility = facility;
+ evType->facility = f;
evType->index = i;
field->field_pos = 0;
- type = lookup_named_type(facility,((event*)(events->array[i]))->type);
+ type = lookup_named_type(f,((event*)(events->array[i]))->type);
field->field_type = type;
field->offset_root = 0;
field->fixed_root = 1;
field->current_element = 0;
//construct field tree and type graph
- constructTypeAndFields(facility,((event*)(events->array[i]))->type,field);
+ constructTypeAndFields(f,((event*)(events->array[i]))->type,field);
}
}
* root_field : root field of the event
****************************************************************************/
-void constructTypeAndFields(ltt_facility * fac,type_descriptor * td,
- ltt_field * fld)
+void constructTypeAndFields(LttFacility * fac,type_descriptor * td,
+ LttField * fld)
{
int i;
type_descriptor * tmpTd;
}else if(td->type == LTT_ARRAY || td->type == LTT_SEQUENCE){
if(td->type == LTT_ARRAY)
fld->field_type->element_number = (unsigned)td->size;
- fld->field_type->element_type = g_new(ltt_type*,1);
+ fld->field_type->element_type = g_new(LttType*,1);
tmpTd = td->nested_type;
fld->field_type->element_type[0] = lookup_named_type(fac, tmpTd);
- fld->child = g_new(ltt_field*, 1);
- fld->child[0] = g_new(ltt_field, 1);
+ fld->child = g_new(LttField*, 1);
+ fld->child[0] = g_new(LttField, 1);
sequence_push(&(fac->all_fields), fld->child[0]);
fld->child[0]->field_pos = 0;
constructTypeAndFields(fac, tmpTd, fld->child[0]);
}else if(td->type == LTT_STRUCT){
fld->field_type->element_number = td->fields.position;
- fld->field_type->element_type = g_new(ltt_type*, td->fields.position);
- fld->child = g_new(ltt_field*, td->fields.position);
+ fld->field_type->element_type = g_new(LttType*, td->fields.position);
+ fld->child = g_new(LttField*, td->fields.position);
for(i=0;i<td->fields.position;i++){
tmpTd = ((field*)(td->fields.array[i]))->type;
fld->field_type->element_type[i] = lookup_named_type(fac, tmpTd);
- fld->child[i] = g_new(ltt_field,1);
+ fld->child[i] = g_new(LttField,1);
sequence_push(&(fac->all_fields), fld->child[i]);
fld->child[i]->field_pos = i;
* fac : facility struct
* td : type descriptor
*Return value
- * : either find the named type, or create a new ltt_type
+ * : either find the named type, or create a new LttType
****************************************************************************/
-ltt_type * lookup_named_type(ltt_facility *fac, type_descriptor * td)
+LttType * lookup_named_type(LttFacility *fac, type_descriptor * td)
{
- ltt_type * lttType = NULL;
+ LttType * lttType = NULL;
int i;
char * name;
if(td->type_name){
for(i=0;i<fac->all_named_types.keys.position;i++){
name = (char *)(fac->all_named_types.keys.array[i]);
if(strcmp(name, td->type_name)==0){
- lttType = (ltt_type*)(fac->all_named_types.values.array[i]);
+ lttType = (LttType*)(fac->all_named_types.values.array[i]);
break;
}
}
}
if(!lttType){
- lttType = g_new(ltt_type,1);
+ lttType = g_new(LttType,1);
lttType->type_class = td->type;
if(td->fmt) lttType->fmt = g_strdup(td->fmt);
else lttType->fmt = NULL;
* int : usage count ?? status
****************************************************************************/
-int ltt_facility_close(ltt_facility *f)
+int ltt_facility_close(LttFacility *f)
{
- // f->usage_count--;
- if(f->usage_count > 0) return f->usage_count;
-
//release the memory it occupied
freeFacility(f);
* Functions to release the memory occupied by the facility
****************************************************************************/
-void freeFacility(ltt_facility * fac)
+void freeFacility(LttFacility * fac)
{
int i;
g_free(fac->name); //free facility name
for(i=0;i<fac->event_number;i++){
freeEventtype(fac->events[i]);
}
+ g_free(fac->events);
//free all named types
freeAllNamedTypes(&(fac->all_named_types));
g_free(fac);
}
-void freeEventtype(ltt_eventtype * evType)
+void freeEventtype(LttEventType * evType)
{
g_free(evType->name);
if(evType->description)
g_free((char*)(named_types->keys.array[i]));
//free type
- freeLttType((ltt_type*)(named_types->values.array[i]));
+ freeLttType((LttType*)(named_types->values.array[i]));
}
table_dispose(named_types);
}
{
int i;
for(i=0;i<unnamed_types->position;i++){
- freeLttType((ltt_type*)(unnamed_types->array[i]));
+ freeLttType((LttType*)(unnamed_types->array[i]));
}
sequence_dispose(unnamed_types);
}
{
int i;
for(i=0;i<all_fields->position;i++){
- freeLttField((ltt_field*)(all_fields->array[i]));
+ freeLttField((LttField*)(all_fields->array[i]));
}
sequence_dispose(all_fields);
}
-void freeLttType(ltt_type * type)
+//only free current type, not child types
+void freeLttType(LttType * type)
{
+ int i;
if(type->element_name)
g_free(type->element_name);
if(type->fmt)
g_free(type->fmt);
- if(type->enum_strings)
+ if(type->enum_strings){
+ for(i=0;i<type->element_number;i++)
+ g_free(type->enum_strings[i]);
g_free(type->enum_strings);
- if(type->element_type)
+ }
+
+ if(type->element_type){
g_free(type->element_type);
+ }
g_free(type);
}
-void freeLttField(ltt_field * fld)
+//only free the current field, not child fields
+void freeLttField(LttField * fld)
{
if(fld->child)
g_free(fld->child);
* char * : the facility's name
****************************************************************************/
-char *ltt_facility_name(ltt_facility *f)
+char *ltt_facility_name(LttFacility *f)
{
return f->name;
}
*Input params
* f : the facility that will be closed
*Return value
- * ltt_checksum : the checksum of the facility
+ * LttChecksum : the checksum of the facility
****************************************************************************/
-ltt_checksum ltt_facility_checksum(ltt_facility *f)
+LttChecksum ltt_facility_checksum(LttFacility *f)
{
return f->checksum;
}
+/*****************************************************************************
+ *Function name
+ * ltt_facility_base_id : obtain the facility base id
+ *Input params
+ * f : the facility
+ *Return value
+ * : the base id of the facility
+ ****************************************************************************/
+
+unsigned ltt_facility_base_id(LttFacility *f)
+{
+ return f->base_id;
+}
+
/*****************************************************************************
*Function name
* ltt_facility_eventtype_number: obtain the number of the event types
* unsigned : the number of the event types
****************************************************************************/
-unsigned ltt_facility_eventtype_number(ltt_facility *f)
+unsigned ltt_facility_eventtype_number(LttFacility *f)
{
return (unsigned)(f->event_number);
}
*Input params
* f : the facility that will be closed
*Return value
- * ltt_eventtype * : the event type required
+ * LttEventType * : the event type required
****************************************************************************/
-ltt_eventtype *ltt_facility_eventtype_get(ltt_facility *f, unsigned i)
+LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i)
{
return f->events[i];
}
* f : the facility that will be closed
* name : the name of the event
*Return value
- * ltt_eventtype * : the event type required
+ * LttEventType * : the event type required
****************************************************************************/
-ltt_eventtype *ltt_facility_eventtype_get_by_name(ltt_facility *f, char *name)
+LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, char *name)
{
int i;
- ltt_eventtype * ev;
+ LttEventType * ev;
for(i=0;i<f->event_number;i++){
ev = f->events[i];
if(strcmp(ev->name, name) == 0)break;
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
-/* This program reads the ".event" event definitions input files
- specified as command line arguments and generates corresponding
- ".c" and ".h" files required to trace such events in the kernel.
+/* This program reads the ".xml" event definitions input files
+ and constructs structure for each event.
The program uses a very simple tokenizer, called from a hand written
recursive descent parser to fill a data structure describing the events.
A table of named types is maintained to allow refering to types by name
when the same type is used at several places. Finally a sequence of
all types is maintained to facilitate the freeing of all type
- information when the processing of an ".event" file is finished. */
+ information when the processing of an ".xml" file is finished. */
#include <stdlib.h>
#include <string.h>
void * memAlloc(int size)
{
- void *addr = malloc(size);
+ void * addr;
+ if(size == 0) return NULL;
+ addr = malloc(size);
if(!addr){
printf("Failed to allocate memory");
exit(1);
char *allocAndCopy(char *str)
{
- char *addr = (char *)memAlloc(strlen(str)+1);
+ char * addr;
+ if(str == NULL) return NULL;
+ addr = (char *)memAlloc(strlen(str)+1);
strcpy(addr,str);
return addr;
}
+/**************************************************************************
+ * Function :
+ * getNameAttribute,getFormatAttribute,getSizeAttribute,getValueAttribute
+ * getValueStrAttribute
+ * Description :
+ * Read the attribute from the input file.
+ *
+ * Parameters :
+ * in , input file handle.
+ *
+ * Return values :
+ * address of the attribute.
+ *
+ **************************************************************************/
+
+char * getNameAttribute(parse_file *in)
+{
+ char * token, car;
+ token = getName(in);
+ if(strcmp("name",token))in->error(in,"name was expected");
+ getEqual(in);
+
+ car = seekNextChar(in);
+ if(car == EOF)in->error(in,"name was expected");
+ else if(car == '\"')token = getQuotedString(in);
+ else token = getName(in);
+ return token;
+}
+
+char * getFormatAttribute(parse_file *in)
+{
+ char * token;
+
+ //format is an option
+ token = getToken(in);
+ if(strcmp("/",token) == 0){
+ ungetToken(in);
+ return NULL;
+ }
+
+ if(strcmp("format",token))in->error(in,"format was expected");
+ getEqual(in);
+ token = getQuotedString(in);
+ return token;
+}
+
+int getSizeAttribute(parse_file *in)
+{
+ char * token;
+ getName(in);
+ getEqual(in);
+
+ return getSize(in);
+}
+
+int getValueAttribute(parse_file *in)
+{
+ char * token;
+ getName(in);
+ getEqual(in);
+
+ return getNumber(in);
+}
+
+//for <label name=label_name value=n/>, value is an option
+char * getValueStrAttribute(parse_file *in)
+{
+ char * token;
+
+ token = getToken(in);
+ if(strcmp("/",token) == 0){
+ ungetToken(in);
+ return NULL;
+ }
+
+ if(strcmp("value",token))in->error(in,"value was expected");
+ getEqual(in);
+ token = getToken(in);
+ if(in->type != NUMBER) in->error(in,"number was expected");
+ return token;
+}
+
+char * getDescription(parse_file *in)
+{
+ long int pos;
+ char * token, car, *str;
+
+ pos = ftell(in->fp);
+
+ getLAnglebracket(in);
+ token = getName(in);
+ if(strcmp("description",token)){
+ fseek(in->fp, pos, SEEK_SET);
+ return NULL;
+ }
+
+ getRAnglebracket(in);
+
+ pos = 0;
+ while((car = getc(in->fp)) != EOF) {
+ if(car == '<') break;
+ if(car == '\0') continue;
+ in->buffer[pos] = car;
+ pos++;
+ }
+ if(car == EOF)in->error(in,"not a valid description");
+ in->buffer[pos] = '\0';
+
+ str = allocAndCopy(in->buffer);
+
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("description", token))in->error(in,"not a valid description");
+ getRAnglebracket(in);
+
+ return str;
+}
+
+/*****************************************************************************
+ *Function name
+ * parseFacility : generate event list
+ *Input params
+ * in : input file handle
+ * fac : empty facility
+ *Output params
+ * fac : facility filled with event list
+ ****************************************************************************/
+
+void parseFacility(parse_file *in, facility * fac)
+{
+ char * token;
+ event *ev;
+
+ fac->name = allocAndCopy(getNameAttribute(in));
+ getRAnglebracket(in);
+
+ fac->description = allocAndCopy(getDescription(in));
+
+ while(1){
+ getLAnglebracket(in);
+
+ token = getToken(in);
+ if(in->type == ENDFILE)
+ in->error(in,"the definition of the facility is not finished");
+
+ if(strcmp("event",token) == 0){
+ ev = (event*) memAlloc(sizeof(event));
+ sequence_push(&(fac->events),ev);
+ parseEvent(in,ev, &(fac->unnamed_types), &(fac->named_types));
+ }else if(strcmp("type",token) == 0){
+ parseTypeDefinition(in, &(fac->unnamed_types), &(fac->named_types));
+ }else if(in->type == FORWARDSLASH){
+ break;
+ }else in->error(in,"event or type token expected\n");
+ }
+
+ token = getName(in);
+ if(strcmp("facility",token)) in->error(in,"not the end of the facility");
+ getRAnglebracket(in); //</facility>
+}
/*****************************************************************************
*Function name
*Input params
* in : input file handle
* ev : new event
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
*Output params
* ev : new event (parameters are passed to it)
****************************************************************************/
char *token;
type_descriptor *t;
- getLParenthesis(in);
- token = getName(in);
- ev->name = allocAndCopy(token);
- getComa(in);
+ //<event name=eventtype_name>
+ ev->name = allocAndCopy(getNameAttribute(in));
+ getRAnglebracket(in);
- token = getQuotedString(in);
- ev->description = allocAndCopy(token);
+ //<description>...</descriptio>
+ ev->description = allocAndCopy(getDescription(in));
- token = getToken(in); //token either is a ',' or a ')'
- if(in->type == COMA) token = getName(in);
- ungetToken(in);
+ //event can have STRUCT, TYPEREF or NOTHING
+ getLAnglebracket(in);
- /* We have a possibly empty list of fields, containing struct implied */
- if((in->type == NAME && strcmp(token,"field") == 0) ||
- in->type == RPARENTHESIS) {
- /* Insert an unnamed struct type */
- t = (type_descriptor *)memAlloc(sizeof(type_descriptor));
- t->type_name = NULL;
- t->type = STRUCT;
- t->fmt = NULL;
- if(in->type == NAME) parseFields(in,t, unnamed_types, named_types);
- else if(in->type == RPARENTHESIS) sequence_init(&(t->fields));
- sequence_push(unnamed_types,t);
- ev->type = t;
- }
-
- /* Or a complete type declaration but it must be a struct */
- else if(in->type == NAME){
- ev->type = parseType(in,NULL, unnamed_types, named_types);
- if(ev->type->type != STRUCT && ev->type->type != NONE) in->error(in,"type must be a struct");
+ token = getToken(in);
+ if(in->type == FORWARDSLASH){ //</event> NOTHING
+ ev->type = NULL;
+ }else if(in->type == NAME){
+ if(strcmp("struct",token)==0 || strcmp("typeref",token)==0){
+ ungetToken(in);
+ ev->type = parseType(in,NULL, unnamed_types, named_types);
+ if(ev->type->type != STRUCT && ev->type->type != NONE)
+ in->error(in,"type must be a struct");
+ }else in->error(in, "not a valid type");
+
+ getLAnglebracket(in);
+ getForwardslash(in);
}else in->error(in,"not a struct type");
- getRParenthesis(in);
- getSemiColon(in);
+ token = getName(in);
+ if(strcmp("event",token))in->error(in,"not an event definition");
+ getRAnglebracket(in); //</event>
}
/*****************************************************************************
*Function name
- * parseField : get field infomation from buffer
+ * parseField : get field infomation from buffer
*Input params
- * in : input file handle
- * t : type descriptor
+ * in : input file handle
+ * t : type descriptor
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
****************************************************************************/
void parseFields(parse_file *in, type_descriptor *t, sequence * unnamed_types,
char * token;
field *f;
- sequence_init(&(t->fields));
+ f = (field *)memAlloc(sizeof(field));
+ sequence_push(&(t->fields),f);
- token = getToken(in);
- while(in->type == NAME && strcmp(token,"field") == 0) {
- f = (field *)memAlloc(sizeof(field));
- sequence_push(&(t->fields),f);
-
- getLParenthesis(in);
- f->name = (char *)allocAndCopy(getName(in));
- getComa(in);
- f->description = (char *)allocAndCopy(getQuotedString(in));
- getComa(in);
- f->type = parseType(in,NULL, unnamed_types, named_types);
- getRParenthesis(in);
-
- token = getToken(in);
- if(in->type == COMA) token = getName(in);
- else ungetToken(in); // no more fields, it must be a ')'
- }
+ //<field name=field_name> <description> <type> </field>
+ f->name = allocAndCopy(getNameAttribute(in));
+ getRAnglebracket(in);
+
+ f->description = allocAndCopy(getDescription(in));
+
+ //<int size=...>
+ getLAnglebracket(in);
+ f->type = parseType(in,NULL, unnamed_types, named_types);
- if(in->type == NAME && strcmp(token,"field") != 0)
- in->error(in,"not a field");
+ getLAnglebracket(in);
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("field",token))in->error(in,"not a valid field definition");
+ getRAnglebracket(in); //</field>
}
*Input params
* in : input file handle
* inType : a type descriptor
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
*Return values
* type_descriptor* : a type descriptor
****************************************************************************/
type_descriptor *parseType(parse_file *in, type_descriptor *inType,
sequence * unnamed_types, table * named_types)
{
- char *token, *car;
+ char *token;
type_descriptor *t;
if(inType == NULL) {
if(strcmp(token,"struct") == 0) {
t->type = STRUCT;
- getLParenthesis(in);
- parseFields(in,t, unnamed_types, named_types);
- getRParenthesis(in);
+ getRAnglebracket(in); //<struct>
+ getLAnglebracket(in); //<field name=..>
+ token = getToken(in);
+ sequence_init(&(t->fields));
+ while(strcmp("field",token) == 0){
+ parseFields(in,t, unnamed_types, named_types);
+
+ //next field
+ getLAnglebracket(in);
+ token = getToken(in);
+ }
+ if(strcmp("/",token))in->error(in,"not a valid structure definition");
+ token = getName(in);
+ if(strcmp("struct",token)!=0)
+ in->error(in,"not a valid structure definition");
+ getRAnglebracket(in); //</struct>
+ }
+ else if(strcmp(token,"union") == 0) {
+ t->type = UNION;
+ t->size = getSizeAttribute(in);
+ getRAnglebracket(in); //<union typecodesize=isize>
+
+ getLAnglebracket(in); //<field name=..>
+ token = getToken(in);
+ sequence_init(&(t->fields));
+ while(strcmp("field",token) == 0){
+ parseFields(in,t, unnamed_types, named_types);
+
+ //next field
+ getLAnglebracket(in);
+ token = getToken(in);
+ }
+ if(strcmp("/",token))in->error(in,"not a valid union definition");
+ token = getName(in);
+ if(strcmp("union",token)!=0)
+ in->error(in,"not a valid union definition");
+ getRAnglebracket(in); //</union>
}
else if(strcmp(token,"array") == 0) {
t->type = ARRAY;
- getLParenthesis(in);
- t->size = getNumber(in);
- getComa(in);
+ t->size = getValueAttribute(in);
+ getRAnglebracket(in); //<array size=n>
+
+ getLAnglebracket(in); //<type struct>
t->nested_type = parseType(in,NULL, unnamed_types, named_types);
- getRParenthesis(in);
+
+ getLAnglebracket(in); //</array>
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("array",token))in->error(in,"not a valid array definition");
+ getRAnglebracket(in); //</array>
}
else if(strcmp(token,"sequence") == 0) {
t->type = SEQUENCE;
- getLParenthesis(in);
- t->size = getSize(in);
- getComa(in);
+ t->size = getSizeAttribute(in);
+ getRAnglebracket(in); //<array lengthsize=isize>
+
+ getLAnglebracket(in); //<type struct>
t->nested_type = parseType(in,NULL, unnamed_types, named_types);
- getRParenthesis(in);
+
+ getLAnglebracket(in); //</sequence>
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("sequence",token))in->error(in,"not a valid sequence definition");
+ getRAnglebracket(in); //</sequence>
}
else if(strcmp(token,"enum") == 0) {
+ char * str, *str1;
t->type = ENUM;
sequence_init(&(t->labels));
- getLParenthesis(in);
- t->size = getSize(in);
- getComa(in);
- token = getToken(in);
- if(in->type == QUOTEDSTRING){
- t->fmt = allocAndCopy(token);
- getComa(in);
- }else ungetToken(in);
- getLParenthesis(in);
-
- token = getToken(in);
- while(in->type != RPARENTHESIS) {
- if(in->type != NAME) in->error(in,"Name token was expected");
- car = allocAndCopy(token);
- token = getToken(in);
- if(in->type == COMA){
- sequence_push(&(t->labels),allocAndCopy(car));
- token = getName(in);
- }else if(in->type == EQUAL){ //label followed by '=' and a number, e.x. label1 = 1,
- car = appendString(car, token);
- token = getToken(in);
- if(in->type != NUMBER) in->error(in,"Number token was expected");
- car = appendString(car, token);
- sequence_push(&(t->labels),allocAndCopy(car));
- token = getToken(in);
- if(in->type == COMA) token = getName(in);
- else ungetToken(in);
- }else{
- sequence_push(&(t->labels),allocAndCopy(car));
- ungetToken(in);
- }
- }
- getRParenthesis(in);
- getRParenthesis(in);
+ t->size = getSizeAttribute(in);
+ t->fmt = allocAndCopy(getFormatAttribute(in));
+ getRAnglebracket(in);
+
+ //<label name=label1 value=n/>
+ getLAnglebracket(in);
+ token = getToken(in); //"label" or "/"
+ while(strcmp("label",token) == 0){
+ str = allocAndCopy(getNameAttribute(in));
+ token = getValueStrAttribute(in);
+ if(token){
+ str1 = appendString(str,"=");
+ free(str);
+ str = appendString(str1,token);
+ free(str1);
+ sequence_push(&(t->labels),allocAndCopy(str));
+ free(str);
+ }else
+ sequence_push(&(t->labels),allocAndCopy(str));
+
+ getForwardslash(in);
+ getRAnglebracket(in);
+
+ //next label definition
+ getLAnglebracket(in);
+ token = getToken(in); //"label" or "/"
+ }
+ if(strcmp("/",token))in->error(in, "not a valid enum definition");
+ token = getName(in);
+ if(strcmp("enum",token))in->error(in, "not a valid enum definition");
+ getRAnglebracket(in); //</label>
}
else if(strcmp(token,"int") == 0) {
t->type = INT;
- getLParenthesis(in);
- t->size = getSize(in);
- token = getToken(in);
- if(in->type == COMA) {
- token = getQuotedString(in);
- t->fmt = allocAndCopy(token);
- }
- else ungetToken(in);
- getRParenthesis(in);
+ t->size = getSizeAttribute(in);
+ t->fmt = allocAndCopy(getFormatAttribute(in));
+ getForwardslash(in);
+ getRAnglebracket(in);
}
else if(strcmp(token,"uint") == 0) {
t->type = UINT;
- getLParenthesis(in);
- t->size = getSize(in);
- token = getToken(in);
- if(in->type == COMA) {
- token = getQuotedString(in);
- t->fmt = allocAndCopy(token);
- }
- else ungetToken(in);
- getRParenthesis(in);
+ t->size = getSizeAttribute(in);
+ t->fmt = allocAndCopy(getFormatAttribute(in));
+ getForwardslash(in);
+ getRAnglebracket(in);
}
else if(strcmp(token,"float") == 0) {
t->type = FLOAT;
- getLParenthesis(in);
- t->size = getSize(in);
- token = getToken(in);
- if(in->type == COMA) {
- token = getQuotedString(in);
- t->fmt = allocAndCopy(token);
- }
- else ungetToken(in);
- getRParenthesis(in);
+ t->size = getSizeAttribute(in);
+ t->fmt = allocAndCopy(getFormatAttribute(in));
+ getForwardslash(in);
+ getRAnglebracket(in);
}
else if(strcmp(token,"string") == 0) {
t->type = STRING;
- getLParenthesis(in);
- token = getToken(in);
- if(in->type == QUOTEDSTRING) t->fmt = allocAndCopy(token);
- else ungetToken(in);
- getRParenthesis(in);
+ t->fmt = allocAndCopy(getFormatAttribute(in));
+ getForwardslash(in);
+ getRAnglebracket(in);
}
- else {
- /* Must be a named type */
+ else if(strcmp(token,"typeref") == 0){
+ // Must be a named type
if(inType != NULL)
in->error(in,"Named type cannot refer to a named type");
else {
free(t);
sequence_pop(unnamed_types);
- return(find_named_type(token, named_types));
+ token = getNameAttribute(in);
+ t = find_named_type(token, named_types);
+ getForwardslash(in); //<typeref name=type_name/>
+ getRAnglebracket(in);
+ return t;
}
- }
+ }else in->error(in,"not a valid type");
return t;
}
* find_named_type : find a named type from hash table
*Input params
* name : type name
+ * named_types : array of named types
*Return values
* type_descriptor * : a type descriptor
*****************************************************************************/
* parseTypeDefinition : get type information from type definition
*Input params
* in : input file handle
+ * unnamed_types : array of unamed types
+ * named_types : array of named types
*****************************************************************************/
void parseTypeDefinition(parse_file * in, sequence * unnamed_types,
char *token;
type_descriptor *t;
- getLParenthesis(in);
- token = getName(in);
+ token = getNameAttribute(in);
t = find_named_type(token, named_types);
- getComa(in);
if(t->type != NONE) in->error(in,"redefinition of named type");
+ getRAnglebracket(in); //<type name=type_name>
+ getLAnglebracket(in); //<struct>
+ token = getName(in);
+ if(strcmp("struct",token))in->error(in,"not a valid type definition");
+ ungetToken(in);
parseType(in,t, unnamed_types, named_types);
-
- getRParenthesis(in);
- getSemiColon(in);
+
+ //</type>
+ getLAnglebracket(in);
+ getForwardslash(in);
+ token = getName(in);
+ if(strcmp("type",token))in->error(in,"not a valid type definition");
+ getRAnglebracket(in); //</type>
}
/**************************************************************************
* Function :
- * getComa, getName, getNumber, getLParenthesis, getRParenthesis, getEqual
+ * getComa, getName, getNumber, getEqual
* Description :
* Read a token from the input file, check its type, return it scontent.
*
return atoi(token);
}
-char *getComa(parse_file * in)
+char *getForwardslash(parse_file * in)
{
char *token;
token = getToken(in);
- if(in->type != COMA) in->error(in, "Coma token was expected");
+ if(in->type != FORWARDSLASH) in->error(in, "forward slash token was expected");
return token;
}
-char *getLParenthesis(parse_file * in)
+char *getLAnglebracket(parse_file * in)
{
char *token;
token = getToken(in);
- if(in->type != LPARENTHESIS) in->error(in, "Left parenthesis was expected");
+ if(in->type != LANGLEBRACKET) in->error(in, "Left angle bracket was expected");
return token;
}
-char *getRParenthesis(parse_file * in)
+char *getRAnglebracket(parse_file * in)
{
char *token;
token = getToken(in);
- if(in->type != RPARENTHESIS) in->error(in, "Right parenthesis was expected");
+ if(in->type != RANGLEBRACKET) in->error(in, "Right angle bracket was expected");
return token;
}
return token;
}
-char * getSemiColon(parse_file *in)
+char * getEqual(parse_file *in)
{
char *token;
token = getToken(in);
- if(in->type != SEMICOLON) in->error(in, "semicolon was expected");
+ if(in->type != EQUAL) in->error(in, "equal was expected");
return token;
}
-char * getEqual(parse_file *in)
+char seekNextChar(parse_file *in)
{
- char *token;
-
- token = getToken(in);
- if(in->type != EQUAL) in->error(in, "equal was expected");
- return token;
+ char car;
+ while((car = getc(in->fp)) != EOF) {
+ if(!isspace(car)){
+ ungetc(car,in->fp);
+ return car;
+ }
+ }
+ return EOF;
}
/******************************************************************
case EOF:
in->type = ENDFILE;
break;
- case ',':
- in->type = COMA;
+ case '/':
+ in->type = FORWARDSLASH;
in->buffer[pos] = car;
pos++;
break;
- case '(':
- in->type = LPARENTHESIS;
+ case '<':
+ in->type = LANGLEBRACKET;
in->buffer[pos] = car;
pos++;
break;
- case ')':
- in->type = RPARENTHESIS;
- in->buffer[pos] = car;
- pos++;
- break;
- case ';':
- in->type = SEMICOLON;
+ case '>':
+ in->type = RANGLEBRACKET;
in->buffer[pos] = car;
pos++;
break;
void generateChecksum( char* facName, unsigned long * checksum, sequence * events)
{
unsigned long crc ;
- int pos, nestedStruct;
+ int pos;
event * ev;
char str[256];
crc = crc32(facName);
for(pos = 0; pos < events->position; pos++){
ev = (event *)(events->array[pos]);
- ev->nested = 0; //by default, event has no nested struct
crc = partial_crc32(ev->name,crc);
- nestedStruct = 0;
+ if(!ev->type) continue; //event without type
if(ev->type->type != STRUCT){
sprintf(str,"event '%s' has a type other than STRUCT",ev->name);
error_callback(NULL, str);
}
- crc = getTypeChecksum(crc, ev->type,&nestedStruct);
- if(nestedStruct ) ev->nested = 1;
+ crc = getTypeChecksum(crc, ev->type);
}
*checksum = crc;
}
* unsigned long : checksum
*****************************************************************************/
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type,
- int * nestedStruct)
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type)
{
unsigned long crc = aCrc;
char * str = NULL, buf[16];
- int flag = 0, pos, max, min;
+ int flag = 0, pos;
field * fld;
- data_type dt;
switch(type->type){
case INT:
str = allocAndCopy("struct");
flag = 1;
break;
+ case UNION:
+ str = allocAndCopy("union");
+ flag = 1;
+ break;
default:
error_callback(NULL, "named type has no definition");
break;
if(type->fmt) crc = partial_crc32(type->fmt,crc);
if(type->type == ARRAY || type->type == SEQUENCE){
- dt = type->nested_type->type;
- if(dt == ARRAY || dt == SEQUENCE || dt == STRUCT) *nestedStruct += 1;
- crc = getTypeChecksum(crc,type->nested_type,nestedStruct);
- }else if(type->type == STRUCT){
- if(type->fields.position != 0){//not a empty struct
- max = 0;
- for(pos =0; pos < type->fields.position; pos++){
- min = 0;
- fld = (field *) type->fields.array[pos];
- crc = partial_crc32(fld->name,crc);
- if(fld->type->type == STRUCT) min++;
- crc = getTypeChecksum(crc, fld->type,&min);
- if(min>max) max = min;
- }
- *nestedStruct += max;
- }
+ crc = getTypeChecksum(crc,type->nested_type);
+ }else if(type->type == STRUCT || type->type == UNION){
+ for(pos =0; pos < type->fields.position; pos++){
+ fld = (field *) type->fields.array[pos];
+ crc = partial_crc32(fld->name,crc);
+ crc = getTypeChecksum(crc, fld->type);
+ }
}else if(type->type == ENUM){
for(pos = 0; pos < type->labels.position; pos++)
- crc = partial_crc32((char*)type->labels.array[pos],crc);
+ crc = partial_crc32((char*)type->labels.array[pos],crc);
}
return crc;
char *appendString(char *s, char *suffix)
{
char *tmp;
+ if(suffix == NULL) return s;
tmp = (char *)memAlloc(strlen(s) + strlen(suffix) + 1);
strcpy(tmp,s);
typedef enum _token_type {
ENDFILE,
- COMA,
- LPARENTHESIS,
- RPARENTHESIS,
- SEMICOLON,
+ FORWARDSLASH,
+ LANGLEBRACKET,
+ RANGLEBRACKET,
EQUAL,
QUOTEDSTRING,
NUMBER,
void ungetToken(parse_file * in);
char *getToken(parse_file *in);
-char *getComa(parse_file *in);
-char *getLParenthesis(parse_file *in);
-char *getRParenthesis(parse_file *in);
-char *getSemiColon(parse_file *in);
+char *getForwardslash(parse_file *in);
+char *getLAnglebracket(parse_file *in);
+char *getRAnglebracket(parse_file *in);
char *getQuotedString(parse_file *in);
char *getName(parse_file *in);
-int getNumber(parse_file *in);
-char * getEqual(parse_file *in);
+int getNumber(parse_file *in);
+char *getEqual(parse_file *in);
+char seekNextChar(parse_file *in);
void skipComment(parse_file * in);
void skipEOL(parse_file * in);
ARRAY,
SEQUENCE,
STRUCT,
+ UNION,
NONE
} data_type;
char *name;
char *description;
type_descriptor *type;
- int nested;
} event;
+typedef struct _facility {
+ char * name;
+ char * description;
+ sequence events;
+ sequence unnamed_types;
+ table named_types;
+} facility;
+
int getSize(parse_file *in);
-unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type, int * nestedStruct);
+unsigned long getTypeChecksum(unsigned long aCrc, type_descriptor * type);
+void parseFacility(parse_file *in, facility * fac);
void parseEvent(parse_file *in, event *ev, sequence * unnamed_types, table * named_types);
void parseTypeDefinition(parse_file *in, sequence * unnamed_types, table * named_types);
type_descriptor *parseType(parse_file *in, type_descriptor *t, sequence * unnamed_types, table * named_types);
void generateChecksum(char * facName, unsigned long * checksum, sequence * events);
+/* get attributes */
+char * getNameAttribute(parse_file *in);
+char * getFormatAttribute(parse_file *in);
+int getSizeAttribute(parse_file *in);
+int getValueAttribute(parse_file *in);
+char * getValueStrAttribute(parse_file *in);
+
+char * getDescription(parse_file *in);
+
static char *intOutputTypes[] = {
"int8_t", "int16_t", "int32_t", "int64_t", "short int", "int", "long int" };
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
+#include <dirent.h>
#include <linux/errno.h>
#include <ltt/LTTTypes.h>
#include "parser.h"
-#include <ltt/tracefile.h>
+#include <ltt/trace.h>
-//#include "default.h" //yxx test
+#define DIR_NAME_SIZE 256
/* set the offset of the fields belonging to the event,
need the information of the archecture */
-void setFieldsOffset(ltt_tracefile * t, ltt_eventtype *evT, void *evD);
+void setFieldsOffset(LttTracefile * t, LttEventType *evT, void *evD);
/* get the size of the field type according to the archtecture's
size and endian type(info of the archecture) */
-int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
- int offsetParent, ltt_field * fld, void * evD );
+int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
+ int offsetParent, LttField * fld, void * evD );
/* read a fixed size or a block information from the file (fd) */
int readFile(int fd, void * buf, size_t size, char * mesg);
-int readBlock(ltt_tracefile * tf, int whichBlock);
+int readBlock(LttTracefile * tf, int whichBlock);
/* calculate cycles per nsec for current block */
-void getCyclePerNsec(ltt_tracefile * t);
-
-/* functions to release the memory occupied by the tables of a tracefile */
-void freeKey (gpointer key, gpointer value, gpointer user_data);
-void freeValue (gpointer key, gpointer value, gpointer user_data);
-void freeFacilityNameTable (gpointer key, gpointer value, gpointer user_data);
+void getCyclePerNsec(LttTracefile * t);
/* reinitialize the info of the block which is already in the buffer */
-void updateTracefile(ltt_tracefile * tf);
+void updateTracefile(LttTracefile * tf);
/* go to the next event */
-int skipEvent(ltt_tracefile * t);
+int skipEvent(LttTracefile * t);
-/* compare two time (ltt_time), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
-int timecmp(ltt_time * t1, ltt_time * t2);
+/* compare two time (LttTime), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
+int timecmp(LttTime * t1, LttTime * t2);
/* get an integer number */
int getIntNumber(int size1, void *evD);
-/* Time operation macros for ltt_time (struct timespec) */
+/* Time operation macros for LttTime (struct timespec) */
/* (T3 = T2 - T1) */
#define TimeSub(T3, T2, T1) \
do \
/*****************************************************************************
*Function name
- * ltt_tracefile_open : open a trace file, construct a ltt_tracefile
+ * ltt_tracefile_open : open a trace file, construct a LttTracefile
*Input params
- * pathname : path name of the trace file
+ * t : the trace containing the tracefile
+ * fileName : path name of the trace file
*Return value
- * ltt_tracefile * : the structure represents the opened trace file
+ * : a pointer to a tracefile
****************************************************************************/
-ltt_tracefile *ltt_tracefile_open(char * fileName)
+LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
{
- ltt_tracefile * tf;
- struct stat lTDFStat; /* Trace data file status */
- trace_header_event *trace_header;
- block_header a_block_header;
+ LttTracefile * tf;
+ struct stat lTDFStat; /* Trace data file status */
+ BlockStart a_block_start;
- tf = g_new(ltt_tracefile, 1);
+ tf = g_new(LttTracefile, 1);
//open the file
+ tf->name = g_strdup(fileName);
+ tf->trace = t;
tf->fd = open(fileName, O_RDONLY, 0);
if(tf->fd < 0){
g_error("Unable to open input data file %s\n", fileName);
}
// Is the file large enough to contain a trace
- if(lTDFStat.st_size < sizeof(block_header) + sizeof(trace_header_event)){
+ if(lTDFStat.st_size < sizeof(BlockStart) + EVENT_HEADER_SIZE){
g_error("The input data file %s does not contain a trace\n", fileName);
}
//store the size of the file
tf->file_size = lTDFStat.st_size;
-
- //read the first block header
- if(readFile(tf->fd,(void*)&a_block_header, sizeof(block_header),
- "Unable to read block header"))
- exit(1);
-
- //read the trace header event
- trace_header = g_new(trace_header_event, 1);
- if(readFile(tf->fd,(void*)trace_header, sizeof(trace_header_event),
- "Unable to read trace header event"))
- exit(1);
-
- tf->block_number = tf->file_size / trace_header->buffer_size;
- tf->trace_header = (trace_header_event *)trace_header;
+ tf->block_size = t->system_description->ltt_block_size;
+ tf->block_number = tf->file_size / tf->block_size;
+ tf->which_block = 0;
//allocate memory to contain the info of a block
- tf->buffer = (void *) g_new(char, trace_header->buffer_size);
-
- //read the last block, get the trace end time
- if(readBlock(tf,tf->block_number)) exit(1);
- tf->end_time = tf->a_block_footer->time;
-
- //read the first block, get the trace start time
- if(tf->block_number != 1)
- if(readBlock(tf,1)) exit(1);
- tf->start_time = tf->a_block_header->time;
-
- //get local machine's data type size and endian type
- getDataEndianType(&(tf->my_arch_size), &(tf->my_arch_endian));
+ tf->buffer = (void *) g_new(char, t->system_description->ltt_block_size);
- //initialize all tables
- tf->eventtype_number = 0;
- tf->facility_number = 0;
- tf->index_facility = g_hash_table_new (g_int_hash, g_int_equal);
- tf->facility_name = g_hash_table_new (g_str_hash, g_str_equal);
- tf->base_id_name = g_hash_table_new (g_str_hash, g_int_equal);
- tf->eventtype_event_id = g_ptr_array_new();
+ //read the first block
+ if(readBlock(tf,1)) exit(1);
return tf;
}
-/*****************************************************************************
- *Function name
- * ltt_tracefile_close: close a trace file, release all facilities if their
- * usage count == 0 when close_facilities is true
- *Input params
- * t : tracefile which will be closed
- * close_facilities : bool to show if the facilities need to be released
- *Return value
- * int : ????
- ****************************************************************************/
-
-int ltt_tracefile_close(ltt_tracefile *t, int close_facilities)
-{
- //free index_facility table
- g_hash_table_foreach (t->index_facility, freeKey, NULL);
- g_hash_table_destroy(t->index_facility);
-
- //free base_id_facility table
- g_hash_table_foreach (t->base_id_name, freeValue, NULL);
- g_hash_table_destroy(t->base_id_name);
-
- //free eventtype_event_id array
- g_ptr_array_free (t->eventtype_event_id, TRUE);
-
- //free facility_name table
- g_hash_table_foreach (t->facility_name, freeFacilityNameTable,
- GINT_TO_POINTER(1));
- g_hash_table_destroy(t->facility_name);
-
- //free tracefile structure
- g_free(t->trace_header);
- g_free(t->buffer);
- g_free(t);
- return 0;
-}
/*****************************************************************************
- * functions to release the memory occupied by the tables of a tracefile
+ *Open control and per cpu tracefiles
****************************************************************************/
-void freeKey (gpointer key, gpointer value, gpointer user_data)
+void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
{
- g_free(key);
+ LttTracefile * tf;
+ tf = ltt_tracefile_open(t,tracefile_name);
+ t->per_cpu_tracefile_number++;
+ g_ptr_array_add(t->per_cpu_tracefiles, tf);
}
-void freeValue (gpointer key, gpointer value, gpointer user_data)
+void ltt_tracefile_open_control(LttTrace *t, char * control_name)
{
- g_free(value);
-}
-
-void freeFacilityNameTable (gpointer key, gpointer value, gpointer user_data)
-{
- ltt_facility * fac = (ltt_facility*) value;
- fac->usage_count--;
- if(GPOINTER_TO_INT(user_data) != 0)
- ltt_facility_close(fac);
+ LttTracefile * tf;
+ LttEvent * ev;
+ LttFacility * f;
+ uint16_t evId;
+ void * pos;
+ FacilityLoad fLoad;
+ int i;
+
+ tf = ltt_tracefile_open(t,control_name);
+ t->control_tracefile_number++;
+ g_ptr_array_add(t->control_tracefiles,tf);
+
+ //parse facilities tracefile to get base_id
+ if(strcmp(control_name,"facilities") ==0){
+ while(1){
+ evId = *(uint16_t*)tf->cur_event_pos;
+ if(evId == TRACE_FACILITY_LOAD){
+ pos = tf->cur_event_pos + EVENT_HEADER_SIZE;
+ fLoad.name = (char*)pos;
+ fLoad.checksum = *(LttChecksum*)(pos + sizeof(pos));
+ fLoad.base_code = *(uint32_t*)(pos + sizeof(pos) + sizeof(LttChecksum));
+
+ for(i=0;i<t->facility_number;i++){
+ f = (LttFacility*)g_ptr_array_index(t->facilities,i);
+ if(strcmp(f->name,fLoad.name)==0 && fLoad.checksum==f->checksum){
+ f->base_id = fLoad.base_code;
+ break;
+ }
+ }
+ if(i==t->facility_number)
+ g_error("Facility: %s, checksum: %d is not founded\n",
+ fLoad.name,fLoad.checksum);
+
+ ev = ltt_tracefile_read(tf); //get next event
+ if(!ev) break; //end of tracefile
+ }else if(evId == TRACE_BLOCK_END){
+ //can only reach here if it is the first event
+ g_error("Facilities does not contain any facility_load event\n");
+ }else g_error("Not valid facilities trace file\n");
+ }
+ }
}
/*****************************************************************************
*Function name
- * ltt_tracefile_facility_add: increases the facility usage count and also
- * specifies the base of the numeric range
- * assigned to the event types in the facility
- * for this tracefile
+ * ltt_tracefile_close: close a trace file,
*Input params
- * t : tracefile that the facility will be added
- * f : facility that will be attached to the tracefile
- * base_id : the id for the first event of the facility in the
- * trace file
- *Return value
- * int : ????
+ * t : tracefile which will be closed
****************************************************************************/
-int ltt_tracefile_facility_add(ltt_tracefile *t,ltt_facility *f,int base_id)
+void ltt_tracefile_close(LttTracefile *t)
{
- int * id, *index;
- int i, j, k;
- ltt_eventtype * et;
- gpointer tmpPtr;
-
- //increase the facility usage count
- f->usage_count++;
- t->eventtype_number += f->event_number;
- t->facility_number++;
-
- //insert the facility into index_facility table
- id = g_new(int,1);
- *id = t->facility_number;
- g_hash_table_insert(t->index_facility, (gpointer)id,(gpointer)f);
-
- //insert facility name into table: base_id_name
- id = g_new(int,1);
- *id = base_id;
- g_hash_table_insert(t->base_id_name, (gpointer)(f->name), (gpointer)id);
+ g_free(t->name);
+ g_free(t->buffer);
+ g_free(t);
+}
- //insert facility name into table: facility_name
- g_hash_table_insert(t->facility_name, (gpointer)(f->name), (gpointer)f);
-
- //insert eventtype into the array: eventtype_event_id
- j = base_id + f->event_number;
- k = t->eventtype_event_id->len;
- if(j > t->eventtype_event_id->len){
- for(i=0; i < j - k; i++){
- tmpPtr = (gpointer)g_new(ptr_wrap, 1);
- g_ptr_array_add(t->eventtype_event_id,tmpPtr);
- }
- }
- //initialize the unused elements: NULL
- if(j-k > f->event_number){
- for(i=k; i<base_id; i++){
- tmpPtr = g_ptr_array_index(t->eventtype_event_id, i);
- ((ptr_wrap*)tmpPtr)->ptr = NULL;
- }
+/*****************************************************************************
+ *Get system information
+ ****************************************************************************/
+void getSystemInfo(LttSystemDescription* des, char * pathname)
+{
+ FILE * fp;
+ int i;
+ int entry_number = 15;
+ char buf[DIR_NAME_SIZE];
+ char description[4*DIR_NAME_SIZE];
+ char * ptr;
+
+ fp = fopen(pathname,"r");
+ if(!fp){
+ g_error("Can not open file : %s\n", pathname);
}
-
- //initialize the elements with the eventtypes belonging to the facility
- for(i=0; i<f->event_number; i++){
- tmpPtr = g_ptr_array_index(t->eventtype_event_id, base_id + i);
- ((ptr_wrap*)tmpPtr)->ptr = (gpointer)(f->events[i]);
+
+ while(fgets(buf,DIR_NAME_SIZE, fp)!= NULL){
+ ptr = buf;
+ while(isspace(*ptr)) ptr++;
+ if(strlen(ptr) == 0) continue;
+ break;
}
- //update offset
- for(i=0; i<f->event_number; i++){
- et = f->events[i];
- setFieldsOffset(t, et, NULL);
+ if(strlen(ptr) == 0) g_error("Not a valid file: %s\n", pathname);
+ if(strncmp("<system",ptr,7) !=0)g_error("Not a valid file: %s\n", pathname);
+
+ for(i=0;i<entry_number;i++){
+ if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
+ g_error("Not a valid file: %s\n", pathname);
+ ptr = buf;
+ while(isspace(*ptr)) ptr++;
+ switch(i){
+ case 0:
+ if(strncmp("node_name=",ptr,10)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->node_name = g_strdup(ptr+10);
+ break;
+ case 1:
+ if(strncmp("domainname=",ptr,11)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->domain_name = g_strdup(ptr+11);
+ break;
+ case 2:
+ if(strncmp("cpu=",ptr,4)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->nb_cpu = (unsigned)atoi(ptr+4);
+ break;
+ case 3:
+ if(strncmp("arch_size=",ptr,10)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ if(strcmp(ptr+10,"\"LP32\"") == 0) des->size = LTT_LP32;
+ else if(strcmp(ptr+10,"\"ILP32\"") == 0) des->size = LTT_ILP32;
+ else if(strcmp(ptr+10,"\"LP64\"") == 0) des->size = LTT_LP64;
+ else if(strcmp(ptr+10,"\"ILP64\"") == 0) des->size = LTT_ILP64;
+ else if(strcmp(ptr+10,"\"UNKNOWN\"") == 0) des->size = LTT_UNKNOWN;
+ break;
+ case 4:
+ if(strncmp("endian=",ptr,7)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ if(strcmp(ptr+7,"\"LITTLE_ENDIAN\"") == 0)
+ des->endian = LTT_LITTLE_ENDIAN;
+ else if(strcmp(ptr+7,"\"BIG_ENDIAN\"") == 0)
+ des->endian = LTT_BIG_ENDIAN;
+ break;
+ case 5:
+ if(strncmp("kernel_name=",ptr,12)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->kernel_name = g_strdup(ptr+12);
+ break;
+ case 6:
+ if(strncmp("kernel_release=",ptr,15)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->kernel_release = g_strdup(ptr+15);
+ break;
+ case 7:
+ if(strncmp("kernel_version=",ptr,15)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->kernel_version = g_strdup(ptr+15);
+ break;
+ case 8:
+ if(strncmp("machine=",ptr,8)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->machine = g_strdup(ptr+8);
+ break;
+ case 9:
+ if(strncmp("processor=",ptr,10)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->processor = g_strdup(ptr+10);
+ break;
+ case 10:
+ if(strncmp("hardware_platform=",ptr,18)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->hardware_platform = g_strdup(ptr+18);
+ break;
+ case 11:
+ if(strncmp("operating_system=",ptr,17)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ des->operating_system = g_strdup(ptr+17);
+ break;
+ case 12:
+ if(strncmp("ltt_major_version=",ptr,18)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ ptr += 18;
+ ptr++;//skip begining "
+ ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+ des->ltt_major_version = (unsigned)atoi(ptr);
+ break;
+ case 13:
+ if(strncmp("ltt_minor_version=",ptr,18)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ ptr += 18;
+ ptr++;//skip begining "
+ ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+ des->ltt_minor_version = (unsigned)atoi(ptr);
+ break;
+ case 14:
+ if(strncmp("ltt_block_size=",ptr,15)!=0)
+ g_error("Not a valid file: %s\n", pathname);
+ ptr += 15;
+ ptr++;//skip begining "
+ ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
+ des->ltt_block_size = (unsigned)atoi(ptr);
+ break;
+ default:
+ g_error("Not a valid file: %s\n", pathname);
+ }
}
+ //get description
+ description[0] = '\0';
+ if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
+ g_error("Not a valid file: %s\n", pathname);
+ ptr = buf;
+ while(isspace(*ptr)) ptr++;
+ if(*ptr != '>') g_error("Not a valid file: %s\n", pathname);
+ while((ptr=fgets(buf,DIR_NAME_SIZE, fp))!= NULL){
+ ptr = buf;
+ while(isspace(*ptr)) ptr++;
+ if(strncmp("</system>",ptr,9) == 0 )break;
+ strcat(description, buf);
+ }
+ if(!ptr)g_error("Not a valid file: %s\n", pathname);
+ if(description[0] = '\0')des->description = NULL;
+ des->description = g_strdup(description);
- return 0;
+ fclose(fp);
}
/*****************************************************************************
- * The following functions used to query the info of the machine where the
- * tracefile was generated. A tracefile may be queried for its architecture
- * type(e.g.,"i386", "powerpc", "powerpcle", "s390", "s390x"), its architecture
- * variant(e.g., "att" versus "sun" for m68k), its operating system (e.g.,
- * "linux","bsd"), its generic architecture, and the machine identity (e.g.,
- * system host name). All character strings belong to the associated tracefile
- * and are freed when it is closed
+ *The following functions get facility/tracefile information
****************************************************************************/
-uint32_t ltt_tracefile_arch_type(ltt_tracefile *t)
+void getFacilityInfo(LttTrace *t, char* eventdefs)
{
- return t->trace_header->arch_type;
-}
+ DIR * dir;
+ struct dirent *entry;
+ char * ptr;
+ int i,j;
+ LttFacility * f;
+ LttEventType * et;
+ LttTracefile * tracefile;
+
+ dir = opendir(eventdefs);
+ if(!dir) g_error("Can not open directory: %s\n", eventdefs);
+
+ while((entry = readdir(dir)) != NULL){
+ ptr = &entry->d_name[strlen(entry->d_name)-4];
+ if(strcmp(ptr,".xml") != 0) continue;
+ ltt_facility_open(t,entry->d_name);
+ }
+ closedir(dir);
+
+ tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,0);
+ for(j=0;j<t->facility_number;j++){
+ f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+ for(i=0; i<f->event_number; i++){
+ et = f->events[i];
+ setFieldsOffset(tracefile, et, NULL);
+ }
+ }
+}
-uint32_t ltt_tracefile_arch_variant(ltt_tracefile *t)
+void getControlFileInfo(LttTrace *t, char* control)
{
- return t->trace_header->arch_variant;
+ DIR * dir;
+ struct dirent *entry;
+
+ dir = opendir(control);
+ if(!dir) g_error("Can not open directory: %s\n", control);
+
+ while((entry = readdir(dir)) != NULL){
+ if(strcmp(entry->d_name,"facilities") != 0 ||
+ strcmp(entry->d_name,"interrupts") != 0 ||
+ strcmp(entry->d_name,"processes") != 0) continue;
+
+ ltt_tracefile_open_control(t,entry->d_name);
+ }
+ closedir(dir);
}
-ltt_arch_size ltt_tracefile_arch_size(ltt_tracefile *t)
+void getCpuFileInfo(LttTrace *t, char* cpu)
{
- return t->trace_header->arch_size;
+ DIR * dir;
+ struct dirent *entry;
+
+ dir = opendir(cpu);
+ if(!dir) g_error("Can not open directory: %s\n", cpu);
+
+ while((entry = readdir(dir)) != NULL){
+ if(strcmp(entry->d_name,".") != 0 ||
+ strcmp(entry->d_name,"..") != 0 ){
+ ltt_tracefile_open_cpu(t,entry->d_name);
+ }else continue;
+ }
+ closedir(dir);
}
-ltt_arch_endian ltt_tracefile_arch_endian(ltt_tracefile *t)
-{
- return t->trace_header->arch_endian;
-}
+/*****************************************************************************
+ *A trace is specified as a pathname to the directory containing all the
+ *associated data (control tracefiles, per cpu tracefiles, event
+ *descriptions...).
+ *
+ *When a trace is closed, all the associated facilities, types and fields
+ *are released as well.
+ ****************************************************************************/
-uint32_t ltt_tracefile_system_type(ltt_tracefile *t)
+LttTrace *ltt_trace_open(char *pathname)
{
- return t->trace_header->system_type;
+ LttTrace * t;
+ LttSystemDescription * sys_description;
+ char eventdefs[DIR_NAME_SIZE];
+ char info[DIR_NAME_SIZE];
+ char control[DIR_NAME_SIZE];
+ char cpu[DIR_NAME_SIZE];
+ char tmp[DIR_NAME_SIZE];
+ gboolean has_slash = FALSE;
+
+ //establish the pathname to different directories
+ if(pathname[strlen(pathname)-1] == '/')has_slash = TRUE;
+ strcpy(eventdefs,pathname);
+ if(!has_slash)strcat(eventdefs,"/");
+ strcat(eventdefs,"eventdefs/");
+
+ strcpy(info,pathname);
+ if(!has_slash)strcat(info,"/");
+ strcat(info,"info/");
+
+ strcpy(control,pathname);
+ if(!has_slash)strcat(control,"/");
+ strcat(control,"control/");
+
+ strcpy(cpu,pathname);
+ if(!has_slash)strcat(cpu,"/");
+ strcat(cpu,"cpu/");
+
+ //new trace
+ t = g_new(LttTrace, 1);
+ sys_description = g_new(LttSystemDescription, 1);
+ t->pathname = g_strdup(pathname);
+ t->facility_number = 0;
+ t->control_tracefile_number = 0;
+ t->per_cpu_tracefile_number = 0;
+ t->system_description = sys_description;
+ t->control_tracefiles = g_ptr_array_new();
+ t->per_cpu_tracefiles = g_ptr_array_new();
+ t->facilities = g_ptr_array_new();
+ getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian));
+
+ //get system description
+ strcpy(tmp,info);
+ strcat(tmp,"system.xml");
+ getSystemInfo(sys_description, tmp);
+
+ //get control tracefile info
+ getControlFileInfo(t,control);
+
+ //get cpu tracefile info
+ getCpuFileInfo(t,cpu);
+
+ //get facilities info
+ getFacilityInfo(t,eventdefs);
+
+ return t;
}
-char *ltt_tracefile_system_name(ltt_tracefile *t)
+void ltt_trace_close(LttTrace *t)
{
- return t->trace_header->system_name;
+ int i;
+ LttTracefile * tf;
+ LttFacility * f;
+
+ g_free(t->pathname);
+
+ //free system_description
+ g_free(t->system_description->description);
+ g_free(t->system_description->node_name);
+ g_free(t->system_description->domain_name);
+ g_free(t->system_description->kernel_name);
+ g_free(t->system_description->kernel_release);
+ g_free(t->system_description->kernel_version);
+ g_free(t->system_description->machine);
+ g_free(t->system_description->processor);
+ g_free(t->system_description->hardware_platform);
+ g_free(t->system_description->operating_system);
+ g_free(t->system_description);
+
+ //free control_tracefiles
+ for(i=0;i<t->control_tracefile_number;i++){
+ tf = (LttTracefile*)g_ptr_array_index(t->control_tracefiles,i);
+ ltt_tracefile_close(tf);
+ }
+ g_ptr_array_free(t->control_tracefiles, FALSE);
+
+ //free per_cpu_tracefiles
+ for(i=0;i<t->per_cpu_tracefile_number;i++){
+ tf = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,i);
+ ltt_tracefile_close(tf);
+ }
+ g_ptr_array_free(t->per_cpu_tracefiles, FALSE);
+
+ //free facilities
+ for(i=0;i<t->facility_number;i++){
+ f = (LttFacility*)g_ptr_array_index(t->facilities,i);
+ ltt_facility_close(f);
+ }
+ g_ptr_array_free(t->facilities, FALSE);
+
+ g_free(t);
}
+
/*****************************************************************************
- *Function name
- * ltt_tracefile_cpu_number: get the number of the cpu
- *Input params
- * t : tracefile
- *Return value
- * unsigned : the number of cpu the system has
+ *Get the system description of the trace
****************************************************************************/
-unsigned ltt_tracefile_cpu_number(ltt_tracefile *t)
+LttSystemDescription *ltt_trace_system_description(LttTrace *t)
{
- return (unsigned)(t->trace_header->cpu_number);
+ return t->system_description;
}
/*****************************************************************************
- *Function name
- * ltt_tracefile_cpu_single: does the tracefile contain events only for a
- * single CPU ?
- *Input params
- * t : tracefile
- *Return value
- * int : 1 for YES, 0 for NO
+ * The following functions discover the facilities of the trace
****************************************************************************/
-int ltt_tracefile_cpu_single(ltt_tracefile *t)
+unsigned ltt_trace_facility_number(LttTrace *t)
+{
+ return (unsigned)(t->facility_number);
+}
+
+LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i)
{
- if(t->trace_header->cpu_number_used == 1) return 1;
- else return 0;
+ return (LttFacility*)g_ptr_array_index(t->facilities, i);
}
/*****************************************************************************
*Function name
- * ltt_tracefile_cpu_id: which CPU is contained in the tracefile?
+ * ltt_trace_facility_find : find facilities in the trace
*Input params
- * t : tracefile
+ * t : the trace
+ * name : facility name
+ *Output params
+ * position : position of the facility in the trace
*Return value
- * unsigned : cpu id
+ * : the number of facilities
****************************************************************************/
-unsigned ltt_tracefile_cpu_id(ltt_tracefile *t)
+unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position)
{
- return (unsigned)(t->trace_header->cpu_id);
+ int i, count=0;
+ LttFacility * f;
+ for(i=0;i=t->facility_number;i++){
+ f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+ if(strcmp(f->name,name)==0){
+ count++;
+ if(count==1) *position = i;
+ }else{
+ if(count) break;
+ }
+ }
+ return count;
}
/*****************************************************************************
- * The following functions get the times related to the tracefile
+ * Functions to discover all the event types in the trace
****************************************************************************/
-ltt_time ltt_tracefile_time_start(ltt_tracefile *t)
+unsigned ltt_trace_eventtype_number(LttTrace *t)
{
- return t->start_time;
+ int i;
+ unsigned count = 0;
+ LttFacility * f;
+ for(i=0;i=t->facility_number;i++){
+ f = (LttFacility*)g_ptr_array_index(t->facilities, i);
+ count += f->event_number;
+ }
+ return count;
}
-ltt_time ltt_tracefile_time_end(ltt_tracefile *t)
+LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id)
{
- return t->end_time;
+ LttFacility * facility;
+ int i;
+ for(i=0;i<trace->facility_number;i++){
+ facility = (LttFacility*) g_ptr_array_index(trace->facilities,i);
+ if(id >= facility->base_id &&
+ id < facility->base_id + facility->event_number)
+ break;
+ }
+ if(i==trace->facility_number) return NULL;
+ else return facility;
}
-ltt_time ltt_tracefile_duration(ltt_tracefile *t)
+LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
{
- ltt_time T;
- TimeSub(T, t->end_time, t->start_time);
- return T;
+ LttFacility * f;
+ f = ltt_trace_facility_by_id(t,evId);
+ if(!f) return NULL;
+ return f->events[evId - f->base_id];
}
/*****************************************************************************
- * The following functions discover the facilities added to the tracefile
+ *There is one "per cpu" tracefile for each CPU, numbered from 0 to
+ *the maximum number of CPU in the system. When the number of CPU installed
+ *is less than the maximum, some positions are unused. There are also a
+ *number of "control" tracefiles (facilities, interrupts...).
****************************************************************************/
-
-unsigned ltt_tracefile_facility_number(ltt_tracefile *t)
-{
- return (unsigned)(t->facility_number);
-}
-
-ltt_facility *ltt_tracefile_facility_get(ltt_tracefile *t, unsigned i)
+unsigned ltt_trace_control_tracefile_number(LttTrace *t)
{
- gconstpointer ptr = (gconstpointer)(&i);
- if(i<=0 || i> t->facility_number)return NULL;
- return (ltt_facility*)g_hash_table_lookup(t->index_facility,ptr);
+ return t->control_tracefile_number;
}
-ltt_facility *ltt_tracefile_facility_get_by_name(ltt_tracefile *t,char *name)
+unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t)
{
- ltt_facility * fac;
- fac=(ltt_facility*)g_hash_table_lookup(t->facility_name,(gconstpointer)name);
- return fac;
+ return t->per_cpu_tracefile_number;
}
/*****************************************************************************
- * The following functions to discover all the event types in the facilities
- * added to the tracefile. The event type integer id, unique for the trace,
- * is used
+ *It is possible to search for the tracefiles by name or by CPU position.
+ *The index within the tracefiles of the same type is returned if found
+ *and a negative value otherwise.
****************************************************************************/
-unsigned ltt_tracefile_eventtype_number(ltt_tracefile *t)
+int ltt_trace_control_tracefile_find(LttTrace *t, char *name)
{
- return t->eventtype_number;
+ LttTracefile * tracefile;
+ int i;
+ for(i=0;i<t->control_tracefile_number;i++){
+ tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);
+ if(strcmp(tracefile->name, name)==0)break;
+ }
+ if(i == t->control_tracefile_number) return -1;
+ return i;
}
-ltt_eventtype *ltt_tracefile_eventtype_get(ltt_tracefile *t, unsigned evId)
+int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i)
{
- ptr_wrap * ptr;
- ptr = (ptr_wrap *)g_ptr_array_index(t->eventtype_event_id, (gint)evId);
- return (ltt_eventtype *)(ptr->ptr);
+ LttTracefile * tracefile;
+ int j, name;
+ for(j=0;j<t->per_cpu_tracefile_number;j++){
+ tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, j);
+ name = atoi(tracefile->name);
+ if(name == (int)i)break;
+ }
+ if(j == t->per_cpu_tracefile_number) return -1;
+ return j;
}
/*****************************************************************************
- *Function name
- * ltt_tracefile_eventtype_id
- * : given an event type, find its unique id within
- * the tracefile
- *Input params
- * t : tracefile
- * et : event type
- *Return value
- * unsigned : id of the event type in the tracefile
+ *Get a specific tracefile
****************************************************************************/
-unsigned ltt_tracefile_eventtype_id(ltt_tracefile *t, ltt_eventtype *et)
+LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i)
{
- int *id;
- char *name = et->facility->name;
-
- id = (int*)g_hash_table_lookup(t->base_id_name, (gconstpointer)name);
- if(!id)return 0;
- return (unsigned)(*id + et->index);
+ return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
+}
+
+LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i)
+{
+ return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
}
/*****************************************************************************
- *Function name
- * ltt_tracefile_eventtype_root_field
- * : get the root field associated with an event type
- * for the tracefile
- *Input params
- * t : tracefile
- * id : event id
- *Return value
- * ltt_field * : root field of the event
+ *Get the name of a tracefile
****************************************************************************/
-ltt_field *ltt_tracefile_eventtype_root_field(ltt_tracefile *t, unsigned id)
+char *ltt_tracefile_name(LttTracefile *tf)
{
- ltt_eventtype * et;
- et = ltt_tracefile_eventtype_get(t, id);
- if(!et) return NULL;
- return et->root_field;
+ return tf->name;
}
/*****************************************************************************
*Input params
* t : tracefile
* time : criteria of the time
- *Return value
- * int : error code
- * ENOENT, end of the file
- * EINVAL, lseek fail
- * EIO, can not read from the file
****************************************************************************/
-int ltt_tracefile_seek_time(ltt_tracefile *t, ltt_time time)
+void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
{
int err;
- ltt_time lttTime;
- int headTime = timecmp(&(t->a_block_header->time), &time);
- int tailTime = timecmp(&(t->a_block_footer->time), &time);
+ LttTime lttTime;
+ int headTime = timecmp(&(t->a_block_start->time), &time);
+ int tailTime = timecmp(&(t->a_block_end->time), &time);
if(headTime < 0 && tailTime > 0){
lttTime = getEventTime(t);
err = timecmp(<tTime, &time);
- if(err >= 0){
- if( ( (t->which_block != 1 && t->which_event != 0) ||
- (t->which_block == 1 && t->which_event != 1) ) &&
- ((t->prev_event_time.tv_sec==0 && t->prev_event_time.tv_nsec==0) ||
- timecmp(&t->prev_event_time, &time) >= 0 ) ){
+ if(err > 0){
+ if(t->which_event==1 || timecmp(&t->prev_event_time,&time)<0){
+ return;
+ }else{
updateTracefile(t);
return ltt_tracefile_seek_time(t, time);
}
}else if(err < 0){
err = t->which_block;
- if(ltt_tracefile_read(t) == NULL) return ENOENT;
+ if(ltt_tracefile_read(t) == NULL){
+ g_printf("End of file\n");
+ return;
+ }
if(t->which_block == err)
return ltt_tracefile_seek_time(t,time);
- }
+ }else return;
}else if(headTime > 0){
if(t->which_block == 1){
updateTracefile(t);
t->prev_block_end_time.tv_nsec == 0 ) ||
timecmp(&(t->prev_block_end_time),&time) > 0 ){
err=readBlock(t,t->which_block-1);
- if(err) return err;
+ if(err) g_error("Can not read tracefile: %s\n", t->name);
return ltt_tracefile_seek_time(t, time) ;
}else{
updateTracefile(t);
}else if(tailTime <= 0){
if(t->which_block != t->block_number){
err=readBlock(t,t->which_block+1);
- if(err) return err;
- }else return ENOENT;
+ if(err) g_error("Can not read tracefile: %s\n", t->name);
+ }else {
+ g_printf("End of file\n");
+ return;
+ }
if(tailTime < 0) return ltt_tracefile_seek_time(t, time);
}else if(headTime == 0){
updateTracefile(t);
}
- return 0;
}
/*****************************************************************************
*Input params
* t : tracefile
*Return value
- * ltt_event * : an event to be processed
+ * LttEvent * : an event to be processed
****************************************************************************/
-ltt_event *ltt_tracefile_read(ltt_tracefile *t)
+LttEvent *ltt_tracefile_read(LttTracefile *t)
{
- ltt_event * lttEvent = (ltt_event *)g_new(ltt_event, 1);
- ltt_eventtype * evT;
- ltt_facility * fac;
+ LttEvent * lttEvent = (LttEvent *)g_new(LttEvent, 1);
+ int err;
//update the fields of the current event and go to the next event
- if(skipEvent(t)) return NULL;
+ err = skipEvent(t);
+ if(err == ENOENT) return NULL;
+ if(err == ERANGE) g_error("event id is out of range\n");
+ if(err)g_error("Can not read tracefile\n");
+
+ lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos));
+ if(lttEvent->event_id == TRACE_TIME_HEARTBEAT)
+ t->cur_heart_beat_number++;
t->current_event_time = getEventTime(t);
- lttEvent->event_id = (int)(*(uint8_t *)(t->cur_event_pos));
- evT = ltt_tracefile_eventtype_get(t, (unsigned)lttEvent->event_id);
- fac = evT->facility;
- // if(evT->index == TRACE_EV_HEARTBEAT && strcmp(fac->name, "default")==0)
- // t->cur_heart_beat_number++;
- lttEvent->cycle_count=*(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
+ lttEvent->time_delta = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE);
+ lttEvent->event_time = t->current_event_time;
+
+ lttEvent->event_cycle_count = ((uint64_t)1)<<32 * t->cur_heart_beat_number
+ + lttEvent->time_delta;
+
lttEvent->tracefile = t;
lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE;
* EIO : can not read from the file
****************************************************************************/
-int readBlock(ltt_tracefile * tf, int whichBlock)
+int readBlock(LttTracefile * tf, int whichBlock)
{
off_t nbBytes;
uint32_t lostSize;
if(whichBlock - tf->which_block == 1 && tf->which_block != 0){
- tf->prev_block_end_time = tf->a_block_footer->time;
+ tf->prev_block_end_time = tf->a_block_end->time;
}else{
tf->prev_block_end_time.tv_sec = 0;
tf->prev_block_end_time.tv_nsec = 0;
tf->prev_event_time.tv_sec = 0;
tf->prev_event_time.tv_nsec = 0;
- nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->trace_header->buffer_size),
- SEEK_SET);
+ nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET);
if(nbBytes == -1) return EINVAL;
- if(readFile(tf->fd,tf->buffer,tf->trace_header->buffer_size,
- "Unable to read a block")) return EIO;
+ if(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block"))
+ return EIO;
+ tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE);
+ lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t));
+ tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size -
+ lostSize + EVENT_HEADER_SIZE);
- tf->a_block_header=(block_header *) tf->buffer;
- lostSize = *(uint32_t*)(tf->buffer + tf->trace_header->buffer_size
- - sizeof(uint32_t));
- /* skip event ID and time delta to get the address of the block foot */
- tf->a_block_footer=(block_footer *)(tf->buffer+tf->trace_header->buffer_size
- -lostSize+sizeof(uint8_t)+sizeof(uint32_t));
tf->which_block = whichBlock;
- tf->which_event = 0;
- tf->first_event_pos = tf->buffer + sizeof(block_header);
- if(tf->which_block == 1){
- tf->which_event++;
- tf->first_event_pos += sizeof(trace_header_event);
- }
- tf->cur_event_pos = tf->first_event_pos;
- tf->current_event_time = tf->a_block_header->time;
+ tf->which_event = 1;
+ tf->cur_event_pos = tf->a_block_start + sizeof(BlockStart); //first event
tf->cur_heart_beat_number = 0;
+
+ tf->current_event_time = getEventTime(tf);
getCyclePerNsec(tf);
* tf : tracefile
****************************************************************************/
-void updateTracefile(ltt_tracefile * tf)
+void updateTracefile(LttTracefile * tf)
{
- if(tf->which_block == 1)tf->which_event = 1;
- else tf->which_event = 0;
- tf->cur_event_pos = tf->first_event_pos;
- tf->current_event_time = tf->a_block_header->time;
+ tf->which_event = 1;
+ tf->cur_event_pos = tf->a_block_start + sizeof(BlockStart);
+ tf->current_event_time = getEventTime(tf);
tf->cur_heart_beat_number = 0;
tf->prev_event_time.tv_sec = 0;
* ERANGE : event id is out of range
****************************************************************************/
-int skipEvent(ltt_tracefile * t)
+int skipEvent(LttTracefile * t)
{
int evId, err;
void * evData;
- ltt_eventtype * evT;
- ltt_field * rootFld;
+ LttEventType * evT;
+ LttField * rootFld;
- evId = (int)(*(uint8_t *)(t->cur_event_pos));
+ evId = (int)(*(uint16_t *)(t->cur_event_pos));
evData = t->cur_event_pos + EVENT_HEADER_SIZE;
- evT = ltt_tracefile_eventtype_get(t,(unsigned)evId);
+ evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
if(evT) rootFld = evT->root_field;
else return ERANGE;
evT->latest_event = t->which_event;
//the next event is in the next block
- if(t->which_event == t->a_block_header->event_count - 1){
+ if(evId == TRACE_BLOCK_END){
if(t->which_block == t->block_number) return ENOENT;
err = readBlock(t, t->which_block + 1);
if(err) return err;
* t : tracefile
****************************************************************************/
-void getCyclePerNsec(ltt_tracefile * t)
+void getCyclePerNsec(LttTracefile * t)
{
- ltt_time lBufTotalTime; /* Total time for this buffer */
- ltt_cycle_count lBufTotalNSec; /* Total time for this buffer in nsecs */
- ltt_cycle_count lBufTotalCycle;/* Total cycles for this buffer */
+ LttTime lBufTotalTime; /* Total time for this buffer */
+ LttCycleCount lBufTotalNSec; /* Total time for this buffer in nsecs */
+ LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */
/* Calculate the total time for this buffer */
- TimeSub(lBufTotalTime,t->a_block_footer->time, t->a_block_header->time);
+ TimeSub(lBufTotalTime,t->a_block_end->time, t->a_block_start->time);
/* Calculate the total cycles for this bufffer */
- lBufTotalCycle = t->a_block_footer->cycle_count
- - t->a_block_header->cycle_count;
+ lBufTotalCycle = t->a_block_end->cycle_count
+ - t->a_block_start->cycle_count;
/* Convert the total time to nsecs */
lBufTotalNSec = lBufTotalTime.tv_sec * 1000000000 + lBufTotalTime.tv_nsec;
*Input params
* tf : tracefile
*Return value
- * ltt_time : the time of the event
+ * LttTime : the time of the event
****************************************************************************/
-ltt_time getEventTime(ltt_tracefile * tf)
+LttTime getEventTime(LttTracefile * tf)
{
- ltt_time time;
- ltt_cycle_count cycle_count; /* cycle count for the current event */
- ltt_cycle_count lEventTotalCycle; /* Total cycles from start for event */
- double lEventNSec; /* Total usecs from start for event */
- ltt_time lTimeOffset; /* Time offset in struct ltt_time */
+ LttTime time;
+ LttCycleCount cycle_count; // cycle count for the current event
+ LttCycleCount lEventTotalCycle; // Total cycles from start for event
+ double lEventNSec; // Total usecs from start for event
+ LttTime lTimeOffset; // Time offset in struct LttTime
- /* Calculate total time in cycles from start of buffer for this event */
- cycle_count = *(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
+ // Calculate total time in cycles from start of buffer for this event
+ cycle_count = (LttCycleCount)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
if(tf->cur_heart_beat_number)
cycle_count += ((uint64_t)1)<<32 * tf->cur_heart_beat_number;
- lEventTotalCycle=cycle_count-(tf->a_block_header->cycle_count & 0xFFFFFFFF);
+ lEventTotalCycle = cycle_count - tf->a_block_start->cycle_count;
- /* Convert it to nsecs */
+ // Convert it to nsecs
lEventNSec = lEventTotalCycle / tf->cycle_per_nsec;
- /* Determine offset in struct ltt_time */
+ // Determine offset in struct LttTime
lTimeOffset.tv_nsec = (long)lEventNSec % 1000000000;
lTimeOffset.tv_sec = (long)lEventNSec / 1000000000;
- TimeAdd(time, tf->a_block_header->time, lTimeOffset);
+ TimeAdd(time, tf->a_block_start->time, lTimeOffset);
return time;
}
* evD : event data, it may be NULL
****************************************************************************/
-void setFieldsOffset(ltt_tracefile * t, ltt_eventtype * evT, void * evD)
+void setFieldsOffset(LttTracefile * t, LttEventType * evT, void * evD)
{
- ltt_field * rootFld = evT->root_field;
+ LttField * rootFld = evT->root_field;
// rootFld->base_address = evD;
rootFld->field_size = getFieldtypeSize(t, evT, 0,0,rootFld, evD);
* int : size of the field
****************************************************************************/
-int getFieldtypeSize(ltt_tracefile * t, ltt_eventtype * evT, int offsetRoot,
- int offsetParent, ltt_field * fld, void * evD)
+int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
+ int offsetParent, LttField * fld, void * evD)
{
int size, size1, element_number, i, offset1, offset2;
- ltt_type * type = fld->field_type;
+ LttType * type = fld->field_type;
- if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){
- return fld->field_size;
- }
+ if(!t){
+ if(evT->latest_block==t->which_block && evT->latest_event==t->which_event){
+ return fld->field_size;
+ }
+ }
if(fld->field_fixed == 1){
if(fld == evT->root_field) return fld->field_size;
if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
if(fld->field_fixed == -1){
- size = (int) ltt_type_size(t, type);
+ size = (int) ltt_type_size(t->trace, type);
fld->field_fixed = 1;
}else size = fld->field_size;
}else size = fld->field_size;
}else if(type->type_class == LTT_SEQUENCE){
- size1 = (int) ltt_type_size(t, type);
+ size1 = (int) ltt_type_size(t->trace, type);
if(fld->field_fixed == -1){
fld->field_fixed = 0;
size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL);
* int : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2
****************************************************************************/
-int timecmp(ltt_time * t1, ltt_time * t2)
+int timecmp(LttTime * t1, LttTime * t2)
{
- ltt_time T;
+ LttTime T;
TimeSub(T, *t1, *t2);
if(T.tv_sec == 0 && T.tv_nsec == 0) return 0;
else if(T.tv_sec > 0 || (T.tv_sec==0 && T.tv_nsec > 0)) return 1;
* endian : endian type, little or big
****************************************************************************/
-void getDataEndianType(ltt_arch_size * size, ltt_arch_endian * endian)
+void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
{
int i = 1;
char c = (char) i;
* char * : the name of the event type
****************************************************************************/
-char *ltt_eventtype_name(ltt_eventtype *et)
+char *ltt_eventtype_name(LttEventType *et)
{
return et->name;
}
* char * : the description of the event type
****************************************************************************/
-char *ltt_eventtype_description(ltt_eventtype *et)
+char *ltt_eventtype_description(LttEventType *et)
{
return et->description;
}
+/*****************************************************************************
+ *Function name
+ * ltt_eventtype_facility : get the facility which contains the event type
+ *Input params
+ * et : an event type
+ *Return value
+ * LttFacility * : the facility
+ ****************************************************************************/
+
+LttFacility *ltt_eventtype_facility(LttEventType *et)
+{
+ return et->facility;
+}
+
+/*****************************************************************************
+ *Function name
+ * ltt_eventtype_relative_id : get the relative id of the event type
+ *Input params
+ * et : an event type
+ *Return value
+ * unsigned * : the relative id
+ ****************************************************************************/
+
+unsigned *ltt_eventtype_relative_id(LttEventType *et)
+{
+ return (unsigned*)&et->index;
+}
+
+/*****************************************************************************
+ *Function name
+ * ltt_eventtype_id : get the id of the event type
+ *Input params
+ * et : an event type
+ *Return value
+ * unsigned * : the id
+ ****************************************************************************/
+
+unsigned *ltt_eventtype_id(LttEventType *et)
+{
+ unsigned *id = g_new(unsigned,1);
+ *id = et->facility->base_id + et->index;
+ return (unsigned*)id;
+}
+
/*****************************************************************************
*Function name
* ltt_eventtype_type : get the type of the event type
*Input params
* et : an event type
*Return value
- * ltt_type * : the type of the event type
+ * LttType * : the type of the event type
****************************************************************************/
-ltt_type *ltt_eventtype_type(ltt_eventtype *et)
+LttType *ltt_eventtype_type(LttEventType *et)
{
return et->root_field->field_type;
}
+/*****************************************************************************
+ *Function name
+ * ltt_eventtype_field : get the root filed of the event type
+ *Input params
+ * et : an event type
+ *Return value
+ * LttField * : the root filed of the event type
+ ****************************************************************************/
+
+LttField *ltt_eventtype_field(LttEventType *et)
+{
+ return et->root_field;
+}
+
/*****************************************************************************
*Function name
* ltt_type_name : get the name of the type
* char * : the name of the type
****************************************************************************/
-char *ltt_type_name(ltt_type *t)
+char *ltt_type_name(LttType *t)
{
return t->element_name;
}
*Input params
* t : a type
*Return value
- * ltt_type_enum : the type class of the type
+ * LttTypeEnum : the type class of the type
****************************************************************************/
-ltt_type_enum ltt_type_class(ltt_type *t)
+LttTypeEnum ltt_type_class(LttType *t)
{
return t->type_class;
}
* unsigned : the type size
****************************************************************************/
-unsigned ltt_type_size(ltt_tracefile * tf, ltt_type *t)
+unsigned ltt_type_size(LttTrace * trace, LttType *t)
{
if(t->type_class==LTT_STRUCT || t->type_class==LTT_ARRAY ||
t->type_class==LTT_STRING) return 0;
if(t->size < sizeof(intSizes)/sizeof(unsigned))
return intSizes[t->size];
else{
- ltt_arch_size size = tf->trace_header->arch_size;
+ LttArchSize size = trace->system_description->size;
if(size == LTT_LP32)
return sizeof(int16_t);
else if(size == LTT_ILP32 || size == LTT_LP64)
*Input params
* t : a type
*Return value
- * ltt_type : the type of nested element of array or sequence
+ * LttType : the type of nested element of array or sequence
****************************************************************************/
-ltt_type *ltt_type_element_type(ltt_type *t)
+LttType *ltt_type_element_type(LttType *t)
{
if(t->type_class != LTT_ARRAY || t->type_class != LTT_SEQUENCE)
return NULL;
* unsigned : the number of elements for arrays
****************************************************************************/
-unsigned ltt_type_element_number(ltt_type *t)
+unsigned ltt_type_element_number(LttType *t)
{
if(t->type_class != LTT_ARRAY)
return 0;
* unsigned : the number of members for structure
****************************************************************************/
-unsigned ltt_type_member_number(ltt_type *t)
+unsigned ltt_type_member_number(LttType *t)
{
- if(t->type_class != LTT_STRUCT)
+ if(t->type_class != LTT_STRUCT || t->type_class != LTT_UNION)
return 0;
return t->element_number;
}
* t : a type
* i : index of the member
*Return value
- * ltt_type * : the type of structure member
+ * LttType * : the type of structure member
****************************************************************************/
-ltt_type *ltt_type_member_type(ltt_type *t, unsigned i)
+LttType *ltt_type_member_type(LttType *t, unsigned i)
{
if(t->type_class != LTT_STRUCT) return NULL;
if(i > t->element_number || i == 0 ) return NULL;
* char * : symbolic string associated with a value
****************************************************************************/
-char *ltt_enum_string_get(ltt_type *t, unsigned i)
+char *ltt_enum_string_get(LttType *t, unsigned i)
{
if(t->type_class != LTT_ENUM) return NULL;
if(i > t->element_number || i == 0 ) return NULL;
*Input params
* f : a field
*Return value
- * ltt_field * : the field of the nested element
+ * LttField * : the field of the nested element
****************************************************************************/
-ltt_field *ltt_field_element(ltt_field *f)
+LttField *ltt_field_element(LttField *f)
{
if(f->field_type->type_class != LTT_ARRAY ||
f->field_type->type_class != LTT_SEQUENCE)
* f : a field
* i : index of member field
*Return value
- * ltt_field * : the field of the nested element
+ * LttField * : the field of the nested element
****************************************************************************/
-ltt_field *ltt_field_member(ltt_field *f, unsigned i)
+LttField *ltt_field_member(LttField *f, unsigned i)
{
if(f->field_type->type_class != LTT_STRUCT) return NULL;
if(i==0 || i>f->field_type->element_number) return NULL;
* ltt_tyoe * : the type of field
****************************************************************************/
-ltt_type *ltt_field_type(ltt_field *f)
+LttType *ltt_field_type(LttField *f)
{
return f->field_type;
}
projects / lttv.git / commitdiff
