[lttv.git] / ltt / branches / yangxx / convert / convert.c

#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <linux/errno.h>  

#include <glib.h>
#include "LTTTypes.h"
#include "LinuxEvents.h"

#define write_to_buffer(DEST, SRC, SIZE) \
do\
{\
   memcpy(DEST, SRC, SIZE);\
   DEST += SIZE;\
} while(0);

int readFile(int fd, void * buf, size_t size, char * mesg)
{
   ssize_t nbBytes;
   nbBytes = read(fd, buf, size);
   if(nbBytes != size){
     printf("%s\n",mesg);
     exit(1);
   }
   return 0;
}

void getDataEndianType(char * size, char * endian)
{
  int i = 1;
  char c = (char) i;
  int sizeInt=sizeof(int), sizeLong=sizeof(long), sizePointer=sizeof(void *);

  if(c == 1) strcpy(endian,"LITTLE_ENDIAN");
  else strcpy(endian, "BIG_ENDIAN");

  if(sizeInt == 2 && sizeLong == 4 && sizePointer == 4) 
    strcpy(size,"LP32");
  else if(sizeInt == 4 && sizeLong == 4 && sizePointer == 4) 
    strcpy(size,"ILP32");
  else if(sizeInt == 4 && sizeLong == 8 && sizePointer == 8) 
    strcpy(size,"LP64");
  else if(sizeInt == 8 && sizeLong == 8 && sizePointer == 8) 
    strcpy(size,"ILP64");
  else strcpy(size,"UNKNOWN");
}

#define BUFFER_SIZE 80

typedef struct _buffer_start{
  uint32_t seconds;
  uint32_t nanoseconds;
  uint64_t cycle_count;
  uint32_t block_id;  
} __attribute__ ((packed)) buffer_start;

typedef struct _heartbeat{
  uint32_t seconds;
  uint32_t nanoseconds;
  uint64_t cycle_count;
} __attribute__ ((packed)) heartbeat;


