X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ffacility.c;h=53519c02a683046b00b0b10b2c95aa16931a3aff;hb=3b10b765f2ed7b5758cf37c4dea8cb511edd289a;hp=f8e8962ffdb089e33e8b4508d57e1f178cd232aa;hpb=fc063e40663e33543deebe5e57d6847f2aca5da7;p=lttv.git diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c index f8e8962f..53519c02 100644 --- a/ltt/branches/poly/ltt/facility.c +++ b/ltt/branches/poly/ltt/facility.c @@ -1,5 +1,6 @@ /* This file is part of the Linux Trace Toolkit viewer * Copyright (C) 2003-2004 Xiangxiu Yang + * 2005 Mathieu Desnoyers * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License Version 2 as @@ -16,26 +17,42 @@ * MA 02111-1307, USA. */ +#ifdef HAVE_CONFIG_H +#include +#endif + #include #include #include +#include +#include +#include +#include + + #include "parser.h" #include #include "ltt-private.h" #include +#ifndef g_open +#define g_open open +#endif + +#define g_close close + /* search for the (named) type in the table, if it does not exist create a new one */ -LttType * lookup_named_type(LttFacility *fac, type_descriptor * td); +LttType * lookup_named_type(LttFacility *fac, type_descriptor_t * td); /* construct directed acyclic graph for types, and tree for fields */ -void constructTypeAndFields(LttFacility * fac,type_descriptor * td, +void construct_types_and_fields(LttFacility * fac, type_descriptor_t * td, LttField * fld); /* generate the facility according to the events belongin to it */ void generateFacility(LttFacility * f, facility_t * fac, - LttChecksum checksum); + guint32 checksum); /* functions to release the memory occupied by a facility */ void freeFacility(LttFacility * facility); @@ -51,33 +68,46 @@ void freeLttNamedType(LttType * type); *Input params * t : the trace containing the facilities * pathname : the path name of the facility + * + *returns 0 on success, 1 on error. ****************************************************************************/ -void ltt_facility_open(LttTrace * t, char * pathname) +int ltt_facility_open(LttFacility *f, LttTrace * t, gchar * pathname) { - char *token; - parse_file in; - char buffer[BUFFER_SIZE]; + int ret = 0; + gchar *token; + parse_file_t in; facility_t * fac; - LttFacility * f; - LttChecksum checksum; + unsigned long checksum; + //GError * error = NULL; + gchar buffer[BUFFER_SIZE]; - in.buffer = buffer; + in.buffer = &(buffer[0]); in.lineno = 0; in.error = error_callback; in.name = pathname; + //in.fd = g_open(in.name, O_RDONLY, 0); + //if(in.fd < 0 ) { in.fp = fopen(in.name, "r"); - if(!in.fp ) in.error(&in,"cannot open input file"); + if(in.fp == NULL) { + g_warning("cannot open facility description file %s", + in.name); + ret = 1; + goto open_error; + } + + //in.channel = g_io_channel_unix_new(in.fd); + //in.pos = 0; while(1){ token = getToken(&in); if(in.type == ENDFILE) break; - if(strcmp(token, "<")) in.error(&in,"not a facility file"); + if(g_ascii_strcasecmp(token, "<")) in.error(&in,"not a facility file"); token = getName(&in); - - if(strcmp("facility",token) == 0) { + + if(g_ascii_strcasecmp("facility",token) == 0) { fac = g_new(facility_t, 1); fac->name = NULL; fac->description = NULL; @@ -88,19 +118,14 @@ void ltt_facility_open(LttTrace * t, char * pathname) parseFacility(&in, fac); //check if any namedType is not defined - g_assert(checkNamedTypesImplemented(&fac->named_types) == 0); + checkNamedTypesImplemented(&fac->named_types); - g_assert(generateChecksum(fac->name, &checksum, &fac->events) == 0); + generateChecksum(fac->name, &checksum, &fac->events); - f = g_new(LttFacility,1); - f->base_id = 0; generateFacility(f, fac, checksum); - t->facility_number++; - g_ptr_array_add(t->facilities,f); - - free(fac->name); - free(fac->description); + g_free(fac->name); + g_free(fac->description); freeEvents(&fac->events); sequence_dispose(&fac->events); freeNamedType(&fac->named_types); @@ -109,9 +134,24 @@ void ltt_facility_open(LttTrace * t, char * pathname) sequence_dispose(&fac->unnamed_types); g_free(fac); } - else in.error(&in,"facility token was expected"); + else { + g_warning("facility token was expected in file %s", in.name); + ret = 1; + goto parse_error; + } } + + parse_error: + //g_io_channel_shutdown(in.channel, FALSE, &error); /* No flush */ + //if(error != NULL) { fclose(in.fp); +open_error: + // g_warning("Can not close file: \n%s\n", error->message); + // g_error_free(error); + //} + + //g_close(in.fd); + return ret; } @@ -124,57 +164,76 @@ void ltt_facility_open(LttTrace * t, char * pathname) * checksum : checksum of the facility ****************************************************************************/ -void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) +void generateFacility(LttFacility *f, facility_t *fac, guint32 checksum) { char * facilityName = fac->name; - sequence * events = &fac->events; + sequence_t * events = &fac->events; int i; - LttEventType * evType; + //LttEventType * evType; + LttEventType * event_type; LttField * field; LttType * type; - f->name = g_strdup(facilityName); - f->event_number = events->position; - f->checksum = checksum; + g_assert(f->name == g_quark_from_string(facilityName)); + g_assert(f->checksum == checksum); + + //f->event_number = events->position; //initialize inner structures - f->events = g_new(LttEventType*,f->event_number); - f->named_types_number = fac->named_types.keys.position; - f->named_types = g_new(LttType*, fac->named_types.keys.position); - for(i=0;inamed_types.keys.position;i++) f->named_types[i] = NULL; + f->events = g_array_sized_new (FALSE, TRUE, sizeof(LttEventType), + events->position); + //f->events = g_new(LttEventType*,f->event_number); + f->events = g_array_set_size(f->events, events->position); + + g_datalist_init(&f->events_by_name); + g_datalist_init(&f->named_types); + + //f->named_types_number = fac->named_types.keys.position; + //f->named_types = g_array_sized_new (FALSE, TRUE, sizeof(LttType), + // fac->named_types.keys.position); + //f->named_types = g_new(LttType*, fac->named_types.keys.position); + //f->named_types = g_array_set_size(f->named_types, + // fac->named_types.keys.position); //for each event, construct field tree and type graph for(i=0;iposition;i++){ - evType = g_new(LttEventType,1); - f->events[i] = evType; + event_type = &g_array_index(f->events, LttEventType, i); + //evType = g_new(LttEventType,1); + //f->events[i] = evType; - evType->name = g_strdup(((event_t*)(events->array[i]))->name); - evType->description=g_strdup(((event_t*)(events->array[i]))->description); + event_type->name = + g_quark_from_string(((event_t*)(events->array[i]))->name); + + g_datalist_id_set_data(&f->events_by_name, event_type->name, + event_type); + + event_type->description = + g_strdup(((event_t*)(events->array[i]))->description); field = g_new(LttField, 1); - evType->root_field = field; - evType->facility = f; - evType->index = i; + event_type->root_field = field; + event_type->facility = f; + event_type->index = i; if(((event_t*)(events->array[i]))->type != NULL){ - field->field_pos = 0; + // field->field_pos = 0; type = lookup_named_type(f,((event_t*)(events->array[i]))->type); field->field_type = type; field->offset_root = 0; - field->fixed_root = 1; + field->fixed_root = FIELD_UNKNOWN; field->offset_parent = 0; - field->fixed_parent = 1; + field->fixed_parent = FIELD_UNKNOWN; // field->base_address = NULL; field->field_size = 0; - field->field_fixed = -1; + field->fixed_size = FIELD_UNKNOWN; field->parent = NULL; field->child = NULL; field->current_element = 0; //construct field tree and type graph - constructTypeAndFields(f,((event_t*)(events->array[i]))->type,field); + construct_types_and_fields(f,((event_t*)(events->array[i]))->type,field); }else{ - evType->root_field = NULL; + event_type->root_field = NULL; g_free(field); } } @@ -183,7 +242,7 @@ void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) /***************************************************************************** *Function name - * constructTypeAndFields : construct field tree and type graph, + * construct_types_and_fields : construct field tree and type graph, * internal recursion function *Input params * fac : facility struct @@ -191,7 +250,106 @@ void generateFacility(LttFacility *f, facility_t *fac,LttChecksum checksum) * root_field : root field of the event ****************************************************************************/ -void constructTypeAndFields(LttFacility * fac,type_descriptor * td, + +void construct_types_and_fields(LttFacility * fac, type_descriptor_t * td, + LttField * fld) +{ + int i; + type_descriptor_t * tmpTd; + + switch(td->type) { + case INT: + case UINT: + case FLOAT: + fld->field_type->size = td->size; + break; + case POINTER: + case LONG: + case ULONG: + case SIZE_T: + case SSIZE_T: + case OFF_T: + fld->field_type->size = 0; + break; + case STRING: + fld->field_type->size = 0; + break; + case ENUM: + fld->field_type->element_number = td->labels.position; + fld->field_type->enum_strings = g_new(GQuark,td->labels.position); + for(i=0;ilabels.position;i++){ + fld->field_type->enum_strings[i] + = g_quark_from_string(((char*)(td->labels.array[i]))); + } + fld->field_type->size = td->size; + break; + + case ARRAY: + fld->field_type->element_number = (unsigned)td->size; + case SEQUENCE: + 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(LttField*, 1); + fld->child[0] = g_new(LttField, 1); + + fld->child[0]->field_type = fld->field_type->element_type[0]; + fld->child[0]->offset_root = 0; + fld->child[0]->fixed_root = FIELD_UNKNOWN; + fld->child[0]->offset_parent = 0; + fld->child[0]->fixed_parent = FIELD_UNKNOWN; + fld->child[0]->field_size = 0; + fld->child[0]->fixed_size = FIELD_UNKNOWN; + fld->child[0]->parent = fld; + fld->child[0]->child = NULL; + fld->child[0]->current_element = 0; + construct_types_and_fields(fac, tmpTd, fld->child[0]); + break; + + case STRUCT: + case UNION: + fld->field_type->element_number = td->fields.position; + + g_assert(fld->field_type->element_type == NULL); + fld->field_type->element_type = g_new(LttType*, td->fields.position); + + fld->child = g_new(LttField*, td->fields.position); + for(i=0;ifields.position;i++){ + tmpTd = ((field_t*)(td->fields.array[i]))->type; + + fld->field_type->element_type[i] = lookup_named_type(fac, tmpTd); + fld->child[i] = g_new(LttField,1); + + // fld->child[i]->field_pos = i; + fld->child[i]->field_type = fld->field_type->element_type[i]; + + fld->child[i]->field_type->element_name + = g_quark_from_string(((field_t*)(td->fields.array[i]))->name); + + fld->child[i]->offset_root = 0; + fld->child[i]->fixed_root = FIELD_UNKNOWN; + fld->child[i]->offset_parent = 0; + fld->child[i]->fixed_parent = FIELD_UNKNOWN; + fld->child[i]->field_size = 0; + fld->child[i]->fixed_size = FIELD_UNKNOWN; + fld->child[i]->parent = fld; + fld->child[i]->child = NULL; + fld->child[i]->current_element = 0; + construct_types_and_fields(fac, tmpTd, fld->child[i]); + } + break; + + default: + g_error("construct_types_and_fields : unknown type"); + } + + +} + + + +#if 0 +void construct_types_and_fields(LttFacility * fac, type_descriptor * td, LttField * fld) { int i, flag; @@ -203,10 +361,10 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, if(td->type == LTT_ENUM){ fld->field_type->element_number = td->labels.position; - fld->field_type->enum_strings = g_new(char*,td->labels.position); + fld->field_type->enum_strings = g_new(GQuark,td->labels.position); for(i=0;ilabels.position;i++){ fld->field_type->enum_strings[i] - = g_strdup(((char*)(td->labels.array[i]))); + = g_quark_from_string(((char*)(td->labels.array[i]))); } }else if(td->type == LTT_ARRAY || td->type == LTT_SEQUENCE){ if(td->type == LTT_ARRAY) @@ -217,7 +375,7 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child = g_new(LttField*, 1); fld->child[0] = g_new(LttField, 1); - fld->child[0]->field_pos = 0; +// fld->child[0]->field_pos = 0; fld->child[0]->field_type = fld->field_type->element_type[0]; fld->child[0]->offset_root = fld->offset_root; fld->child[0]->fixed_root = fld->fixed_root; @@ -229,7 +387,7 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[0]->parent = fld; fld->child[0]->child = NULL; fld->child[0]->current_element = 0; - constructTypeAndFields(fac, tmpTd, fld->child[0]); + construct_types_and_fields(fac, tmpTd, fld->child[0]); }else if(td->type == LTT_STRUCT){ fld->field_type->element_number = td->fields.position; @@ -252,8 +410,8 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[i]->field_type = fld->field_type->element_type[i]; if(flag){ - fld->child[i]->field_type->element_name - = g_strdup(((type_fields*)(td->fields.array[i]))->name); + fld->child[i]->field_type->element_name + = g_quark_from_string(((type_fields*)(td->fields.array[i]))->name); } fld->child[i]->offset_root = -1; @@ -266,11 +424,11 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->child[i]->parent = fld; fld->child[i]->child = NULL; fld->child[i]->current_element = 0; - constructTypeAndFields(fac, tmpTd, fld->child[i]); + construct_types_and_fields(fac, tmpTd, fld->child[i]); } } } - +#endif //0 /***************************************************************************** *Function name @@ -283,44 +441,35 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, * : either find the named type, or create a new LttType ****************************************************************************/ -LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) +LttType * lookup_named_type(LttFacility *fac, type_descriptor_t * td) { - LttType * lttType = NULL; - unsigned int i; - char * name; - if(td->type_name){ - for(i=0;inamed_types_number; i++){ - if(fac->named_types[i] == NULL) break; - name = fac->named_types[i]->type_name; - if(strcmp(name, td->type_name)==0){ - lttType = fac->named_types[i]; - // if(lttType->element_name) g_free(lttType->element_name); - // lttType->element_name = NULL; - break; - } - } + LttType *type = NULL; + GQuark name = 0; + + if(td->type_name != NULL) { + /* Named type */ + name = g_quark_from_string(td->type_name); + + type = g_datalist_id_get_data(&fac->named_types, name); } - if(!lttType){ - lttType = g_new(LttType,1); - lttType->type_class = td->type; - if(td->fmt) lttType->fmt = g_strdup(td->fmt); - else lttType->fmt = NULL; - lttType->size = td->size; - lttType->enum_strings = NULL; - lttType->element_type = NULL; - lttType->element_number = 0; - lttType->element_name = NULL; - if(td->type_name){ - lttType->type_name = g_strdup(td->type_name); - fac->named_types[i] = lttType; - } - else{ - lttType->type_name = NULL; - } + if(type == NULL){ + /* Create the type */ + type = g_new(LttType,1); + type->type_name = name; + type->type_class = td->type; + if(td->fmt) type->fmt = g_strdup(td->fmt); + else type->fmt = NULL; + type->size = td->size; + type->enum_strings = NULL; + type->element_type = NULL; + type->element_number = 0; + + if(td->type_name != NULL) + g_datalist_id_set_data_full(&fac->named_types, name, + type, (GDestroyNotify)freeLttNamedType); } - - return lttType; + return type; } @@ -330,16 +479,12 @@ LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) * if usage count = 0, release the memory *Input params * f : facility that will be closed - *Return value - * int : usage count ?? status ****************************************************************************/ -int ltt_facility_close(LttFacility *f) +void ltt_facility_close(LttFacility *f) { //release the memory it occupied freeFacility(f); - - return 0; } /***************************************************************************** @@ -348,30 +493,22 @@ int ltt_facility_close(LttFacility *f) void freeFacility(LttFacility * fac) { - unsigned int i; - g_free(fac->name); //free facility name + guint i; + LttEventType *et; - //free event types - for(i=0;ievent_number;i++){ - freeEventtype(fac->events[i]); + for(i=0; ievents->len; i++) { + et = &g_array_index (fac->events, LttEventType, i); + freeEventtype(et); } - g_free(fac->events); + g_array_free(fac->events, TRUE); - //free all named types - for(i=0;inamed_types_number;i++){ - freeLttNamedType(fac->named_types[i]); - fac->named_types[i] = NULL; - } - g_free(fac->named_types); + g_datalist_clear(&fac->named_types); - //free the facility itself - g_free(fac); } void freeEventtype(LttEventType * evType) { LttType * root_type; - g_free(evType->name); if(evType->description) g_free(evType->description); if(evType->root_field){ @@ -379,14 +516,10 @@ void freeEventtype(LttEventType * evType) freeLttField(evType->root_field); freeLttType(&root_type); } - - g_free(evType); } void freeLttNamedType(LttType * type) { - g_free(type->type_name); - type->type_name = NULL; freeLttType(&type); } @@ -394,16 +527,13 @@ void freeLttType(LttType ** type) { unsigned int i; if(*type == NULL) return; - if((*type)->type_name){ - return; //this is a named type - } - if((*type)->element_name) - g_free((*type)->element_name); + if((*type)->type_name != 0) return; //this is a named type. + //if((*type)->type_name){ + // return; //this is a named type + //} if((*type)->fmt) g_free((*type)->fmt); if((*type)->enum_strings){ - for(i=0;i<(*type)->element_number;i++) - g_free((*type)->enum_strings[i]); g_free((*type)->enum_strings); } @@ -443,12 +573,12 @@ void freeLttField(LttField * fld) *Function name * ltt_facility_name : obtain the facility's name *Input params - * f : the facility that will be closed + * f : the facility *Return value - * char * : the facility's name + * GQuark : the facility's name ****************************************************************************/ -char *ltt_facility_name(LttFacility *f) +GQuark ltt_facility_name(LttFacility *f) { return f->name; } @@ -457,12 +587,12 @@ char *ltt_facility_name(LttFacility *f) *Function name * ltt_facility_checksum : obtain the facility's checksum *Input params - * f : the facility that will be closed + * f : the facility *Return value - * LttChecksum : the checksum of the facility + * : the checksum of the facility ****************************************************************************/ -LttChecksum ltt_facility_checksum(LttFacility *f) +guint32 ltt_facility_checksum(LttFacility *f) { return f->checksum; } @@ -476,9 +606,9 @@ LttChecksum ltt_facility_checksum(LttFacility *f) * : the base id of the facility ****************************************************************************/ -unsigned ltt_facility_base_id(LttFacility *f) +guint ltt_facility_id(LttFacility *f) { - return f->base_id; + return f->id; } /***************************************************************************** @@ -487,12 +617,12 @@ unsigned ltt_facility_base_id(LttFacility *f) *Input params * f : the facility that will be closed *Return value - * unsigned : the number of the event types + * : the number of the event types ****************************************************************************/ -unsigned ltt_facility_eventtype_number(LttFacility *f) +guint8 ltt_facility_eventtype_number(LttFacility *f) { - return (f->event_number); + return (f->events->len); } /***************************************************************************** @@ -505,9 +635,12 @@ unsigned ltt_facility_eventtype_number(LttFacility *f) * LttEventType * : the event type required ****************************************************************************/ -LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i) +LttEventType *ltt_facility_eventtype_get(LttFacility *f, guint8 i) { - return f->events[i]; + if(!f->exists) return NULL; + + g_assert(i < f->events->len); + return &g_array_index(f->events, LttEventType, i); } /***************************************************************************** @@ -516,22 +649,15 @@ LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i) * : obtain the event type according to event name * event name is unique in the facility *Input params - * f : the facility that will be closed + * f : the facility * name : the name of the event *Return value * LttEventType * : the event type required ****************************************************************************/ -LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, char *name) +LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, GQuark name) { - unsigned int i; - LttEventType * ev; - for(i=0;ievent_number;i++){ - ev = f->events[i]; - if(strcmp(ev->name, name) == 0)break; - } - - if(i==f->event_number) return NULL; - else return ev; + LttEventType *et = g_datalist_id_get_data(&f->events_by_name, name); + return et; }