X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=a1decdde550577f03245ba5df868622beaacd12d;hb=fc063e40663e33543deebe5e57d6847f2aca5da7;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..a1decdde 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -18,10 +18,12 @@
 
 #include <stdio.h>
 #include <fcntl.h>
+#include <string.h>
+#include <dirent.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <dirent.h>
-#include <linux/errno.h>  
+#include <errno.h>
+#include <unistd.h>
 
 // For realpath
 #include <limits.h>
@@ -33,8 +35,11 @@
 #include "ltt-private.h"
 #include <ltt/trace.h>
 #include <ltt/facility.h>
+#include <ltt/event.h>
+#include <ltt/type.h>
 
 #define DIR_NAME_SIZE 256
+#define UNUSED __attribute__((__unused__))
 
 /* set the offset of the fields belonging to the event,
    need the information of the archecture */
@@ -60,7 +65,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 +75,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 +120,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 +154,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 +162,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 +215,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 +250,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 +287,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 +305,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 +363,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 +385,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 +414,7 @@ void getCpuFileInfo(LttTrace *t, char* cpu)
     }else continue;
   }  
   closedir(dir);
+  return 0;
 }
 
 /*****************************************************************************
@@ -389,29 +424,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 +483,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 +498,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 +566,7 @@ LttTrace *ltt_trace_copy(LttTrace *self)
 
 void ltt_trace_close(LttTrace *t)
 {
-  int i;
+  unsigned int i;
   LttTracefile * tf;
   LttFacility * f;
 
@@ -576,7 +649,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;i<t->facility_number;i++){
     f = (LttFacility*)g_ptr_array_index(t->facilities, i);
@@ -596,7 +669,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;i<t->facility_number;i++){
@@ -609,7 +682,7 @@ unsigned ltt_trace_eventtype_number(LttTrace *t)
 LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id)
 {
   LttFacility * facility;
-  int i;
+  unsigned int i;
   for(i=0;i<trace->facility_number;i++){
     facility = (LttFacility*) g_ptr_array_index(trace->facilities,i);
     if(id >= facility->base_id && 
@@ -650,10 +723,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;i<t->control_tracefile_number;i++){
     tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);
     if(strcmp(tracefile->name, name)==0)break;
@@ -662,17 +735,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;j<t->per_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;i<t->per_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 +771,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;i<t->control_tracefile_number;i++){
@@ -730,8 +805,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 +914,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 +929,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 +975,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 +988,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 +1033,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 +1045,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 +1093,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 +1188,7 @@ void updateTracefile(LttTracefile * tf)
 
 int skipEvent(LttTracefile * t)
 {
-  int evId, err;
+  int evId;
   void * evData;
   LttEventType * evT;
   LttField * rootFld;
@@ -1112,6 +1224,7 @@ int skipEvent(LttTracefile * t)
   return 0;
 }
 
+
 /*****************************************************************************
  *Function name
  *    getCyclePerNsec : calculate cycles per nsec for current block
@@ -1429,3 +1542,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;
+}
+