X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=ltt%2Fbranches%2Fpoly%2Fltt%2Ftracefile.c;h=31100215d80f9340cefee0bd52a664435d23ba1e;hb=8655430bd9f02ea37f252ed65885320aedd75ff3;hp=cfe76e10c44a6444d0a82304c1811f860ecacd2a;hpb=f439de065dfbf93d5ccb1bbf511c3793e76527cc;p=lttv.git

diff --git a/ltt/branches/poly/ltt/tracefile.c b/ltt/branches/poly/ltt/tracefile.c
index cfe76e10..31100215 100644
--- a/ltt/branches/poly/ltt/tracefile.c
+++ b/ltt/branches/poly/ltt/tracefile.c
@@ -45,7 +45,6 @@
 #include "ltt-private.h"
 #include <ltt/trace.h>
 #include <ltt/event.h>
-//#include <ltt/type.h>
 #include <ltt/ltt-types.h>
 #include <ltt/marker.h>
 
@@ -105,8 +104,6 @@ static guint64 cycles_2_ns(LttTracefile *tf, guint64 cycles);
 /* go to the next event */
 static int ltt_seek_next_event(LttTracefile *tf);
 
-//void ltt_update_event_size(LttTracefile *tf);
-
 static int open_tracefiles(LttTrace *trace, gchar *root_path,
     gchar *relative_path);
 static int ltt_process_facility_tracefile(LttTracefile *tf);
@@ -114,8 +111,6 @@ static void ltt_tracefile_time_span_get(LttTracefile *tf,
                                         LttTime *start, LttTime *end);
 static void group_time_span_get(GQuark name, gpointer data, gpointer user_data);
 static gint map_block(LttTracefile * tf, guint block_num);
-static int ltt_seek_next_event(LttTracefile *tf);
-static void __attribute__((constructor)) init(void);
 static void ltt_update_event_size(LttTracefile *tf);
 
 /* Enable event debugging */
@@ -126,107 +121,11 @@ void ltt_event_debug(int state)
   a_event_debug = state;
 }
 
-//void precompute_offsets(LttFacility *fac, LttEventType *event);
-
-#if 0
-/* Functions to parse system.xml file (using glib xml parser) */
-static void parser_start_element (GMarkupParseContext  __UNUSED__ *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)){
-    *error = g_error_new(G_MARKUP_ERROR,
-                         G_LOG_LEVEL_WARNING,
-                         "This is not system.xml file");
-    return;
-  }
-  
-  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{
-      *error = g_error_new(G_MARKUP_ERROR,
-                           G_LOG_LEVEL_WARNING,
-                           "Not a valid attribute");
-      return;      
-    }
-    i++;
-  }
-}
-
-static void  parser_characters   (GMarkupParseContext __UNUSED__ *context,
-				  const gchar          *text,
-				  gsize __UNUSED__      text_len,
-				  gpointer              user_data,
-				  GError __UNUSED__     **error)
-{
-  LttSystemDescription* des = (LttSystemDescription* )user_data;
-  des->description = g_strdup(text);
-}
-#endif //0
-
-#if 0
-LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
-    guint num)
-{
-  g_assert(num < t->facilities_by_num->len);
-  
-  return &g_array_index(t->facilities_by_num, LttFacility, num);
-
-}
-#endif //0
-
-guint ltt_trace_get_num_cpu(LttTrace *t)
-{
-  return t->num_cpu;
-}
-
-
 /* trace can be NULL
  *
  * Return value : 0 success, 1 bad tracefile
  */
