X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ffacility.c;h=1d9ed5f66fb807b35a848e986017f6889ab02b56;hb=3aee1200b100fe8063661fd2d8eaa5fbbfc1977f;hp=84baac98421ce92a6c4a5907015e908b90bba2b7;hpb=6fd96dfe209f45c21b91defb30a9938a49f09b78;p=lttv.git diff --git a/ltt/branches/poly/ltt/facility.c b/ltt/branches/poly/ltt/facility.c index 84baac98..1d9ed5f6 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 @@ -46,12 +47,12 @@ 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_t * fac, - LttChecksum checksum); + guint32 checksum); /* functions to release the memory occupied by a facility */ void freeFacility(LttFacility * facility); @@ -67,16 +68,17 @@ 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, gchar * pathname) +int ltt_facility_open(LttFacility *f, LttTrace * t, gchar * pathname) { gchar *token; parse_file in; gsize length; facility_t * fac; - LttFacility * f; - LttChecksum checksum; + guint32 checksum; GError * error = NULL; gchar buffer[BUFFER_SIZE]; @@ -86,7 +88,11 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) in.name = pathname; in.fd = g_open(in.name, O_RDONLY, 0); - if(in.fd < 0 ) in.error(&in,"cannot open input file"); + 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; @@ -113,13 +119,8 @@ void ltt_facility_open(LttTrace * t, gchar * pathname) 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); - g_free(fac->name); g_free(fac->description); freeEvents(&fac->events); @@ -130,9 +131,13 @@ void ltt_facility_open(LttTrace * t, gchar * 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); @@ -152,57 +157,76 @@ void ltt_facility_open(LttTrace * t, gchar * 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; 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); } } @@ -211,7 +235,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 @@ -219,7 +243,87 @@ 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 * td, + LttField * fld) +{ + 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; @@ -231,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) @@ -245,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; @@ -257,7 +361,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; @@ -280,8 +384,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; @@ -294,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 @@ -313,43 +417,25 @@ void constructTypeAndFields(LttFacility * fac,type_descriptor * td, LttType * lookup_named_type(LttFacility *fac, type_descriptor * td) { - LttType * lttType = NULL; - unsigned int i=0; - gchar * 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(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; - } - } - } + 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; - lttType->element_name = NULL; - if(td->type_name){ - lttType->type_name = g_strdup(td->type_name); - fac->named_types[i] = lttType; /* i is initialized, checked. */ - } - else{ - lttType->type_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; } @@ -359,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; } /***************************************************************************** @@ -377,30 +459,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){ @@ -408,14 +482,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); } @@ -423,16 +493,12 @@ 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){ + // 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); } @@ -472,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 ****************************************************************************/ -gchar *ltt_facility_name(LttFacility *f) +GQuark ltt_facility_name(LttFacility *f) { return f->name; } @@ -486,12 +552,12 @@ gchar *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; } @@ -505,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; } /***************************************************************************** @@ -516,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 (f->event_number); + return (f->events->len); } /***************************************************************************** @@ -534,9 +600,10 @@ 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]; + g_assert(i < f->events->len); + return &g_array_index(f->events, LttEventType, i); } /***************************************************************************** @@ -551,18 +618,8 @@ LttEventType *ltt_facility_eventtype_get(LttFacility *f, unsigned i) * LttEventType * : the event type required ****************************************************************************/ -LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, gchar *name) +LttEventType *ltt_facility_eventtype_get_by_name(LttFacility *f, GQuark name) { - unsigned int i; - LttEventType * ev = NULL; - - for(i=0;ievent_number;i++){ - LttEventType *iter_ev = f->events[i]; - if(g_ascii_strcasecmp(iter_ev->name, name) == 0) { - ev = iter_ev; - break; - } - } - return ev; + LttEventType *et = g_datalist_get_data(f->events_by_name, name); }