X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=c5f98c3c27b0a7b205e5fd39139afbbec65b4617;hb=338d4282832c1e0002ccdeeb36555271959dd57b;hp=07b8ab3a837a1f3d5cb7a69124a1f58f5482df87;hpb=308711e5772586ce8ecc22ce04e571b175309b8e;p=lttv.git

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index 07b8ab3a..c5f98c3c 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 <stdio.h>
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -5,9 +23,11 @@
 #include <dirent.h>
 #include <linux/errno.h>  
 
-#include <ltt/LTTTypes.h>  
 #include "parser.h"
+#include <ltt/ltt.h>
+#include "ltt-private.h"
 #include <ltt/trace.h>
+#include <ltt/facility.h>
 
 #define DIR_NAME_SIZE 256
 
@@ -34,6 +54,85 @@ void updateTracefile(LttTracefile * tf);
 int skipEvent(LttTracefile * t);
 
 
+/* 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);
+}
+
+
 /*****************************************************************************
  *Function name
  *    ltt_tracefile_open : open a trace file, construct a LttTracefile
@@ -108,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;
@@ -128,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;i<t->facility_number;i++){
 	  f = (LttFacility*)g_ptr_array_index(t->facilities,i);
@@ -171,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("<system",ptr,7) !=0)g_error("Not a valid file: %s\n", pathname);
-
-  for(i=0;i<entry_number;i++){
-    if(fgets(buf,DIR_NAME_SIZE, fp)== NULL)
-      g_error("Not a valid file: %s\n", pathname);
-    buf[strlen(buf)-1] = '\0';
-    ptr = buf;
-    while(isspace(*ptr)) ptr++;
-    switch(i){
-      case 0:
-	if(strncmp("node_name=",ptr,10)!=0)
-	  g_error("Not a valid file: %s\n", pathname);
-	des->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("</system>",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);
 }
 
@@ -382,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);
@@ -398,8 +384,41 @@ 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.
+ *
  ****************************************************************************/
 
+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;
@@ -409,30 +428,33 @@ LttTrace *ltt_trace_open(const 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;
@@ -459,6 +481,12 @@ LttTrace *ltt_trace_open(const 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.
@@ -739,6 +767,77 @@ unsigned ltt_tracefile_block_number(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)
 {
@@ -779,23 +878,23 @@ void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
     if(t->which_block == 1){
       updateTracefile(t);      
     }else{
-      if(ltt_time_compare(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(tailTime == 0){
     t->cur_event_pos = t->last_event_pos;
     t->current_event_time = time;  
@@ -854,15 +953,16 @@ LttEvent *ltt_tracefile_read(LttTracefile *t)
     if(err)g_error("Can not read tracefile");    
   }
 
-  lttEvent->event_id = (int)(*(uint16_t *)(t->cur_event_pos));
+  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 = t->cur_cycle_count;
 
   lttEvent->tracefile = t;
   lttEvent->data = t->cur_event_pos + EVENT_HEADER_SIZE;  
@@ -873,8 +973,6 @@ LttEvent *ltt_tracefile_read(LttTracefile *t)
   err = skipEvent(t);
   if(err == ERANGE) g_error("event id is out of range\n");
 
-  lttEvent->event_cycle_count = t->cur_cycle_count;
-
   return lttEvent;
 }
 
@@ -917,7 +1015,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;
@@ -936,7 +1034,7 @@ 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;
@@ -989,7 +1087,7 @@ int skipEvent(LttTracefile * t)
   LttEventType * evT;
   LttField * rootFld;
 
-  evId   = (int)(*(uint16_t *)(t->cur_event_pos));
+  evId   = (int)(*(guint16 *)(t->cur_event_pos));
   evData = t->cur_event_pos + EVENT_HEADER_SIZE;
 
   evT    = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
@@ -1062,35 +1160,33 @@ LttTime getEventTime(LttTracefile * tf)
   LttTime       time;
   LttCycleCount cycle_count;      // cycle count for the current event
   LttCycleCount lEventTotalCycle; // Total cycles from start for event
-  double        lEventNSec;       // Total usecs from start for event
+  LttCycleCount lEventNSec;       // Total usecs from start for event
   LttTime       lTimeOffset;      // Time offset in struct LttTime
-  uint16_t      evId;
-  int64_t       nanoSec, tmpCycleCount = (((uint64_t)1)<<32);
-  static LttCycleCount preCycleCount = 0;
-  static int   count = 0;
+  guint16       evId;
+  LttCycleCount tmpCycleCount = (((LttCycleCount)1)<<32);
 
-  evId = *(uint16_t*)tf->cur_event_pos;
+  evId = *(guint16 *)tf->cur_event_pos;
   if(evId == TRACE_BLOCK_START){
-    count = 0;
-    preCycleCount = 0;
+    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){
-    count = 0;
-    preCycleCount = 0;
+    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)*(uint32_t*)(tf->cur_event_pos + EVENT_ID_SIZE);
+  cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
   
-  if(cycle_count < preCycleCount)count++;
-  preCycleCount = cycle_count;
-  cycle_count += tmpCycleCount * count;  
+  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 > count)
-    cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - count);  
+  //  if(tf->cur_heart_beat_number > tf->count)
+  //    cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count);  
 
   tf->cur_cycle_count = cycle_count;
 
@@ -1098,12 +1194,11 @@ LttTime getEventTime(LttTracefile * tf)
   lEventTotalCycle -= tf->a_block_start->cycle_count;
 
   // Convert it to nsecs
-  lEventNSec = lEventTotalCycle / tf->cycle_per_nsec;
-  nanoSec    = lEventNSec;
+  lEventNSec = (double)lEventTotalCycle / (double)tf->cycle_per_nsec;
 
   // Determine offset in struct LttTime 
-  lTimeOffset.tv_nsec = nanoSec % NANOSECONDS_PER_SECOND;
-  lTimeOffset.tv_sec  = nanoSec / NANOSECONDS_PER_SECOND;
+  lTimeOffset.tv_nsec = lEventNSec % NANOSECONDS_PER_SECOND;
+  lTimeOffset.tv_sec  = lEventNSec / NANOSECONDS_PER_SECOND;
 
   time = ltt_time_add(tf->a_block_start->time, lTimeOffset);  
   
@@ -1271,11 +1366,11 @@ int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
 
 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;
 }
@@ -1309,3 +1404,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;
+}
+