-int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t)
+static int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t)
 {
   guint32 *magic_number = (guint32*)header;
   struct ltt_trace_header_any *any = (struct ltt_trace_header_any *)header;
@@ -338,7 +237,7 @@ int parse_trace_header(void *header, LttTracefile *tf, LttTrace *t)
  *                       : 0 for success, -1 otherwise.
  ****************************************************************************/ 
 
-gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
+static gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
 {
   struct stat    lTDFStat;    /* Trace data file status */
   struct ltt_block_start_header *header;
@@ -427,11 +326,6 @@ end:
   return -1;
 }
 
-LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
-{
-  return tf->trace;
-}
-
 #if 0
 /*****************************************************************************
  *Open control and per cpu tracefiles
@@ -507,7 +401,7 @@ gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name)
  *    t                  : tracefile which will be closed
  ****************************************************************************/
 
-void ltt_tracefile_close(LttTracefile *t)
+static void ltt_tracefile_close(LttTracefile *t)
 {
   int page_size = getpagesize();
 
@@ -675,7 +569,7 @@ void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
  * The left side is the name, the right side is the number.
  */
 
-int get_tracefile_name_number(gchar *raw_name,
+static int get_tracefile_name_number(gchar *raw_name,
                               GQuark *name,
                               guint *num,
                               gulong *tid,
@@ -793,7 +687,7 @@ void compute_tracefile_group(GQuark key_id,
 }
 
 
-void ltt_tracefile_group_destroy(gpointer data)
+static void ltt_tracefile_group_destroy(gpointer data)
 {
   GArray *group = (GArray *)data;
   int i;
@@ -807,7 +701,7 @@ void ltt_tracefile_group_destroy(gpointer data)
   g_array_free(group, TRUE);
 }
 
-gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
+static gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
 {
   GArray *group = (GArray *)data;
   int i;
@@ -833,7 +727,7 @@ gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
  * A tracefile group is simply an array where all the per cpu tracefiles sit.
  */
 
-int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path)
+static int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path)
 {
   DIR *dir = opendir(root_path);
   struct dirent *entry;
@@ -946,134 +840,10 @@ int open_tracefiles(LttTrace *trace, gchar *root_path, gchar *relative_path)
   return 0;
 }
 
-/* ltt_get_facility_description
- *
- * Opens the file corresponding to the requested facility (identified by fac_id
- * and checksum).
- *
- * The name searched is : %trace root%/eventdefs/facname_checksum.xml
- *
- * Returns 0 on success, or 1 on failure.
- */
-#if 0
-static int ltt_get_facility_description(LttFacility *f, 
-                                        LttTrace *t,
-                                        LttTracefile *fac_tf)
-{
-  char desc_file_name[PATH_MAX];
-  const gchar *text;
-  guint textlen;
-  gint err;
-  gint arch_spec;
-  gint fac_name_len;
-
-  text = g_quark_to_string(t->pathname);
-  textlen = strlen(text);
-  
-  if(textlen >= PATH_MAX) goto name_error;
-  strcpy(desc_file_name, text);
-
-  text = "/eventdefs/";
-  textlen+=strlen(text);
-  if(textlen >= PATH_MAX) goto name_error;
-  strcat(desc_file_name, text);
-  
-  text = g_quark_to_string(f->name);
-  fac_name_len = strlen(text);
-  textlen+=fac_name_len;
-  if(textlen >= PATH_MAX) goto name_error;
-  strcat(desc_file_name, text);
-
-  /* arch specific facilities are named like this : name_arch */
-  if(fac_name_len+1 < sizeof("_arch"))
-    arch_spec = 0;
-  else {
-    if(!strcmp(&text[fac_name_len+1-sizeof("_arch")], "_arch"))
-      arch_spec = 1;
-    else
-      arch_spec = 0;
-  }
-
-#if 0
-  text = "_";
-  textlen+=strlen(text);
-  if(textlen >= PATH_MAX) goto name_error;
-  strcat(desc_file_name, text);
-
-  err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1,
-      "%u", f->checksum);
-  if(err < 0) goto name_error;
-
-  textlen=strlen(desc_file_name);
-  
-#endif //0
-  
-  if(arch_spec) {
-    switch(t->arch_type) {
-      case LTT_ARCH_TYPE_I386:
-        text = "_i386";
-        break;
-      case LTT_ARCH_TYPE_PPC:
-        text = "_ppc";
-        break;
-      case LTT_ARCH_TYPE_SH:
-        text = "_sh";
-        break;
-      case LTT_ARCH_TYPE_S390:
-        text = "_s390";
-        break;
-      case LTT_ARCH_TYPE_MIPS:
-        text = "_mips";
-        break;
-      case LTT_ARCH_TYPE_ARM:
-        text = "_arm";
-        break;
-      case LTT_ARCH_TYPE_PPC64:
-        text = "_ppc64";
-        break;
-      case LTT_ARCH_TYPE_X86_64:
-        text = "_x86_64";
-        break;
-      case LTT_ARCH_TYPE_C2:
-        text = "_c2";
-        break;
-      case LTT_ARCH_TYPE_POWERPC:
-        text = "_powerpc";
-        break;
-      default:
-        g_error("Trace from unsupported architecture.");
-    }
-    textlen+=strlen(text);
-    if(textlen >= PATH_MAX) goto name_error;
-    strcat(desc_file_name, text);
-  }
-  
-  text = ".xml";
-  textlen+=strlen(text);
-  if(textlen >= PATH_MAX) goto name_error;
-  strcat(desc_file_name, text);
-
-  err = ltt_facility_open(f, t, desc_file_name);
-  if(err) goto facility_error;
-
-  return 0;
-
-facility_error:
-name_error:
-  return 1;
-}
-
-static void ltt_fac_ids_destroy(gpointer data)
-{
-  GArray *fac_ids = (GArray *)data;
-
-  g_array_free(fac_ids, TRUE);
-}
-#endif //0
 
 /* Presumes the tracefile is already seeked at the beginning. It makes sense,
  * because it must be done just after the opening */
-int ltt_process_facility_tracefile(LttTracefile *tf)
+static int ltt_process_facility_tracefile(LttTracefile *tf)
 {
   int err;
   //LttFacility *fac;
@@ -1274,12 +1044,6 @@ alloc_error:
 
 }
 
-GQuark ltt_trace_name(const 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.
@@ -1297,80 +1061,6 @@ void ltt_trace_close(LttTrace *t)
 }
 
 
-/*****************************************************************************
- *Get the system description of the trace
- ****************************************************************************/
-#if 0
-LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id)
-{
-  g_assert(id < t->facilities_by_num->len);
-  return &g_array_index(t->facilities_by_num, LttFacility, id);
-}
-
-/* ltt_trace_facility_get_by_name
- *
- * Returns the GArray of facility indexes. All the fac_ids that matches the
- * requested facility name.
- *
- * If name is not found, returns NULL.
- */
-GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name)
-{
-  return g_datalist_id_get_data(&t->facilities_by_name, name);
-}
-#endif //0
-
-/*****************************************************************************
- * Functions to discover all the event types in the trace 
- ****************************************************************************/
-
-#if 0
-unsigned ltt_trace_eventtype_number(LttTrace *t)
-{
-  unsigned int i;
-  unsigned count = 0;
-  unsigned int num = t->facility_number;
-  LttFacility * f;
-  
-  for(i=0;i<num;i++){
-    f = (LttFacility*)g_ptr_array_index(t->facilities, i);
-    count += f->event_number;
-  }
-  return count;
-}
-#endif //0
-
-#if 0
-//use an iteration on all the trace facilities, and inside iteration on all the
-//event types in each facilities instead.
-LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
-{
-  LttEventType *event_type;
-  
-  LttFacility * f;
-  f = ltt_trace_facility_by_id(t,evId);
-
-  if(unlikely(!f)) event_type = NULL;
-  else event_type = f->events[evId - f->base_id];
-
-  return event_type;
-}
-#endif //0
-
-#if 0
-/*****************************************************************************
- * ltt_trace_find_tracefile
- *
- * Find a tracefile by name and index in the group.
- *
- * Returns a pointer to the tracefiles, else NULL.
- ****************************************************************************/
-
-LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name)
-{
-}
-#endif //0
-
 /*****************************************************************************
  * Get the start time and end time of the trace 
  ****************************************************************************/