int main(int argc, char ** argv){

  int fd, *fdCpu;
  FILE * fp;
  int  fdFac, fdIntr, fdProc;
  char arch_size[BUFFER_SIZE];
  char endian[BUFFER_SIZE];
  char node_name[BUFFER_SIZE];
  char domainname[BUFFER_SIZE];
  char kernel_name[BUFFER_SIZE];
  char kernel_release[BUFFER_SIZE];
  char kernel_version[BUFFER_SIZE];
  char machine[BUFFER_SIZE];
  char processor[BUFFER_SIZE];
  char hardware_platform[BUFFER_SIZE];
  char operating_system[BUFFER_SIZE];
  int  cpu;
  int  ltt_block_size;
  int  ltt_major_version;
  int  ltt_minor_version;
  int  ltt_log_cpu;
  char buf[BUFFER_SIZE];
  int i,j;

  uint8_t cpu_id;
  struct stat      lTDFStat;   
  off_t file_size;                  
  int block_number, block_size;                 
  char * buffer, **buf_out, cpuStr[BUFFER_SIZE];
  char * buf_fac, * buf_intr, * buf_proc;
  void ** write_pos, *write_pos_fac, * write_pos_intr, *write_pos_proc;
  trace_start *tStart;
  trace_buffer_start *tBufStart;
  trace_buffer_end *tBufEnd;
  trace_file_system * tFileSys;
  uint16_t newId, startId;
  uint8_t  evId;
  uint32_t time_delta, startTimeDelta;
  void * cur_pos, *end_pos;
  buffer_start start;
  buffer_start end;
  heartbeat beat;
  int beat_count = 0;
  int *size_count;
  gboolean * has_event;
  uint32_t size_lost;
  int reserve_size = sizeof(buffer_start) + sizeof(uint16_t) + 2*sizeof(uint32_t);//lost_size and buffer_end event

  if(argc != 3){
    printf("need a trace file and cpu number\n");
    exit(1);
  }

  cpu = atoi(argv[2]);
  printf("cpu number = %d\n", cpu);


  getDataEndianType(arch_size, endian);
  printf("Arch_size: %s,  Endian: %s\n", arch_size, endian);

  fp = fopen("sysInfo.out","r");
  if(!fp){
    g_error("Unable to open file sysInfo.out\n");
  }

  for(i=0;i<9;i++){
    if(!fgets(buf,BUFFER_SIZE-1,fp))
      g_error("The format of sysInfo.out is not right\n");
    if(strncmp(buf,"node_name=",10)==0){
      strcpy(node_name,&buf[10]);
      node_name[strlen(node_name)-1] = '\0';
    }else if(strncmp(buf,"domainname=",11)==0){
      strcpy(domainname,&buf[11]);
      domainname[strlen(domainname)-1] = '\0';
    }else if(strncmp(buf,"kernel_name=",12)==0){
      strcpy(kernel_name,&buf[12]);
      kernel_name[strlen(kernel_name)-1] = '\0';
    }else if(strncmp(buf,"kernel_release=",15)==0){
      strcpy(kernel_release,&buf[15]);
      kernel_release[strlen(kernel_release)-1] = '\0';
    }else if(strncmp(buf,"kernel_version=",15)==0){
      strcpy(kernel_version,&buf[15]);
      kernel_version[strlen(kernel_version)-1] = '\0';
    }else if(strncmp(buf,"machine=",8)==0){
      strcpy(machine,&buf[8]);
      machine[strlen(machine)-1] = '\0';
    }else if(strncmp(buf,"processor=",10)==0){
      strcpy(processor,&buf[10]);
      processor[strlen(processor)-1] = '\0';
    }else if(strncmp(buf,"hardware_platform=",18)==0){
      strcpy(hardware_platform,&buf[18]);
      hardware_platform[strlen(hardware_platform)-1] = '\0';
    }else if(strncmp(buf,"operating_system=",17)==0){
      strcpy(operating_system,&buf[17]);
      operating_system[strlen(operating_system)-1] = '\0';
    }
  }
  fclose(fp);

  if(mkdir("foo", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo directory");
  if(mkdir("foo/info", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/info directory");
  if(mkdir("foo/cpu", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/cpu directory");
  if(mkdir("foo/control", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/control directory");
  if(mkdir("foo/eventdefs", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/eventdefs directory");
  
  fp = fopen("foo/info/system.xml","w");
  if(!fp){
    g_error("Unable to open file system.xml\n");
  }

  fd = open(argv[1], O_RDONLY, 0);
  if(fd < 0){
    g_error("Unable to open input data file %s\n", argv[1]);
  }

  fdFac = open("foo/control/facilities",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
  if(fdFac < 0){
    g_error("Unable to open file facilities\n");
  }
  fdIntr = open("foo/control/interrupts",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
  if(fdIntr<0){
    g_error("Unable to open file interrupts\n");
  }
  fdProc = open("foo/control/processes",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
  if(fdIntr<0){
    g_error("Unable to open file process\n");
  }


  if(fstat(fd, &lTDFStat) < 0){
    g_error("Unable to get the status of the input data file\n");
  }
  file_size = lTDFStat.st_size;

  buffer = g_new(char, 4000);
  readFile(fd,(void*)buffer, 3500, "Unable to read block header");

  cur_pos= buffer;
  evId = *(uint8_t *)cur_pos;
  cur_pos += sizeof(uint8_t);
  newId = evId;
  time_delta = *(uint32_t*)cur_pos;
  cur_pos += sizeof(uint32_t); 
  tBufStart = (trace_buffer_start*)cur_pos;
  cur_pos += sizeof(trace_buffer_start);
  cur_pos += sizeof(uint16_t); //Skip event size

  evId = *(uint8_t *)cur_pos;
  cur_pos += sizeof(uint8_t);
  cur_pos += sizeof(uint32_t); 
  tStart = (trace_start*)cur_pos;

  startId = newId;
  startTimeDelta = time_delta;
  start.seconds = tBufStart->Time.tv_sec;
  start.nanoseconds = tBufStart->Time.tv_usec;
  start.cycle_count = tBufStart->TSC;
  start.block_id = tBufStart->ID;
  end.block_id = start.block_id;

  ltt_major_version = tStart->MajorVersion;
  ltt_minor_version = tStart->MinorVersion;
  ltt_block_size    = tStart->BufferSize;
  ltt_log_cpu       = tStart->LogCPUID;

  block_size = ltt_block_size;
  block_number = file_size/block_size;

  g_free(buffer);
  buffer         = g_new(char, block_size);
  buf_fac        = g_new(char, block_size);
  write_pos_fac  = buf_fac;
  buf_intr       = g_new(char, block_size);
  write_pos_intr = buf_intr;
  buf_proc       = g_new(char, block_size);
  write_pos_proc = buf_proc;
  
  buf_out    = g_new(char*,cpu);
  write_pos  = g_new(void*, cpu);
  fdCpu      = g_new(int, cpu); 
  size_count = g_new(int, cpu);
  has_event  = g_new(gboolean, cpu);
  for(i=0;i<cpu;i++){
    has_event[i] = FALSE;
    if(i==0)has_event[i] = TRUE;
    buf_out[i] = g_new(char, block_size);
    write_pos[i] = NULL;;
    sprintf(cpuStr,"foo/cpu/%d\0",i);
    fdCpu[i] = open(cpuStr, O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH); //for cpu i
    if(fdCpu[i] < 0)  g_error("Unable to open  cpu file %d\n", i);    
  }
  lseek(fd,0,SEEK_SET);


  for(i=0;i<block_number;i++){
    int event_count = 0;
    beat_count = 0;

    for(j=1;j<cpu;j++)has_event[j] = FALSE;
    for(j=0;j<cpu;j++) write_pos[j] = buf_out[j];
    write_pos_intr = buf_intr;
    write_pos_fac = buf_fac;
    write_pos_proc = buf_proc;

    readFile(fd,(void*)buffer, block_size, "Unable to read block header");

    cur_pos= buffer;
    evId = *(uint8_t *)cur_pos;
    cur_pos += sizeof(uint8_t);
    newId = evId;
    time_delta = *(uint32_t*)cur_pos;
    cur_pos += sizeof(uint32_t); 
    tBufStart = (trace_buffer_start*)cur_pos;
    cur_pos += sizeof(trace_buffer_start);
    cur_pos += sizeof(uint16_t); //Skip event size

    startId = newId;
    startTimeDelta = time_delta;
    start.seconds = tBufStart->Time.tv_sec;
    start.nanoseconds = tBufStart->Time.tv_usec;
    start.cycle_count = tBufStart->TSC;
    start.block_id = tBufStart->ID;
    end.block_id = start.block_id;

    end_pos = buffer + block_size; //end of the buffer
    size_lost = *(uint32_t*)(end_pos - sizeof(uint32_t));

    end_pos = buffer + block_size - size_lost ; //buffer_end event
    tBufEnd = (trace_buffer_end*)(end_pos+sizeof(uint8_t)+sizeof(uint32_t));
    end.seconds = tBufEnd->Time.tv_sec;
    end.nanoseconds = tBufEnd->Time.tv_usec;
    end.cycle_count = tBufEnd->TSC;
    
    //skip buffer start and trace start events
    if(i==0) //the first block
      cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(trace_start) + 2*(sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t));
    else //other blocks
      cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t);

    for(j=0;j<cpu;j++)
      size_count[j] = sizeof(buffer_start) + sizeof(uint16_t) + sizeof(uint32_t);

    //for cpu 0, always make records
    write_to_buffer(write_pos[0],(void*)&startId, sizeof(uint16_t));    
    write_to_buffer(write_pos[0],(void*)&startTimeDelta, sizeof(uint32_t));
    write_to_buffer(write_pos[0],(void*)&start, sizeof(buffer_start));
    
    //write start block event into processes and interrupts files
    write_to_buffer(write_pos_intr,(void*)&startId, sizeof(uint16_t));    
    write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
    write_to_buffer(write_pos_intr,(void*)&start, sizeof(buffer_start));
    write_to_buffer(write_pos_proc,(void*)&startId, sizeof(uint16_t));    
    write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
    write_to_buffer(write_pos_proc,(void*)&start, sizeof(buffer_start));

    while(1){
      int event_size;
      uint64_t timeDelta;
      uint8_t  subId;

      if(ltt_log_cpu){
	cpu_id = *(uint8_t*)cur_pos;
	cur_pos += sizeof(uint8_t);
	if(cpu_id != 0 && has_event[cpu_id] == FALSE){
	  has_event[cpu_id] = TRUE;
	  write_to_buffer(write_pos[cpu_id],(void*)&startId,sizeof(uint16_t));
	  write_to_buffer(write_pos[cpu_id],(void*)&startTimeDelta, sizeof(uint32_t));
	  write_to_buffer(write_pos[cpu_id],(void*)&start, sizeof(buffer_start));	
	}
      }
      evId = *(uint8_t *)cur_pos;
      newId = evId;
      cur_pos += sizeof(uint8_t);
      time_delta = *(uint32_t*)cur_pos;
      cur_pos += sizeof(uint32_t); 

      if(ltt_log_cpu){
	write_to_buffer(write_pos[cpu_id],(void*)&newId,sizeof(uint16_t));
	write_to_buffer(write_pos[cpu_id],(void*)&time_delta, sizeof(uint32_t));     	
      }else{	
	write_to_buffer(write_pos[0],(void*)&newId,sizeof(uint16_t));
	write_to_buffer(write_pos[0],(void*)&time_delta, sizeof(uint32_t));     
      }
      
      if(evId == TRACE_BUFFER_END){
	if(ltt_log_cpu){
	  int size, i;
	  if(has_event[i])
	    write_to_buffer(write_pos[cpu_id],(void*)&end,sizeof(buffer_start));
	  for(i=0;i<cpu;i++){
	    if(has_event[i]){
	      size = block_size - size_count[i];
	      write_pos[i] = buf_out[i] + block_size - sizeof(uint32_t);
	      write_to_buffer(write_pos[i],(void*)&size, sizeof(uint32_t));
	      write(fdCpu[i],(void*)buf_out[i], block_size);	    
	    }
	  }
	}else {
	  int size = block_size - size_count[0];
	  write_to_buffer(write_pos[0],(void*)&end,sizeof(buffer_start));   
	  write_pos[0] = buf_out[0] + block_size - sizeof(uint32_t);
  	  write_to_buffer(write_pos[0],(void*)&size, sizeof(uint32_t));
	  write(fdCpu[0],(void*)buf_out[0], block_size);
	}

	//write out processes and intrrupts files
	{
	  int size_intr =(int) (write_pos_intr - (void*)buf_intr);
	  int size_proc =(int) (write_pos_proc - (void*)buf_proc);
	  write_to_buffer(write_pos_intr,(void*)&end,sizeof(buffer_start));   
	  write_to_buffer(write_pos_proc,(void*)&end,sizeof(buffer_start));   
	  write_pos_intr = buf_intr + block_size - sizeof(uint32_t);
	  write_pos_proc = buf_intr + block_size - sizeof(uint32_t);
  	  write_to_buffer(write_pos_intr,(void*)&size_intr, sizeof(uint32_t));
  	  write_to_buffer(write_pos_proc,(void*)&size_proc, sizeof(uint32_t));
	  write(fdIntr,(void*)buf_intr,block_size);	  
	  write(fdProc,(void*)buf_proc,block_size);	  
	}
	break;   
      }

      event_count++;
      switch(evId){
	case TRACE_SYSCALL_ENTRY:
	  event_size = sizeof(trace_syscall_entry);
	  break;
	case TRACE_SYSCALL_EXIT:
	  event_size = 0;
	  break;
	case TRACE_TRAP_ENTRY:
	  event_size = sizeof(trace_trap_entry);
	  break;
	case TRACE_TRAP_EXIT:
	  event_size = 0;
	  break;
	case TRACE_IRQ_ENTRY:
	  event_size = sizeof(trace_irq_entry);
	  timeDelta = time_delta;
	  write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t)); 
	  write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
	  write_to_buffer(write_pos_intr,cur_pos, event_size);
	  break;
	case TRACE_IRQ_EXIT:
	  event_size = 0;
	  timeDelta = time_delta;
	  write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
	  write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
	  break;
	case TRACE_SCHEDCHANGE:
	  event_size = sizeof(trace_schedchange);
	  break;
	case TRACE_KERNEL_TIMER:
	  event_size = 0;
	  break;
	case TRACE_SOFT_IRQ:
	  event_size = sizeof(trace_soft_irq);
	  timeDelta = time_delta;
	  write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
	  write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
	  write_to_buffer(write_pos_intr,cur_pos, event_size);
	  break;
	case TRACE_PROCESS:
	  event_size = sizeof(trace_process);
	  timeDelta = time_delta;
	  subId = *(uint8_t*)cur_pos;
	  if(subId == TRACE_PROCESS_FORK || subId ==TRACE_PROCESS_EXIT){
	    write_to_buffer(write_pos_proc,(void*)&newId, sizeof(uint16_t));
	    write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint64_t));
	    write_to_buffer(write_pos_proc,cur_pos, event_size);
	  } 
	  break;
	case TRACE_FILE_SYSTEM:
	  event_size = sizeof(trace_file_system)- sizeof(char*);
	  break;
	case TRACE_TIMER:
	  event_size = sizeof(trace_timer);
	  break;
	case TRACE_MEMORY:
	  event_size = sizeof(trace_memory);
	  break;
	case TRACE_SOCKET:
	  event_size = sizeof(trace_socket);
	  break;
	case TRACE_IPC:
	  event_size = sizeof(trace_ipc);
	  break;
	case TRACE_NETWORK:
	  event_size = sizeof(trace_network);
	  break;
	case TRACE_HEARTBEAT:
	  beat_count++;
	  beat.seconds = 0;
	  beat.nanoseconds = 0;
	  beat.cycle_count = start.cycle_count + beat_count * (0XFFFF+1);
	  event_size = 0;
	  break;
        default:
	  event_size = -1;
	  break;
      }
      if(evId != TRACE_FILE_SYSTEM && event_size >=0){
	if(ltt_log_cpu){
	  size_count[cpu_id] += sizeof(uint16_t) + sizeof(uint32_t) + event_size;
	  if(size_count[cpu_id] > block_size - reserve_size){
	    printf("size count exceeds the limit of the buffer\n");
	    exit(1);
	  }
	  write_to_buffer(write_pos[cpu_id], cur_pos, event_size); 
	}else{
	  size_count[0] += sizeof(uint16_t) + sizeof(uint32_t) + event_size;
	  if(size_count[0] > block_size - reserve_size){
	    printf("size count exceeds the limit of the buffer\n");
	    exit(1);
	  }
	  write_to_buffer(write_pos[0], cur_pos, event_size); 
	}
	
	if(evId == TRACE_HEARTBEAT){
	  if(ltt_log_cpu){
	    size_count[cpu_id] += sizeof(heartbeat);
	    write_to_buffer(write_pos[cpu_id],(void*)&beat , sizeof(heartbeat)); 	 
	  }else{
	    size_count[0] +=  sizeof(heartbeat);
	    write_to_buffer(write_pos[0], (void*)&beat, sizeof(heartbeat)); 	    	  
	  }
	}

	cur_pos += event_size + sizeof(uint16_t); //skip data_size
      }else if(evId == TRACE_FILE_SYSTEM){
	size_t nbBytes;
	char  c = '\0';
	tFileSys = (trace_file_system*)cur_pos;
	subId = tFileSys->event_sub_id;	
	if(subId == TRACE_FILE_SYSTEM_OPEN || subId == TRACE_FILE_SYSTEM_EXEC){
	  nbBytes = tFileSys->event_data2 +1;
	}else nbBytes = 0;

	if(ltt_log_cpu){
	  size_count[cpu_id] += nbBytes + sizeof(uint16_t) + sizeof(uint32_t)+ event_size;
	  if(size_count[cpu_id] > block_size - reserve_size){
	    printf("size count exceeds the limit of the buffer\n");
	    exit(1);
	  }
	  write_to_buffer(write_pos[cpu_id], cur_pos, event_size); 	
	  cur_pos += event_size + sizeof(char*);
	  if(nbBytes){
	    write_to_buffer(write_pos[cpu_id], cur_pos, nbBytes); 	
	  }else{
	    write_to_buffer(write_pos[cpu_id], (void*)&c, 1);
	  }
	}else{
	  size_count[0] += nbBytes + sizeof(uint16_t) + sizeof(uint32_t)+event_size;
	  if(size_count[0] > block_size - reserve_size){
	    printf("size count exceeds the limit of the buffer\n");
	    exit(1);
	  }
	  write_to_buffer(write_pos[0], cur_pos, event_size);
	  cur_pos += event_size + sizeof(char*);
	  if(nbBytes){
	    write_to_buffer(write_pos[0], cur_pos, nbBytes); 	
	  }else{
	    write_to_buffer(write_pos[0], (void*)&c, 1);
	  }
	}
	cur_pos += nbBytes + sizeof(uint16_t); //skip data_size
      }else if(event_size == -1){
	printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId, i, event_count);
	exit(1);
      }
    } //end while(1)
 
  }

  
  //write to system.xml
  fprintf(fp,"<system\n");
  fprintf(fp,"node_name=\"%s\"\n", node_name);
  fprintf(fp,"domainname=\"%s\"\n", domainname);
  fprintf(fp,"cpu=%d\n", cpu);
  fprintf(fp,"arch_size=\"%s\"\n", arch_size);
  fprintf(fp,"endian=\"%s\"\n",endian);
  fprintf(fp,"kernel_name=\"%s\"\n",kernel_name);
  fprintf(fp,"kernel_release=\"%s\"\n",kernel_release);
  fprintf(fp,"kernel_version=\"%s\"\n",kernel_version);
  fprintf(fp,"machine=\"%s\"\n",machine);
  fprintf(fp,"processor=\"%s\"\n",processor);
  fprintf(fp,"hardware_platform=\"%s\"\n",hardware_platform);
  fprintf(fp,"operating_system=\"%s\"\n",operating_system);
  fprintf(fp,"ltt_major_version=%d\n",ltt_major_version);
  fprintf(fp,"ltt_minor_version=%d\n",ltt_minor_version);
  fprintf(fp,"ltt_block_size=%d\n",ltt_block_size);
  fprintf(fp,">\n");
  fprintf(fp,"This is just a test\n");
  fprintf(fp,"</system>\n");
  fflush(fp);

  fclose(fp);

  close(fdFac);
  close(fdIntr);
  close(fdProc); 
  close(fd);
  for(i=0;i<cpu;i++) close(fdCpu[i]);

}
Commit	Line	Data
821bc1e4	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];
cb4cdc19	94	char * buf_fac, * buf_intr, * buf_proc;
cb4cdc19	95	void ** write_pos, write_pos_fac, write_pos_intr, *write_pos_proc;
821bc1e4	96	trace_start *tStart;
	97	trace_buffer_start *tBufStart;
	98	trace_buffer_end *tBufEnd;
	99	trace_file_system * tFileSys;
5f126063	100	uint16_t newId, startId;
5f126063	101	uint8_t evId;
821bc1e4	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
fc032b6b	203	cur_pos= buffer;
821bc1e4	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);
821bc1e4	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);
cb4cdc19	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
821bc1e4	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
5f126063	264	for(j=1;j<cpu;j++)has_event[j] = FALSE;
821bc1e4	265	for(j=0;j<cpu;j++) write_pos[j] = buf_out[j];
5c11f653	266	write_pos_intr = buf_intr;
	267	write_pos_fac = buf_fac;
	268	write_pos_proc = buf_proc;
821bc1e4	269
	270	readFile(fd,(void*)buffer, block_size, "Unable to read block header");
	271
5f126063	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
821bc1e4	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
90665986	294	tBufEnd = (trace_buffer_end*)(end_pos+sizeof(uint8_t)+sizeof(uint32_t));
821bc1e4	295	end.seconds = tBufEnd->Time.tv_sec;
	296	end.nanoseconds = tBufEnd->Time.tv_usec;
	297	end.cycle_count = tBufEnd->TSC;
	298
	299	//skip buffer start and trace start events
	300	if(i==0) //the first block
	301	cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(trace_start) + 2*(sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t));
	302	else //other blocks
	303	cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t);
	304
	305	for(j=0;j<cpu;j++)
	306	size_count[j] = sizeof(buffer_start) + sizeof(uint16_t) + sizeof(uint32_t);
	307
	308	//for cpu 0, always make records
	309	write_to_buffer(write_pos[0],(void*)&startId, sizeof(uint16_t));
	310	write_to_buffer(write_pos[0],(void*)&startTimeDelta, sizeof(uint32_t));
	311	write_to_buffer(write_pos[0],(void*)&start, sizeof(buffer_start));
cb4cdc19	312
	313	//write start block event into processes and interrupts files
	314	write_to_buffer(write_pos_intr,(void*)&startId, sizeof(uint16_t));
	315	write_to_buffer(write_pos_intr,(void*)&startTimeDelta, sizeof(uint32_t));
	316	write_to_buffer(write_pos_intr,(void*)&start, sizeof(buffer_start));
	317	write_to_buffer(write_pos_proc,(void*)&startId, sizeof(uint16_t));
	318	write_to_buffer(write_pos_proc,(void*)&startTimeDelta, sizeof(uint32_t));
	319	write_to_buffer(write_pos_proc,(void*)&start, sizeof(buffer_start));
821bc1e4	320
	321	while(1){
	322	int event_size;
	323	uint64_t timeDelta;
	324	uint8_t subId;
	325
	326	if(ltt_log_cpu){
	327	cpu_id = (uint8_t)cur_pos;
	328	cur_pos += sizeof(uint8_t);
	329	if(cpu_id != 0 && has_event[cpu_id] == FALSE){
	330	has_event[cpu_id] = TRUE;
	331	write_to_buffer(write_pos[cpu_id],(void*)&startId,sizeof(uint16_t));
	332	write_to_buffer(write_pos[cpu_id],(void*)&startTimeDelta, sizeof(uint32_t));
	333	write_to_buffer(write_pos[cpu_id],(void*)&start, sizeof(buffer_start));
	334	}
	335	}
	336	evId = (uint8_t )cur_pos;
	337	newId = evId;
	338	cur_pos += sizeof(uint8_t);
	339	time_delta = (uint32_t)cur_pos;
	340	cur_pos += sizeof(uint32_t);
	341
	342	if(ltt_log_cpu){
	343	write_to_buffer(write_pos[cpu_id],(void*)&newId,sizeof(uint16_t));
	344	write_to_buffer(write_pos[cpu_id],(void*)&time_delta, sizeof(uint32_t));
	345	}else{
	346	write_to_buffer(write_pos[0],(void*)&newId,sizeof(uint16_t));
	347	write_to_buffer(write_pos[0],(void*)&time_delta, sizeof(uint32_t));
	348	}
	349
	350	if(evId == TRACE_BUFFER_END){
	351	if(ltt_log_cpu){
	352	int size, i;
	353	if(has_event[i])
	354	write_to_buffer(write_pos[cpu_id],(void*)&end,sizeof(buffer_start));
	355	for(i=0;i<cpu;i++){
	356	if(has_event[i]){
	357	size = block_size - size_count[i];
	358	write_pos[i] = buf_out[i] + block_size - sizeof(uint32_t);
	359	write_to_buffer(write_pos[i],(void*)&size, sizeof(uint32_t));
	360	write(fdCpu[i],(void*)buf_out[i], block_size);
	361	}
	362	}
	363	}else {
	364	int size = block_size - size_count[0];
	365	write_to_buffer(write_pos[0],(void*)&end,sizeof(buffer_start));
	366	write_pos[0] = buf_out[0] + block_size - sizeof(uint32_t);
	367	write_to_buffer(write_pos[0],(void*)&size, sizeof(uint32_t));
	368	write(fdCpu[0],(void*)buf_out[0], block_size);
cb4cdc19	369	}
	370
	371	//write out processes and intrrupts files
	372	{
	373	int size_intr =(int) (write_pos_intr - (void*)buf_intr);
	374	int size_proc =(int) (write_pos_proc - (void*)buf_proc);
	375	write_to_buffer(write_pos_intr,(void*)&end,sizeof(buffer_start));
	376	write_to_buffer(write_pos_proc,(void*)&end,sizeof(buffer_start));
	377	write_pos_intr = buf_intr + block_size - sizeof(uint32_t);
	378	write_pos_proc = buf_intr + block_size - sizeof(uint32_t);
	379	write_to_buffer(write_pos_intr,(void*)&size_intr, sizeof(uint32_t));
	380	write_to_buffer(write_pos_proc,(void*)&size_proc, sizeof(uint32_t));
	381	write(fdIntr,(void*)buf_intr,block_size);
	382	write(fdProc,(void*)buf_proc,block_size);
	383	}
821bc1e4	384	break;
	385	}
	386
	387	event_count++;
	388	switch(evId){
	389	case TRACE_SYSCALL_ENTRY:
	390	event_size = sizeof(trace_syscall_entry);
	391	break;
	392	case TRACE_SYSCALL_EXIT:
	393	event_size = 0;
	394	break;
	395	case TRACE_TRAP_ENTRY:
	396	event_size = sizeof(trace_trap_entry);
	397	break;
	398	case TRACE_TRAP_EXIT:
	399	event_size = 0;
	400	break;
	401	case TRACE_IRQ_ENTRY:
	402	event_size = sizeof(trace_irq_entry);
	403	timeDelta = time_delta;
cb4cdc19	404	write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
	405	write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
	406	write_to_buffer(write_pos_intr,cur_pos, event_size);
821bc1e4	407	break;
	408	case TRACE_IRQ_EXIT:
	409	event_size = 0;
	410	timeDelta = time_delta;
cb4cdc19	411	write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
cb4cdc19	412	write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
821bc1e4	413	break;
	414	case TRACE_SCHEDCHANGE:
	415	event_size = sizeof(trace_schedchange);
	416	break;
	417	case TRACE_KERNEL_TIMER:
	418	event_size = 0;
	419	break;
	420	case TRACE_SOFT_IRQ:
	421	event_size = sizeof(trace_soft_irq);
	422	timeDelta = time_delta;
cb4cdc19	423	write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
	424	write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
	425	write_to_buffer(write_pos_intr,cur_pos, event_size);
821bc1e4	426	break;
	427	case TRACE_PROCESS:
	428	event_size = sizeof(trace_process);
	429	timeDelta = time_delta;
	430	subId = (uint8_t)cur_pos;
	431	if(subId == TRACE_PROCESS_FORK \|\| subId ==TRACE_PROCESS_EXIT){
cb4cdc19	432	write_to_buffer(write_pos_proc,(void*)&newId, sizeof(uint16_t));
	433	write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint64_t));
	434	write_to_buffer(write_pos_proc,cur_pos, event_size);
821bc1e4	435	}
	436	break;
	437	case TRACE_FILE_SYSTEM:
fc032b6b	438	event_size = sizeof(trace_file_system)- sizeof(char*);
821bc1e4	439	break;
	440	case TRACE_TIMER:
	441	event_size = sizeof(trace_timer);
	442	break;
	443	case TRACE_MEMORY:
	444	event_size = sizeof(trace_memory);
	445	break;
	446	case TRACE_SOCKET:
	447	event_size = sizeof(trace_socket);
	448	break;
	449	case TRACE_IPC:
	450	event_size = sizeof(trace_ipc);
	451	break;
	452	case TRACE_NETWORK:
	453	event_size = sizeof(trace_network);
	454	break;
	455	case TRACE_HEARTBEAT:
	456	beat_count++;
	457	beat.seconds = 0;
	458	beat.nanoseconds = 0;
	459	beat.cycle_count = start.cycle_count + beat_count * (0XFFFF+1);
	460	event_size = 0;
	461	break;
	462	default:
	463	event_size = -1;
	464	break;
	465	}
	466	if(evId != TRACE_FILE_SYSTEM && event_size >=0){
	467	if(ltt_log_cpu){
	468	size_count[cpu_id] += sizeof(uint16_t) + sizeof(uint32_t) + event_size;
	469	if(size_count[cpu_id] > block_size - reserve_size){
	470	printf("size count exceeds the limit of the buffer\n");
	471	exit(1);
	472	}
	473	write_to_buffer(write_pos[cpu_id], cur_pos, event_size);
	474	}else{
	475	size_count[0] += sizeof(uint16_t) + sizeof(uint32_t) + event_size;
	476	if(size_count[0] > block_size - reserve_size){
	477	printf("size count exceeds the limit of the buffer\n");
	478	exit(1);
	479	}
	480	write_to_buffer(write_pos[0], cur_pos, event_size);
	481	}
	482
	483	if(evId == TRACE_HEARTBEAT){
	484	if(ltt_log_cpu){
fc032b6b	485	size_count[cpu_id] += sizeof(heartbeat);
112cb545	486	write_to_buffer(write_pos[cpu_id],(void*)&beat , sizeof(heartbeat));
821bc1e4	487	}else{
fc032b6b	488	size_count[0] += sizeof(heartbeat);
112cb545	489	write_to_buffer(write_pos[0], (void*)&beat, sizeof(heartbeat));
821bc1e4	490	}
	491	}
	492
	493	cur_pos += event_size + sizeof(uint16_t); //skip data_size
	494	}else if(evId == TRACE_FILE_SYSTEM){
	495	size_t nbBytes;
fc032b6b	496	char c = '\0';
821bc1e4	497	tFileSys = (trace_file_system*)cur_pos;
	498	subId = tFileSys->event_sub_id;
	499	if(subId == TRACE_FILE_SYSTEM_OPEN \|\| subId == TRACE_FILE_SYSTEM_EXEC){
	500	nbBytes = tFileSys->event_data2 +1;
	501	}else nbBytes = 0;
821bc1e4	502
821bc1e4	503	if(ltt_log_cpu){
11452dc4	504	size_count[cpu_id] += nbBytes + sizeof(uint16_t) + sizeof(uint32_t)+ event_size;
821bc1e4	505	if(size_count[cpu_id] > block_size - reserve_size){
	506	printf("size count exceeds the limit of the buffer\n");
	507	exit(1);
	508	}
fc032b6b	509	write_to_buffer(write_pos[cpu_id], cur_pos, event_size);
	510	cur_pos += event_size + sizeof(char*);
	511	if(nbBytes){
	512	write_to_buffer(write_pos[cpu_id], cur_pos, nbBytes);
	513	}else{
	514	write_to_buffer(write_pos[cpu_id], (void*)&c, 1);
	515	}
821bc1e4	516	}else{
11452dc4	517	size_count[0] += nbBytes + sizeof(uint16_t) + sizeof(uint32_t)+event_size;
821bc1e4	518	if(size_count[0] > block_size - reserve_size){
	519	printf("size count exceeds the limit of the buffer\n");
	520	exit(1);
	521	}
fc032b6b	522	write_to_buffer(write_pos[0], cur_pos, event_size);
	523	cur_pos += event_size + sizeof(char*);
	524	if(nbBytes){
	525	write_to_buffer(write_pos[0], cur_pos, nbBytes);
	526	}else{
	527	write_to_buffer(write_pos[0], (void*)&c, 1);
	528	}
821bc1e4	529	}
	530	cur_pos += nbBytes + sizeof(uint16_t); //skip data_size
	531	}else if(event_size == -1){
	532	printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId, i, event_count);
	533	exit(1);
	534	}
	535	} //end while(1)
	536
	537	}
	538
	539
	540
	541
	542
	543	//write to system.xml
	544	fprintf(fp,"<system\n");
	545	fprintf(fp,"node_name=\"%s\"\n", node_name);
	546	fprintf(fp,"domainname=\"%s\"\n", domainname);
	547	fprintf(fp,"cpu=%d\n", cpu);
	548	fprintf(fp,"arch_size=\"%s\"\n", arch_size);
	549	fprintf(fp,"endian=\"%s\"\n",endian);
	550	fprintf(fp,"kernel_name=\"%s\"\n",kernel_name);
	551	fprintf(fp,"kernel_release=\"%s\"\n",kernel_release);
	552	fprintf(fp,"kernel_version=\"%s\"\n",kernel_version);
	553	fprintf(fp,"machine=\"%s\"\n",machine);
	554	fprintf(fp,"processor=\"%s\"\n",processor);
	555	fprintf(fp,"hardware_platform=\"%s\"\n",hardware_platform);
	556	fprintf(fp,"operating_system=\"%s\"\n",operating_system);
	557	fprintf(fp,"ltt_major_version=%d\n",ltt_major_version);
	558	fprintf(fp,"ltt_minor_version=%d\n",ltt_minor_version);
	559	fprintf(fp,"ltt_block_size=%d\n",ltt_block_size);
	560	fprintf(fp,">\n");
	561	fprintf(fp,"This is just a test\n");
	562	fprintf(fp,"</system>\n");
	563	fflush(fp);
	564
	565	fclose(fp);
	566
	567	close(fdFac);
	568	close(fdIntr);
	569	close(fdProc);
	570	close(fd);
	571	for(i=0;i<cpu;i++) close(fdCpu[i]);
	572
	573	}
	574