X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ffacility.c;h=5b854131c6244652c328034dd4d1fd1a4b490d52;hb=70076b6a47206b1e6c668cdc468e23953ae1f2fb;hp=bd50c198f90845a53d26439ac4cb5fc90556fd8f;hpb=1417d99025759138157bdaea4f32b7cd8f1f92e4;p=lttv.git diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c index bd50c198..5b854131 100644 --- a/ltt/branches/poly/ltt/facility.c +++ b/ltt/branches/poly/ltt/facility.c @@ -1,28 +1,65 @@ +/* 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 + * published by the Free Software Foundation; + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif + #include #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); /* 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 * td, LttField * fld); /* generate the facility according to the events belongin to it */ -void generateFacility(LttFacility * f, facility * fac, - LttChecksum checksum); +void generateFacility(LttFacility * f, facility_t * fac, + guint32 checksum); /* functions to release the memory occupied by a facility */ void freeFacility(LttFacility * facility); void freeEventtype(LttEventType * evType); void freeLttType(LttType ** type); void freeLttField(LttField * fld); +void freeLttNamedType(LttType * type); /***************************************************************************** @@ -31,34 +68,44 @@ void freeLttField(LttField * fld); *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; + gchar *token; parse_file in; - char buffer[BUFFER_SIZE]; - facility * fac; - LttFacility * f; - LttChecksum checksum; + gsize length; + facility_t * fac; + guint32 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.fp = fopen(in.name, "r"); - if(!in.fp ) in.error(&in,"cannot open input file"); + in.fd = g_open(in.name, O_RDONLY, 0); + if(in.fd < 0 ) { + g_warning("cannot open facility description file %s", + in.name); + return 1; + } + + 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) { - fac = g_new(facility, 1); + + if(g_ascii_strcasecmp("facility",token) == 0) { + fac = g_new(facility_t, 1); fac->name = NULL; fac->description = NULL; sequence_init(&(fac->events)); @@ -68,18 +115,14 @@ void ltt_facility_open(LttTrace * t, char * pathname) parseFacility(&in, fac); //check if any namedType is not defined - checkNamedTypesImplemented(&fac->named_types); + g_assert(checkNamedTypesImplemented(&fac->named_types) == 0); - generateChecksum(fac->name, &checksum, &fac->events); + g_assert(generateChecksum(fac->name, &checksum, &fac->events) == 0); - 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); + g_free(fac->name); + g_free(fac->description); freeEvents(&fac->events); sequence_dispose(&fac->events); freeNamedType(&fac->named_types); @@ -88,9 +131,20 @@ 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); + goto parse_error; + } + } + + parse_error: + g_io_channel_shutdown(in.channel, FALSE, &error); /* No flush */ + if(error != NULL) { + g_warning("Can not close file: \n%s\n", error->message); + g_error_free(error); } - fclose(in.fp); + + g_close(in.fd); } @@ -103,57 +157,76 @@ void ltt_facility_open(LttTrace * t, char * pathname) * checksum : checksum of the facility ****************************************************************************/ -void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum) +void generateFacility(LttFacility *f, facility_t *fac, guint32 checksum) { char * facilityName = fac->name; sequence * 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*)(events->array[i]))->name); - evType->description=g_strdup(((event*)(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*)(events->array[i]))->type != NULL){ - field->field_pos = 0; - type = lookup_named_type(f,((event*)(events->array[i]))->type); + if(((event_t*)(events->array[i]))->type != NULL){ + // 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*)(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); } } @@ -162,7 +235,7 @@ void generateFacility(LttFacility *f, facility *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 @@ -170,10 +243,90 @@ void generateFacility(LttFacility *f, facility *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 * td, LttField * fld) { - int i; + int i, flag; + type_descriptor * tmpTd; + + switch(td->type) { + case LTT_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]))); + } + break; + case LTT_ARRAY: + fld->field_type->element_number = (unsigned)td->size; + case LTT_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 LTT_STRUCT: + case LTT_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 = ((type_fields*)(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(((type_fields*)(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; type_descriptor * tmpTd; // if(td->type == LTT_STRING || td->type == LTT_SEQUENCE) @@ -182,10 +335,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) @@ -196,7 +349,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; @@ -208,20 +361,33 @@ 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; - fld->field_type->element_type = g_new(LttType*, td->fields.position); + + if(fld->field_type->element_type == NULL){ + fld->field_type->element_type = g_new(LttType*, td->fields.position); + flag = 1; + }else{ + flag = 0; + } + fld->child = g_new(LttField*, td->fields.position); for(i=0;ifields.position;i++){ - tmpTd = ((field*)(td->fields.array[i]))->type; - fld->field_type->element_type[i] = lookup_named_type(fac, tmpTd); + tmpTd = ((type_fields*)(td->fields.array[i]))->type; + + if(flag) + 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_strdup(((field*)(td->fields.array[i]))->name); + + if(flag){ + fld->child[i]->field_type->element_name + = g_quark_from_string(((type_fields*)(td->fields.array[i]))->name); + } + fld->child[i]->offset_root = -1; fld->child[i]->fixed_root = -1; fld->child[i]->offset_parent = -1; @@ -232,11 +398,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 @@ -251,39 +417,25 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) { - LttType * lttType = NULL; - 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]->element_name; - if(strcmp(name, td->type_name)==0){ - lttType = fac->named_types[i]; - break; - } - } - } + GQuark name = g_quark_from_string(td->type_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; - if(td->type_name){ - lttType->element_name = g_strdup(td->type_name); - fac->named_types[i] = lttType; - } - else{ - lttType->element_name = NULL; - } + LttType *type = g_datalist_id_get_data(&fac->named_types, name); + + if(type == NULL){ + type = g_new(LttType,1); + type->type_name = name; + g_datalist_id_set_data_full(&fac->named_types, name, + type, (GDestroyNotify)freeLttNamedType); + 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; } - return lttType; + return type; } @@ -293,16 +445,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; } /***************************************************************************** @@ -311,51 +459,52 @@ int ltt_facility_close(LttFacility *f) void freeFacility(LttFacility * fac) { - 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 - g_free(fac->named_types); + g_datalist_clear(&fac->named_types); - //free the facility itself - g_free(fac); } void freeEventtype(LttEventType * evType) { - g_free(evType->name); + LttType * root_type; if(evType->description) g_free(evType->description); if(evType->root_field){ + root_type = evType->root_field->field_type; freeLttField(evType->root_field); + freeLttType(&root_type); } +} - g_free(evType); +void freeLttNamedType(LttType * type) +{ + freeLttType(&type); } void freeLttType(LttType ** type) { - int i; + unsigned int i; if(*type == NULL) return; - if((*type)->element_name) - g_free((*type)->element_name); + //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); } if((*type)->element_type){ - // for(i=0;i<(*type)->element_number;i++) - // freeLttType(&((*type)->element_type[i])); + for(i=0;i<(*type)->element_number;i++) + freeLttType(&((*type)->element_type[i])); g_free((*type)->element_type); } g_free(*type); @@ -365,7 +514,7 @@ void freeLttType(LttType ** type) void freeLttField(LttField * fld) { int i; - int size; + int size = 0; if(fld->field_type){ if(fld->field_type->type_class == LTT_ARRAY || @@ -374,7 +523,6 @@ void freeLttField(LttField * fld) }else if(fld->field_type->type_class == LTT_STRUCT){ size = fld->field_type->element_number; } - freeLttType(&(fld->field_type)); } if(fld->child){ @@ -390,12 +538,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; } @@ -404,12 +552,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; } @@ -423,9 +571,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; } /***************************************************************************** @@ -434,12 +582,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 (unsigned)(f->event_number); + return (f->events->len); } /***************************************************************************** @@ -452,9 +600,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); } /***************************************************************************** @@ -463,22 +614,14 @@ 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) { - 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_get_data(&f->events_by_name, name); }