X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=e2db16122004fc5a44c604507608f90c19aed611;hb=449cb9d7c0cdefefcf7a698a54e95168f24c5d4c;hp=31d8734bc693d850cb568d52ef4a26fb47472de9;hpb=09ad4797c84b03978d1e669a166f1b9f2f761d03;p=lttv.git diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c index 31d8734b..e2db1612 100644 --- a/ltt/branches/poly/ltt/tracefile.c +++ b/ltt/branches/poly/ltt/tracefile.c @@ -1,3 +1,21 @@ +/* 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 @@ -5,9 +23,11 @@ #include #include -#include #include "parser.h" +#include +#include "ltt-private.h" #include +#include #define DIR_NAME_SIZE 256 @@ -33,40 +53,84 @@ void updateTracefile(LttTracefile * tf); /* go to the next event */ int skipEvent(LttTracefile * t); -/* compare two time (LttTime), 0:t1=t2, -1:t1t2 */ -int timecmp(LttTime * t1, LttTime * t2); - -/* get an integer number */ -int getIntNumber(int size1, void *evD); - - -/* Time operation macros for LttTime (struct timespec) */ -/* (T3 = T2 - T1) */ -#define TimeSub(T3, T2, T1) \ -do \ -{\ - (T3).tv_sec = (T2).tv_sec - (T1).tv_sec; \ - (T3).tv_nsec = (T2).tv_nsec - (T1).tv_nsec; \ - if((T3).tv_nsec < 0)\ - {\ - (T3).tv_sec--;\ - (T3).tv_nsec += 1000000000;\ - }\ -} while(0) - -/* (T3 = T2 + T1) */ -#define TimeAdd(T3, T2, T1) \ -do \ -{\ - (T3).tv_sec = (T2).tv_sec + (T1).tv_sec; \ - (T3).tv_nsec = (T2).tv_nsec + (T1).tv_nsec; \ - if((T3).tv_nsec >= 1000000000)\ - {\ - (T3).tv_sec += (T3).tv_nsec / 1000000000;\ - (T3).tv_nsec = (T3).tv_nsec % 1000000000;\ - }\ -} while(0) +/* Functions to parse system.xml file (using glib xml parser) */ +static void parser_start_element (GMarkupParseContext *context, + const gchar *element_name, + const gchar **attribute_names, + const gchar **attribute_values, + gpointer user_data, + GError **error) +{ + int i=0; + LttSystemDescription* des = (LttSystemDescription* )user_data; + if(strcmp("system", element_name)){ + g_warning("This is not system.xml file\n"); + exit(1); + } + + while(attribute_names[i]){ + if(strcmp("node_name", attribute_names[i])==0){ + des->node_name = g_strdup(attribute_values[i]); + }else if(strcmp("domainname", attribute_names[i])==0){ + des->domain_name = g_strdup(attribute_values[i]); + }else if(strcmp("cpu", attribute_names[i])==0){ + des->nb_cpu = atoi(attribute_values[i]); + }else if(strcmp("arch_size", attribute_names[i])==0){ + if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32; + else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32; + else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64; + else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64; + else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN; + }else if(strcmp("endian", attribute_names[i])==0){ + if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0) + des->endian = LTT_LITTLE_ENDIAN; + else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0) + des->endian = LTT_BIG_ENDIAN; + }else if(strcmp("kernel_name", attribute_names[i])==0){ + des->kernel_name = g_strdup(attribute_values[i]); + }else if(strcmp("kernel_release", attribute_names[i])==0){ + des->kernel_release = g_strdup(attribute_values[i]); + }else if(strcmp("kernel_version", attribute_names[i])==0){ + des->kernel_version = g_strdup(attribute_values[i]); + }else if(strcmp("machine", attribute_names[i])==0){ + des->machine = g_strdup(attribute_values[i]); + }else if(strcmp("processor", attribute_names[i])==0){ + des->processor = g_strdup(attribute_values[i]); + }else if(strcmp("hardware_platform", attribute_names[i])==0){ + des->hardware_platform = g_strdup(attribute_values[i]); + }else if(strcmp("operating_system", attribute_names[i])==0){ + des->operating_system = g_strdup(attribute_values[i]); + }else if(strcmp("ltt_major_version", attribute_names[i])==0){ + des->ltt_major_version = atoi(attribute_values[i]); + }else if(strcmp("ltt_minor_version", attribute_names[i])==0){ + des->ltt_minor_version = atoi(attribute_values[i]); + }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); + } + i++; + } +} + +static void parser_end_element (GMarkupParseContext *context, + const gchar *element_name, + gpointer user_data, + GError **error) +{ +} + +static void parser_characters (GMarkupParseContext *context, + const gchar *text, + gsize text_len, + gpointer user_data, + GError **error) +{ + LttSystemDescription* des = (LttSystemDescription* )user_data; + des->description = g_strdup(text); +} /***************************************************************************** @@ -143,7 +207,7 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name) LttTracefile * tf; LttEvent * ev; LttFacility * f; - uint16_t evId; + guint16 evId; void * pos; FacilityLoad fLoad; int i; @@ -163,7 +227,7 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name) pos = ev->data; fLoad.name = (char*)pos; fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name)); - fLoad.base_code = *(uint32_t*)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); + fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum)); for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities,i); @@ -180,7 +244,6 @@ void ltt_tracefile_open_control(LttTrace *t, char * control_name) }else if(ev->event_id == TRACE_BLOCK_END){ break; }else g_error("Not valid facilities trace file\n"); - g_free(ev); } } } @@ -207,147 +270,33 @@ void ltt_tracefile_close(LttTracefile *t) void getSystemInfo(LttSystemDescription* des, char * pathname) { FILE * fp; - int i; - int entry_number = 15; char buf[DIR_NAME_SIZE]; char description[4*DIR_NAME_SIZE]; - char * ptr; + + GMarkupParseContext * context; + GError * error; + GMarkupParser markup_parser = + { + parser_start_element, + parser_end_element, + parser_characters, + NULL, /* passthrough */ + NULL /* error */ + }; fp = fopen(pathname,"r"); if(!fp){ g_error("Can not open file : %s\n", pathname); } - while(fgets(buf,DIR_NAME_SIZE, fp)!= NULL){ - ptr = buf; - while(isspace(*ptr)) ptr++; - if(strlen(ptr) == 0) continue; - break; - } + context = g_markup_parse_context_new(&markup_parser, 0, des,NULL); - if(strlen(ptr) == 0) g_error("Not a valid file: %s\n", pathname); - if(strncmp("node_name = g_strdup(ptr+10); - break; - case 1: - if(strncmp("domainname=",ptr,11)!=0) - g_error("Not a valid file: %s\n", pathname); - des->domain_name = g_strdup(ptr+11); - break; - case 2: - if(strncmp("cpu=",ptr,4)!=0) - g_error("Not a valid file: %s\n", pathname); - des->nb_cpu = (unsigned)atoi(ptr+4); - break; - case 3: - if(strncmp("arch_size=",ptr,10)!=0) - g_error("Not a valid file: %s\n", pathname); - if(strcmp(ptr+10,"\"LP32\"") == 0) des->size = LTT_LP32; - else if(strcmp(ptr+10,"\"ILP32\"") == 0) des->size = LTT_ILP32; - else if(strcmp(ptr+10,"\"LP64\"") == 0) des->size = LTT_LP64; - else if(strcmp(ptr+10,"\"ILP64\"") == 0) des->size = LTT_ILP64; - else if(strcmp(ptr+10,"\"UNKNOWN\"") == 0) des->size = LTT_UNKNOWN; - break; - case 4: - if(strncmp("endian=",ptr,7)!=0) - g_error("Not a valid file: %s\n", pathname); - if(strcmp(ptr+7,"\"LITTLE_ENDIAN\"") == 0) - des->endian = LTT_LITTLE_ENDIAN; - else if(strcmp(ptr+7,"\"BIG_ENDIAN\"") == 0) - des->endian = LTT_BIG_ENDIAN; - break; - case 5: - if(strncmp("kernel_name=",ptr,12)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_name = g_strdup(ptr+12); - break; - case 6: - if(strncmp("kernel_release=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_release = g_strdup(ptr+15); - break; - case 7: - if(strncmp("kernel_version=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - des->kernel_version = g_strdup(ptr+15); - break; - case 8: - if(strncmp("machine=",ptr,8)!=0) - g_error("Not a valid file: %s\n", pathname); - des->machine = g_strdup(ptr+8); - break; - case 9: - if(strncmp("processor=",ptr,10)!=0) - g_error("Not a valid file: %s\n", pathname); - des->processor = g_strdup(ptr+10); - break; - case 10: - if(strncmp("hardware_platform=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - des->hardware_platform = g_strdup(ptr+18); - break; - case 11: - if(strncmp("operating_system=",ptr,17)!=0) - g_error("Not a valid file: %s\n", pathname); - des->operating_system = g_strdup(ptr+17); - break; - case 12: - if(strncmp("ltt_major_version=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 18; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_major_version = (unsigned)atoi(ptr); - break; - case 13: - if(strncmp("ltt_minor_version=",ptr,18)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 18; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_minor_version = (unsigned)atoi(ptr); - break; - case 14: - if(strncmp("ltt_block_size=",ptr,15)!=0) - g_error("Not a valid file: %s\n", pathname); - ptr += 15; - // ptr++;//skip begining " - // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending " - des->ltt_block_size = (unsigned)atoi(ptr); - break; - default: - g_error("Not a valid file: %s\n", pathname); - } - } - - //get description - description[0] = '\0'; - if(fgets(buf,DIR_NAME_SIZE, fp)== NULL) - g_error("Not a valid file: %s\n", pathname); - ptr = buf; - while(isspace(*ptr)) ptr++; - if(*ptr != '>') g_error("Not a valid file: %s\n", pathname); - while((ptr=fgets(buf,DIR_NAME_SIZE, fp))!= NULL){ - ptr = buf; - while(isspace(*ptr)) ptr++; - if(strncmp("",ptr,9) == 0 )break; - strcat(description, buf); + 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(!ptr)g_error("Not a valid file: %s\n", pathname); - if(description[0] = '\0')des->description = NULL; - des->description = g_strdup(description); - fclose(fp); } @@ -418,7 +367,8 @@ void getCpuFileInfo(LttTrace *t, char* cpu) while((entry = readdir(dir)) != NULL){ if(strcmp(entry->d_name,".") != 0 && - strcmp(entry->d_name,"..") != 0 ){ + strcmp(entry->d_name,"..") != 0 && + strcmp(entry->d_name,".svn") != 0){ strcpy(name,cpu); strcat(name,entry->d_name); ltt_tracefile_open_cpu(t,name); @@ -434,9 +384,42 @@ void getCpuFileInfo(LttTrace *t, char* cpu) * *When a trace is closed, all the associated facilities, types and fields *are released as well. + * + * MD : If pathname is already absolute, we do not add current working + * directory to it. + * ****************************************************************************/ -LttTrace *ltt_trace_open(char *pathname) +void get_absolute_pathname(const char *pathname, char * abs_pathname) +{ + char * ptr, *ptr1; + size_t size = DIR_NAME_SIZE; + abs_pathname[0] = '\0'; + + if(pathname[0] == '/') + { + strcat(abs_pathname, pathname); + return; + } + + if(!getcwd(abs_pathname, size)){ + g_warning("Can not get current working directory\n"); + strcat(abs_pathname, pathname); + return; + } + + strcat(abs_pathname,"/"); + + ptr = (char*)pathname; + ptr1 = ptr + 1; + while(*ptr == '.' && *ptr1 == '.'){ + ptr += 3; + ptr1 = ptr + 1; + } + strcat(abs_pathname,ptr); +} + +LttTrace *ltt_trace_open(const char *pathname) { LttTrace * t; LttSystemDescription * sys_description; @@ -445,30 +428,33 @@ LttTrace *ltt_trace_open(char *pathname) char control[DIR_NAME_SIZE]; char cpu[DIR_NAME_SIZE]; char tmp[DIR_NAME_SIZE]; + char abs_path[DIR_NAME_SIZE]; gboolean has_slash = FALSE; + get_absolute_pathname(pathname, abs_path); + //establish the pathname to different directories - if(pathname[strlen(pathname)-1] == '/')has_slash = TRUE; - strcpy(eventdefs,pathname); + if(abs_path[strlen(abs_path)-1] == '/')has_slash = TRUE; + strcpy(eventdefs,abs_path); if(!has_slash)strcat(eventdefs,"/"); strcat(eventdefs,"eventdefs/"); - strcpy(info,pathname); + strcpy(info,abs_path); if(!has_slash)strcat(info,"/"); strcat(info,"info/"); - strcpy(control,pathname); + strcpy(control,abs_path); if(!has_slash)strcat(control,"/"); strcat(control,"control/"); - strcpy(cpu,pathname); + strcpy(cpu,abs_path); if(!has_slash)strcat(cpu,"/"); strcat(cpu,"cpu/"); //new trace t = g_new(LttTrace, 1); sys_description = g_new(LttSystemDescription, 1); - t->pathname = g_strdup(pathname); + t->pathname = g_strdup(abs_path); t->facility_number = 0; t->control_tracefile_number = 0; t->per_cpu_tracefile_number = 0; @@ -495,6 +481,22 @@ LttTrace *ltt_trace_open(char *pathname) return t; } +char * ltt_trace_name(LttTrace *t) +{ + return t->pathname; +} + + +/****************************************************************************** + * When we copy a trace, we want all the opening actions to happen again : + * the trace will be reopened and totally independant from the original. + * That's why we call ltt_trace_open. + *****************************************************************************/ +LttTrace *ltt_trace_copy(LttTrace *self) +{ + return ltt_trace_open(self->pathname); +} + void ltt_trace_close(LttTrace *t) { int i; @@ -582,7 +584,7 @@ unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position) { int i, count=0; LttFacility * f; - for(i=0;i=t->facility_number;i++){ + for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities, i); if(strcmp(f->name,name)==0){ count++; @@ -603,7 +605,7 @@ unsigned ltt_trace_eventtype_number(LttTrace *t) int i; unsigned count = 0; LttFacility * f; - for(i=0;i=t->facility_number;i++){ + for(i=0;ifacility_number;i++){ f = (LttFacility*)g_ptr_array_index(t->facilities, i); count += f->event_number; } @@ -685,7 +687,7 @@ int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i) LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i) { - return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i); + return (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i); } LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i) @@ -693,6 +695,52 @@ LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i) return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i); } +/***************************************************************************** + * Get the start time and end time of the trace + ****************************************************************************/ + +void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end) +{ + LttTime startSmall, startTmp, endBig, endTmp; + int i, j=0; + LttTracefile * tf; + + for(i=0;icontrol_tracefile_number;i++){ + tf = g_ptr_array_index(t->control_tracefiles, i); + readBlock(tf,1); + startTmp = tf->a_block_start->time; + readBlock(tf,tf->block_number); + endTmp = tf->a_block_end->time; + if(i==0){ + startSmall = startTmp; + endBig = endTmp; + j = 1; + continue; + } + if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp; + if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; + } + + for(i=0;iper_cpu_tracefile_number;i++){ + tf = g_ptr_array_index(t->per_cpu_tracefiles, i); + readBlock(tf,1); + startTmp = tf->a_block_start->time; + readBlock(tf,tf->block_number); + endTmp = tf->a_block_end->time; + if(j == 0 && i==0){ + startSmall = startTmp; + endBig = endTmp; + continue; + } + if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp; + if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp; + } + + *start = startSmall; + *end = endBig; +} + + /***************************************************************************** *Get the name of a tracefile ****************************************************************************/ @@ -702,6 +750,15 @@ char *ltt_tracefile_name(LttTracefile *tf) return tf->name; } +/***************************************************************************** + * Get the number of blocks in the tracefile + ****************************************************************************/ + +unsigned ltt_tracefile_block_number(LttTracefile *tf) +{ + return tf->block_number; +} + /***************************************************************************** *Function name * ltt_tracefile_seek_time: seek to the first event of the trace with time @@ -710,63 +767,136 @@ char *ltt_tracefile_name(LttTracefile *tf) * t : tracefile * time : criteria of the time ****************************************************************************/ +void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time, + int start_block, int end_block) +{ + int err, tmp_block, s, e; + int headTime; + int tailTime; + + err=readBlock(t,start_block); + if(err) g_error("Can not read tracefile: %s\n", t->name); + if(start_block == end_block)return; + + tailTime = ltt_time_compare(t->a_block_end->time, time); + if(tailTime >= 0) return; + + err=readBlock(t,end_block); + if(err) g_error("Can not read tracefile: %s\n", t->name); + if(start_block+1 == end_block)return; + + headTime = ltt_time_compare(t->a_block_start->time, time); + if(headTime <= 0 ) return; + + tmp_block = (end_block + start_block)/2; + err=readBlock(t,tmp_block); + if(err) g_error("Can not read tracefile: %s\n", t->name); + + headTime = ltt_time_compare(t->a_block_start->time, time); + tailTime = ltt_time_compare(t->a_block_end->time, time); + if(headTime <= 0 && tailTime >= 0) return; + + if(headTime > 0){ + s = start_block + 1; + e = tmp_block - 1; + if(s <= e) + ltt_tracefile_find_time_block(t, time, s, e); + else return; + } + + if(tailTime < 0){ + s = tmp_block + 1; + e = end_block - 1; + if(s <= e) + ltt_tracefile_find_time_block(t, time, s, e); + else return; + } +} + +void ltt_tracefile_backward_find_time_block(LttTracefile *t, LttTime time) +{ + int t_time, h_time, err; + err=readBlock(t,t->which_block-1); + if(err) g_error("Can not read tracefile: %s\n", t->name); + h_time = ltt_time_compare(t->a_block_start->time, time); + t_time = ltt_time_compare(t->a_block_end->time, time); + if(h_time == 0){ + int tmp; + if(t->which_block == 1) return; + err=readBlock(t,t->which_block-1); + if(err) g_error("Can not read tracefile: %s\n", t->name); + tmp = ltt_time_compare(t->a_block_end->time, time); + if(tmp == 0) return ltt_tracefile_seek_time(t, time); + err=readBlock(t,t->which_block+1); + if(err) g_error("Can not read tracefile: %s\n", t->name); + }else if(h_time > 0){ + ltt_tracefile_find_time_block(t, time, 1, t->which_block); + return ltt_tracefile_seek_time(t, time) ; + }else{ + if(t_time >= 0) return ltt_tracefile_seek_time(t, time); + err=readBlock(t,t->which_block+1); + if(err) g_error("Can not read tracefile: %s\n", t->name); + } +} void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) { int err; LttTime lttTime; - int headTime = timecmp(&(t->a_block_start->time), &time); - int tailTime = timecmp(&(t->a_block_end->time), &time); + int headTime = ltt_time_compare(t->a_block_start->time, time); + int tailTime = ltt_time_compare(t->a_block_end->time, time); LttEvent * ev; if(headTime < 0 && tailTime > 0){ - lttTime = getEventTime(t); - err = timecmp(<tTime, &time); - if(err > 0){ - if(t->which_event==2 || timecmp(&t->prev_event_time,&time)<0){ - return; - }else{ - updateTracefile(t); - return ltt_tracefile_seek_time(t, time); - } - }else if(err < 0){ - while(1){ - ev = ltt_tracefile_read(t); - if(ev == NULL){ - g_print("End of file\n"); + 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){ return; + }else{ + updateTracefile(t); + return ltt_tracefile_seek_time(t, time); } - g_free(ev); - lttTime = getEventTime(t); - err = timecmp(<tTime, &time); - if(err >= 0)return; - } - }else return; - }else if(headTime > 0){ + }else if(err < 0){ + while(1){ + ev = ltt_tracefile_read(t); + if(ev == NULL){ + g_print("End of file\n"); + return; + } + lttTime = getEventTime(t); + err = ltt_time_compare(lttTime, time); + if(err >= 0)return; + } + }else return; + }else{//we are at the end of the block + updateTracefile(t); + return ltt_tracefile_seek_time(t, time); + } + }else if(headTime >= 0){ if(t->which_block == 1){ updateTracefile(t); }else{ - if(timecmp(&(t->prev_block_end_time),&time) >= 0 ){ - err=readBlock(t,t->which_block-1); - if(err) g_error("Can not read tracefile: %s\n", t->name); - return ltt_tracefile_seek_time(t, time) ; + if(ltt_time_compare(t->prev_block_end_time, time) >= 0 || + (t->prev_block_end_time.tv_sec == 0 && + t->prev_block_end_time.tv_nsec == 0 )){ + ltt_tracefile_backward_find_time_block(t, time); }else{ updateTracefile(t); } } }else if(tailTime < 0){ if(t->which_block != t->block_number){ - err=readBlock(t,t->which_block+1); - if(err) g_error("Can not read tracefile: %s\n", t->name); + ltt_tracefile_find_time_block(t, time, t->which_block+1, t->block_number); + return ltt_tracefile_seek_time(t, time); }else { - g_print("End of file\n"); + t->cur_event_pos = t->buffer + t->block_size; + g_print("End of file\n"); return; } - if(tailTime < 0) return ltt_tracefile_seek_time(t, time); - }else if(headTime == 0){ - updateTracefile(t); }else if(tailTime == 0){ - t->cur_event_pos = t->a_block_end - EVENT_HEADER_SIZE; + t->cur_event_pos = t->last_event_pos; t->current_event_time = time; t->cur_heart_beat_number = 0; t->prev_event_time.tv_sec = 0; @@ -775,6 +905,32 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) } } +/***************************************************************************** + * Seek to the first event with position equal or larger to ep + ****************************************************************************/ + +void ltt_tracefile_seek_position(LttTracefile *t, LttEventPosition *ep) +{ + //if we are at the right place, just return + if(t->which_block == ep->block_num && t->which_event == ep->event_num) + return; + + if(t->which_block == ep->block_num) updateTracefile(t); + else readBlock(t,ep->block_num); + + //event offset is availiable + if(ep->old_position){ + t->cur_heart_beat_number = ep->heart_beat_number; + t->cur_event_pos = t->buffer + ep->event_offset; + return; + } + + //only block number and event index are availiable + while(t->which_event < ep->event_num) ltt_tracefile_read(t); + + return; +} + /***************************************************************************** *Function name * ltt_tracefile_read : read the current event, set the pointer to the next @@ -786,34 +942,37 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time) LttEvent *ltt_tracefile_read(LttTracefile *t) { - LttEvent * lttEvent = (LttEvent *)g_new(LttEvent, 1); + LttEvent * lttEvent = &t->an_event; int err; - lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos)); + if(t->cur_event_pos == t->buffer + t->block_size){ + if(t->which_block == t->block_number){ + return NULL; + } + err = readBlock(t, t->which_block + 1); + if(err)g_error("Can not read tracefile"); + } + + lttEvent->event_id = (int)(*(guint16 *)(t->cur_event_pos)); if(lttEvent->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 = *(uint32_t*)(t->cur_event_pos + EVENT_ID_SIZE); + lttEvent->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE); lttEvent->event_time = t->current_event_time; - lttEvent->event_cycle_count = ((uint64_t)1)<<32 * t->cur_heart_beat_number - + lttEvent->time_delta; - 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 == ENOMEM){ - g_free(lttEvent); - return NULL; - } - if(err == ENOENT) return lttEvent; if(err == ERANGE) g_error("event id is out of range\n"); - if(err)g_error("Can not read tracefile\n"); + + lttEvent->event_cycle_count = t->cur_cycle_count; return lttEvent; } @@ -857,7 +1016,7 @@ int readFile(int fd, void * buf, size_t size, char * mesg) int readBlock(LttTracefile * tf, int whichBlock) { off_t nbBytes; - uint32_t lostSize; + guint32 lostSize; if(whichBlock - tf->which_block == 1 && tf->which_block != 0){ tf->prev_block_end_time = tf->a_block_end->time; @@ -876,9 +1035,10 @@ int readBlock(LttTracefile * tf, int whichBlock) return EIO; tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE); - lostSize = *(uint32_t*)(tf->buffer + tf->block_size - sizeof(uint32_t)); + lostSize = *(guint32 *)(tf->buffer + tf->block_size - sizeof(guint32)); tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size - lostSize + EVENT_HEADER_SIZE); + tf->last_event_pos = tf->buffer + tf->block_size - lostSize; tf->which_block = whichBlock; tf->which_event = 1; @@ -918,10 +1078,6 @@ void updateTracefile(LttTracefile * tf) * t : tracefile *return value * 0 : success - * EINVAL : lseek fail - * EIO : can not read from the file - * ENOMEM : end of file - * ENOENT : last event * ERANGE : event id is out of range ****************************************************************************/ @@ -931,53 +1087,30 @@ int skipEvent(LttTracefile * t) void * evData; LttEventType * evT; LttField * rootFld; - static int evCount = 0; - - if(evCount){ - if(t->which_block == t->block_number && - evCount == t->which_event){ - return ENOMEM; - }else evCount = 0; - } - evId = (int)(*(uint16_t *)(t->cur_event_pos)); + evId = (int)(*(guint16 *)(t->cur_event_pos)); evData = t->cur_event_pos + EVENT_HEADER_SIZE; - //regard BLOCK_START, END and HEARTBEAT as special case, there are buildin events - if(evId != TRACE_BLOCK_START && evId != TRACE_BLOCK_END && evId != TRACE_TIME_HEARTBEAT){ - evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId); + evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId); - if(evT) rootFld = evT->root_field; - else return ERANGE; + if(evT) rootFld = evT->root_field; + else return ERANGE; - if(rootFld){ - //event has string/sequence or the last event is not the same event - if((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event) - && rootFld->field_fixed == 0){ - setFieldsOffset(t, evT, evData, t->trace); - } - t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size; - }else t->cur_event_pos += EVENT_HEADER_SIZE; - - evT->latest_block = t->which_block; - evT->latest_event = t->which_event; - }else{ - if(evId == TRACE_BLOCK_START || evId == TRACE_BLOCK_END){ - t->cur_event_pos += sizeof(BlockStart) + EVENT_HEADER_SIZE; - }else{ - t->cur_event_pos += sizeof(TimeHeartbeat) + EVENT_HEADER_SIZE; + if(rootFld){ + //event has string/sequence or the last event is not the same event + if((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event) + && rootFld->field_fixed == 0){ + setFieldsOffset(t, evT, evData, t->trace); } - } - + t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size; + }else t->cur_event_pos += EVENT_HEADER_SIZE; + + evT->latest_block = t->which_block; + evT->latest_event = t->which_event; + //the next event is in the next block if(evId == TRACE_BLOCK_END){ - if(t->which_block == t->block_number){ - t->which_event++; - evCount = t->which_event; - return ENOENT; - } - err = readBlock(t, t->which_block + 1); - if(err) return err; + t->cur_event_pos = t->buffer + t->block_size; }else{ t->which_event++; t->current_event_time = getEventTime(t); @@ -1000,14 +1133,16 @@ void getCyclePerNsec(LttTracefile * t) LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */ /* Calculate the total time for this buffer */ - TimeSub(lBufTotalTime,t->a_block_end->time, t->a_block_start->time); + lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time); /* Calculate the total cycles for this bufffer */ - lBufTotalCycle = t->a_block_end->cycle_count - - t->a_block_start->cycle_count; + lBufTotalCycle = t->a_block_end->cycle_count; + lBufTotalCycle -= t->a_block_start->cycle_count; /* Convert the total time to nsecs */ - lBufTotalNSec = lBufTotalTime.tv_sec * 1000000000 + lBufTotalTime.tv_nsec; + lBufTotalNSec = lBufTotalTime.tv_sec; + lBufTotalNSec *= NANOSECONDS_PER_SECOND; + lBufTotalNSec += lBufTotalTime.tv_nsec; t->cycle_per_nsec = (double)lBufTotalCycle / (double)lBufTotalNSec; } @@ -1028,30 +1163,47 @@ LttTime getEventTime(LttTracefile * tf) LttCycleCount lEventTotalCycle; // Total cycles from start for event double lEventNSec; // Total usecs from start for event LttTime lTimeOffset; // Time offset in struct LttTime - uint16_t evId; - - evId = *(uint16_t*)tf->cur_event_pos; - if(evId == TRACE_BLOCK_START) + guint16 evId; + gint64 nanoSec, tmpCycleCount = (((guint64)1)<<32); + + evId = *(guint16 *)tf->cur_event_pos; + if(evId == TRACE_BLOCK_START){ + tf->count = 0; + tf->pre_cycle_count = 0; + tf->cur_cycle_count = tf->a_block_start->cycle_count; return tf->a_block_start->time; - else if(evId == TRACE_BLOCK_END) + }else if(evId == TRACE_BLOCK_END){ + tf->count = 0; + tf->pre_cycle_count = 0; + tf->cur_cycle_count = tf->a_block_end->cycle_count; return tf->a_block_end->time; + } + + // Calculate total time in cycles from start of buffer for this event + cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE); + + if(cycle_count < tf->pre_cycle_count)tf->count++; + tf->pre_cycle_count = cycle_count; + cycle_count += tmpCycleCount * tf->count; + if(tf->cur_heart_beat_number > tf->count) + cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count); - // Calculate total time in cycles from start of buffer for this event - cycle_count = (LttCycleCount)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE); - if(tf->cur_heart_beat_number) - cycle_count += ((uint64_t)1)<<32 * tf->cur_heart_beat_number; - lEventTotalCycle = cycle_count - tf->a_block_start->cycle_count; + tf->cur_cycle_count = cycle_count; + + lEventTotalCycle = cycle_count; + lEventTotalCycle -= tf->a_block_start->cycle_count; // Convert it to nsecs lEventNSec = lEventTotalCycle / tf->cycle_per_nsec; - - // Determine offset in struct LttTime - lTimeOffset.tv_nsec = (long)lEventNSec % 1000000000; - lTimeOffset.tv_sec = (long)lEventNSec / 1000000000; + nanoSec = lEventNSec; - TimeAdd(time, tf->a_block_start->time, lTimeOffset); + // Determine offset in struct LttTime + lTimeOffset.tv_nsec = nanoSec % NANOSECONDS_PER_SECOND; + lTimeOffset.tv_sec = nanoSec / NANOSECONDS_PER_SECOND; + time = ltt_time_add(tf->a_block_start->time, lTimeOffset); + return time; } @@ -1131,6 +1283,7 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, }else if(type->type_class == 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; @@ -1202,24 +1355,6 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot, return size; } -/***************************************************************************** - *Function name - * timecmp : compare two time - *Input params - * t1 : first time - * t2 : second time - *Return value - * int : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2 - ****************************************************************************/ - -int timecmp(LttTime * t1, LttTime * t2) -{ - LttTime T; - TimeSub(T, *t1, *t2); - if(T.tv_sec == 0 && T.tv_nsec == 0) return 0; - else if(T.tv_sec > 0 || (T.tv_sec==0 && T.tv_nsec > 0)) return 1; - else return -1; -} /***************************************************************************** *Function name @@ -1233,11 +1368,11 @@ int timecmp(LttTime * t1, LttTime * t2) int getIntNumber(int size, void *evD) { - int64_t i; - if(size == 1) i = *(int8_t *)evD; - else if(size == 2) i = *(int16_t *)evD; - else if(size == 4) i = *(int32_t *)evD; - else if(size == 8) i = *(int64_t *)evD; + gint64 i; + 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; } @@ -1271,3 +1406,34 @@ void getDataEndianType(LttArchSize * size, LttArchEndian * endian) else *size = LTT_UNKNOWN; } +/* get the node name of the system */ + +char * ltt_trace_system_description_node_name (LttSystemDescription * s) +{ + return s->node_name; +} + + +/* get the domain name of the system */ + +char * ltt_trace_system_description_domain_name (LttSystemDescription * s) +{ + return s->domain_name; +} + + +/* get the description of the system */ + +char * ltt_trace_system_description_description (LttSystemDescription * s) +{ + return s->description; +} + + +/* get the start time of the trace */ + +LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s) +{ + return s->trace_start; +} +