@@ -1401,7 +1091,7 @@ struct tracefile_time_span_get_args {
   LttTime *end;
 };
 
-void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
+static void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
 {
   struct tracefile_time_span_get_args *args =
           (struct tracefile_time_span_get_args*)user_data;
@@ -1422,6 +1112,8 @@ void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
   }
 }
 
+/* return the start and end time of a trace */
+
 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
 {
   LttTime min_start = ltt_time_infinite;
@@ -1436,51 +1128,6 @@ void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
 }
 
 
-/*****************************************************************************
- *Get the name of a tracefile
- ****************************************************************************/
-
-GQuark ltt_tracefile_name(const LttTracefile *tf)
-{
-  return tf->name;
-}
-
-GQuark ltt_tracefile_long_name(const LttTracefile *tf)
-{
-  return tf->long_name;
-}
-
-
-
-guint ltt_tracefile_cpu(LttTracefile *tf)
-{
-  return tf->cpu_num;
-}
-
-guint ltt_tracefile_tid(LttTracefile *tf)
-{
-  return tf->tid;
-}
-
-guint ltt_tracefile_pgid(LttTracefile *tf)
-{
-  return tf->pgid;
-}
-
-guint64 ltt_tracefile_creation(LttTracefile *tf)
-{
-  return tf->creation;
-}
-/*****************************************************************************
- * Get the number of blocks in the tracefile 
- ****************************************************************************/
-
-guint ltt_tracefile_block_number(LttTracefile *tf)
-{
-  return tf->num_blocks; 
-}
-
-
 /* Seek to the first event in a tracefile that has a time equal or greater than
  * the time passed in parameter.
  *
@@ -1605,8 +1252,8 @@ fail:
 }
 
 
-int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) {
-  
+int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep)
+{
   int err;
   
   if(ep->tracefile != tf) {
@@ -1916,7 +1563,7 @@ int ltt_tracefile_read_update_event(LttTracefile *tf)
  *    EIO             : can not read from the file
  ****************************************************************************/
 
