X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=dd84a3966b36b4aa2edc4ffbdbcfee46fe96e37c;hb=8959a0c85e48eda1a73038bb74708a01b1d0886d;hp=225f7eacfe67d95026361b75a311ce6af0380994;hpb=04b44e05c17a54fcb7e2cccf5c10a4edf8c7fd5c;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 225f7eac..dd84a396 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -18,10 +18,12 @@ #include #include +#include +#include #include #include -#include -#include +#include +#include // For realpath #include @@ -33,8 +35,17 @@ #include "ltt-private.h" #include #include +#include +#include #define DIR_NAME_SIZE 256 +#define __UNUSED__ __attribute__((__unused__)) + + +/* obtain the time of an event */ + +static inline LttTime getEventTime(LttTracefile * tf); + /* set the offset of the fields belonging to the event, need the information of the archecture */ @@ -60,7 +71,7 @@ int skipEvent(LttTracefile * t); /* Functions to parse system.xml file (using glib xml parser) */ -static void parser_start_element (GMarkupParseContext *context, +static void parser_start_element (GMarkupParseContext __UNUSED__ *context, const gchar *element_name, const gchar **attribute_names, const gchar **attribute_values, @@ -70,8 +81,10 @@ static void parser_start_element (GMarkupParseContext *context, int i=0; LttSystemDescription* des = (LttSystemDescription* )user_data; if(strcmp("system", element_name)){ - g_warning("This is not system.xml file\n"); - exit(1); + *error = g_error_new(G_MARKUP_ERROR, + G_LOG_LEVEL_WARNING, + "This is not system.xml file"); + return; } while(attribute_names[i]){ @@ -113,25 +126,20 @@ static void parser_start_element (GMarkupParseContext *context, }else if(strcmp("ltt_block_size", attribute_names[i])==0){ des->ltt_block_size = atoi(attribute_values[i]); }else{ - g_warning("Not a valid attribute\n"); - exit(1); + *error = g_error_new(G_MARKUP_ERROR, + G_LOG_LEVEL_WARNING, + "Not a valid attribute"); + return; } i++; } } -static void parser_end_element (GMarkupParseContext *context, - const gchar *element_name, - gpointer user_data, - GError **error) -{ -} - -static void parser_characters (GMarkupParseContext *context, +static void parser_characters (GMarkupParseContext __UNUSED__ *context, const gchar *text, - gsize text_len, + gsize __UNUSED__ text_len, gpointer user_data, - GError **error) + GError __UNUSED__ **error) { LttSystemDescription* des = (LttSystemDescription* )user_data; des->description = g_strdup(text); @@ -152,7 +160,6 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName) { LttTracefile * tf; struct stat lTDFStat; /* Trace data file status */ - BlockStart a_block_start; tf = g_new(LttTracefile, 1); @@ -161,16 +168,23 @@ LttTracefile* ltt_tracefile_open(LttTrace * t, char * 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); + g_warning("Unable to open input data file %s\n", fileName); + g_free(tf->name); + g_free(tf); + return NULL; } // Get the file's status if(fstat(tf->fd, &lTDFStat) < 0){ - g_error("Unable to get the status of the input data file %s\n", fileName); + g_warning("Unable to get the status of the input data file %s\n", fileName); + g_free(tf->name); + close(tf->fd); + g_free(tf); + return NULL; } // Is the file large enough to contain a trace - if(lTDFStat.st_size < sizeof(BlockStart) + EVENT_HEADER_SIZE){ + if(lTDFStat.st_size < (off_t)(sizeof(BlockStart) + EVENT_HEADER_SIZE)){ g_print("The input data file %s does not contain a trace\n", fileName); g_free(tf->name); close(tf->fd); @@ -207,29 +221,30 @@ void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name) g_ptr_array_add(t->per_cpu_tracefiles, tf); } -void ltt_tracefile_open_control(LttTrace *t, char * control_name) +gint ltt_tracefile_open_control(LttTrace *t, char * control_name) { LttTracefile * tf; - LttEvent * ev; + LttEvent ev; LttFacility * f; - guint16 evId; void * pos; FacilityLoad fLoad; - int i; + unsigned int i; tf = ltt_tracefile_open(t,control_name); - if(!tf) return; + if(!tf) { + g_warning("ltt_tracefile_open_control : bad file descriptor"); + return -1; + } t->control_tracefile_number++; g_ptr_array_add(t->control_tracefiles,tf); //parse facilities tracefile to get base_id if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){ while(1){ - ev = ltt_tracefile_read(tf); - if(!ev)return; // end of file + if(!ltt_tracefile_read(tf,&ev)) return 0; // end of file - if(ev->event_id == TRACE_FACILITY_LOAD){ - pos = ev->data; + if(ev.event_id == TRACE_FACILITY_LOAD){ + pos = ev.data; fLoad.name = (char*)pos; fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name)); fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); @@ -241,16 +256,22 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name) break; } } - if(i==t->facility_number) - g_error("Facility: %s, checksum: %d is not founded\n", - fLoad.name,fLoad.checksum); - }else if(ev->event_id == TRACE_BLOCK_START){ + if(i==t->facility_number) { + g_warning("Facility: %s, checksum: %u is not found", + fLoad.name,(unsigned int)fLoad.checksum); + return -1; + } + }else if(ev.event_id == TRACE_BLOCK_START){ continue; - }else if(ev->event_id == TRACE_BLOCK_END){ + }else if(ev.event_id == TRACE_BLOCK_END){ break; - }else g_error("Not valid facilities trace file\n"); + }else { + g_warning("Not valid facilities trace file"); + return -1; + } } } + return 0; } /***************************************************************************** @@ -272,18 +293,17 @@ void ltt_tracefile_close(LttTracefile *t) /***************************************************************************** *Get system information ****************************************************************************/ -void getSystemInfo(LttSystemDescription* des, char * pathname) +gint getSystemInfo(LttSystemDescription* des, char * pathname) { FILE * fp; char buf[DIR_NAME_SIZE]; - char description[4*DIR_NAME_SIZE]; GMarkupParseContext * context; - GError * error; + GError * error = NULL; GMarkupParser markup_parser = { parser_start_element, - parser_end_element, + NULL, parser_characters, NULL, /* passthrough */ NULL /* error */ @@ -291,36 +311,47 @@ void getSystemInfo(LttSystemDescription* des, char * pathname) fp = fopen(pathname,"r"); if(!fp){ - g_error("Can not open file : %s\n", pathname); + g_warning("Can not open file : %s\n", pathname); + return -1; } context = g_markup_parse_context_new(&markup_parser, 0, des,NULL); while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){ if(!g_markup_parse_context_parse(context, buf, DIR_NAME_SIZE, &error)){ - g_warning("Can not parse xml file: \n%s\n", error->message); - exit(1); + if(error != NULL) { + g_warning("Can not parse xml file: \n%s\n", error->message); + g_error_free(error); + } + g_markup_parse_context_free(context); + fclose(fp); + return -1; } } + g_markup_parse_context_free(context); fclose(fp); + return 0; } /***************************************************************************** *The following functions get facility/tracefile information ****************************************************************************/ -void getFacilityInfo(LttTrace *t, char* eventdefs) +gint getFacilityInfo(LttTrace *t, char* eventdefs) { DIR * dir; struct dirent *entry; char * ptr; - int i,j; + unsigned int i,j; LttFacility * f; LttEventType * et; char name[DIR_NAME_SIZE]; dir = opendir(eventdefs); - if(!dir) g_error("Can not open directory: %s\n", eventdefs); + if(!dir) { + g_warning("Can not open directory: %s\n", eventdefs); + return -1; + } while((entry = readdir(dir)) != NULL){ ptr = &entry->d_name[strlen(entry->d_name)-4]; @@ -338,16 +369,20 @@ void getFacilityInfo(LttTrace *t, char* eventdefs) setFieldsOffset(NULL, et, NULL, t); } } + return 0; } -void getControlFileInfo(LttTrace *t, char* control) +gint getControlFileInfo(LttTrace *t, char* control) { DIR * dir; struct dirent *entry; char name[DIR_NAME_SIZE]; dir = opendir(control); - if(!dir) g_error("Can not open directory: %s\n", control); + if(!dir) { + g_warning("Can not open directory: %s\n", control); + return -1; + } while((entry = readdir(dir)) != NULL){ if(strcmp(entry->d_name,"facilities") != 0 && @@ -356,19 +391,24 @@ void getControlFileInfo(LttTrace *t, char* control) strcpy(name,control); strcat(name,entry->d_name); - ltt_tracefile_open_control(t,name); + if(ltt_tracefile_open_control(t,name)) + return -1; } closedir(dir); + return 0; } -void getCpuFileInfo(LttTrace *t, char* cpu) +gint getCpuFileInfo(LttTrace *t, char* cpu) { DIR * dir; struct dirent *entry; char name[DIR_NAME_SIZE]; dir = opendir(cpu); - if(!dir) g_error("Can not open directory: %s\n", cpu); + if(!dir) { + g_warning("Can not open directory: %s\n", cpu); + return -1; + } while((entry = readdir(dir)) != NULL){ if(strcmp(entry->d_name,".") != 0 && @@ -380,6 +420,7 @@ void getCpuFileInfo(LttTrace *t, char* cpu) }else continue; } closedir(dir); + return 0; } /***************************************************************************** @@ -389,29 +430,31 @@ void getCpuFileInfo(LttTrace *t, char* cpu) * *When a trace is closed, all the associated facilities, types and fields *are released as well. + */ + + +/**************************************************************************** + * get_absolute_pathname * + * return the unique pathname in the system + * * MD : Fixed this function so it uses realpath, dealing well with * forgotten cases (.. were not used correctly before). * ****************************************************************************/ - void get_absolute_pathname(const char *pathname, char * abs_pathname) { - char * ptr, *ptr1; - size_t size = DIR_NAME_SIZE; abs_pathname[0] = '\0'; if ( realpath (pathname, abs_pathname) != NULL) return; else { - // FIXME : Path is wrong, is it ok to return the pathname unmodified ? + /* error, return the original path unmodified */ strcpy(abs_pathname, pathname); return; } - return; - } LttTrace *ltt_trace_open(const char *pathname) @@ -446,8 +489,8 @@ LttTrace *ltt_trace_open(const char *pathname) strcat(cpu,"cpu/"); //new trace - t = g_new(LttTrace, 1); sys_description = g_new(LttSystemDescription, 1); + t = g_new(LttTrace, 1); t->pathname = g_strdup(abs_path); t->facility_number = 0; t->control_tracefile_number = 0; @@ -461,16 +504,52 @@ LttTrace *ltt_trace_open(const char *pathname) //get system description strcpy(tmp,info); strcat(tmp,"system.xml"); - getSystemInfo(sys_description, tmp); + if(getSystemInfo(sys_description, tmp)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } + + //get facilities info - getFacilityInfo(t,eventdefs); + if(getFacilityInfo(t,eventdefs)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } //get control tracefile info getControlFileInfo(t,control); + /* + if(getControlFileInfo(t,control)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + }*/ // With fatal error //get cpu tracefile info - getCpuFileInfo(t,cpu); + if(getCpuFileInfo(t,cpu)) { + g_ptr_array_free(t->facilities, TRUE); + g_ptr_array_free(t->per_cpu_tracefiles, TRUE); + g_ptr_array_free(t->control_tracefiles, TRUE); + g_free(sys_description); + g_free(t->pathname); + g_free(t); + return NULL; + } return t; } @@ -493,7 +572,7 @@ LttTrace *ltt_trace_copy(LttTrace *self) void ltt_trace_close(LttTrace *t) { - int i; + unsigned int i; LttTracefile * tf; LttFacility * f; @@ -576,7 +655,7 @@ LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i) unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) { - int i, count=0; + unsigned int i, count=0; LttFacility * f; for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities, i); @@ -596,7 +675,7 @@ unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) unsigned ltt_trace_eventtype_number(LttTrace *t) { - int i; + unsigned int i; unsigned count = 0; LttFacility * f; for(i=0;ifacility_number;i++){ @@ -608,16 +687,20 @@ unsigned ltt_trace_eventtype_number(LttTrace *t) LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id) { - LttFacility * facility; - int i; + LttFacility * facility = NULL; + unsigned int i; + for(i=0;ifacility_number;i++){ - facility = (LttFacility*) g_ptr_array_index(trace->facilities,i); - if(id >= facility->base_id && - id < facility->base_id + facility->event_number) + LttFacility *iter_facility = + (LttFacility*) g_ptr_array_index(trace->facilities,i); + if(id >= iter_facility->base_id && + id < iter_facility->base_id + iter_facility->event_number) { + facility = iter_facility; break; + } } - if(i==trace->facility_number) return NULL; - else return facility; + + return facility; } LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId) @@ -650,10 +733,10 @@ unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t) *and a negative value otherwise. ****************************************************************************/ -int ltt_trace_control_tracefile_find(LttTrace *t, char *name) +int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name) { LttTracefile * tracefile; - int i; + unsigned int i; for(i=0;icontrol_tracefile_number;i++){ tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i); if(strcmp(tracefile->name, name)==0)break; @@ -662,17 +745,19 @@ int ltt_trace_control_tracefile_find(LttTrace *t, char *name) return i; } -int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i) +/* not really useful. We just have to know that cpu tracefiles + * comes before control tracefiles. + */ +int ltt_trace_per_cpu_tracefile_find(LttTrace *t, const gchar *name) { LttTracefile * tracefile; - int j, name; - for(j=0;jper_cpu_tracefile_number;j++){ - tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, j); - name = atoi(tracefile->name); - if(name == (int)i)break; + unsigned int i; + for(i=0;iper_cpu_tracefile_number;i++){ + tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i); + if(strcmp(tracefile->name, name)==0)break; } - if(j == t->per_cpu_tracefile_number) return -1; - return j; + if(i == t->per_cpu_tracefile_number) return -1; + return i; } /***************************************************************************** @@ -696,7 +781,7 @@ LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i) void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) { LttTime startSmall, startTmp, endBig, endTmp; - int i, j=0; + unsigned int i, j=0; LttTracefile * tf; for(i=0;icontrol_tracefile_number;i++){ @@ -730,8 +815,8 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; } - *start = startSmall; - *end = endBig; + if(start != NULL) *start = startSmall; + if(end != NULL) *end = endBig; } @@ -839,14 +924,14 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) LttTime lttTime; int headTime = ltt_time_compare(t->a_block_start->time, time); int tailTime = ltt_time_compare(t->a_block_end->time, time); - LttEvent * ev; + LttEvent ev; if(headTime < 0 && tailTime > 0){ if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) { lttTime = getEventTime(t); err = ltt_time_compare(lttTime, time); if(err > 0){ - if(t->which_event==2 || (&t->prev_event_time,&time)<0){ + if(t->which_event==2 || ltt_time_compare(t->prev_event_time,time)<0){ return; }else{ updateTracefile(t); @@ -854,8 +939,7 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) } }else if(err < 0){ while(1){ - ev = ltt_tracefile_read(t); - if(ev == NULL){ + if(ltt_tracefile_read(t,&ev) == NULL) { g_print("End of file\n"); return; } @@ -901,6 +985,9 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) /***************************************************************************** * Seek to the first event with position equal or larger to ep + * + * Modified by Mathieu Desnoyers to used faster offset position instead of + * re-reading the whole buffer. ****************************************************************************/ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) @@ -911,16 +998,38 @@ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) if(t->which_block == ep->block_num) updateTracefile(t); else readBlock(t,ep->block_num); - - //event offset is availiable + //event offset is available if(ep->old_position){ - t->cur_heart_beat_number = ep->heart_beat_number; + int err; + + t->which_event = ep->event_num; t->cur_event_pos = t->buffer + ep->event_offset; + t->prev_event_time = ep->event_time; + t->current_event_time = ep->event_time; + t->cur_heart_beat_number = ep->heart_beat_number; + t->cur_cycle_count = ep->event_cycle_count; + + /* This is a workaround for fast position seek */ + t->last_event_pos = ep->last_event_pos; + t->prev_block_end_time = ep->prev_block_end_time; + t->prev_event_time = ep->prev_event_time; + t->pre_cycle_count = ep->pre_cycle_count; + t->count = ep->count; + /* end of workaround */ + + //update the fields of the current event and go to the next event + err = skipEvent(t); + if(err == ERANGE) g_error("event id is out of range\n"); + return; } - //only block number and event index are availiable - while(t->which_event < ep->event_num) ltt_tracefile_read(t); + //only block number and event index are available + //MD: warning : this is slow! + g_warning("using slow O(n) tracefile seek position"); + + LttEvent event; + while(t->which_event < ep->event_num) ltt_tracefile_read(t, &event); return; } @@ -934,9 +1043,8 @@ void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep) * LttEvent * : an event to be processed ****************************************************************************/ -LttEvent *ltt_tracefile_read(LttTracefile *t) +LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event) { - LttEvent * lttEvent = &t->an_event; int err; if(t->cur_event_pos == t->buffer + t->block_size){ @@ -947,27 +1055,37 @@ LttEvent *ltt_tracefile_read(LttTracefile *t) if(err)g_error("Can not read tracefile"); } - lttEvent->event_id = (int)(*(guint16 *)(t->cur_event_pos)); - if(lttEvent->event_id == TRACE_TIME_HEARTBEAT) + event->event_id = (int)(*(guint16 *)(t->cur_event_pos)); + if(event->event_id == TRACE_TIME_HEARTBEAT) t->cur_heart_beat_number++; t->prev_event_time = t->current_event_time; // t->current_event_time = getEventTime(t); - lttEvent->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE); - lttEvent->event_time = t->current_event_time; - lttEvent->event_cycle_count = t->cur_cycle_count; + event->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE); + event->event_time = t->current_event_time; + event->event_cycle_count = t->cur_cycle_count; + + event->tracefile = t; + event->data = t->cur_event_pos + EVENT_HEADER_SIZE; + event->which_block = t->which_block; + event->which_event = t->which_event; + + /* This is a workaround for fast position seek */ + event->last_event_pos = t->last_event_pos; + event->prev_block_end_time = t->prev_block_end_time; + event->prev_event_time = t->prev_event_time; + event->pre_cycle_count = t->pre_cycle_count; + event->count = t->count; + /* end of workaround */ + - lttEvent->tracefile = t; - lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE; - lttEvent->which_block = t->which_block; - lttEvent->which_event = t->which_event; //update the fields of the current event and go to the next event err = skipEvent(t); if(err == ERANGE) g_error("event id is out of range\n"); - return lttEvent; + return event; } /**************************************************************************** @@ -985,10 +1103,14 @@ LttEvent *ltt_tracefile_read(LttTracefile *t) int readFile(int fd, void * buf, size_t size, char * mesg) { - ssize_t nbBytes; - nbBytes = read(fd, buf, size); - if(nbBytes != size){ - printf("%s\n",mesg); + ssize_t nbBytes = read(fd, buf, size); + + if((size_t)nbBytes != size) { + if(nbBytes < 0) { + perror("Error in readFile : "); + } else { + g_warning("%s",mesg); + } return EIO; } return 0; @@ -1076,7 +1198,7 @@ void updateTracefile(LttTracefile * tf) int skipEvent(LttTracefile * t) { - int evId, err; + int evId; void * evData; LttEventType * evT; LttField * rootFld; @@ -1112,6 +1234,7 @@ int skipEvent(LttTracefile * t) return 0; } + /***************************************************************************** *Function name * getCyclePerNsec : calculate cycles per nsec for current block @@ -1149,15 +1272,14 @@ void getCyclePerNsec(LttTracefile * t) * LttTime : the time of the event ****************************************************************************/ -LttTime getEventTime(LttTracefile * tf) +static inline LttTime getEventTime(LttTracefile * tf) { LttTime time; LttCycleCount cycle_count; // cycle count for the current event LttCycleCount lEventTotalCycle; // Total cycles from start for event - LttCycleCount lEventNSec; // Total usecs from start for event + double lEventNSec; // Total nsecs from start for event LttTime lTimeOffset; // Time offset in struct LttTime guint16 evId; - LttCycleCount tmpCycleCount = (((LttCycleCount)1)<<32); evId = *(guint16 *)tf->cur_event_pos; if(evId == TRACE_BLOCK_START){ @@ -1177,7 +1299,7 @@ LttTime getEventTime(LttTracefile * tf) if(cycle_count < tf->pre_cycle_count)tf->count++; tf->pre_cycle_count = cycle_count; - cycle_count += tmpCycleCount * tf->count; + cycle_count += (LttCycleCount)tf->count << 32; // if(tf->cur_heart_beat_number > tf->count) // cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count); @@ -1191,8 +1313,7 @@ LttTime getEventTime(LttTracefile * tf) lEventNSec = (double)lEventTotalCycle / (double)tf->cycle_per_nsec; // Determine offset in struct LttTime - lTimeOffset.tv_nsec = lEventNSec % NANOSECONDS_PER_SECOND; - lTimeOffset.tv_sec = lEventNSec / NANOSECONDS_PER_SECOND; + lTimeOffset = ltt_time_from_double(lEventNSec); time = ltt_time_add(tf->a_block_start->time, lTimeOffset); @@ -1247,6 +1368,107 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, if(fld == evT->root_field) return fld->field_size; } + switch(type->type_class) { + case LTT_ARRAY: + element_number = (int) type->element_number; + if(fld->field_fixed == -1){ + size = getFieldtypeSize(t, evT, offsetRoot, + 0,fld->child[0], NULL, trace); + if(size == 0){ //has string or sequence + fld->field_fixed = 0; + }else{ + fld->field_fixed = 1; + size *= element_number; + } + }else if(fld->field_fixed == 0){// has string or sequence + size = 0; + for(i=0;ichild[0], evD+size, trace); + } + }else size = fld->field_size; + break; + + case LTT_SEQUENCE: + size1 = (int) ltt_type_size(trace, type); + if(fld->field_fixed == -1){ + fld->sequ_number_size = size1; + fld->field_fixed = 0; + size = getFieldtypeSize(t, evT, offsetRoot, + 0,fld->child[0], NULL, trace); + fld->element_size = size; + }else{//0: sequence + element_number = getIntNumber(size1,evD); + type->element_number = element_number; + if(fld->element_size > 0){ + size = element_number * fld->element_size; + }else{//sequence has string or sequence + size = 0; + for(i=0;ichild[0], evD+size+size1, trace); + } + } + size += size1; + } + break; + + case LTT_STRING: + size = 0; + if(fld->field_fixed == -1){ + fld->field_fixed = 0; + }else{//0: string + size = strlen((char*)evD) + 1; //include end : '\0' + } + break; + + case LTT_STRUCT: + element_number = (int) type->element_number; + size = 0; + if(fld->field_fixed == -1){ + offset1 = offsetRoot; + offset2 = 0; + for(i=0;ichild[i], NULL, trace); + if(size1 > 0 && size >= 0){ + size += size1; + if(offset1 >= 0) offset1 += size1; + offset2 += size1; + }else{ + size = -1; + offset1 = -1; + offset2 = -1; + } + } + if(size == -1){ + fld->field_fixed = 0; + size = 0; + }else fld->field_fixed = 1; + }else if(fld->field_fixed == 0){ + offset1 = offsetRoot; + offset2 = 0; + for(i=0;ichild[i],evD+offset2, trace); + offset1 += size; + offset2 += size; + } + size = offset2; + }else size = fld->field_size; + break; + + default: + if(fld->field_fixed == -1){ + size = (int) ltt_type_size(trace, type); + fld->field_fixed = 1; + }else size = fld->field_size; + break; + } + + + +#if 0 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){ @@ -1335,6 +1557,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, size = offset2; }else size = fld->field_size; } +#endif //0 fld->offset_root = offsetRoot; fld->offset_parent = offsetParent; @@ -1355,18 +1578,31 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, * size : the size of the integer * evD : the event data *Return value - * int : an integer + * gint64 : a 64 bits integer ****************************************************************************/ -int getIntNumber(int size, void *evD) +gint64 getIntNumber(int size, void *evD) { gint64 i; + + switch(size) { + case 1: i = *(gint8 *)evD; break; + case 2: i = *(gint16 *)evD; break; + case 4: i = *(gint32 *)evD; break; + case 8: i = *(gint64 *)evD; break; + default: i = *(gint64 *)evD; + g_critical("getIntNumber : integer size %d unknown", size); + break; + } + +#if 0 if(size == 1) i = *(gint8 *)evD; else if(size == 2) i = *(gint16 *)evD; else if(size == 4) i = *(gint32 *)evD; else if(size == 8) i = *(gint64 *)evD; - - return (int) i; +#endif //0 + + return (gint64)i; } /***************************************************************************** @@ -1429,3 +1665,19 @@ LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s) return s->trace_start; } + +LttTracefile *ltt_tracefile_new() +{ + return g_new(LttTracefile, 1); +} + +void ltt_tracefile_destroy(LttTracefile *tf) +{ + g_free(tf); +} + +void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src) +{ + *dest = *src; +} +