ltt/branches/poly/ltt/tracefile.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2005 Mathieu Desnoyers
   3  *
   4  * Complete rewrite from the original version made by XangXiu Yang.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License Version 2 as
   8  * published by the Free Software Foundation;
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18  * MA 02111-1307, USA.
  19  */
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <fcntl.h>
  27 #include <string.h>
  28 #include <dirent.h>
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <errno.h>
  32 #include <unistd.h>
  33 #include <math.h>
  34 #include <glib.h>
  35 #include <malloc.h>
  36 #include <sys/mman.h>
  37
  38 // For realpath
  39 #include <limits.h>
  40 #include <stdlib.h>
  41
  42
  43 #include "parser.h"
  44 #include <ltt/ltt.h>
  45 #include "ltt-private.h"
  46 #include <ltt/trace.h>
  47 #include <ltt/facility.h>
  48 #include <ltt/event.h>
  49 #include <ltt/type.h>
  50 #include <ltt/ltt-types.h>
  51
  52
  53 /* Facility names used in this file */
  54
  55 GQuark LTT_FACILITY_NAME_HEARTBEAT,
  56        LTT_EVENT_NAME_HEARTBEAT;
  57 GQuark LTT_TRACEFILE_NAME_FACILITIES;
  58
  59 #ifndef g_open
  60 #define g_open open
  61 #endif
  62
  63
  64 #define __UNUSED__ __attribute__((__unused__))
  65
  66 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  67
  68 #ifndef g_debug
  69 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  70 #endif
  71
  72 #define g_close close
  73
  74 /* Those macros must be called from within a function where page_size is a known
  75  * variable */
  76 #define PAGE_MASK (~(page_size-1))
  77 #define PAGE_ALIGN(addr)  (((addr)+page_size-1)&PAGE_MASK)
  78
  79 /* obtain the time of an event */
  80
  81 static inline LttTime getEventTime(LttTracefile * tf);
  82
  83
  84 /* set the offset of the fields belonging to the event,
  85    need the information of the archecture */
  86 void set_fields_offsets(LttTracefile *tf, LttEventType *event_type);
  87 //size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
  88
  89 /* get the size of the field type according to
  90  * The facility size information. */
  91 static inline void preset_field_type_size(LttTracefile *tf,
  92     LttEventType *event_type,
  93     off_t offset_root, off_t offset_parent,
  94     enum field_status *fixed_root, enum field_status *fixed_parent,
  95     LttField *field);
  96
  97 /* map a fixed size or a block information from the file (fd) */
  98 static gint map_block(LttTracefile * tf, guint block_num);
  99
 100 /* calculate nsec per cycles for current block */
 101 static double calc_nsecs_per_cycle(LttTracefile * t);
 102
 103 /* go to the next event */
 104 static int ltt_seek_next_event(LttTracefile *tf);
 105
 106 void ltt_update_event_size(LttTracefile *tf);
 107
 108 #if 0
 109 /* Functions to parse system.xml file (using glib xml parser) */
 110 static void parser_start_element (GMarkupParseContext  __UNUSED__ *context,
 111                                   const gchar          *element_name,
 112                                   const gchar         **attribute_names,
 113                                   const gchar         **attribute_values,
 114                                   gpointer              user_data,
 115                                   GError              **error)
 116 {
 117   int i=0;
 118   LttSystemDescription* des = (LttSystemDescription* )user_data;
 119   if(strcmp("system", element_name)){
 120     *error = g_error_new(G_MARKUP_ERROR,
 121                          G_LOG_LEVEL_WARNING,
 122                          "This is not system.xml file");
 123     return;
 124   }
 125
 126   while(attribute_names[i]){
 127     if(strcmp("node_name", attribute_names[i])==0){
 128         des->node_name = g_strdup(attribute_values[i]);
 129     }else if(strcmp("domainname", attribute_names[i])==0){
 130         des->domain_name = g_strdup(attribute_values[i]);
 131     }else if(strcmp("cpu", attribute_names[i])==0){
 132         des->nb_cpu = atoi(attribute_values[i]);
 133     }else if(strcmp("arch_size", attribute_names[i])==0){
 134         if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32;
 135         else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32;
 136         else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64;
 137         else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64;
 138         else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN;
 139     }else if(strcmp("endian", attribute_names[i])==0){
 140         if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0)
 141           des->endian = LTT_LITTLE_ENDIAN;
 142         else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0)
 143           des->endian = LTT_BIG_ENDIAN;
 144     }else if(strcmp("kernel_name", attribute_names[i])==0){
 145         des->kernel_name = g_strdup(attribute_values[i]);
 146     }else if(strcmp("kernel_release", attribute_names[i])==0){
 147         des->kernel_release = g_strdup(attribute_values[i]);
 148     }else if(strcmp("kernel_version", attribute_names[i])==0){
 149         des->kernel_version = g_strdup(attribute_values[i]);
 150     }else if(strcmp("machine", attribute_names[i])==0){
 151         des->machine = g_strdup(attribute_values[i]);
 152     }else if(strcmp("processor", attribute_names[i])==0){
 153         des->processor = g_strdup(attribute_values[i]);
 154     }else if(strcmp("hardware_platform", attribute_names[i])==0){
 155         des->hardware_platform = g_strdup(attribute_values[i]);
 156     }else if(strcmp("operating_system", attribute_names[i])==0){
 157         des->operating_system = g_strdup(attribute_values[i]);
 158     }else if(strcmp("ltt_major_version", attribute_names[i])==0){
 159         des->ltt_major_version = atoi(attribute_values[i]);
 160     }else if(strcmp("ltt_minor_version", attribute_names[i])==0){
 161         des->ltt_minor_version = atoi(attribute_values[i]);
 162     }else if(strcmp("ltt_block_size", attribute_names[i])==0){
 163         des->ltt_block_size = atoi(attribute_values[i]);
 164     }else{
 165       *error = g_error_new(G_MARKUP_ERROR,
 166                            G_LOG_LEVEL_WARNING,
 167                            "Not a valid attribute");
 168       return;
 169     }
 170     i++;
 171   }
 172 }
 173
 174 static void  parser_characters   (GMarkupParseContext __UNUSED__ *context,
 175                                   const gchar          *text,
 176                                   gsize __UNUSED__      text_len,
 177                                   gpointer              user_data,
 178                                   GError __UNUSED__     **error)
 179 {
 180   LttSystemDescription* des = (LttSystemDescription* )user_data;
 181   des->description = g_strdup(text);
 182 }
 183 #endif //0
 184 LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
 185     guint num)
 186 {
 187   g_assert(num < t->facilities_by_num->len);
 188
 189   return &g_array_index(t->facilities_by_num, LttFacility, num);
 190
 191 }
 192
 193
 194 /*****************************************************************************
 195  *Function name
 196  *    ltt_tracefile_open : open a trace file, construct a LttTracefile
 197  *Input params
 198  *    t                  : the trace containing the tracefile
 199  *    fileName           : path name of the trace file
 200  *    tf                 : the tracefile structure
 201  *Return value
 202  *                       : 0 for success, -1 otherwise.
 203  ****************************************************************************/
 204
 205 gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
 206 {
 207   struct stat    lTDFStat;    /* Trace data file status */
 208   struct ltt_block_start_header *header;
 209   int page_size = getpagesize();
 210
 211   //open the file
 212   tf->long_name = g_quark_from_string(fileName);
 213   tf->trace = t;
 214   tf->fd = open(fileName, O_RDONLY);
 215   if(tf->fd < 0){
 216     g_warning("Unable to open input data file %s\n", fileName);
 217     goto end;
 218   }
 219
 220   // Get the file's status
 221   if(fstat(tf->fd, &lTDFStat) < 0){
 222     g_warning("Unable to get the status of the input data file %s\n", fileName);
 223     goto close_file;
 224   }
 225
 226   // Is the file large enough to contain a trace
 227   if(lTDFStat.st_size < (off_t)(sizeof(struct ltt_block_start_header))){
 228     g_print("The input data file %s does not contain a trace\n", fileName);
 229     goto close_file;
 230   }
 231
 232   /* Temporarily map the buffer start header to get trace information */
 233   /* Multiple of pages aligned head */
 234   tf->buffer.head = mmap(0,
 235       PAGE_ALIGN(sizeof(struct ltt_block_start_header)), PROT_READ,
 236       MAP_PRIVATE, tf->fd, 0);
 237   if(tf->buffer.head == MAP_FAILED) {
 238     perror("Error in allocating memory for buffer of tracefile");
 239     goto close_file;
 240   }
 241   g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
 242
 243   header = (struct ltt_block_start_header*)tf->buffer.head;
 244
 245   if(header->trace.magic_number == LTT_MAGIC_NUMBER)
 246     tf->reverse_bo = 0;
 247   else if(header->trace.magic_number == LTT_REV_MAGIC_NUMBER)
 248     tf->reverse_bo = 1;
 249   else  /* invalid magic number, bad tracefile ! */
 250     goto unmap_file;
 251
 252   //store the size of the file
 253   tf->file_size = lTDFStat.st_size;
 254   tf->buf_size = ltt_get_uint32(LTT_GET_BO(tf), &header->buf_size);
 255   tf->num_blocks = tf->file_size / tf->buf_size;
 256
 257   if(munmap(tf->buffer.head,
 258         PAGE_ALIGN(sizeof(struct ltt_block_start_header)))) {
 259     g_warning("unmap size : %u\n",
 260         PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
 261     perror("munmap error");
 262     g_assert(0);
 263   }
 264   tf->buffer.head = NULL;
 265
 266   //read the first block
 267   if(map_block(tf,0)) {
 268     perror("Cannot map block for tracefile");
 269     goto close_file;
 270   }
 271
 272   return 0;
 273
 274   /* Error */
 275 unmap_file:
 276   if(munmap(tf->buffer.head,
 277         PAGE_ALIGN(sizeof(struct ltt_block_start_header)))) {
 278     g_warning("unmap size : %u\n",
 279         PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
 280     perror("munmap error");
 281     g_assert(0);
 282   }
 283 close_file:
 284   close(tf->fd);
 285 end:
 286   return -1;
 287 }
 288
 289 LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
 290 {
 291   return tf->trace;
 292 }
 293
 294 #if 0
 295 /*****************************************************************************
 296  *Open control and per cpu tracefiles
 297  ****************************************************************************/
 298
 299 void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name)
 300 {
 301   LttTracefile * tf;
 302   tf = ltt_tracefile_open(t,tracefile_name);
 303   if(!tf) return;
 304   t->per_cpu_tracefile_number++;
 305   g_ptr_array_add(t->per_cpu_tracefiles, tf);
 306 }
 307
 308 gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name)
 309 {
 310   LttTracefile * tf;
 311   LttEvent ev;
 312   LttFacility * f;
 313   void * pos;
 314   FacilityLoad fLoad;
 315   unsigned int i;
 316
 317   tf = ltt_tracefile_open(t,control_name);
 318   if(!tf) {
 319           g_warning("ltt_tracefile_open_control : bad file descriptor");
 320     return -1;
 321   }
 322   t->control_tracefile_number++;
 323   g_ptr_array_add(t->control_tracefiles,tf);
 324
 325   //parse facilities tracefile to get base_id
 326   if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){
 327     while(1){
 328       if(!ltt_tracefile_read(tf,&ev)) return 0; // end of file
 329
 330       if(ev.event_id == TRACE_FACILITY_LOAD){
 331         pos = ev.data;
 332         fLoad.name = (gchar*)pos;
 333         fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
 334         fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
 335
 336         for(i=0;i<t->facility_number;i++){
 337           f = (LttFacility*)g_ptr_array_index(t->facilities,i);
 338           if(strcmp(f->name,fLoad.name)==0 && fLoad.checksum==f->checksum){
 339             f->base_id = fLoad.base_code;
 340             break;
 341           }
 342         }
 343         if(i==t->facility_number) {
 344           g_warning("Facility: %s, checksum: %u is not found",
 345                   fLoad.name,(unsigned int)fLoad.checksum);
 346     return -1;
 347   }
 348       }else if(ev.event_id == TRACE_BLOCK_START){
 349         continue;
 350       }else if(ev.event_id == TRACE_BLOCK_END){
 351         break;
 352       }else {
 353         g_warning("Not valid facilities trace file");
 354         return -1;
 355       }
 356     }
 357   }
 358   return 0;
 359 }
 360 #endif //0
 361
 362 /*****************************************************************************
 363  *Function name
 364  *    ltt_tracefile_close: close a trace file,
 365  *Input params
 366  *    t                  : tracefile which will be closed
 367  ****************************************************************************/
 368
 369 void ltt_tracefile_close(LttTracefile *t)
 370 {
 371   int page_size = getpagesize();
 372
 373   if(t->buffer.head != NULL)
 374     if(munmap(t->buffer.head, PAGE_ALIGN(t->buf_size))) {
 375     g_warning("unmap size : %u\n",
 376         PAGE_ALIGN(t->buf_size));
 377     perror("munmap error");
 378     g_assert(0);
 379   }
 380
 381   close(t->fd);
 382 }
 383
 384
 385 /*****************************************************************************
 386  *Get system information
 387  ****************************************************************************/
 388 #if 0
 389 gint getSystemInfo(LttSystemDescription* des, gchar * pathname)
 390 {
 391   int fd;
 392   GIOChannel *iochan;
 393   gchar *buf = NULL;
 394   gsize length;
 395
 396   GMarkupParseContext * context;
 397   GError * error = NULL;
 398   GMarkupParser markup_parser =
 399     {
 400       parser_start_element,
 401       NULL,
 402       parser_characters,
 403       NULL,  /*  passthrough  */
 404       NULL   /*  error        */
 405     };
 406
 407   fd = g_open(pathname, O_RDONLY, 0);
 408   if(fd == -1){
 409     g_warning("Can not open file : %s\n", pathname);
 410     return -1;
 411   }
 412
 413   iochan = g_io_channel_unix_new(fd);
 414
 415   context = g_markup_parse_context_new(&markup_parser, 0, des,NULL);
 416
 417   //while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){
 418   while(g_io_channel_read_line(iochan, &buf, &length, NULL, &error)
 419       != G_IO_STATUS_EOF) {
 420
 421     if(error != NULL) {
 422       g_warning("Can not read xml file: \n%s\n", error->message);
 423       g_error_free(error);
 424     }
 425     if(!g_markup_parse_context_parse(context, buf, length, &error)){
 426       if(error != NULL) {
 427         g_warning("Can not parse xml file: \n%s\n", error->message);
 428         g_error_free(error);
 429       }
 430       g_markup_parse_context_free(context);
 431
 432       g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
 433       if(error != NULL) {
 434         g_warning("Can not close file: \n%s\n", error->message);
 435         g_error_free(error);
 436       }
 437
 438       close(fd);
 439       return -1;
 440     }
 441   }
 442   g_markup_parse_context_free(context);
 443
 444   g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
 445   if(error != NULL) {
 446     g_warning("Can not close file: \n%s\n", error->message);
 447     g_error_free(error);
 448   }
 449
 450   g_close(fd);
 451
 452   g_free(buf);
 453   return 0;
 454 }
 455 #endif //0
 456
 457 /*****************************************************************************
 458  *The following functions get facility/tracefile information
 459  ****************************************************************************/
 460 #if 0
 461 gint getFacilityInfo(LttTrace *t, gchar* eventdefs)
 462 {
 463   GDir * dir;
 464   const gchar * name;
 465   unsigned int i,j;
 466   LttFacility * f;
 467   LttEventType * et;
 468   gchar fullname[DIR_NAME_SIZE];
 469   GError * error = NULL;
 470
 471   dir = g_dir_open(eventdefs, 0, &error);
 472
 473   if(error != NULL) {
 474     g_warning("Can not open directory: %s, %s\n", eventdefs, error->message);
 475     g_error_free(error);
 476     return -1;
 477   }
 478
 479   while((name = g_dir_read_name(dir)) != NULL){
 480     if(!g_pattern_match_simple("*.xml", name)) continue;
 481     strcpy(fullname,eventdefs);
 482     strcat(fullname,name);
 483     ltt_facility_open(t,fullname);
 484   }
 485   g_dir_close(dir);
 486
 487   for(j=0;j<t->facility_number;j++){
 488     f = (LttFacility*)g_ptr_array_index(t->facilities, j);
 489     for(i=0; i<f->event_number; i++){
 490       et = f->events[i];
 491       setFieldsOffset(NULL, et, NULL, t);
 492     }
 493   }
 494   return 0;
 495 }
 496 #endif //0
 497
 498 /*****************************************************************************
 499  *A trace is specified as a pathname to the directory containing all the
 500  *associated data (control tracefiles, per cpu tracefiles, event
 501  *descriptions...).
 502  *
 503  *When a trace is closed, all the associated facilities, types and fields
 504  *are released as well.
 505  */
 506
 507
 508 /****************************************************************************
 509  * get_absolute_pathname
 510  *
 511  * return the unique pathname in the system
 512  *
 513  * MD : Fixed this function so it uses realpath, dealing well with
 514  * forgotten cases (.. were not used correctly before).
 515  *
 516  ****************************************************************************/
 517 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
 518 {
 519   abs_pathname[0] = '\0';
 520
 521   if ( realpath (pathname, abs_pathname) != NULL)
 522     return;
 523   else
 524   {
 525     /* error, return the original path unmodified */
 526     strcpy(abs_pathname, pathname);
 527     return;
 528   }
 529   return;
 530 }
 531
 532 /* Search for something like : .*_.*
 533  *
 534  * The left side is the name, the right side is the number.
 535  */
 536
 537 int get_tracefile_name_number(const gchar *raw_name,
 538                               GQuark *name,
 539                               guint *num)
 540 {
 541   guint raw_name_len = strlen(raw_name);
 542   gchar char_name[PATH_MAX];
 543   gchar *digit_begin;
 544   int i;
 545   int underscore_pos;
 546   long int cpu_num;
 547   gchar *endptr;
 548
 549   for(i=raw_name_len-1;i>=0;i--) {
 550     if(raw_name[i] == '_') break;
 551   }
 552   if(i==0)  /* Either not found or name length is 0 */
 553     return -1;
 554   underscore_pos = i;
 555
 556   cpu_num = strtol(raw_name+underscore_pos+1, &endptr, 10);
 557
 558   if(endptr == raw_name+underscore_pos+1)
 559     return -1; /* No digit */
 560   if(cpu_num == LONG_MIN || cpu_num == LONG_MAX)
 561     return -1; /* underflow / overflow */
 562
 563   strncpy(char_name, raw_name, underscore_pos);
 564
 565   char_name[underscore_pos] = '\0';
 566
 567   *name = g_quark_from_string(char_name);
 568   *num = cpu_num;
 569
 570   return 0;
 571 }
 572
 573
 574 GData **ltt_trace_get_tracefiles_groups(LttTrace *trace)
 575 {
 576   return &trace->tracefiles;
 577 }
 578
 579
 580 void compute_tracefile_group(GQuark key_id,
 581                              GArray *group,
 582                              struct compute_tracefile_group_args *args)
 583 {
 584   int i;
 585   LttTracefile *tf;
 586
 587   for(i=0; i<group->len; i++) {
 588     tf = &g_array_index (group, LttTracefile, i);
 589     if(tf->cpu_online)
 590       args->func(tf, args->func_args);
 591   }
 592 }
 593
 594
 595 void ltt_tracefile_group_destroy(gpointer data)
 596 {
 597   GArray *group = (GArray *)data;
 598   int i;
 599   LttTracefile *tf;
 600
 601   for(i=0; i<group->len; i++) {
 602     tf = &g_array_index (group, LttTracefile, i);
 603     if(tf->cpu_online)
 604       ltt_tracefile_close(tf);
 605   }
 606   g_array_free(group, TRUE);
 607 }
 608
 609 gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
 610 {
 611   GArray *group = (GArray *)data;
 612   int i;
 613   LttTracefile *tf;
 614
 615   for(i=0; i<group->len; i++) {
 616     tf = &g_array_index (group, LttTracefile, i);
 617     if(tf->cpu_online) return 1;
 618   }
 619   return 0;
 620 }
 621
 622
 623 /* Open each tracefile under a specific directory. Put them in a
 624  * GData : permits to access them using their tracefile group pathname.
 625  * i.e. access control/modules tracefile group by index :
 626  * "control/module".
 627  *
 628  * relative path is the path relative to the trace root
 629  * root path is the full path
 630  *
 631  * A tracefile group is simply an array where all the per cpu tracefiles sits.
 632  */
 633
 634 static int open_tracefiles(LttTrace *trace, gchar *root_path,
 635     gchar *relative_path)
 636 {
 637         DIR *dir = opendir(root_path);
 638         struct dirent *entry;
 639         struct stat stat_buf;
 640         int ret;
 641
 642         gchar path[PATH_MAX];
 643         int path_len;
 644         gchar *path_ptr;
 645
 646   int rel_path_len;
 647   gchar rel_path[PATH_MAX];
 648   gchar *rel_path_ptr;
 649   LttTracefile tmp_tf;
 650
 651         if(dir == NULL) {
 652                 perror(root_path);
 653                 return ENOENT;
 654         }
 655
 656         strncpy(path, root_path, PATH_MAX-1);
 657         path_len = strlen(path);
 658         path[path_len] = '/';
 659         path_len++;
 660         path_ptr = path + path_len;
 661
 662   strncpy(rel_path, relative_path, PATH_MAX-1);
 663   rel_path_len = strlen(rel_path);
 664   rel_path[rel_path_len] = '/';
 665   rel_path_len++;
 666   rel_path_ptr = rel_path + rel_path_len;
 667
 668         while((entry = readdir(dir)) != NULL) {
 669
 670                 if(entry->d_name[0] == '.') continue;
 671
 672                 strncpy(path_ptr, entry->d_name, PATH_MAX - path_len);
 673                 strncpy(rel_path_ptr, entry->d_name, PATH_MAX - rel_path_len);
 674
 675                 ret = stat(path, &stat_buf);
 676                 if(ret == -1) {
 677                         perror(path);
 678                         continue;
 679                 }
 680
 681                 g_debug("Tracefile file or directory : %s\n", path);
 682
 683                 if(S_ISDIR(stat_buf.st_mode)) {
 684
 685                         g_debug("Entering subdirectory...\n");
 686                         ret = open_tracefiles(trace, path, rel_path);
 687                         if(ret < 0) continue;
 688                 } else if(S_ISREG(stat_buf.st_mode)) {
 689                         GQuark name;
 690       guint num;
 691       GArray *group;
 692       LttTracefile *tf;
 693       guint len;
 694
 695       if(get_tracefile_name_number(rel_path, &name, &num))
 696         continue; /* invalid name */
 697
 698                         g_debug("Opening file.\n");
 699       if(ltt_tracefile_open(trace, path, &tmp_tf)) {
 700         g_info("Error opening tracefile %s", path);
 701
 702         continue; /* error opening the tracefile : bad magic number ? */
 703       }
 704
 705       g_debug("Tracefile name is %s and number is %u",
 706           g_quark_to_string(name), num);
 707
 708       tmp_tf.cpu_online = 1;
 709       tmp_tf.cpu_num = num;
 710       tmp_tf.name = name;
 711
 712       group = g_datalist_id_get_data(&trace->tracefiles, name);
 713       if(group == NULL) {
 714         /* Elements are automatically cleared when the array is allocated.
 715          * It makes the cpu_online variable set to 0 : cpu offline, by default.
 716          */
 717         group = g_array_sized_new (FALSE, TRUE, sizeof(LttTracefile), 10);
 718         g_datalist_id_set_data_full(&trace->tracefiles, name,
 719                                  group, ltt_tracefile_group_destroy);
 720       }
 721
 722       /* Add the per cpu tracefile to the named group */
 723       unsigned int old_len = group->len;
 724       if(num+1 > old_len)
 725         group = g_array_set_size(group, num+1);
 726       g_array_index (group, LttTracefile, num) = tmp_tf;
 727
 728                 }
 729         }
 730
 731         closedir(dir);
 732
 733         return 0;
 734 }
 735
 736 /* ltt_get_facility_description
 737  *
 738  * Opens the trace corresponding to the requested facility (identified by fac_id
 739  * and checksum).
 740  *
 741  * The name searched is : %trace root%/eventdefs/facname_checksum.xml
 742  *
 743  * Returns 0 on success, or 1 on failure.
 744  */
 745
 746 static int ltt_get_facility_description(LttFacility *f,
 747                                         LttTrace *t,
 748                                         LttTracefile *fac_tf)
 749 {
 750   char desc_file_name[PATH_MAX];
 751   const gchar *text;
 752   guint textlen;
 753   gint err;
 754
 755   text = g_quark_to_string(t->pathname);
 756   textlen = strlen(text);
 757
 758   if(textlen >= PATH_MAX) goto name_error;
 759   strcpy(desc_file_name, text);
 760
 761   text = "/eventdefs/";
 762   textlen+=strlen(text);
 763   if(textlen >= PATH_MAX) goto name_error;
 764   strcat(desc_file_name, text);
 765
 766   text = g_quark_to_string(f->name);
 767   textlen+=strlen(text);
 768   if(textlen >= PATH_MAX) goto name_error;
 769   strcat(desc_file_name, text);
 770
 771   text = "_";
 772   textlen+=strlen(text);
 773   if(textlen >= PATH_MAX) goto name_error;
 774   strcat(desc_file_name, text);
 775
 776   err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1,
 777       "%u", f->checksum);
 778   if(err < 0) goto name_error;
 779
 780   textlen=strlen(desc_file_name);
 781
 782   text = ".xml";
 783   textlen+=strlen(text);
 784   if(textlen >= PATH_MAX) goto name_error;
 785   strcat(desc_file_name, text);
 786
 787   err = ltt_facility_open(f, t, desc_file_name);
 788   if(err) goto facility_error;
 789
 790   return 0;
 791
 792 facility_error:
 793 name_error:
 794   return 1;
 795 }
 796
 797 static void ltt_fac_ids_destroy(gpointer data)
 798 {
 799   GArray *fac_ids = (GArray *)data;
 800
 801   g_array_free(fac_ids, TRUE);
 802 }
 803
 804
 805 /* Presumes the tracefile is already seeked at the beginning. It makes sense,
 806  * because it must be done just after the opening */
 807 static int ltt_process_facility_tracefile(LttTracefile *tf)
 808 {
 809   int err;
 810   LttFacility *fac;
 811   GArray *fac_ids;
 812   guint i;
 813   LttEventType *et;
 814
 815   while(1) {
 816     err = ltt_tracefile_read_seek(tf);
 817     if(err == EPERM) goto seek_error;
 818     else if(err == ERANGE) break; /* End of tracefile */
 819
 820     err = ltt_tracefile_read_update_event(tf);
 821     if(err) goto update_error;
 822
 823     /* We are on a facility load/or facility unload/ or heartbeat event */
 824     /* The rules are :
 825      * * facility 0 is hardcoded : this is the core facility. It will be shown
 826      *   in the facility array though, and is shown as "loaded builtin" in the
 827      *   trace.
 828      * It contains event :
 829      *  0 : facility load
 830      *  1 : facility unload
 831      *  2 : state dump facility load
 832      *  3 : heartbeat
 833      */
 834     if(tf->event.facility_id != LTT_FACILITY_CORE) {
 835       /* Should only contain core facility */
 836       g_warning("Error in processing facility file %s, "
 837           "should not contain facility id  %u.", g_quark_to_string(tf->name),
 838           tf->event.facility_id);
 839       err = EPERM;
 840       goto fac_id_error;
 841     } else {
 842
 843       struct LttFacilityLoad *fac_load_data;
 844       struct LttStateDumpFacilityLoad *fac_state_dump_load_data;
 845       char *fac_name;
 846
 847       // FIXME align
 848       switch((enum ltt_core_events)tf->event.event_id) {
 849         case LTT_EVENT_FACILITY_LOAD:
 850           fac_name = (char*)(tf->event.data);
 851           g_debug("Doing LTT_EVENT_FACILITY_LOAD of facility %s",
 852               fac_name);
 853           fac_load_data =
 854             (struct LttFacilityLoad *)
 855                 (tf->event.data + strlen(fac_name) + 1);
 856           fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
 857               ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id));
 858           g_assert(fac->exists == 0);
 859           fac->name = g_quark_from_string(fac_name);
 860           fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
 861                           &fac_load_data->checksum);
 862           fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id);
 863           fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
 864                           &fac_load_data->pointer_size);
 865           fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
 866                           &fac_load_data->long_size);
 867           fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
 868                           &fac_load_data->size_t_size);
 869           fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
 870                           &fac_load_data->alignment);
 871
 872           if(ltt_get_facility_description(fac, tf->trace, tf))
 873             continue; /* error opening description */
 874
 875           fac->trace = tf->trace;
 876
 877           /* Preset the field offsets */
 878           for(i=0; i<fac->events->len; i++){
 879             et = &g_array_index(fac->events, LttEventType, i);
 880             set_fields_offsets(tf, et);
 881           }
 882
 883           fac->exists = 1;
 884
 885           fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
 886                                 fac->name);
 887           if(fac_ids == NULL) {
 888             fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
 889             g_datalist_id_set_data_full(&tf->trace->facilities_by_name,
 890                                      fac->name,
 891                                      fac_ids, ltt_fac_ids_destroy);
 892           }
 893           g_array_append_val(fac_ids, fac->id);
 894
 895           break;
 896         case LTT_EVENT_FACILITY_UNLOAD:
 897           g_debug("Doing LTT_EVENT_FACILITY_UNLOAD");
 898           /* We don't care about unload : facilities ID are valid for the whole
 899            * trace. They simply won't be used after the unload. */
 900           break;
 901         case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
 902           fac_name = (char*)(tf->event.data);
 903           g_debug("Doing LTT_EVENT_STATE_DUMP_FACILITY_LOAD of facility %s",
 904               fac_name);
 905           fac_state_dump_load_data =
 906             (struct LttStateDumpFacilityLoad *)
 907                 (tf->event.data + strlen(fac_name) + 1);
 908           fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
 909               ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id));
 910           g_assert(fac->exists == 0);
 911           fac->name = g_quark_from_string(fac_name);
 912           fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
 913                           &fac_state_dump_load_data->checksum);
 914           fac->id = fac_state_dump_load_data->id;
 915           fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
 916                           &fac_state_dump_load_data->pointer_size);
 917           fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
 918                           &fac_state_dump_load_data->long_size);
 919           fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
 920                           &fac_state_dump_load_data->size_t_size);
 921           fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
 922                           &fac_state_dump_load_data->alignment);
 923           if(ltt_get_facility_description(fac, tf->trace, tf))
 924             continue; /* error opening description */
 925
 926           fac->trace = tf->trace;
 927
 928           /* Preset the field offsets */
 929           for(i=0; i<fac->events->len; i++){
 930             et = &g_array_index(fac->events, LttEventType, i);
 931             set_fields_offsets(tf, et);
 932           }
 933
 934           fac->exists = 1;
 935
 936           fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
 937               fac->name);
 938           if(fac_ids == NULL) {
 939             fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
 940             g_datalist_id_set_data_full(&tf->trace->facilities_by_name,
 941                                      fac->name,
 942                                      fac_ids, ltt_fac_ids_destroy);
 943           }
 944           g_array_append_val(fac_ids, fac->id);
 945
 946           break;
 947         case LTT_EVENT_HEARTBEAT:
 948           break;
 949         default:
 950           g_warning("Error in processing facility file %s, "
 951               "unknown event id %hhu in core facility.",
 952               g_quark_to_string(tf->name),
 953               tf->event.event_id);
 954           err = EPERM;
 955           goto event_id_error;
 956       }
 957     }
 958   }
 959   return 0;
 960
 961   /* Error handling */
 962 facility_error:
 963 event_id_error:
 964 fac_id_error:
 965 update_error:
 966 seek_error:
 967   g_warning("An error occured in facility tracefile parsing");
 968   return err;
 969 }
 970
 971
 972 LttTrace *ltt_trace_open(const gchar *pathname)
 973 {
 974   gchar abs_path[PATH_MAX];
 975   LttTrace  * t;
 976   LttTracefile *tf;
 977   GArray *group;
 978   int i;
 979   struct ltt_block_start_header *header;
 980
 981   t = g_new(LttTrace, 1);
 982   if(!t) goto alloc_error;
 983
 984   get_absolute_pathname(pathname, abs_path);
 985   t->pathname = g_quark_from_string(abs_path);
 986
 987   /* Open all the tracefiles */
 988   g_datalist_init(&t->tracefiles);
 989   if(open_tracefiles(t, abs_path, ""))
 990     goto open_error;
 991
 992   /* Prepare the facilities containers : array and mapping */
 993   /* Array is zeroed : the "exists" field is set to false by default */
 994   t->facilities_by_num = g_array_sized_new (FALSE,
 995                                             TRUE, sizeof(LttFacility),
 996                                             NUM_FACILITIES);
 997   t->facilities_by_num = g_array_set_size(t->facilities_by_num, NUM_FACILITIES);
 998
 999   g_datalist_init(&t->facilities_by_name);
1000
1001   /* Parse each trace control/facilitiesN files : get runtime fac. info */
1002   group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES);
1003   if(group == NULL) {
1004     g_error("Trace %s has no facility tracefile", abs_path);
1005     g_assert(0);
1006     goto facilities_error;
1007   }
1008
1009   /* Get the trace information for the control/facility 0 tracefile */
1010   g_assert(group->len > 0);
1011   tf = &g_array_index (group, LttTracefile, 0);
1012   header = (struct ltt_block_start_header*)tf->buffer.head;
1013   t->arch_type = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_type);
1014   t->arch_variant = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_variant);
1015   t->arch_size = header->trace.arch_size;
1016   t->ltt_major_version = header->trace.major_version;
1017   t->ltt_minor_version = header->trace.minor_version;
1018   t->flight_recorder = header->trace.flight_recorder;
1019   t->has_heartbeat = header->trace.has_heartbeat;
1020   t->has_alignment = header->trace.has_alignment;
1021   t->has_tsc = header->trace.has_tsc;
1022
1023
1024   for(i=0; i<group->len; i++) {
1025     tf = &g_array_index (group, LttTracefile, i);
1026     if(ltt_process_facility_tracefile(tf))
1027       goto facilities_error;
1028   }
1029
1030   return t;
1031
1032   /* Error handling */
1033 facilities_error:
1034   g_datalist_clear(&t->facilities_by_name);
1035   g_array_free(t->facilities_by_num, TRUE);
1036 open_error:
1037   g_datalist_clear(&t->tracefiles);
1038   g_free(t);
1039 alloc_error:
1040   return NULL;
1041
1042 }
1043
1044 GQuark ltt_trace_name(LttTrace *t)
1045 {
1046   return t->pathname;
1047 }
1048
1049
1050 /******************************************************************************
1051  * When we copy a trace, we want all the opening actions to happen again :
1052  * the trace will be reopened and totally independant from the original.
1053  * That's why we call ltt_trace_open.
1054  *****************************************************************************/
1055 LttTrace *ltt_trace_copy(LttTrace *self)
1056 {
1057   return ltt_trace_open(g_quark_to_string(self->pathname));
1058 }
1059
1060 void ltt_trace_close(LttTrace *t)
1061 {
1062   guint i;
1063   LttFacility *fac;
1064
1065   for(i=0; i<t->facilities_by_num->len; i++) {
1066     fac = &g_array_index (t->facilities_by_num, LttFacility, i);
1067     if(fac->exists)
1068       ltt_facility_close(fac);
1069   }
1070
1071   g_datalist_clear(&t->facilities_by_name);
1072   g_array_free(t->facilities_by_num, TRUE);
1073   g_datalist_clear(&t->tracefiles);
1074   g_free(t);
1075 }
1076
1077
1078 /*****************************************************************************
1079  *Get the system description of the trace
1080  ****************************************************************************/
1081
1082 LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id)
1083 {
1084   g_assert(id < t->facilities_by_num->len);
1085   return &g_array_index(t->facilities_by_num, LttFacility, id);
1086 }
1087
1088 /* ltt_trace_facility_get_by_name
1089  *
1090  * Returns the GArray of facility indexes. All the fac_ids that matches the
1091  * requested facility name.
1092  *
1093  * If name is not found, returns NULL.
1094  */
1095 GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name)
1096 {
1097   return g_datalist_id_get_data(&t->facilities_by_name, name);
1098 }
1099
1100 /*****************************************************************************
1101  * Functions to discover all the event types in the trace
1102  ****************************************************************************/
1103
1104 #if 0
1105 unsigned ltt_trace_eventtype_number(LttTrace *t)
1106 {
1107   unsigned int i;
1108   unsigned count = 0;
1109   unsigned int num = t->facility_number;
1110   LttFacility * f;
1111
1112   for(i=0;i<num;i++){
1113     f = (LttFacility*)g_ptr_array_index(t->facilities, i);
1114     count += f->event_number;
1115   }
1116   return count;
1117 }
1118 #endif //0
1119
1120 #if 0
1121 //use an iteration on all the trace facilities, and inside iteration on all the
1122 //event types in each facilities instead.
1123 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
1124 {
1125   LttEventType *event_type;
1126
1127   LttFacility * f;
1128   f = ltt_trace_facility_by_id(t,evId);
1129
1130   if(unlikely(!f)) event_type = NULL;
1131   else event_type = f->events[evId - f->base_id];
1132
1133   return event_type;
1134 }
1135 #endif //0
1136
1137 #if 0
1138 /*****************************************************************************
1139  * ltt_trace_find_tracefile
1140  *
1141  * Find a tracefile by name and index in the group.
1142  *
1143  * Returns a pointer to the tracefiles, else NULL.
1144  ****************************************************************************/
1145
1146 LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name)
1147 {
1148 }
1149 #endif //0
1150
1151 /*****************************************************************************
1152  * Get the start time and end time of the trace
1153  ****************************************************************************/
1154
1155 static void ltt_tracefile_time_span_get(LttTracefile *tf,
1156                                         LttTime *start, LttTime *end)
1157 {
1158   struct ltt_block_start_header * header;
1159   int err;
1160
1161   err = map_block(tf, 0);
1162   if(unlikely(err)) {
1163     g_error("Can not map block");
1164     *start = ltt_time_infinite;
1165   } else
1166     *start = tf->buffer.begin.timestamp;
1167
1168   err = map_block(tf, tf->num_blocks - 1);  /* Last block */
1169   if(unlikely(err)) {
1170     g_error("Can not map block");
1171     *end = ltt_time_zero;
1172   } else
1173     *end = tf->buffer.end.timestamp;
1174 }
1175
1176 struct tracefile_time_span_get_args {
1177   LttTrace *t;
1178   LttTime *start;
1179   LttTime *end;
1180 };
1181
1182 static void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
1183 {
1184   struct tracefile_time_span_get_args *args =
1185           (struct tracefile_time_span_get_args*)user_data;
1186
1187   GArray *group = (GArray *)data;
1188   int i;
1189   LttTracefile *tf;
1190   LttTime tmp_start;
1191   LttTime tmp_end;
1192
1193   for(i=0; i<group->len; i++) {
1194     tf = &g_array_index (group, LttTracefile, i);
1195     if(tf->cpu_online) {
1196       ltt_tracefile_time_span_get(tf, &tmp_start, &tmp_end);
1197       if(ltt_time_compare(*args->start, tmp_start)>0) *args->start = tmp_start;
1198       if(ltt_time_compare(*args->end, tmp_end)<0) *args->end = tmp_end;
1199     }
1200   }
1201 }
1202
1203 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
1204 {
1205   LttTime min_start = ltt_time_infinite;
1206   LttTime max_end = ltt_time_zero;
1207   struct tracefile_time_span_get_args args = { t, &min_start, &max_end };
1208
1209   g_datalist_foreach(&t->tracefiles, &group_time_span_get, &args);
1210
1211   if(start != NULL) *start = min_start;
1212   if(end != NULL) *end = max_end;
1213
1214 }
1215
1216
1217 /*****************************************************************************
1218  *Get the name of a tracefile
1219  ****************************************************************************/
1220
1221 GQuark ltt_tracefile_name(LttTracefile *tf)
1222 {
1223   return tf->name;
1224 }
1225
1226
1227 guint ltt_tracefile_num(LttTracefile *tf)
1228 {
1229   return tf->cpu_num;
1230 }
1231
1232 /*****************************************************************************
1233  * Get the number of blocks in the tracefile
1234  ****************************************************************************/
1235
1236 guint ltt_tracefile_block_number(LttTracefile *tf)
1237 {
1238   return tf->num_blocks;
1239 }
1240
1241
1242 /* Seek to the first event in a tracefile that has a time equal or greater than
1243  * the time passed in parameter.
1244  *
1245  * If the time parameter is outside the tracefile time span, seek to the first
1246  * event or if after, return ERANGE.
1247  *
1248  * If the time parameter is before the first event, we have to seek specially to
1249  * there.
1250  *
1251  * If the time is after the end of the trace, return ERANGE.
1252  *
1253  * Do a binary search to find the right block, then a sequential search in the
1254  * block to find the event.
1255  *
1256  * In the special case where the time requested fits inside a block that has no
1257  * event corresponding to the requested time, the first event of the next block
1258  * will be seeked.
1259  *
1260  * IMPORTANT NOTE : // FIXME everywhere...
1261  *
1262  * You MUST NOT do a ltt_tracefile_read right after a ltt_tracefile_seek_time :
1263  * you will jump over an event if you do.
1264  *
1265  * Return value : 0 : no error, the tf->event can be used
1266  *                ERANGE : time if after the last event of the trace
1267  *                otherwise : this is an error.
1268  *
1269  * */
1270
1271 int ltt_tracefile_seek_time(LttTracefile *tf, LttTime time)
1272 {
1273   int ret = 0;
1274   int err;
1275   unsigned int block_num, high, low;
1276
1277   /* seek at the beginning of trace */
1278   err = map_block(tf, 0);  /* First block */
1279   if(unlikely(err)) {
1280     g_error("Can not map block");
1281     goto fail;
1282   }
1283
1284  /* If the time is lower or equal the beginning of the trace,
1285   * go to the first event. */
1286   if(ltt_time_compare(time, tf->buffer.begin.timestamp) <= 0) {
1287     ret = ltt_tracefile_read(tf);
1288     if(ret == ERANGE) goto range;
1289     else if (ret) goto fail;
1290     goto found; /* There is either no event in the trace or the event points
1291                    to the first event in the trace */
1292   }
1293
1294   err = map_block(tf, tf->num_blocks - 1);  /* Last block */
1295   if(unlikely(err)) {
1296     g_error("Can not map block");
1297     goto fail;
1298   }
1299
1300  /* If the time is after the end of the trace, return ERANGE. */
1301   if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
1302     goto range;
1303   }
1304
1305   /* Binary search the block */
1306   high = tf->num_blocks - 1;
1307   low = 0;
1308
1309   while(1) {
1310     block_num = ((high-low) / 2) + low;
1311
1312     err = map_block(tf, block_num);
1313     if(unlikely(err)) {
1314       g_error("Can not map block");
1315       goto fail;
1316     }
1317     if(high == low) {
1318       /* We cannot divide anymore : this is what would happen if the time
1319        * requested was exactly between two consecutive buffers'end and start
1320        * timestamps. This is also what would happend if we didn't deal with out
1321        * of span cases prior in this function. */
1322       /* The event is right in the buffer!
1323        * (or in the next buffer first event) */
1324       while(1) {
1325         ret = ltt_tracefile_read(tf);
1326         if(ret == ERANGE) goto range; /* ERANGE or EPERM */
1327         else if(ret) goto fail;
1328
1329         if(ltt_time_compare(time, tf->event.event_time) >= 0)
1330           break;
1331       }
1332
1333     } else if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) {
1334       /* go to lower part */
1335       high = block_num;
1336     } else if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
1337       /* go to higher part */
1338       low = block_num;
1339     } else {/* The event is right in the buffer!
1340                (or in the next buffer first event) */
1341       while(1) {
1342         ret = ltt_tracefile_read(tf);
1343         if(ret == ERANGE) goto range; /* ERANGE or EPERM */
1344         else if(ret) goto fail;
1345
1346         if(ltt_time_compare(time, tf->event.event_time) >= 0)
1347           break;
1348       }
1349       goto found;
1350     }
1351   }
1352
1353 found:
1354   return 0;
1355 range:
1356   return ERANGE;
1357
1358   /* Error handling */
1359 fail:
1360   g_error("ltt_tracefile_seek_time failed on tracefile %s",
1361       g_quark_to_string(tf->name));
1362   return EPERM;
1363 }
1364
1365
1366 int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) {
1367
1368   int err;
1369
1370   if(ep->tracefile != tf) {
1371     goto fail;
1372   }
1373
1374   err = map_block(tf, ep->block);
1375   if(unlikely(err)) {
1376     g_error("Can not map block");
1377     goto fail;
1378   }
1379
1380   tf->event.offset = ep->offset;
1381
1382   err = ltt_tracefile_read_update_event(tf);
1383   if(err) goto fail;
1384   err = ltt_tracefile_read_op(tf);
1385   if(err) goto fail;
1386
1387   return;
1388
1389 fail:
1390   g_error("ltt_tracefile_seek_time failed on tracefile %s",
1391       g_quark_to_string(tf->name));
1392 }
1393
1394 /* Calculate the real event time based on the buffer boundaries */
1395 LttTime ltt_interpolate_time(LttTracefile *tf, LttEvent *event)
1396 {
1397   LttTime time;
1398
1399   g_assert(tf->trace->has_tsc);
1400
1401   time = ltt_time_from_uint64(
1402       (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count) *
1403                                           tf->buffer.nsecs_per_cycle);
1404   time = ltt_time_add(tf->buffer.begin.timestamp, time);
1405
1406   return time;
1407 }
1408
1409
1410 /* Get the current event of the tracefile : valid until the next read */
1411 LttEvent *ltt_tracefile_get_event(LttTracefile *tf)
1412 {
1413   return &tf->event;
1414 }
1415
1416
1417
1418 /*****************************************************************************
1419  *Function name
1420  *    ltt_tracefile_read : Read the next event in the tracefile
1421  *Input params
1422  *    t                  : tracefile
1423  *Return value
1424  *
1425  *    Returns 0 if an event can be used in tf->event.
1426  *    Returns ERANGE on end of trace. The event in tf->event still can be used.
1427  *    Returns EPERM on error.
1428  *
1429  *    This function does make the tracefile event structure point to the event
1430  *    currently pointed to by the tf->event.
1431  *
1432  *    Note : you must call a ltt_tracefile_seek to the beginning of the trace to
1433  *    reinitialize it after an error if you want results to be coherent.
1434  *    It would be the case if a end of trace last buffer has no event : the end
1435  *    of trace wouldn't be returned, but an error.
1436  *    We make the assumption there is at least one event per buffer.
1437  ****************************************************************************/
1438
1439 int ltt_tracefile_read(LttTracefile *tf)
1440 {
1441   int err;
1442
1443   err = ltt_tracefile_read_seek(tf);
1444   if(err) return err;
1445   err = ltt_tracefile_read_update_event(tf);
1446   if(err) return err;
1447   err = ltt_tracefile_read_op(tf);
1448   if(err) return err;
1449
1450   return 0;
1451 }
1452
1453 int ltt_tracefile_read_seek(LttTracefile *tf)
1454 {
1455   int err;
1456
1457   /* Get next buffer until we finally have an event, or end of trace */
1458   while(1) {
1459     err = ltt_seek_next_event(tf);
1460     if(unlikely(err == ENOPROTOOPT)) {
1461       return EPERM;
1462     }
1463
1464     /* Are we at the end of the buffer ? */
1465     if(err == ERANGE) {
1466       if(unlikely(tf->buffer.index == tf->num_blocks-1)){ /* end of trace ? */
1467         return ERANGE;
1468       } else {
1469         /* get next block */
1470         err = map_block(tf, tf->buffer.index + 1);
1471         if(unlikely(err)) {
1472           g_error("Can not map block");
1473           return EPERM;
1474         }
1475       }
1476     } else break; /* We found an event ! */
1477   }
1478
1479   return 0;
1480 }
1481
1482
1483 /* do specific operation on events */
1484 int ltt_tracefile_read_op(LttTracefile *tf)
1485 {
1486   int err;
1487   LttFacility *f;
1488   void * pos;
1489   LttEvent *event;
1490
1491   event = &tf->event;
1492
1493    /* do event specific operation */
1494
1495   /* do something if its an heartbeat event : increment the heartbeat count */
1496   //if(event->facility_id == LTT_FACILITY_CORE)
1497   //  if(event->event_id == LTT_EVENT_HEARTBEAT)
1498   //    tf->cur_heart_beat_number++;
1499
1500   return 0;
1501 }
1502
1503
1504 /* same as ltt_tracefile_read, but does not seek to the next event nor call
1505  * event specific operation. */
1506 int ltt_tracefile_read_update_event(LttTracefile *tf)
1507 {
1508   int err;
1509   LttFacility *f;
1510   void * pos;
1511   LttEvent *event;
1512
1513   event = &tf->event;
1514   pos = tf->buffer.head + event->offset;
1515
1516   /* Read event header */
1517
1518   //TODO align
1519
1520   if(tf->trace->has_tsc) {
1521     if(tf->trace->has_heartbeat) {
1522       event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf),
1523                                             pos);
1524       /* 32 bits -> 64 bits tsc */
1525       /* note : still works for seek and non seek cases. */
1526       if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) {
1527         tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL)
1528                             + 0x100000000ULL)
1529                                 | (guint64)event->time.timestamp;
1530         event->tsc = tf->buffer.tsc;
1531       } else {
1532         /* no overflow */
1533         tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL)
1534                                 | (guint64)event->time.timestamp;
1535         event->tsc = tf->buffer.tsc;
1536       }
1537       pos += sizeof(guint32);
1538     } else {
1539       event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos);
1540       tf->buffer.tsc = event->tsc;
1541       pos += sizeof(guint64);
1542     }
1543
1544     event->event_time = ltt_interpolate_time(tf, event);
1545   } else {
1546     event->time.delta.tv_sec = 0;
1547     event->time.delta.tv_nsec = ltt_get_uint32(LTT_GET_BO(tf),
1548                                           pos) * NSEC_PER_USEC;
1549     tf->buffer.tsc = 0;
1550     event->tsc = tf->buffer.tsc;
1551
1552     event->event_time = ltt_time_add(tf->buffer.begin.timestamp,
1553                                      event->time.delta);
1554     pos += sizeof(guint32);
1555   }
1556
1557   event->facility_id = *(guint8*)pos;
1558   pos += sizeof(guint8);
1559
1560   event->event_id = *(guint8*)pos;
1561   pos += sizeof(guint8);
1562
1563   event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos);
1564   pos += sizeof(guint16);
1565
1566   event->data = pos;
1567
1568   /* get the data size and update the event fields with the current
1569    * information */
1570   ltt_update_event_size(tf);
1571
1572   return 0;
1573 }
1574
1575
1576 /****************************************************************************
1577  *Function name
1578  *    map_block       : map a block from the file
1579  *Input Params
1580  *    lttdes          : ltt trace file
1581  *    whichBlock      : the block which will be read
1582  *return value
1583  *    0               : success
1584  *    EINVAL          : lseek fail
1585  *    EIO             : can not read from the file
1586  ****************************************************************************/
1587
1588 static gint map_block(LttTracefile * tf, guint block_num)
1589 {
1590   int page_size = getpagesize();
1591   struct ltt_block_start_header *header;
1592
1593   g_assert(block_num < tf->num_blocks);
1594
1595   if(tf->buffer.head != NULL) {
1596     if(munmap(tf->buffer.head, PAGE_ALIGN(tf->buf_size))) {
1597     g_warning("unmap size : %u\n",
1598         PAGE_ALIGN(tf->buf_size));
1599       perror("munmap error");
1600       g_assert(0);
1601     }
1602   }
1603
1604
1605   /* Multiple of pages aligned head */
1606   tf->buffer.head = mmap(0,
1607       PAGE_ALIGN(tf->buf_size),
1608       PROT_READ, MAP_PRIVATE, tf->fd,
1609       PAGE_ALIGN((off_t)tf->buf_size * (off_t)block_num));
1610
1611   if(tf->buffer.head == MAP_FAILED) {
1612     perror("Error in allocating memory for buffer of tracefile");
1613     g_assert(0);
1614     goto map_error;
1615   }
1616   g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
1617
1618
1619   tf->buffer.index = block_num;
1620
1621   header = (struct ltt_block_start_header*)tf->buffer.head;
1622
1623   tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf),
1624                                               &header->begin.timestamp);
1625   tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC;
1626   g_warning("block %u begin : %lu.%lu", block_num,
1627       tf->buffer.begin.timestamp.tv_sec, tf->buffer.begin.timestamp.tv_nsec);
1628   tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
1629                                               &header->begin.cycle_count);
1630   tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf),
1631                                               &header->end.timestamp);
1632   tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC;
1633   g_warning("block %u end : %lu.%lu", block_num,
1634       tf->buffer.end.timestamp.tv_sec, tf->buffer.end.timestamp.tv_nsec);
1635   tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
1636                                               &header->end.cycle_count);
1637   tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf),
1638                                               &header->lost_size);
1639
1640   tf->buffer.tsc =  tf->buffer.begin.cycle_count;
1641   tf->event.tsc = tf->buffer.tsc;
1642
1643   /* FIXME
1644    * eventually support variable buffer size : will need a partial pre-read of
1645    * the headers to create an index when we open the trace... eventually. */
1646   g_assert(tf->buf_size  == ltt_get_uint32(LTT_GET_BO(tf),
1647                                              &header->buf_size));
1648
1649   /* Now that the buffer is mapped, calculate the time interpolation for the
1650    * block. */
1651
1652   tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
1653
1654   /* Make the current event point to the beginning of the buffer :
1655    * it means that the event read must get the first event. */
1656   tf->event.tracefile = tf;
1657   tf->event.block = block_num;
1658   tf->event.offset = 0;
1659
1660   return 0;
1661
1662 map_error:
1663   return -errno;
1664
1665 }
1666
1667 /* It will update the fields offsets too */
1668 void ltt_update_event_size(LttTracefile *tf)
1669 {
1670   ssize_t size = 0;
1671
1672   /* Specific handling of core events : necessary to read the facility control
1673    * tracefile. */
1674   LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
1675                                           tf->event.facility_id);
1676
1677   if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) {
1678     switch((enum ltt_core_events)tf->event.event_id) {
1679   case LTT_EVENT_FACILITY_LOAD:
1680     size = strlen((char*)tf->event.data) + 1;
1681     g_debug("Update Event facility load of facility %s", (char*)tf->event.data);
1682     size += sizeof(struct LttFacilityLoad);
1683     break;
1684   case LTT_EVENT_FACILITY_UNLOAD:
1685     g_debug("Update Event facility unload");
1686     size = sizeof(struct LttFacilityUnload);
1687     break;
1688   case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
1689     size = strlen((char*)tf->event.data) + 1;
1690     g_debug("Update Event facility load state dump of facility %s",
1691         (char*)tf->event.data);
1692     size += sizeof(struct LttStateDumpFacilityLoad);
1693     break;
1694   case LTT_EVENT_HEARTBEAT:
1695     g_debug("Update Event heartbeat");
1696     size = sizeof(TimeHeartbeat);
1697     break;
1698   default:
1699     g_warning("Error in getting event size : tracefile %s, "
1700         "unknown event id %hhu in core facility.",
1701         g_quark_to_string(tf->name),
1702         tf->event.event_id);
1703     goto event_id_error;
1704
1705     }
1706   } else {
1707     if(!f->exists) {
1708       g_error("Unknown facility %hhu (0x%hhx) in tracefile %s",
1709           tf->event.facility_id,
1710           tf->event.facility_id,
1711           g_quark_to_string(tf->name));
1712       goto facility_error;
1713     }
1714
1715     LttEventType *event_type =
1716       ltt_facility_eventtype_get(f, tf->event.event_id);
1717
1718     if(!event_type) {
1719       g_error("Unknown event id %hhu in facility %s in tracefile %s",
1720           tf->event.event_id,
1721           g_quark_to_string(f->name),
1722           g_quark_to_string(tf->name));
1723       goto event_type_error;
1724     }
1725
1726     if(event_type->root_field)
1727       size = get_field_type_size(tf, event_type,
1728           0, 0, event_type->root_field, tf->event.data);
1729     else
1730       size = 0;
1731
1732     g_debug("Event root field : f.e %hhu.%hhu size %zd",
1733         tf->event.facility_id,
1734         tf->event.event_id, size);
1735   }
1736
1737   tf->event.data_size = size;
1738
1739   /* Check consistency between kernel and LTTV structure sizes */
1740   g_assert(tf->event.data_size == tf->event.event_size);
1741
1742   return;
1743
1744 facility_error:
1745 event_type_error:
1746 event_id_error:
1747   tf->event.data_size = 0;
1748 }
1749
1750
1751 /* Take the tf current event offset and use the event facility id and event id
1752  * to figure out where is the next event offset.
1753  *
1754  * This is an internal function not aiming at being used elsewhere : it will
1755  * not jump over the current block limits. Please consider using
1756  * ltt_tracefile_read to do this.
1757  *
1758  * Returns 0 on success
1759  *         ERANGE if we are at the end of the buffer.
1760  *         ENOPROTOOPT if an error occured when getting the current event size.
1761  */
1762 static int ltt_seek_next_event(LttTracefile *tf)
1763 {
1764   int ret = 0;
1765   void *pos;
1766   ssize_t event_size;
1767
1768   /* seek over the buffer header if we are at the buffer start */
1769   if(tf->event.offset == 0) {
1770     tf->event.offset += sizeof(struct ltt_block_start_header);
1771
1772     if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
1773       ret = ERANGE;
1774     }
1775     goto found;
1776   }
1777
1778
1779   pos = tf->event.data;
1780
1781   if(tf->event.data_size < 0) goto error;
1782
1783   pos += (size_t)tf->event.data_size;
1784
1785   tf->event.offset = pos - tf->buffer.head;
1786
1787   if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
1788     ret = ERANGE;
1789     goto found;
1790   }
1791
1792 found:
1793   return ret;
1794
1795 error:
1796   g_error("Error in ltt_seek_next_event for tracefile %s",
1797       g_quark_to_string(tf->name));
1798   return ENOPROTOOPT;
1799 }
1800
1801
1802 /*****************************************************************************
1803  *Function name
1804  *    calc_nsecs_per_cycle : calculate nsecs per cycle for current block
1805  *Input Params
1806  *    t               : tracefile
1807  ****************************************************************************/
1808
1809 static double calc_nsecs_per_cycle(LttTracefile * tf)
1810 {
1811   LttTime           lBufTotalTime; /* Total time for this buffer */
1812   double            lBufTotalNSec; /* Total time for this buffer in nsecs */
1813   LttCycleCount     lBufTotalCycle;/* Total cycles for this buffer */
1814
1815   /* Calculate the total time for this buffer */
1816   lBufTotalTime = ltt_time_sub(
1817        ltt_get_time(LTT_GET_BO(tf), &tf->buffer.end.timestamp),
1818        ltt_get_time(LTT_GET_BO(tf), &tf->buffer.begin.timestamp));
1819
1820   /* Calculate the total cycles for this bufffer */
1821   lBufTotalCycle  = ltt_get_uint64(LTT_GET_BO(tf), &tf->buffer.end.cycle_count);
1822   lBufTotalCycle -= ltt_get_uint64(LTT_GET_BO(tf),
1823                      &tf->buffer.begin.cycle_count);
1824
1825   /* Convert the total time to double */
1826   lBufTotalNSec  = ltt_time_to_double(lBufTotalTime);
1827
1828   return lBufTotalNSec / (double)lBufTotalCycle;
1829
1830 }
1831 #if 0
1832 void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD)
1833 {
1834   LttField * rootFld = evT->root_field;
1835   //  rootFld->base_address = evD;
1836
1837   if(likely(rootFld))
1838     rootFld->field_size = getFieldtypeSize(tf, evT->facility,
1839         evT, 0,0,rootFld, evD);
1840 }
1841 #endif //0
1842
1843 /*****************************************************************************
1844  *Function name
1845  *    set_fields_offsets : set the precomputable offset of the fields
1846  *Input params
1847  *    tracefile       : opened trace file
1848  *    event_type      : the event type
1849  ****************************************************************************/
1850
1851 void set_fields_offsets(LttTracefile *tf, LttEventType *event_type)
1852 {
1853   LttField *field = event_type->root_field;
1854   enum field_status fixed_root = FIELD_FIXED, fixed_parent = FIELD_FIXED;
1855
1856   if(likely(field))
1857     preset_field_type_size(tf, event_type, 0, 0,
1858         &fixed_root, &fixed_parent,
1859         field);
1860
1861 }
1862
1863
1864 /*****************************************************************************
1865  *Function name
1866  *    preset_field_type_size : set the fixed sizes of the field type
1867  *Input params
1868  *    tf              : tracefile
1869  *    event_type      : event type
1870  *    offset_root     : offset from the root
1871  *    offset_parent   : offset from the parent
1872  *    fixed_root      : Do we know a fixed offset to the root ?
1873  *    fixed_parent    : Do we know a fixed offset to the parent ?
1874  *    field           : field
1875  ****************************************************************************/
1876 void preset_field_type_size(LttTracefile *tf, LttEventType *event_type,
1877     off_t offset_root, off_t offset_parent,
1878     enum field_status *fixed_root, enum field_status *fixed_parent,
1879     LttField *field)
1880 {
1881   enum field_status local_fixed_root, local_fixed_parent;
1882   guint i;
1883   LttType *type;
1884
1885   g_assert(field->fixed_root == FIELD_UNKNOWN);
1886   g_assert(field->fixed_parent == FIELD_UNKNOWN);
1887   g_assert(field->fixed_size == FIELD_UNKNOWN);
1888
1889   type = field->field_type;
1890
1891   field->fixed_root = *fixed_root;
1892   if(field->fixed_root == FIELD_FIXED)
1893     field->offset_root = offset_root;
1894   else
1895     field->offset_root = 0;
1896
1897   field->fixed_parent = *fixed_parent;
1898   if(field->fixed_parent == FIELD_FIXED)
1899     field->offset_parent = offset_parent;
1900   else
1901     field->offset_parent = 0;
1902
1903   size_t current_root_offset;
1904   size_t current_offset;
1905   enum field_status current_child_status, final_child_status;
1906   size_t max_size;
1907
1908   switch(type->type_class) {
1909     case LTT_INT:
1910     case LTT_UINT:
1911     case LTT_FLOAT:
1912     case LTT_ENUM:
1913       field->field_size = ltt_type_size(tf->trace, type);
1914       field->fixed_size = FIELD_FIXED;
1915       break;
1916     case LTT_POINTER:
1917       field->field_size = (off_t)event_type->facility->pointer_size;
1918       field->fixed_size = FIELD_FIXED;
1919       break;
1920     case LTT_LONG:
1921     case LTT_ULONG:
1922       field->field_size = (off_t)event_type->facility->long_size;
1923       field->fixed_size = FIELD_FIXED;
1924       break;
1925     case LTT_SIZE_T:
1926     case LTT_SSIZE_T:
1927     case LTT_OFF_T:
1928       field->field_size = (off_t)event_type->facility->size_t_size;
1929       field->fixed_size = FIELD_FIXED;
1930       break;
1931     case LTT_SEQUENCE:
1932       local_fixed_root = FIELD_VARIABLE;
1933       local_fixed_parent = FIELD_VARIABLE;
1934       preset_field_type_size(tf, event_type,
1935         0, 0,
1936         &local_fixed_root, &local_fixed_parent,
1937         field->child[0]);
1938       field->fixed_size = FIELD_VARIABLE;
1939       field->field_size = 0;
1940       *fixed_root = FIELD_VARIABLE;
1941       *fixed_parent = FIELD_VARIABLE;
1942       break;
1943     case LTT_STRING:
1944       field->fixed_size = FIELD_VARIABLE;
1945       field->field_size = 0;
1946       *fixed_root = FIELD_VARIABLE;
1947       *fixed_parent = FIELD_VARIABLE;
1948       break;
1949     case LTT_ARRAY:
1950       local_fixed_root = FIELD_VARIABLE;
1951       local_fixed_parent = FIELD_VARIABLE;
1952       preset_field_type_size(tf, event_type,
1953         0, 0,
1954         &local_fixed_root, &local_fixed_parent,
1955         field->child[0]);
1956       field->fixed_size = field->child[0]->fixed_size;
1957       if(field->fixed_size == FIELD_FIXED) {
1958         field->field_size = type->element_number * field->child[0]->field_size;
1959       } else {
1960         field->field_size = 0;
1961         *fixed_root = FIELD_VARIABLE;
1962         *fixed_parent = FIELD_VARIABLE;
1963       }
1964       break;
1965     case LTT_STRUCT:
1966       current_root_offset = field->offset_root;
1967       current_offset = 0;
1968       current_child_status = FIELD_FIXED;
1969       for(i=0;i<type->element_number;i++) {
1970         preset_field_type_size(tf, event_type,
1971           current_root_offset, current_offset,
1972           fixed_root, &current_child_status,
1973           field->child[i]);
1974         if(current_child_status == FIELD_FIXED) {
1975           current_root_offset += field->child[i]->field_size;
1976           current_offset += field->child[i]->field_size;
1977         } else {
1978           current_root_offset = 0;
1979           current_offset = 0;
1980         }
1981       }
1982       if(current_child_status != FIELD_FIXED) {
1983         *fixed_parent = current_child_status;
1984         field->field_size = 0;
1985         field->fixed_size = current_child_status;
1986       } else {
1987         field->field_size = current_offset;
1988         field->fixed_size = FIELD_FIXED;
1989       }
1990       break;
1991     case LTT_UNION:
1992       current_root_offset = field->offset_root;
1993       current_offset = 0;
1994       max_size = 0;
1995       final_child_status = FIELD_FIXED;
1996       for(i=0;i<type->element_number;i++) {
1997         enum field_status current_root_child_status = FIELD_FIXED;
1998         enum field_status current_child_status = FIELD_FIXED;
1999         preset_field_type_size(tf, event_type,
2000           current_root_offset, current_offset,
2001           &current_root_child_status, &current_child_status,
2002           field->child[i]);
2003         if(current_child_status != FIELD_FIXED)
2004           final_child_status = current_child_status;
2005         else
2006           max_size = max(max_size, field->child[i]->field_size);
2007       }
2008       if(final_child_status != FIELD_FIXED) {
2009         *fixed_root = final_child_status;
2010         *fixed_parent = final_child_status;
2011         field->field_size = 0;
2012         field->fixed_size = current_child_status;
2013       } else {
2014         field->field_size = max_size;
2015         field->fixed_size = FIELD_FIXED;
2016       }
2017       break;
2018   }
2019
2020 }
2021
2022
2023 /*****************************************************************************
2024  *Function name
2025  *    check_fields_compatibility : Check for compatibility between two fields :
2026  *    do they use the same inner structure ?
2027  *Input params
2028  *    event_type1     : event type
2029  *    event_type2     : event type
2030  *    field1          : field
2031  *    field2          : field
2032  *Returns : 0 if identical
2033  *          1 if not.
2034  ****************************************************************************/
2035 gint check_fields_compatibility(LttEventType *event_type1,
2036     LttEventType *event_type2,
2037     LttField *field1, LttField *field2)
2038 {
2039   guint different = 0;
2040   enum field_status local_fixed_root, local_fixed_parent;
2041   guint i;
2042   LttType *type1;
2043   LttType *type2;
2044
2045   if(field1 == NULL) {
2046     if(field2 == NULL) goto end;
2047     else {
2048       different = 1;
2049       goto end;
2050     }
2051   } else if(field2 == NULL) {
2052     different = 1;
2053     goto end;
2054   }
2055
2056   g_assert(field1->fixed_root != FIELD_UNKNOWN);
2057   g_assert(field2->fixed_root != FIELD_UNKNOWN);
2058   g_assert(field1->fixed_parent != FIELD_UNKNOWN);
2059   g_assert(field2->fixed_parent != FIELD_UNKNOWN);
2060   g_assert(field1->fixed_size != FIELD_UNKNOWN);
2061   g_assert(field2->fixed_size != FIELD_UNKNOWN);
2062
2063   type1 = field1->field_type;
2064   type2 = field2->field_type;
2065
2066   size_t current_root_offset;
2067   size_t current_offset;
2068   enum field_status current_child_status, final_child_status;
2069   size_t max_size;
2070
2071   if(type1->type_class != type2->type_class) {
2072     different = 1;
2073     goto end;
2074   }
2075   if(type1->element_name != type2->element_name) {
2076     different = 1;
2077     goto end;
2078   }
2079
2080   switch(type1->type_class) {
2081     case LTT_INT:
2082     case LTT_UINT:
2083     case LTT_FLOAT:
2084     case LTT_POINTER:
2085     case LTT_LONG:
2086     case LTT_ULONG:
2087     case LTT_SIZE_T:
2088     case LTT_SSIZE_T:
2089     case LTT_OFF_T:
2090       if(field1->field_size != field2->field_size) {
2091         different = 1;
2092         goto end;
2093       }
2094       break;
2095     case LTT_ENUM:
2096       if(type1->element_number != type2->element_number) {
2097         different = 1;
2098         goto end;
2099       }
2100       for(i=0;i<type1->element_number;i++) {
2101         if(type1->enum_strings[i] != type2->enum_strings[i]) {
2102           different = 1;
2103           goto end;
2104         }
2105       }
2106       break;
2107     case LTT_SEQUENCE:
2108       /* Two elements : size and child */
2109       g_assert(type1->element_number != type2->element_number);
2110       for(i=0;i<type1->element_number;i++) {
2111         if(check_fields_compatibility(event_type1, event_type2,
2112           field1->child[0], field2->child[0])) {
2113           different = 1;
2114           goto end;
2115         }
2116       }
2117       break;
2118     case LTT_STRING:
2119       break;
2120     case LTT_ARRAY:
2121       if(field1->field_size != field2->field_size) {
2122         different = 1;
2123         goto end;
2124       }
2125       /* Two elements : size and child */
2126       g_assert(type1->element_number != type2->element_number);
2127       for(i=0;i<type1->element_number;i++) {
2128         if(check_fields_compatibility(event_type1, event_type2,
2129           field1->child[0], field2->child[0])) {
2130           different = 1;
2131           goto end;
2132         }
2133       }
2134       break;
2135     case LTT_STRUCT:
2136     case LTT_UNION:
2137       if(type1->element_number != type2->element_number) {
2138         different = 1;
2139         break;
2140       }
2141       for(i=0;i<type1->element_number;i++) {
2142         if(check_fields_compatibility(event_type1, event_type2,
2143           field1->child[0], field2->child[0])) {
2144           different = 1;
2145           goto end;
2146         }
2147       }
2148       break;
2149   }
2150 end:
2151   return different;
2152 }
2153
2154
2155
2156
2157 #if 0
2158 /*****************************************************************************
2159  *Function name
2160  *    getFieldtypeSize: get the size of the field type (primitive type)
2161  *Input params
2162  *    evT             : event type
2163  *    offsetRoot      : offset from the root
2164  *    offsetParent    : offset from the parrent
2165  *    fld             : field
2166  *    evD             : event data, it may be NULL
2167  *Return value
2168  *    int             : size of the field
2169  ****************************************************************************/
2170
2171 static inline gint getFieldtypeSize(LttTracefile *tf,
2172        LttEventType * evT, gint offsetRoot,
2173              gint offsetParent, LttField * fld, void *evD)
2174 {
2175   gint size, size1, element_number, i, offset1, offset2;
2176   LttType * type = fld->field_type;
2177
2178   /* This likely has been tested with gcov : half of them.. */
2179   if(unlikely(fld->field_fixed == 1)){
2180     /* tested : none */
2181     if(unlikely(fld == evT->root_field)) {
2182       size = fld->field_size;
2183       goto end_getFieldtypeSize;
2184     }
2185   }
2186
2187   /* From gcov profiling : half string, half struct, can we gain something
2188    * from that ? (Mathieu) */
2189   switch(type->type_class) {
2190     case LTT_ARRAY:
2191       element_number = (int) type->element_number;
2192       if(fld->field_fixed == -1){
2193         size = getFieldtypeSize(tf, evT, offsetRoot,
2194                                 0,fld->child[0], NULL);
2195         if(size == 0){ //has string or sequence
2196           fld->field_fixed = 0;
2197         }else{
2198           fld->field_fixed = 1;
2199           size *= element_number;
2200         }
2201       }else if(fld->field_fixed == 0){// has string or sequence
2202         size = 0;
2203         for(i=0;i<element_number;i++){
2204           size += getFieldtypeSize(tf, evT, offsetRoot+size,size,
2205           fld->child[0], evD+size);
2206         }
2207       }else size = fld->field_size;
2208       if(unlikely(!evD)){
2209         fld->fixed_root    = (offsetRoot==-1)   ? 0 : 1;
2210         fld->fixed_parent  = (offsetParent==-1) ? 0 : 1;
2211       }
2212
2213       break;
2214
2215     case LTT_SEQUENCE:
2216       size1 = (int) ltt_type_size(fac, type);
2217       if(fld->field_fixed == -1){
2218         fld->sequ_number_size = size1;
2219         fld->field_fixed = 0;
2220         size = getFieldtypeSize(evT, offsetRoot,
2221                                 0,fld->child[0], NULL);
2222         fld->element_size = size;
2223       }else{//0: sequence
2224         element_number = getIntNumber(tf,size1,evD);
2225         type->element_number = element_number;
2226         if(fld->element_size > 0){
2227           size = element_number * fld->element_size;
2228         }else{//sequence has string or sequence
2229           size = 0;
2230           for(i=0;i<element_number;i++){
2231             size += getFieldtypeSize(tf, evT,
2232                                      offsetRoot+size+size1,size+size1,
2233                                      fld->child[0], evD+size+size1);
2234           }
2235         }
2236         size += size1;
2237       }
2238       if(unlikely(!evD)){
2239         fld->fixed_root    = (offsetRoot==-1)   ? 0 : 1;
2240         fld->fixed_parent  = (offsetParent==-1) ? 0 : 1;
2241       }
2242
2243       break;
2244
2245     case LTT_STRING:
2246       size = 0;
2247       if(fld->field_fixed == -1){
2248         fld->field_fixed = 0;
2249       }else{//0: string
2250         /* Hope my implementation is faster than strlen (Mathieu) */
2251         char *ptr=(char*)evD;
2252         size = 1;
2253         /* from gcov : many many strings are empty, make it the common case.*/
2254         while(unlikely(*ptr != '\0')) { size++; ptr++; }
2255         //size = ptr - (char*)evD + 1; //include end : '\0'
2256       }
2257       fld->fixed_root    = (offsetRoot==-1)   ? 0 : 1;
2258       fld->fixed_parent  = (offsetParent==-1) ? 0 : 1;
2259
2260       break;
2261
2262     case LTT_STRUCT:
2263       element_number = (int) type->element_number;
2264       size = 0;
2265       /* tested with gcov */
2266       if(unlikely(fld->field_fixed == -1)){
2267         offset1 = offsetRoot;
2268         offset2 = 0;
2269         for(i=0;i<element_number;i++){
2270           size1=getFieldtypeSize(tf, evT,offset1,offset2,
2271                                  fld->child[i], NULL);
2272           if(likely(size1 > 0 && size >= 0)){
2273             size += size1;
2274             if(likely(offset1 >= 0)) offset1 += size1;
2275               offset2 += size1;
2276           }else{
2277             size = -1;
2278             offset1 = -1;
2279             offset2 = -1;
2280           }
2281         }
2282         if(unlikely(size == -1)){
2283            fld->field_fixed = 0;
2284            size = 0;
2285         }else fld->field_fixed = 1;
2286       }else if(likely(fld->field_fixed == 0)){
2287         offset1 = offsetRoot;
2288         offset2 = 0;
2289         for(i=0;unlikely(i<element_number);i++){
2290           size=getFieldtypeSize(tf, evT, offset1, offset2,
2291                                 fld->child[i], evD+offset2);
2292           offset1 += size;
2293           offset2 += size;
2294         }
2295         size = offset2;
2296       }else size = fld->field_size;
2297       fld->fixed_root    = (offsetRoot==-1)   ? 0 : 1;
2298       fld->fixed_parent  = (offsetParent==-1) ? 0 : 1;
2299       break;
2300
2301     default:
2302       if(unlikely(fld->field_fixed == -1)){
2303         size = (int) ltt_type_size(LTT_GET_BO(tf), type);
2304         fld->field_fixed = 1;
2305       }else size = fld->field_size;
2306       if(unlikely(!evD)){
2307         fld->fixed_root    = (offsetRoot==-1)   ? 0 : 1;
2308         fld->fixed_parent  = (offsetParent==-1) ? 0 : 1;
2309       }
2310       break;
2311   }
2312
2313   fld->offset_root     = offsetRoot;
2314   fld->offset_parent   = offsetParent;
2315   fld->field_size      = size;
2316
2317 end_getFieldtypeSize:
2318
2319   return size;
2320 }
2321 #endif //0
2322
2323 /*****************************************************************************
2324  *Function name
2325  *    ltt_get_int    : get an integer number
2326  *Input params
2327  *    reverse_byte_order: must we reverse the byte order ?
2328  *    size            : the size of the integer
2329  *    ptr             : the data pointer
2330  *Return value
2331  *    gint64          : a 64 bits integer
2332  ****************************************************************************/
2333
2334 gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data)
2335 {
2336   gint64 val;
2337
2338   switch(size) {
2339     case 1: val = *((gint8*)data); break;
2340     case 2: val = ltt_get_int16(reverse_byte_order, data); break;
2341     case 4: val = ltt_get_int32(reverse_byte_order, data); break;
2342     case 8: val = ltt_get_int64(reverse_byte_order, data); break;
2343     default: val = ltt_get_int64(reverse_byte_order, data);
2344              g_critical("get_int : integer size %d unknown", size);
2345              break;
2346   }
2347
2348   return val;
2349 }
2350
2351 /*****************************************************************************
2352  *Function name
2353  *    ltt_get_uint    : get an unsigned integer number
2354  *Input params
2355  *    reverse_byte_order: must we reverse the byte order ?
2356  *    size            : the size of the integer
2357  *    ptr             : the data pointer
2358  *Return value
2359  *    guint64         : a 64 bits unsigned integer
2360  ****************************************************************************/
2361
2362 guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data)
2363 {
2364   guint64 val;
2365
2366   switch(size) {
2367     case 1: val = *((gint8*)data); break;
2368     case 2: val = ltt_get_uint16(reverse_byte_order, data); break;
2369     case 4: val = ltt_get_uint32(reverse_byte_order, data); break;
2370     case 8: val = ltt_get_uint64(reverse_byte_order, data); break;
2371     default: val = ltt_get_uint64(reverse_byte_order, data);
2372              g_critical("get_uint : unsigned integer size %d unknown",
2373                  size);
2374              break;
2375   }
2376
2377   return val;
2378 }
2379
2380
2381 /* get the node name of the system */
2382
2383 char * ltt_trace_system_description_node_name (LttSystemDescription * s)
2384 {
2385   return s->node_name;
2386 }
2387
2388
2389 /* get the domain name of the system */
2390
2391 char * ltt_trace_system_description_domain_name (LttSystemDescription * s)
2392 {
2393   return s->domain_name;
2394 }
2395
2396
2397 /* get the description of the system */
2398
2399 char * ltt_trace_system_description_description (LttSystemDescription * s)
2400 {
2401   return s->description;
2402 }
2403
2404
2405 /* get the start time of the trace */
2406
2407 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
2408 {
2409   return s->trace_start;
2410 }
2411
2412
2413 LttTracefile *ltt_tracefile_new()
2414 {
2415   return g_new(LttTracefile, 1);
2416 }
2417
2418 void ltt_tracefile_destroy(LttTracefile *tf)
2419 {
2420   g_free(tf);
2421 }
2422
2423 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
2424 {
2425   *dest = *src;
2426 }
2427
2428 /* Before library loading... */
2429
2430 static void __attribute__((constructor)) init(void)
2431 {
2432   LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
2433   LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
2434
2435   LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities");
2436 }
2437