-gint map_block(LttTracefile * tf, guint block_num)
+static gint map_block(LttTracefile * tf, guint block_num)
 {
   int page_size = getpagesize();
   struct ltt_block_start_header *header;
@@ -2168,53 +1815,6 @@ void ltt_update_event_size(LttTracefile *tf)
         tf->event.event_size, tf->event.data_size);
     exit(-1);
   }
-
-#if 0
-  LttEventType *event_type = 
-    ltt_facility_eventtype_get(f, tf->event.event_id);
-
-  if(!event_type) {
-    g_warning("Unknown event id %hhu in facility %s in tracefile %s",
-        tf->event.event_id,
-        g_quark_to_string(f->name),
-        g_quark_to_string(tf->name));
-    goto event_type_error;
-  }
-  
-  /* Compute the dynamic offsets */
-  compute_offsets(tf, f, event_type, &size, tf->event.data);
-
-  //g_debug("Event root field : f.e %hhu.%hhu size %zd",
-  //    tf->event.facility_id,
-  //    tf->event.event_id, size);
-
-no_offset: 
-  tf->event.data_size = size;
-  
-  /* Check consistency between kernel and LTTV structure sizes */
-  if(tf->event.event_size == 0xFFFF) {
-    /* Event size too big to fit in the event size field */
-    tf->event.event_size = tf->event.data_size;
-  }
-  if (tf->event.data_size != tf->event.event_size) {
-    g_error("Kernel/LTTV event size differs for event %s.%s: kernel %u, LTTV %u",
-        g_quark_to_string(f->name), g_quark_to_string(event_type->name),
-    tf->event.event_size, tf->event.data_size);
-    exit(-1);
-  }
-  //g_assert(tf->event.data_size == tf->event.event_size);
-
-  return;
-
-event_type_error:
-event_id_error:
-  if(tf->event.event_size == 0xFFFF) {
-    g_error("Cannot jump over an unknown event bigger than 0xFFFE bytes");
-  }
-  /* The facility is unknown : use the kernel information about this event
-   * to jump over it. */
-  tf->event.data_size = tf->event.event_size;
-#endif //0
 }
 
 
@@ -2229,7 +1829,7 @@ event_id_error:
  *         ERANGE if we are at the end of the buffer.
  *         ENOPROTOOPT if an error occured when getting the current event size.
  */
-int ltt_seek_next_event(LttTracefile *tf)
+static int ltt_seek_next_event(LttTracefile *tf)
 {
   int ret = 0;
   void *pos;
@@ -3232,7 +2832,7 @@ LttTime ltt_trace_start_time_monotonic(LttTrace *t)
   return t->start_time_from_tsc;
 }
 
-LttTracefile *ltt_tracefile_new()
+static LttTracefile *ltt_tracefile_new()
 {
   LttTracefile *tf;
   tf = g_new(LttTracefile, 1);
@@ -3240,19 +2840,19 @@ LttTracefile *ltt_tracefile_new()
   return tf;
 }
 
-void ltt_tracefile_destroy(LttTracefile *tf)
+static void ltt_tracefile_destroy(LttTracefile *tf)
 {
   g_free(tf);
 }
 
-void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
+static void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
 {
   *dest = *src;
 }
 
 /* Before library loading... */
 
-void init(void)
+static __attribute__((constructor)) void init(void)
 {
   LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
   LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");