ltt/branches/poly/ltt/convert/convert.c

   1 #include <stdio.h>
   2 #include <unistd.h>
   3 #include <fcntl.h>
   4 #include <sys/stat.h>
   5 #include <sys/types.h>
   6 #include <errno.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include <glib.h>
  11 #include "LTTTypes.h"
  12 #include "LinuxEvents.h"
  13
  14 #define TRACE_HEARTBEAT_ID  19
  15 #define PROCESS_FORK_ID     20
  16 #define PROCESS_EXIT_ID     21
  17
  18 #define INFO_ENTRY          9
  19 #define OVERFLOW_FIGURE     0x100000000ULL
  20
  21 typedef struct _new_process
  22 {
  23   uint32_t  event_data1;     /* Data associated with event */
  24   uint32_t  event_data2;
  25 } LTT_PACKED_STRUCT new_process;
  26
  27 #define write_to_buffer(DEST, SRC, SIZE) \
  28 do\
  29 {\
  30    memcpy(DEST, SRC, SIZE);\
  31    DEST += SIZE;\
  32 } while(0);
  33
  34 int readFile(int fd, void * buf, size_t size, char * mesg)
  35 {
  36    ssize_t nbBytes = read(fd, buf, size);
  37
  38    if((size_t)nbBytes != size) {
  39      if(nbBytes < 0) {
  40        perror("Error in readFile : ");
  41      } else {
  42        printf("%s\n",mesg);
  43      }
  44      exit(1);
  45    }
  46    return 0;
  47 }
  48
  49 void getDataEndianType(char * size, char * endian)
  50 {
  51   int i = 1;
  52   char c = (char) i;
  53   int sizeInt=sizeof(int), sizeLong=sizeof(long), sizePointer=sizeof(void *);
  54
  55   if(c == 1) strcpy(endian,"LITTLE_ENDIAN");
  56   else strcpy(endian, "BIG_ENDIAN");
  57
  58   if(sizeInt == 2 && sizeLong == 4 && sizePointer == 4)
  59     strcpy(size,"LP32");
  60   else if(sizeInt == 4 && sizeLong == 4 && sizePointer == 4)
  61     strcpy(size,"ILP32");
  62   else if(sizeInt == 4 && sizeLong == 8 && sizePointer == 8)
  63     strcpy(size,"LP64");
  64   else if(sizeInt == 8 && sizeLong == 8 && sizePointer == 8)
  65     strcpy(size,"ILP64");
  66   else strcpy(size,"UNKNOWN");
  67 }
  68
  69 #define BUFFER_SIZE 80
  70
  71 typedef struct _buffer_start{
  72   uint32_t seconds;
  73   uint32_t nanoseconds;
  74   uint64_t cycle_count;
  75   uint32_t block_id;
  76 } __attribute__ ((packed)) buffer_start;
  77
  78 typedef struct _heartbeat{
  79   uint32_t seconds;
  80   uint32_t nanoseconds;
  81   uint64_t cycle_count;
  82 } __attribute__ ((packed)) heartbeat;
  83
  84
  85 int main(int argc, char ** argv){
  86
  87   int fd, fdCpu;
  88   FILE * fp;
  89   int  fdFac, fdIntr, fdProc;
  90   char arch_size[BUFFER_SIZE];
  91   char endian[BUFFER_SIZE];
  92   char node_name[BUFFER_SIZE];
  93   char domainname[BUFFER_SIZE];
  94   char kernel_name[BUFFER_SIZE];
  95   char kernel_release[BUFFER_SIZE];
  96   char kernel_version[BUFFER_SIZE];
  97   char machine[BUFFER_SIZE];
  98   char processor[BUFFER_SIZE];
  99   char hardware_platform[BUFFER_SIZE];
 100   char operating_system[BUFFER_SIZE];
 101   int  cpu;
 102   int  ltt_block_size=0;
 103   int  ltt_major_version=0;
 104   int  ltt_minor_version=0;
 105   int  ltt_log_cpu;
 106   char buf[BUFFER_SIZE];
 107   int i, k;
 108
 109   uint8_t cpu_id;
 110
 111   char foo[4*BUFFER_SIZE];
 112   char foo_eventdefs[4*BUFFER_SIZE];
 113   char foo_control[4*BUFFER_SIZE];
 114   char foo_cpu[4*BUFFER_SIZE];
 115   char foo_info[4*BUFFER_SIZE];
 116
 117   char foo_control_facilities[4*BUFFER_SIZE];
 118   char foo_control_processes[4*BUFFER_SIZE];
 119   char foo_control_interrupts[4*BUFFER_SIZE];
 120   char foo_info_system[4*BUFFER_SIZE];
 121
 122   struct stat      lTDFStat;
 123   off_t file_size;
 124   int block_number, block_size;
 125   char * buffer, *buf_out, cpuStr[4*BUFFER_SIZE];
 126   char * buf_fac, * buf_intr, * buf_proc;
 127   void * write_pos, *write_pos_fac, * write_pos_intr, *write_pos_proc;
 128   trace_start *tStart;
 129   trace_buffer_start *tBufStart;
 130   trace_buffer_end *tBufEnd;
 131   trace_file_system * tFileSys;
 132   uint16_t newId, startId, tmpId;
 133   uint8_t  evId;
 134   uint32_t time_delta, startTimeDelta;
 135   void * cur_pos, *end_pos;
 136   buffer_start start, start_proc, start_intr;
 137   buffer_start end, end_proc, end_intr;
 138   heartbeat beat;
 139   uint64_t beat_count;
 140   uint32_t size_lost;
 141   int reserve_size = sizeof(buffer_start) + sizeof(uint16_t) + 2*sizeof(uint32_t);//lost_size and buffer_end event
 142   int nb_para;
 143
 144   new_process process;
 145
 146   if(argc < 4){
 147     printf("Usage : ./convert processfile_name number_of_cpu tracefile1 tracefile2 ... trace_creation_directory\n");
 148                 printf("For more details, see README.\n");
 149     exit(1);
 150   }
 151
 152   cpu = atoi(argv[2]);
 153   printf("cpu number = %d\n", cpu);
 154   nb_para = 3 + cpu;
 155
 156   if(argc != nb_para && argc != nb_para+1){
 157     printf("need trace files and cpu number or root directory for the new tracefile\n");
 158     exit(1);
 159   }
 160
 161   if(argc == nb_para){
 162     strcpy(foo, "foo");
 163     strcpy(foo_eventdefs, "foo/eventdefs");
 164     strcpy(foo_control, "foo/control");
 165     strcpy(foo_cpu, "foo/cpu");
 166     strcpy(foo_info, "foo/info");
 167   }else{
 168     strcpy(foo, argv[nb_para]);
 169     strcpy(foo_eventdefs, argv[nb_para]);
 170     strcat(foo_eventdefs,"/eventdefs");
 171     strcpy(foo_control, argv[nb_para]);
 172     strcat(foo_control,"/control");
 173     strcpy(foo_cpu, argv[nb_para]);
 174     strcat(foo_cpu,"/cpu");
 175     strcpy(foo_info, argv[nb_para]);
 176     strcat(foo_info,"/info");
 177   }
 178   strcpy(foo_control_facilities, foo_control);
 179   strcat(foo_control_facilities,"/facilities");
 180   strcpy(foo_control_processes, foo_control);
 181   strcat(foo_control_processes, "/processes");
 182   strcpy(foo_control_interrupts, foo_control);
 183   strcat(foo_control_interrupts, "/interrupts");
 184   strcpy(foo_info_system, foo_info);
 185   strcat(foo_info_system, "/system.xml");
 186
 187
 188   getDataEndianType(arch_size, endian);
 189   printf("Arch_size: %s,  Endian: %s\n", arch_size, endian);
 190
 191   fp = fopen("sysInfo.out","r");
 192   if(!fp){
 193     g_error("Unable to open file sysInfo.out\n");
 194   }
 195
 196   for(i=0;i<INFO_ENTRY;i++){
 197     if(!fgets(buf,BUFFER_SIZE-1,fp))
 198       g_error("The format of sysInfo.out is not right\n");
 199     if(strncmp(buf,"node_name=",10)==0){
 200       strcpy(node_name,&buf[10]);
 201       node_name[strlen(node_name)-1] = '\0';
 202     }else if(strncmp(buf,"domainname=",11)==0){
 203       strcpy(domainname,&buf[11]);
 204       domainname[strlen(domainname)-1] = '\0';
 205     }else if(strncmp(buf,"kernel_name=",12)==0){
 206       strcpy(kernel_name,&buf[12]);
 207       kernel_name[strlen(kernel_name)-1] = '\0';
 208     }else if(strncmp(buf,"kernel_release=",15)==0){
 209       strcpy(kernel_release,&buf[15]);
 210       kernel_release[strlen(kernel_release)-1] = '\0';
 211     }else if(strncmp(buf,"kernel_version=",15)==0){
 212       strcpy(kernel_version,&buf[15]);
 213       kernel_version[strlen(kernel_version)-1] = '\0';
 214     }else if(strncmp(buf,"machine=",8)==0){
 215       strcpy(machine,&buf[8]);
 216       machine[strlen(machine)-1] = '\0';
 217     }else if(strncmp(buf,"processor=",10)==0){
 218       strcpy(processor,&buf[10]);
 219       processor[strlen(processor)-1] = '\0';
 220     }else if(strncmp(buf,"hardware_platform=",18)==0){
 221       strcpy(hardware_platform,&buf[18]);
 222       hardware_platform[strlen(hardware_platform)-1] = '\0';
 223     }else if(strncmp(buf,"operating_system=",17)==0){
 224       strcpy(operating_system,&buf[17]);
 225       operating_system[strlen(operating_system)-1] = '\0';
 226     }
 227   }
 228   fclose(fp);
 229
 230   if(mkdir(foo, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 231     g_error("can not make %s directory", foo);
 232   if(mkdir(foo_info, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 233     g_error("can not make %s directory", foo_info);
 234   if(mkdir(foo_cpu, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 235     g_error("can not make %s directory", foo_cpu);
 236   if(mkdir(foo_control, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 237     g_error("can not make %s directory", foo_control);
 238   if(mkdir(foo_eventdefs, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 239     g_error("can not make %s directory", foo_eventdefs);
 240
 241   fp = fopen(foo_info_system,"w");
 242   if(!fp){
 243     g_error("Unable to open file system.xml\n");
 244   }
 245
 246   fdFac = open(foo_control_facilities,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 247   if(fdFac < 0){
 248     g_error("Unable to open file facilities\n");
 249   }
 250   fdIntr = open(foo_control_interrupts,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 251   if(fdIntr<0){
 252     g_error("Unable to open file interrupts\n");
 253   }
 254   fdProc = open(foo_control_processes,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 255   if(fdProc<0){
 256     g_error("Unable to open file process\n");
 257   }
 258
 259
 260   for(k=0;k<cpu;k++){
 261     fd = open(argv[nb_para-cpu+k], O_RDONLY, 0);
 262     if(fd < 0){
 263       g_error("Unable to open input data file %s\n", argv[nb_para-cpu+k]);
 264     }
 265
 266     if(fstat(fd, &lTDFStat) < 0){
 267       g_error("Unable to get the status of the input data file\n");
 268     }
 269     file_size = lTDFStat.st_size;
 270
 271     buffer = g_new(char, 4000);
 272     readFile(fd,(void*)buffer, 3500, "Unable to read block header");
 273
 274     cur_pos= buffer;
 275     evId = *(uint8_t *)cur_pos;
 276     cur_pos += sizeof(uint8_t);
 277     newId = evId;
 278     time_delta = *(uint32_t*)cur_pos;
 279     cur_pos += sizeof(uint32_t);
 280     tBufStart = (trace_buffer_start*)cur_pos;
 281     cur_pos += sizeof(trace_buffer_start);
 282     cur_pos += sizeof(uint16_t); //Skip event size
 283
 284     evId = *(uint8_t *)cur_pos;
 285     cur_pos += sizeof(uint8_t);
 286     cur_pos += sizeof(uint32_t);
 287     tStart = (trace_start*)cur_pos;
 288
 289     startId = newId;
 290     startTimeDelta = time_delta;
 291     start.seconds = tBufStart->Time.tv_sec;
 292     start.nanoseconds = tBufStart->Time.tv_usec;
 293     start.cycle_count = tBufStart->TSC;
 294     start.block_id = tBufStart->ID;
 295     end.block_id = start.block_id;
 296
 297     ltt_major_version = tStart->MajorVersion;
 298     ltt_minor_version = tStart->MinorVersion;
 299     ltt_block_size    = tStart->BufferSize;
 300     ltt_log_cpu       = tStart->LogCPUID;
 301
 302     block_size = ltt_block_size;
 303     block_number = file_size/block_size;
 304
 305     g_free(buffer);
 306     buffer         = g_new(char, block_size);
 307     buf_fac        = g_new(char, block_size);
 308     write_pos_fac  = buf_fac;
 309     buf_intr       = g_new(char, block_size);
 310     write_pos_intr = buf_intr;
 311     buf_proc       = g_new(char, block_size);
 312     write_pos_proc = buf_proc;
 313
 314     buf_out = g_new(char, block_size);
 315     write_pos = buf_out;
 316     sprintf(cpuStr,"%s/%d",foo_cpu,k);
 317     fdCpu = open(cpuStr, O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH); //for cpu k
 318     if(fdCpu < 0)  g_error("Unable to open  cpu file %d\n", k);
 319     lseek(fd,0,SEEK_SET);
 320
 321     for(i=0;i<block_number;i++){
 322       int event_count = 0;
 323
 324       memset((void*)buf_out, 0, block_size);
 325       write_pos = buf_out;
 326       memset((void*)buf_intr, 0, block_size);
 327       memset((void*)buf_fac, 0, block_size);
 328       memset((void*)buf_proc, 0, block_size);
 329       write_pos_intr = buf_intr;
 330       write_pos_fac = buf_fac;
 331       write_pos_proc = buf_proc;
 332
 333       memset((void*)buffer,0,block_size);
 334       readFile(fd,(void*)buffer, block_size, "Unable to read block header");
 335
 336       cur_pos= buffer;
 337       evId = *(uint8_t *)cur_pos;
 338       cur_pos += sizeof(uint8_t);
 339       newId = evId;
 340       time_delta = *(uint32_t*)cur_pos;
 341       cur_pos += sizeof(uint32_t);
 342       tBufStart = (trace_buffer_start*)cur_pos;
 343       cur_pos += sizeof(trace_buffer_start);
 344       cur_pos += sizeof(uint16_t); //Skip event size
 345
 346       startId = newId;
 347       startTimeDelta = time_delta;
 348       start.seconds = tBufStart->Time.tv_sec;
 349       /* usec -> nsec (Mathieu) */
 350       start.nanoseconds = tBufStart->Time.tv_usec * 1000;
 351       start.cycle_count = tBufStart->TSC;
 352       beat_count = start.cycle_count;
 353       start.block_id = tBufStart->ID;
 354       end.block_id = start.block_id;
 355
 356       end_pos = buffer + block_size; //end of the buffer
 357       size_lost = *(uint32_t*)(end_pos - sizeof(uint32_t));
 358
 359       end_pos = buffer + block_size - size_lost ; //buffer_end event
 360       if(ltt_log_cpu){
 361         tBufEnd = (trace_buffer_end*)(end_pos + 2 * sizeof(uint8_t)+sizeof(uint32_t));
 362       }else{
 363         tBufEnd = (trace_buffer_end*)(end_pos+sizeof(uint8_t)+sizeof(uint32_t));
 364       }
 365       end.seconds = tBufEnd->Time.tv_sec;
 366       /* usec -> nsec (Mathieu) */
 367       end.nanoseconds = tBufEnd->Time.tv_usec * 1000;
 368       end.cycle_count = tBufEnd->TSC;
 369
 370       //skip buffer start and trace start events
 371       if(i==0) //the first block
 372         cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(trace_start) + 2*(sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t));
 373       else //other blocks
 374         cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t);
 375
 376       //write start block event
 377       write_to_buffer(write_pos,(void*)&startId, sizeof(uint16_t));
 378       write_to_buffer(write_pos,(void*)&startTimeDelta, sizeof(uint32_t));
 379       write_to_buffer(write_pos,(void*)&start, sizeof(buffer_start));
 380
 381       //write start block event into processes and interrupts files
 382       write_to_buffer(write_pos_intr,(void*)&startId, sizeof(uint16_t));
 383       write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
 384       start_intr = start;
 385       start_intr.nanoseconds -= 20;
 386       write_to_buffer(write_pos_intr,(void*)&start_intr, sizeof(buffer_start));
 387
 388       write_to_buffer(write_pos_proc,(void*)&startId, sizeof(uint16_t));
 389       write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
 390       start_proc = start;
 391       start_proc.nanoseconds -= 40;
 392       write_to_buffer(write_pos_proc,(void*)&start_proc, sizeof(buffer_start));
 393
 394       //parse *.proc file to get process and irq info
 395       if(i == 0){
 396         int        lIntID;                 /* Interrupt ID */
 397         int        lPID, lPPID;            /* Process PID and Parent PID */
 398         char       lName[256];             /* Process name */
 399         FILE *          fProc;
 400         uint16_t        defaultId;
 401         trace_irq_entry irq;
 402
 403         fProc = fopen(argv[1],"r");
 404         if(!fProc){
 405           g_error("Unable to open file %s\n", argv[1]);
 406         }
 407
 408         while(fscanf(fProc, "PID: %d; PPID: %d; NAME: %s\n", &lPID, &lPPID, lName) > 0){
 409           defaultId = PROCESS_FORK_ID;
 410           process.event_data1 = lPID;
 411           process.event_data2 = lPPID;
 412           write_to_buffer(write_pos_proc,(void*)&defaultId, sizeof(uint16_t));
 413           write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
 414           write_to_buffer(write_pos_proc,(void*)&process, sizeof(new_process));
 415         }
 416
 417         while(fscanf(fProc, "IRQ: %d; NAME: ", &lIntID) > 0){
 418           /* Read 'til the end of the line */
 419           fgets(lName, 200, fProc);
 420
 421           defaultId =  TRACE_IRQ_ENTRY;
 422           irq.irq_id = lIntID;
 423           irq.kernel = 1;
 424           write_to_buffer(write_pos_intr,(void*)&defaultId, sizeof(uint16_t));
 425           write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
 426           write_to_buffer(write_pos_intr,(void*)&irq, sizeof(trace_irq_entry));
 427         }
 428         fclose(fProc);
 429       }
 430
 431       while(1){
 432         int event_size;
 433         uint64_t timeDelta;
 434         uint8_t  subId;
 435
 436         if(ltt_log_cpu){
 437           cpu_id = *(uint8_t*)cur_pos;
 438           cur_pos += sizeof(uint8_t);
 439         }
 440         evId = *(uint8_t *)cur_pos;
 441         newId = evId;
 442         if(evId == TRACE_HEARTBEAT) {
 443           newId = TRACE_HEARTBEAT_ID;
 444         }
 445         cur_pos += sizeof(uint8_t);
 446         time_delta = *(uint32_t*)cur_pos;
 447         cur_pos += sizeof(uint32_t);
 448
 449         //write event_id and time_delta
 450         write_to_buffer(write_pos,(void*)&newId,sizeof(uint16_t));
 451         write_to_buffer(write_pos,(void*)&time_delta, sizeof(uint32_t));
 452
 453         if(evId == TRACE_BUFFER_END){
 454 #if 0 //(Mathieu : already set correctly to tBufEnd.TSC)
 455     end.cycle_count = start.cycle_count
 456                          + beat_count * OVERFLOW_FIGURE;
 457 #endif //)
 458           int size = block_size + ((void*)buf_out - write_pos)+ sizeof(uint16_t) + sizeof(uint32_t);
 459           write_to_buffer(write_pos,(void*)&end,sizeof(buffer_start));
 460           write_pos = buf_out + block_size - sizeof(uint32_t);
 461           write_to_buffer(write_pos,(void*)&size, sizeof(uint32_t));
 462           write(fdCpu,(void*)buf_out, block_size);
 463
 464           //write out processes and intrrupts files
 465           {
 466             int size_intr = block_size - (write_pos_intr - (void*)buf_intr);
 467             int size_proc = block_size - (write_pos_proc - (void*)buf_proc);
 468             write_to_buffer(write_pos_intr,(void*)&newId,sizeof(uint16_t));
 469             write_to_buffer(write_pos_intr,(void*)&time_delta, sizeof(uint32_t));
 470             end_intr = end;
 471             end_intr.nanoseconds -= 20;
 472             write_to_buffer(write_pos_intr,(void*)&end_intr,sizeof(buffer_start));
 473
 474             write_to_buffer(write_pos_proc,(void*)&newId,sizeof(uint16_t));
 475             write_to_buffer(write_pos_proc,(void*)&time_delta, sizeof(uint32_t));
 476             end_proc = end;
 477             end_proc.nanoseconds -= 40;
 478             write_to_buffer(write_pos_proc,(void*)&end_proc,sizeof(buffer_start));
 479
 480             write_pos_intr = buf_intr + block_size - sizeof(uint32_t);
 481             write_pos_proc = buf_proc + block_size - sizeof(uint32_t);
 482             write_to_buffer(write_pos_intr,(void*)&size_intr, sizeof(uint32_t));
 483             write_to_buffer(write_pos_proc,(void*)&size_proc, sizeof(uint32_t));
 484             //for now don't output processes and interrupt information
 485             //    write(fdIntr,(void*)buf_intr,block_size);
 486             //    write(fdProc,(void*)buf_proc,block_size);
 487           }
 488           break;
 489         }
 490
 491         event_count++;
 492         switch(evId){
 493           case TRACE_SYSCALL_ENTRY:
 494             event_size = sizeof(trace_syscall_entry);
 495             break;
 496           case TRACE_SYSCALL_EXIT:
 497             event_size = 0;
 498             break;
 499           case TRACE_TRAP_ENTRY:
 500             event_size = sizeof(trace_trap_entry);
 501             break;
 502           case TRACE_TRAP_EXIT:
 503             event_size = 0;
 504             break;
 505           case TRACE_IRQ_ENTRY:
 506             event_size = sizeof(trace_irq_entry);
 507             timeDelta = time_delta;
 508             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 509             write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 510             write_to_buffer(write_pos_intr,cur_pos, event_size);
 511             break;
 512           case TRACE_IRQ_EXIT:
 513             event_size = 0;
 514             timeDelta = time_delta;
 515             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 516             write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 517             break;
 518           case TRACE_SCHEDCHANGE:
 519             event_size = sizeof(trace_schedchange);
 520             break;
 521           case TRACE_KERNEL_TIMER:
 522             event_size = 0;
 523             break;
 524           case TRACE_SOFT_IRQ:
 525             event_size = sizeof(trace_soft_irq);
 526             //    timeDelta = time_delta;
 527             //    write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 528             //    write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 529             //    write_to_buffer(write_pos_intr,cur_pos, event_size);
 530             break;
 531           case TRACE_PROCESS:
 532             event_size = sizeof(trace_process);
 533             timeDelta = time_delta;
 534             subId = *(uint8_t*)cur_pos;
 535             if(subId == TRACE_PROCESS_FORK || subId ==TRACE_PROCESS_EXIT){
 536               if( subId == TRACE_PROCESS_FORK)tmpId = PROCESS_FORK_ID;
 537               else tmpId = PROCESS_EXIT_ID;
 538               write_to_buffer(write_pos_proc,(void*)&tmpId, sizeof(uint16_t));
 539               write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint32_t));
 540
 541               process = *(new_process*)(cur_pos + sizeof(uint8_t));
 542               write_to_buffer(write_pos_proc,(void*)&process, sizeof(new_process));
 543             }
 544             break;
 545           case TRACE_FILE_SYSTEM:
 546             event_size = sizeof(trace_file_system)- sizeof(char*);
 547             break;
 548           case TRACE_TIMER:
 549             event_size = sizeof(trace_timer);
 550             break;
 551           case TRACE_MEMORY:
 552             event_size = sizeof(trace_memory);
 553             break;
 554           case TRACE_SOCKET:
 555             event_size = sizeof(trace_socket);
 556             break;
 557           case TRACE_IPC:
 558             event_size = sizeof(trace_ipc);
 559             break;
 560           case TRACE_NETWORK:
 561             event_size = sizeof(trace_network);
 562             break;
 563           case TRACE_HEARTBEAT:
 564       /* Fix (Mathieu) */
 565       if(timeDelta < (0xFFFFFFFF&beat_count)) {
 566         /* Overflow */
 567         beat_count += 0x100000000ULL - (uint64_t)(0xFFFFFFFF&beat_count)
 568                                      + (uint64_t)timeDelta;
 569       } else {
 570         /* No overflow */
 571         beat_count += timeDelta - (0xFFFFFFFF&beat_count);
 572       }
 573             beat.seconds = 0;
 574             beat.nanoseconds = 0;
 575             beat.cycle_count = beat_count;
 576             event_size = 0;
 577
 578             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 579             write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 580             write_to_buffer(write_pos_intr,(void*)&beat, sizeof(heartbeat));
 581             write_to_buffer(write_pos_proc,(void*)&newId, sizeof(uint16_t));
 582             write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint32_t));
 583             write_to_buffer(write_pos_proc,(void*)&beat, sizeof(heartbeat));
 584             break;
 585           default:
 586             event_size = -1;
 587             break;
 588         }
 589         if(evId != TRACE_FILE_SYSTEM && event_size >=0){
 590           write_to_buffer(write_pos, cur_pos, event_size);
 591
 592           if(evId == TRACE_HEARTBEAT){
 593             write_to_buffer(write_pos, (void*)&beat, sizeof(heartbeat));
 594           }
 595
 596           cur_pos += event_size + sizeof(uint16_t); //skip data_size
 597         }else if(evId == TRACE_FILE_SYSTEM){
 598           size_t nbBytes;
 599           char  c = '\0';
 600           tFileSys = (trace_file_system*)cur_pos;
 601           subId = tFileSys->event_sub_id;
 602           if(subId == TRACE_FILE_SYSTEM_OPEN || subId == TRACE_FILE_SYSTEM_EXEC){
 603             nbBytes = tFileSys->event_data2 +1;
 604           }else nbBytes = 0;
 605
 606           write_to_buffer(write_pos, cur_pos, event_size);
 607           cur_pos += event_size + sizeof(char*);
 608           if(nbBytes){
 609             write_to_buffer(write_pos, cur_pos, nbBytes);
 610           }else{
 611             write_to_buffer(write_pos, (void*)&c, 1);
 612           }
 613           cur_pos += nbBytes + sizeof(uint16_t); //skip data_size
 614         }else if(event_size == -1){
 615           printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId, i, event_count);
 616           exit(1);
 617         }
 618       } //end while(1)
 619     }
 620     close(fd);
 621     close(fdCpu);
 622     g_free(buffer);
 623     buffer = NULL;
 624     g_free(buf_fac);
 625     g_free(buf_intr);
 626     g_free(buf_proc);
 627     g_free(buf_out);
 628   }
 629
 630
 631
 632
 633
 634   //write to system.xml
 635   fprintf(fp,"<system \n");
 636   fprintf(fp,"node_name=\"%s\" \n", node_name);
 637   fprintf(fp,"domainname=\"%s\" \n", domainname);
 638   fprintf(fp,"cpu=\"%d\" \n", cpu);
 639   fprintf(fp,"arch_size=\"%s\" \n", arch_size);
 640   fprintf(fp,"endian=\"%s\" \n",endian);
 641   fprintf(fp,"kernel_name=\"%s\" \n",kernel_name);
 642   fprintf(fp,"kernel_release=\"%s\" \n",kernel_release);
 643   fprintf(fp,"kernel_version=\"%s\" \n",kernel_version);
 644   fprintf(fp,"machine=\"%s\" \n",machine);
 645   fprintf(fp,"processor=\"%s\" \n",processor);
 646   fprintf(fp,"hardware_platform=\"%s\" \n",hardware_platform);
 647   fprintf(fp,"operating_system=\"%s\" \n",operating_system);
 648   fprintf(fp,"ltt_major_version=\"%d\" \n",ltt_major_version);
 649   fprintf(fp,"ltt_minor_version=\"%d\" \n",ltt_minor_version);
 650   fprintf(fp,"ltt_block_size=\"%d\" \n",ltt_block_size);
 651   fprintf(fp,">\n");
 652   fprintf(fp,"This is just a test\n");
 653   fprintf(fp,"</system>\n");
 654   fflush(fp);
 655
 656   close(fdFac);
 657   close(fdIntr);
 658   close(fdProc);
 659   fclose(fp);
 660
 661   return 0;
 662 }
 663