X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ffacility.c;h=1aa6b432e6089e074b2ff4209cff7637c6f5dc49;hb=86005ded65d58cd800f80dfb31e78adb7d1149bf;hp=7efcbce08895af9caed18878fd5e1e70d6f994cc;hpb=8710c6c7ff79301b4802e595c25d2cdb43af8154;p=lttv.git diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c index 7efcbce0..1aa6b432 100644 --- a/ltt/branches/poly/ltt/facility.c +++ b/ltt/branches/poly/ltt/facility.c @@ -1,11 +1,42 @@ +/* This file is part of the Linux Trace Toolkit viewer + * Copyright (C) 2003-2004 Xiangxiu Yang + * + * 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. + */ + #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); @@ -15,17 +46,15 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttField * fld); /* generate the facility according to the events belongin to it */ -void generateFacility(LttFacility * f, facility * fac, +void generateFacility(LttFacility * f, facility_t * fac, LttChecksum checksum); /* functions to release the memory occupied by a facility */ 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(LttType * type); +void freeLttType(LttType ** type); void freeLttField(LttField * fld); +void freeLttNamedType(LttType * type); /***************************************************************************** @@ -36,32 +65,37 @@ void freeLttField(LttField * fld); * pathname : the path name of the facility ****************************************************************************/ -void ltt_facility_open(LttTrace * t, char * pathname) +void ltt_facility_open(LttTrace * t, gchar * pathname) { - char *token; + gchar *token; parse_file in; - char buffer[BUFFER_SIZE]; - facility * fac; + gsize length; + facility_t * fac; LttFacility * f; LttChecksum 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 ) in.error(&in,"cannot open input file"); + + 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)); @@ -71,29 +105,37 @@ 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); + 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); table_dispose(&fac->named_types); freeTypes(&fac->unnamed_types); sequence_dispose(&fac->unnamed_types); - free(fac); + g_free(fac); } else in.error(&in,"facility token was expected"); } - fclose(in.fp); + + 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); + } + + g_close(in.fd); } @@ -106,7 +148,7 @@ 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,LttChecksum checksum) { char * facilityName = fac->name; sequence * events = &fac->events; @@ -121,27 +163,26 @@ void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum) //initialize inner structures 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)); + 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; //for each event, construct field tree and type graph for(i=0;iposition;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); + evType->name = g_strdup(((event_t*)(events->array[i]))->name); + evType->description=g_strdup(((event_t*)(events->array[i]))->description); field = g_new(LttField, 1); - sequence_push(&(f->all_fields), field); evType->root_field = field; evType->facility = f; evType->index = i; - if(((event*)(events->array[i]))->type != NULL){ + if(((event_t*)(events->array[i]))->type != NULL){ field->field_pos = 0; - type = lookup_named_type(f,((event*)(events->array[i]))->type); + type = lookup_named_type(f,((event_t*)(events->array[i]))->type); field->field_type = type; field->offset_root = 0; field->fixed_root = 1; @@ -153,11 +194,11 @@ void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum) field->parent = NULL; field->child = NULL; field->current_element = 0; - + //construct field tree and type graph - constructTypeAndFields(f,((event*)(events->array[i]))->type,field); + constructTypeAndFields(f,((event_t*)(events->array[i]))->type,field); }else{ - evType->root_field = NULL; + evType->root_field = NULL; g_free(field); } } @@ -177,7 +218,7 @@ void generateFacility(LttFacility *f, facility *fac,LttChecksum checksum) void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttField * fld) { - int i; + int i, flag; type_descriptor * tmpTd; // if(td->type == LTT_STRING || td->type == LTT_SEQUENCE) @@ -199,7 +240,6 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, fld->field_type->element_type[0] = lookup_named_type(fac, tmpTd); 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; fld->child[0]->field_type = fld->field_type->element_type[0]; @@ -216,18 +256,30 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, 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(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); - sequence_push(&(fac->all_fields), fld->child[i]); 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_strdup(((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; @@ -258,14 +310,18 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) { LttType * lttType = NULL; - int i; - char * name; + unsigned int i=0; + gchar * name; + if(td->type_name){ - for(i=0;iall_named_types.keys.position;i++){ - name = (char *)(fac->all_named_types.keys.array[i]); - if(strcmp(name, td->type_name)==0){ - lttType = (LttType*)(fac->all_named_types.values.array[i]); - break; + for(i=0;inamed_types_number; i++){ + if(fac->named_types[i] == NULL) break; + name = fac->named_types[i]->type_name; + if(g_ascii_strcasecmp(name, td->type_name)==0){ + lttType = fac->named_types[i]; + // if(lttType->element_name) g_free(lttType->element_name); + // lttType->element_name = NULL; + break; } } } @@ -279,14 +335,13 @@ LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) lttType->enum_strings = NULL; lttType->element_type = NULL; lttType->element_number = 0; + lttType->element_name = NULL; if(td->type_name){ - name = g_strdup(td->type_name); - table_insert(&(fac->all_named_types),name,lttType); - lttType->element_name = name; + lttType->type_name = g_strdup(td->type_name); + fac->named_types[i] = lttType; /* i is initialized, checked. */ } else{ - sequence_push(&(fac->all_unnamed_types), lttType); - lttType->element_name = NULL; + lttType->type_name = NULL; } } @@ -318,7 +373,7 @@ int ltt_facility_close(LttFacility *f) void freeFacility(LttFacility * fac) { - int i; + unsigned int i; g_free(fac->name); //free facility name //free event types @@ -328,13 +383,11 @@ void freeFacility(LttFacility * fac) g_free(fac->events); //free all named types - freeAllNamedTypes(&(fac->all_named_types)); - - //free all unnamed types - freeAllUnamedTypes(&(fac->all_unnamed_types)); - - //free all fields - freeAllFields(&(fac->all_fields)); + for(i=0;inamed_types_number;i++){ + freeLttNamedType(fac->named_types[i]); + fac->named_types[i] = NULL; + } + g_free(fac->named_types); //free the facility itself g_free(fac); @@ -342,68 +395,72 @@ void freeFacility(LttFacility * fac) void freeEventtype(LttEventType * evType) { + LttType * root_type; g_free(evType->name); 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 freeAllNamedTypes(table * named_types) +void freeLttNamedType(LttType * type) { - int i; - for(i=0;ikeys.position;i++){ - //free the name of the type - g_free((char*)(named_types->keys.array[i])); - - //free type - freeLttType((LttType*)(named_types->values.array[i])); - } - table_dispose(named_types); + g_free(type->type_name); + type->type_name = NULL; + freeLttType(&type); } -void freeAllUnamedTypes(sequence * unnamed_types) +void freeLttType(LttType ** type) { - int i; - for(i=0;iposition;i++){ - freeLttType((LttType*)(unnamed_types->array[i])); + 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)->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); } - sequence_dispose(unnamed_types); -} -void freeAllFields(sequence * all_fields) -{ - int i; - for(i=0;iposition;i++){ - freeLttField((LttField*)(all_fields->array[i])); + if((*type)->element_type){ + for(i=0;i<(*type)->element_number;i++) + freeLttType(&((*type)->element_type[i])); + g_free((*type)->element_type); } - sequence_dispose(all_fields); + g_free(*type); + *type = NULL; } -//only free current type, not child types -void freeLttType(LttType * type) -{ +void freeLttField(LttField * fld) +{ int i; - if(type->element_name) - g_free(type->element_name); - if(type->fmt) - g_free(type->fmt); - if(type->enum_strings){ - for(i=0;ielement_number;i++) - g_free(type->enum_strings[i]); - g_free(type->enum_strings); - } - - if(type->element_type){ - g_free(type->element_type); + int size = 0; + + if(fld->field_type){ + if(fld->field_type->type_class == LTT_ARRAY || + fld->field_type->type_class == LTT_SEQUENCE){ + size = 1; + }else if(fld->field_type->type_class == LTT_STRUCT){ + size = fld->field_type->element_number; + } } - g_free(type); -} -//only free the current field, not child fields -void freeLttField(LttField * fld) -{ - if(fld->child) + if(fld->child){ + for(i=0; ichild[i])freeLttField(fld->child[i]); + } g_free(fld->child); + } g_free(fld); } @@ -416,7 +473,7 @@ void freeLttField(LttField * fld) * char * : the facility's name ****************************************************************************/ -char *ltt_facility_name(LttFacility *f) +gchar *ltt_facility_name(LttFacility *f) { return f->name; } @@ -460,7 +517,7 @@ unsigned ltt_facility_base_id(LttFacility *f) unsigned ltt_facility_eventtype_number(LttFacility *f) { - return (unsigned)(f->event_number); + return (f->event_number); } /***************************************************************************** @@ -484,22 +541,24 @@ 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, gchar *name) { - int i; - LttEventType * ev; + unsigned int i; + LttEventType * ev = NULL; + for(i=0;ievent_number;i++){ - ev = f->events[i]; - if(strcmp(ev->name, name) == 0)break; + LttEventType *iter_ev = f->events[i]; + if(g_ascii_strcasecmp(iter_ev->name, name) == 0) { + ev = iter_ev; + break; + } } - - if(i==f->event_number) return NULL; - else return ev; + return ev; }