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