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 _buffer_end{
  79   uint32_t seconds;
  80   uint32_t nanoseconds;
  81   uint64_t cycle_count;
  82   uint32_t block_id;
  83 } __attribute__ ((packed)) buffer_end;
  84
  85
  86 typedef struct _heartbeat{
  87   uint32_t seconds;
  88   uint32_t nanoseconds;
  89   uint64_t cycle_count;
  90 } __attribute__ ((packed)) heartbeat;
  91
  92
  93 int main(int argc, char ** argv){
  94
  95   int fd, fdCpu;
  96   FILE * fp;
  97   int  fdFac, fdIntr, fdProc;
  98   char arch_size[BUFFER_SIZE];
  99   char endian[BUFFER_SIZE];
 100   char node_name[BUFFER_SIZE];
 101   char domainname[BUFFER_SIZE];
 102   char kernel_name[BUFFER_SIZE];
 103   char kernel_release[BUFFER_SIZE];
 104   char kernel_version[BUFFER_SIZE];
 105   char machine[BUFFER_SIZE];
 106   char processor[BUFFER_SIZE];
 107   char hardware_platform[BUFFER_SIZE];
 108   char operating_system[BUFFER_SIZE];
 109   int  cpu;
 110   int  ltt_block_size=0;
 111   int  ltt_major_version=0;
 112   int  ltt_minor_version=0;
 113   int  ltt_log_cpu;
 114   guint ltt_trace_start_size = 0;
 115   char buf[BUFFER_SIZE];
 116   int i, k;
 117
 118   uint8_t cpu_id;
 119
 120   char foo[4*BUFFER_SIZE];
 121   char foo_eventdefs[4*BUFFER_SIZE];
 122   char foo_control[4*BUFFER_SIZE];
 123   char foo_cpu[4*BUFFER_SIZE];
 124   char foo_info[4*BUFFER_SIZE];
 125
 126   char foo_control_facilities[4*BUFFER_SIZE];
 127   char foo_control_processes[4*BUFFER_SIZE];
 128   char foo_control_interrupts[4*BUFFER_SIZE];
 129   char foo_info_system[4*BUFFER_SIZE];
 130
 131   struct stat      lTDFStat;
 132   off_t file_size;
 133   int block_number, block_size;
 134   char * buffer, *buf_out, cpuStr[4*BUFFER_SIZE];
 135   char * buf_fac, * buf_intr, * buf_proc;
 136   void * write_pos, *write_pos_fac, * write_pos_intr, *write_pos_proc;
 137   trace_start_any *tStart;
 138   trace_buffer_start *tBufStart;
 139   trace_buffer_end *tBufEnd;
 140   trace_file_system * tFileSys;
 141   uint16_t newId, startId, tmpId;
 142   uint8_t  evId;
 143   uint32_t time_delta, startTimeDelta;
 144   void * cur_pos, *end_pos;
 145   buffer_start start, start_proc, start_intr;
 146   buffer_end end, end_proc, end_intr;
 147   heartbeat beat;
 148   uint64_t adaptation_tsc;    // (Mathieu)
 149   uint32_t size_lost;
 150   int reserve_size = sizeof(buffer_start) +
 151                      sizeof(buffer_end) + //buffer_end event
 152                      sizeof(uint32_t);  //lost size
 153   int nb_para;
 154
 155   new_process process;
 156
 157   if(argc < 4){
 158     printf("Usage : ./convert processfile_name number_of_cpu tracefile1 tracefile2 ... trace_creation_directory\n");
 159                 printf("For more details, see README.\n");
 160     exit(1);
 161   }
 162
 163   cpu = atoi(argv[2]);
 164   printf("cpu number = %d\n", cpu);
 165   nb_para = 3 + cpu;
 166
 167   if(argc != nb_para && argc != nb_para+1){
 168     printf("need trace files and cpu number or root directory for the new tracefile\n");
 169     exit(1);
 170   }
 171
 172   if(argc == nb_para){
 173     strcpy(foo, "foo");
 174     strcpy(foo_eventdefs, "foo/eventdefs");
 175     strcpy(foo_control, "foo/control");
 176     strcpy(foo_cpu, "foo/cpu");
 177     strcpy(foo_info, "foo/info");
 178   }else{
 179     strcpy(foo, argv[nb_para]);
 180     strcpy(foo_eventdefs, argv[nb_para]);
 181     strcat(foo_eventdefs,"/eventdefs");
 182     strcpy(foo_control, argv[nb_para]);
 183     strcat(foo_control,"/control");
 184     strcpy(foo_cpu, argv[nb_para]);
 185     strcat(foo_cpu,"/cpu");
 186     strcpy(foo_info, argv[nb_para]);
 187     strcat(foo_info,"/info");
 188   }
 189   strcpy(foo_control_facilities, foo_control);
 190   strcat(foo_control_facilities,"/facilities");
 191   strcpy(foo_control_processes, foo_control);
 192   strcat(foo_control_processes, "/processes");
 193   strcpy(foo_control_interrupts, foo_control);
 194   strcat(foo_control_interrupts, "/interrupts");
 195   strcpy(foo_info_system, foo_info);
 196   strcat(foo_info_system, "/system.xml");
 197
 198
 199   getDataEndianType(arch_size, endian);
 200   printf("Arch_size: %s,  Endian: %s\n", arch_size, endian);
 201
 202   fp = fopen("sysInfo.out","r");
 203   if(!fp){
 204     g_error("Unable to open file sysInfo.out\n");
 205   }
 206
 207   for(i=0;i<INFO_ENTRY;i++){
 208     if(!fgets(buf,BUFFER_SIZE-1,fp))
 209       g_error("The format of sysInfo.out is not right\n");
 210     if(strncmp(buf,"node_name=",10)==0){
 211       strcpy(node_name,&buf[10]);
 212       node_name[strlen(node_name)-1] = '\0';
 213     }else if(strncmp(buf,"domainname=",11)==0){
 214       strcpy(domainname,&buf[11]);
 215       domainname[strlen(domainname)-1] = '\0';
 216     }else if(strncmp(buf,"kernel_name=",12)==0){
 217       strcpy(kernel_name,&buf[12]);
 218       kernel_name[strlen(kernel_name)-1] = '\0';
 219     }else if(strncmp(buf,"kernel_release=",15)==0){
 220       strcpy(kernel_release,&buf[15]);
 221       kernel_release[strlen(kernel_release)-1] = '\0';
 222     }else if(strncmp(buf,"kernel_version=",15)==0){
 223       strcpy(kernel_version,&buf[15]);
 224       kernel_version[strlen(kernel_version)-1] = '\0';
 225     }else if(strncmp(buf,"machine=",8)==0){
 226       strcpy(machine,&buf[8]);
 227       machine[strlen(machine)-1] = '\0';
 228     }else if(strncmp(buf,"processor=",10)==0){
 229       strcpy(processor,&buf[10]);
 230       processor[strlen(processor)-1] = '\0';
 231     }else if(strncmp(buf,"hardware_platform=",18)==0){
 232       strcpy(hardware_platform,&buf[18]);
 233       hardware_platform[strlen(hardware_platform)-1] = '\0';
 234     }else if(strncmp(buf,"operating_system=",17)==0){
 235       strcpy(operating_system,&buf[17]);
 236       operating_system[strlen(operating_system)-1] = '\0';
 237     }
 238   }
 239   fclose(fp);
 240
 241   if(mkdir(foo, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 242     g_error("can not make %s directory", foo);
 243   if(mkdir(foo_info, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 244     g_error("can not make %s directory", foo_info);
 245   if(mkdir(foo_cpu, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 246     g_error("can not make %s directory", foo_cpu);
 247   if(mkdir(foo_control, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 248     g_error("can not make %s directory", foo_control);
 249   if(mkdir(foo_eventdefs, S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH))
 250     g_error("can not make %s directory", foo_eventdefs);
 251
 252   fp = fopen(foo_info_system,"w");
 253   if(!fp){
 254     g_error("Unable to open file system.xml\n");
 255   }
 256
 257   fdFac = open(foo_control_facilities,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 258   if(fdFac < 0){
 259     g_error("Unable to open file facilities\n");
 260   }
 261   fdIntr = open(foo_control_interrupts,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 262   if(fdIntr<0){
 263     g_error("Unable to open file interrupts\n");
 264   }
 265   fdProc = open(foo_control_processes,O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 266   if(fdProc<0){
 267     g_error("Unable to open file process\n");
 268   }
 269
 270
 271   for(k=0;k<cpu;k++){
 272     fd = open(argv[nb_para-cpu+k], O_RDONLY, 0);
 273     if(fd < 0){
 274       g_error("Unable to open input data file %s\n", argv[nb_para-cpu+k]);
 275     }
 276
 277     if(fstat(fd, &lTDFStat) < 0){
 278       g_error("Unable to get the status of the input data file\n");
 279     }
 280     file_size = lTDFStat.st_size;
 281
 282     buffer = g_new(char, 4000);
 283     readFile(fd,(void*)buffer, 3500, "Unable to read block header");
 284
 285     cur_pos= buffer;
 286     evId = *(uint8_t *)cur_pos;
 287     cur_pos += sizeof(uint8_t);
 288     newId = evId;
 289     time_delta = *(uint32_t*)cur_pos;
 290     cur_pos += sizeof(uint32_t);
 291     tBufStart = (trace_buffer_start*)cur_pos;
 292     cur_pos += sizeof(trace_buffer_start);
 293     cur_pos += sizeof(uint16_t); //Skip event size
 294
 295     evId = *(uint8_t *)cur_pos;
 296     g_assert(evId == TRACE_START);
 297     cur_pos += sizeof(uint8_t); //skip EvId
 298     cur_pos += sizeof(uint32_t); //skip time delta
 299     tStart = (trace_start_any*)cur_pos;
 300     if(tStart->MagicNumber != TRACER_MAGIC_NUMBER)
 301       g_error("Trace magic number does not match : %lx, should be %lx",
 302                tStart->MagicNumber, TRACER_MAGIC_NUMBER);
 303     if(tStart->MajorVersion != TRACER_SUP_VERSION_MAJOR)
 304       g_error("Trace Major number does match : %hu, should be %u",
 305                tStart->MajorVersion, TRACER_SUP_VERSION_MAJOR);
 306
 307     startId = newId;
 308     startTimeDelta = time_delta;
 309     start.seconds = tBufStart->Time.tv_sec;
 310     /* Fix (Mathieu) */
 311     start.nanoseconds = tBufStart->Time.tv_usec * 1000;
 312     start.cycle_count = tBufStart->TSC;
 313     start.block_id = tBufStart->ID;
 314     end.block_id = start.block_id;
 315
 316
 317     g_printf("Trace version %hu.%hu detected\n",
 318              tStart->MajorVersion,
 319              tStart->MinorVersion);
 320     if(tStart->MinorVersion == 2) {
 321       trace_start_2_2* tStart_2_2 = (trace_start_2_2*)tStart;
 322       ltt_major_version = tStart_2_2->MajorVersion;
 323       ltt_minor_version = tStart_2_2->MinorVersion;
 324       ltt_block_size    = tStart_2_2->BufferSize;
 325       ltt_log_cpu       = tStart_2_2->LogCPUID;
 326       ltt_trace_start_size = sizeof(trace_start_2_2);
 327       /* Verify if it's a broken 2.2 format */
 328       if(*(uint8_t*)(cur_pos + sizeof(trace_start_2_2)) == 0) {
 329         /* Cannot have two trace start events. We cannot detect the problem
 330          * if the flight recording flag is set to 1, as it conflicts
 331          * with TRACE_SYSCALL_ENTRY.
 332          */
 333         g_warning("This is a 2.3 trace format that has a 2.2 tag. Please upgrade your kernel");
 334         g_printf("Processing the trace as a 2.3 format\n");
 335
 336         tStart->MinorVersion = 3;
 337       }
 338     }
 339
 340     if(tStart->MinorVersion == 3) {
 341       trace_start_2_3* tStart_2_3 = (trace_start_2_3*)tStart;
 342       ltt_major_version = tStart_2_3->MajorVersion;
 343       ltt_minor_version = tStart_2_3->MinorVersion;
 344       ltt_block_size    = tStart_2_3->BufferSize;
 345       ltt_log_cpu       = tStart_2_3->LogCPUID;
 346       ltt_trace_start_size = sizeof(trace_start_2_3);
 347     /* We do not use the flight recorder information for now, because we
 348      * never use the .proc file anyway */
 349     }
 350
 351     if(ltt_trace_start_size == 0)
 352       g_error("Minor version unknown : %hu. Supported minors : 2, 3",
 353                tStart->MinorVersion);
 354
 355     block_size = ltt_block_size;//FIXME
 356     block_number = file_size/ltt_block_size;
 357
 358     g_free(buffer);
 359     buffer         = g_new(char, ltt_block_size);
 360     buf_fac        = g_new(char, block_size);
 361     write_pos_fac  = buf_fac;
 362     buf_intr       = g_new(char, block_size);
 363     write_pos_intr = buf_intr;
 364     buf_proc       = g_new(char, block_size);
 365     write_pos_proc = buf_proc;
 366
 367     buf_out = g_new(char, block_size);
 368     write_pos = buf_out;
 369     sprintf(cpuStr,"%s/%d",foo_cpu,k);
 370     fdCpu = open(cpuStr, O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH); //for cpu k
 371     if(fdCpu < 0)  g_error("Unable to open  cpu file %d\n", k);
 372     lseek(fd,0,SEEK_SET);
 373
 374     for(i=0;i<block_number;i++){
 375       int event_count = 0;
 376
 377       memset((void*)buf_out, 0, block_size);
 378       write_pos = buf_out;
 379       memset((void*)buf_intr, 0, block_size);
 380       memset((void*)buf_fac, 0, block_size);
 381       memset((void*)buf_proc, 0, block_size);
 382       write_pos_intr = buf_intr;
 383       write_pos_fac = buf_fac;
 384       write_pos_proc = buf_proc;
 385
 386       memset((void*)buffer,0,ltt_block_size);
 387       readFile(fd,(void*)buffer, ltt_block_size, "Unable to read block header");
 388
 389       cur_pos= buffer;
 390       evId = *(uint8_t *)cur_pos;
 391       cur_pos += sizeof(uint8_t);
 392       newId = evId;
 393       time_delta = *(uint32_t*)cur_pos;
 394       cur_pos += sizeof(uint32_t);
 395       tBufStart = (trace_buffer_start*)cur_pos;
 396       cur_pos += sizeof(trace_buffer_start);
 397       cur_pos += sizeof(uint16_t); //Skip event size
 398
 399       startId = newId;
 400       startTimeDelta = time_delta;
 401       start.seconds = tBufStart->Time.tv_sec;
 402       /* usec -> nsec (Mathieu) */
 403       start.nanoseconds = tBufStart->Time.tv_usec * 1000;
 404       start.block_id = tBufStart->ID;
 405       end.block_id = start.block_id;
 406
 407       end_pos = buffer + ltt_block_size; //end of the buffer
 408       size_lost = *(uint32_t*)(end_pos - sizeof(uint32_t));
 409
 410       end_pos = buffer + ltt_block_size - size_lost ; //buffer_end event
 411       if(ltt_log_cpu){
 412         tBufEnd = (trace_buffer_end*)(end_pos + 2 * sizeof(uint8_t)+sizeof(uint32_t));
 413       }else{
 414         tBufEnd = (trace_buffer_end*)(end_pos+sizeof(uint8_t)+sizeof(uint32_t));
 415       }
 416       end.seconds = tBufEnd->Time.tv_sec;
 417       /* usec -> nsec (Mathieu) */
 418       end.nanoseconds = tBufEnd->Time.tv_usec * 1000;
 419       // only 32 bits :(
 420       //end.cycle_count = tBufEnd->TSC;
 421
 422       //skip buffer start and trace start events
 423       if(i==0) {
 424         //the first block
 425         adaptation_tsc = (uint64_t)tBufStart->TSC;
 426               cur_pos = buffer + sizeof(trace_buffer_start)
 427                          + ltt_trace_start_size
 428                          + 2*(sizeof(uint8_t)
 429                          + sizeof(uint16_t)+sizeof(uint32_t));
 430       } else {
 431         //other blocks
 432               cur_pos = buffer + sizeof(trace_buffer_start)
 433                          + sizeof(uint8_t)
 434                          + sizeof(uint16_t)+sizeof(uint32_t);
 435
 436         /* Fix (Mathieu) */
 437         if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
 438           /* Overflow */
 439           adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL)
 440                                        + 0x100000000ULL
 441                                        + (uint64_t)time_delta;
 442         } else {
 443           /* No overflow */
 444           adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
 445         }
 446
 447       }
 448       start.cycle_count = adaptation_tsc;
 449
 450       //write start block event
 451       write_to_buffer(write_pos,(void*)&startId, sizeof(uint16_t));
 452       write_to_buffer(write_pos,(void*)&startTimeDelta, sizeof(uint32_t));
 453       write_to_buffer(write_pos,(void*)&start, sizeof(buffer_start));
 454
 455       //write start block event into processes and interrupts files
 456       write_to_buffer(write_pos_intr,(void*)&startId, sizeof(uint16_t));
 457       write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
 458       start_intr = start;
 459       start_intr.nanoseconds -= 20;
 460       write_to_buffer(write_pos_intr,(void*)&start_intr, sizeof(buffer_start));
 461
 462       write_to_buffer(write_pos_proc,(void*)&startId, sizeof(uint16_t));
 463       write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
 464       start_proc = start;
 465       start_proc.nanoseconds -= 40;
 466       write_to_buffer(write_pos_proc,(void*)&start_proc, sizeof(buffer_start));
 467
 468       //parse *.proc file to get process and irq info
 469       if(i == 0){
 470         int        lIntID;                 /* Interrupt ID */
 471         int        lPID, lPPID;            /* Process PID and Parent PID */
 472         char       lName[256];             /* Process name */
 473         FILE *          fProc;
 474         uint16_t        defaultId;
 475         trace_irq_entry irq;
 476
 477         fProc = fopen(argv[1],"r");
 478         if(!fProc){
 479           g_error("Unable to open file %s\n", argv[1]);
 480         }
 481
 482         while(fscanf(fProc, "PID: %d; PPID: %d; NAME: %s\n", &lPID, &lPPID, lName) > 0){
 483           defaultId = PROCESS_FORK_ID;
 484           process.event_data1 = lPID;
 485           process.event_data2 = lPPID;
 486           write_to_buffer(write_pos_proc,(void*)&defaultId, sizeof(uint16_t));
 487           write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
 488           write_to_buffer(write_pos_proc,(void*)&process, sizeof(new_process));
 489         }
 490
 491         while(fscanf(fProc, "IRQ: %d; NAME: ", &lIntID) > 0){
 492           /* Read 'til the end of the line */
 493           fgets(lName, 200, fProc);
 494
 495           defaultId =  TRACE_IRQ_ENTRY;
 496           irq.irq_id = lIntID;
 497           irq.kernel = 1;
 498           write_to_buffer(write_pos_intr,(void*)&defaultId, sizeof(uint16_t));
 499           write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
 500           write_to_buffer(write_pos_intr,(void*)&irq, sizeof(trace_irq_entry));
 501         }
 502         fclose(fProc);
 503       }
 504
 505       while(1){
 506         int event_size;
 507         uint64_t timeDelta;
 508         uint8_t  subId;
 509
 510         if(ltt_log_cpu){
 511           cpu_id = *(uint8_t*)cur_pos;
 512           cur_pos += sizeof(uint8_t);
 513         }
 514         evId = *(uint8_t *)cur_pos;
 515         newId = evId;
 516         if(evId == TRACE_HEARTBEAT) {
 517           newId = TRACE_HEARTBEAT_ID;
 518         }
 519         cur_pos += sizeof(uint8_t);
 520         time_delta = *(uint32_t*)cur_pos;
 521         cur_pos += sizeof(uint32_t);
 522
 523
 524         //write event_id and time_delta
 525         write_to_buffer(write_pos,(void*)&newId,sizeof(uint16_t));
 526         write_to_buffer(write_pos,(void*)&time_delta, sizeof(uint32_t));
 527
 528   /* Fix (Mathieu) */
 529   if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
 530     /* Overflow */
 531     adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + 0x100000000ULL
 532                                  + (uint64_t)time_delta;
 533   } else {
 534     /* No overflow */
 535     adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
 536   }
 537
 538
 539         if(evId == TRACE_BUFFER_END){
 540 #if 0
 541     /* Fix (Mathieu) */
 542     if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
 543       /* Overflow */
 544      adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + 0x100000000ULL
 545                                    + (uint64_t)time_delta;
 546     } else {
 547       /* No overflow */
 548       adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
 549     }
 550 #endif //0
 551     end.cycle_count = adaptation_tsc;
 552           int size = (void*)buf_out + block_size - write_pos
 553                    - sizeof(buffer_end) - sizeof(uint32_t);
 554
 555     /* size _lost_ ? */
 556     //int size = (void*)buf_out + block_size - write_pos
 557     //            + sizeof(uint16_t) + sizeof(uint32_t);
 558     g_assert((void*)write_pos < (void*)buf_out + block_size);
 559           write_to_buffer(write_pos,(void*)&end,sizeof(buffer_end));
 560           write_pos = buf_out + block_size - sizeof(uint32_t);
 561           write_to_buffer(write_pos,(void*)&size, sizeof(uint32_t));
 562           write(fdCpu,(void*)buf_out, block_size);
 563
 564           //write out processes and intrrupts files
 565           {
 566             int size_intr = block_size + (void*)buf_intr - write_pos_intr
 567                          - sizeof(buffer_end) - sizeof(uint32_t);
 568             int size_proc = block_size + (void*)buf_proc - write_pos_proc
 569                          - sizeof(buffer_end) - sizeof(uint32_t);
 570       //int size_intr = block_size - (write_pos_intr - (void*)buf_intr);
 571       //int size_proc = block_size - (write_pos_proc - (void*)buf_proc);
 572             write_to_buffer(write_pos_intr,(void*)&newId,sizeof(uint16_t));
 573             write_to_buffer(write_pos_intr,(void*)&time_delta, sizeof(uint32_t));
 574             end_intr = end;
 575             end_intr.nanoseconds -= 20;
 576             write_to_buffer(write_pos_intr,(void*)&end_intr,sizeof(buffer_start));
 577
 578             write_to_buffer(write_pos_proc,(void*)&newId,sizeof(uint16_t));
 579             write_to_buffer(write_pos_proc,(void*)&time_delta, sizeof(uint32_t));
 580             end_proc = end;
 581             end_proc.nanoseconds -= 40;
 582             write_to_buffer(write_pos_proc,(void*)&end_proc,sizeof(buffer_start));
 583
 584             write_pos_intr = buf_intr + block_size - sizeof(uint32_t);
 585             write_pos_proc = buf_proc + block_size - sizeof(uint32_t);
 586             write_to_buffer(write_pos_intr,(void*)&size_intr, sizeof(uint32_t));
 587             write_to_buffer(write_pos_proc,(void*)&size_proc, sizeof(uint32_t));
 588             //for now don't output processes and interrupt information
 589             //    write(fdIntr,(void*)buf_intr,block_size);
 590             //    write(fdProc,(void*)buf_proc,block_size);
 591           }
 592           break;
 593         }
 594
 595         event_count++;
 596         switch(evId){
 597           case TRACE_SYSCALL_ENTRY:
 598             event_size = sizeof(trace_syscall_entry);
 599             break;
 600           case TRACE_SYSCALL_EXIT:
 601             event_size = 0;
 602             break;
 603           case TRACE_TRAP_ENTRY:
 604             event_size = sizeof(trace_trap_entry);
 605             break;
 606           case TRACE_TRAP_EXIT:
 607             event_size = 0;
 608             break;
 609           case TRACE_IRQ_ENTRY:
 610             event_size = sizeof(trace_irq_entry);
 611             timeDelta = time_delta;
 612             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 613             write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 614             write_to_buffer(write_pos_intr,cur_pos, event_size);
 615             break;
 616           case TRACE_IRQ_EXIT:
 617             event_size = 0;
 618             timeDelta = time_delta;
 619             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 620             write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 621             break;
 622           case TRACE_SCHEDCHANGE:
 623             event_size = sizeof(trace_schedchange);
 624             break;
 625           case TRACE_KERNEL_TIMER:
 626             event_size = 0;
 627             break;
 628           case TRACE_SOFT_IRQ:
 629             event_size = sizeof(trace_soft_irq);
 630             //    timeDelta = time_delta;
 631             //    write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 632             //    write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
 633             //    write_to_buffer(write_pos_intr,cur_pos, event_size);
 634             break;
 635           case TRACE_PROCESS:
 636             event_size = sizeof(trace_process);
 637             timeDelta = time_delta;
 638             subId = *(uint8_t*)cur_pos;
 639             if(subId == TRACE_PROCESS_FORK || subId ==TRACE_PROCESS_EXIT){
 640               if( subId == TRACE_PROCESS_FORK)tmpId = PROCESS_FORK_ID;
 641               else tmpId = PROCESS_EXIT_ID;
 642               write_to_buffer(write_pos_proc,(void*)&tmpId, sizeof(uint16_t));
 643               write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint32_t));
 644
 645               process = *(new_process*)(cur_pos + sizeof(uint8_t));
 646               write_to_buffer(write_pos_proc,(void*)&process, sizeof(new_process));
 647             }
 648             break;
 649           case TRACE_FILE_SYSTEM:
 650             event_size = sizeof(trace_file_system)- sizeof(char*);
 651             break;
 652           case TRACE_TIMER:
 653             event_size = sizeof(trace_timer);
 654             break;
 655           case TRACE_MEMORY:
 656             event_size = sizeof(trace_memory);
 657             break;
 658           case TRACE_SOCKET:
 659             event_size = sizeof(trace_socket);
 660             break;
 661           case TRACE_IPC:
 662             event_size = sizeof(trace_ipc);
 663             break;
 664           case TRACE_NETWORK:
 665             event_size = sizeof(trace_network);
 666             break;
 667           case TRACE_HEARTBEAT:
 668             beat.seconds = 0;
 669             beat.nanoseconds = 0;
 670             beat.cycle_count = adaptation_tsc;
 671             event_size = 0;
 672
 673             write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 674             write_to_buffer(write_pos_intr,(void*)&time_delta, sizeof(uint32_t));
 675             write_to_buffer(write_pos_intr,(void*)&beat, sizeof(heartbeat));
 676             write_to_buffer(write_pos_proc,(void*)&newId, sizeof(uint16_t));
 677             write_to_buffer(write_pos_proc,(void*)&time_delta, sizeof(uint32_t));
 678             write_to_buffer(write_pos_proc,(void*)&beat, sizeof(heartbeat));
 679             break;
 680           default:
 681             event_size = -1;
 682             break;
 683         }
 684         if(evId != TRACE_FILE_SYSTEM && event_size >=0){
 685           write_to_buffer(write_pos, cur_pos, event_size);
 686
 687           if(evId == TRACE_HEARTBEAT){
 688             write_to_buffer(write_pos, (void*)&beat, sizeof(heartbeat));
 689           }
 690
 691           cur_pos += event_size + sizeof(uint16_t); //skip data_size
 692         }else if(evId == TRACE_FILE_SYSTEM){
 693           size_t nbBytes;
 694           char  c = '\0';
 695           tFileSys = (trace_file_system*)cur_pos;
 696           subId = tFileSys->event_sub_id;
 697           if(subId == TRACE_FILE_SYSTEM_OPEN || subId == TRACE_FILE_SYSTEM_EXEC){
 698             nbBytes = tFileSys->event_data2 +1;
 699           }else nbBytes = 0;
 700
 701           write_to_buffer(write_pos, cur_pos, event_size);
 702           cur_pos += event_size + sizeof(char*);
 703           if(nbBytes){
 704             write_to_buffer(write_pos, cur_pos, nbBytes);
 705           }else{
 706             write_to_buffer(write_pos, (void*)&c, 1);
 707           }
 708           cur_pos += nbBytes + sizeof(uint16_t); //skip data_size
 709         }else if(event_size == -1){
 710           printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId, i, event_count);
 711           exit(1);
 712         }
 713       } //end while(1)
 714     }
 715     close(fd);
 716     close(fdCpu);
 717     g_free(buffer);
 718     buffer = NULL;
 719     g_free(buf_fac);
 720     g_free(buf_intr);
 721     g_free(buf_proc);
 722     g_free(buf_out);
 723   }
 724
 725
 726
 727
 728
 729   //write to system.xml
 730   fprintf(fp,"<system \n");
 731   fprintf(fp,"node_name=\"%s\" \n", node_name);
 732   fprintf(fp,"domainname=\"%s\" \n", domainname);
 733   fprintf(fp,"cpu=\"%d\" \n", cpu);
 734   fprintf(fp,"arch_size=\"%s\" \n", arch_size);
 735   fprintf(fp,"endian=\"%s\" \n",endian);
 736   fprintf(fp,"kernel_name=\"%s\" \n",kernel_name);
 737   fprintf(fp,"kernel_release=\"%s\" \n",kernel_release);
 738   fprintf(fp,"kernel_version=\"%s\" \n",kernel_version);
 739   fprintf(fp,"machine=\"%s\" \n",machine);
 740   fprintf(fp,"processor=\"%s\" \n",processor);
 741   fprintf(fp,"hardware_platform=\"%s\" \n",hardware_platform);
 742   fprintf(fp,"operating_system=\"%s\" \n",operating_system);
 743   fprintf(fp,"ltt_major_version=\"%d\" \n",ltt_major_version);
 744   fprintf(fp,"ltt_minor_version=\"%d\" \n",ltt_minor_version);
 745   fprintf(fp,"ltt_block_size=\"%d\" \n",ltt_block_size);
 746   fprintf(fp,">\n");
 747   fprintf(fp,"This is just a test\n");
 748   fprintf(fp,"</system>\n");
 749   fflush(fp);
 750
 751   close(fdFac);
 752   close(fdIntr);
 753   close(fdProc);
 754   fclose(fp);
 755
 756   g_printf("Conversion completed. Don't forget to copy core.xml to eventdefs directory\n");
 757
 758   return 0;
 759 }
 760