ltt/branches/yangxx/convert/convert.c

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