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   gboolean * has_event;
 109   uint32_t size_lost;
 110   int reserve_size = sizeof(buffer_start) + sizeof(uint16_t) + 2*sizeof(uint32_t);//lost_size and buffer_end event
 111
 112   if(argc != 3){
 113     printf("need a trace file and cpu number\n");
 114     exit(1);
 115   }
 116
 117   cpu = atoi(argv[2]);
 118   printf("cpu number = %d\n", cpu);
 119
 120
 121   getDataEndianType(arch_size, endian);
 122   printf("Arch_size: %s,  Endian: %s\n", arch_size, endian);
 123
 124   fp = fopen("sysInfo.out","r");
 125   if(!fp){
 126     g_error("Unable to open file sysInfo.out\n");
 127   }
 128
 129   for(i=0;i<9;i++){
 130     if(!fgets(buf,BUFFER_SIZE-1,fp))
 131       g_error("The format of sysInfo.out is not right\n");
 132     if(strncmp(buf,"node_name=",10)==0){
 133       strcpy(node_name,&buf[10]);
 134       node_name[strlen(node_name)-1] = '\0';
 135     }else if(strncmp(buf,"domainname=",11)==0){
 136       strcpy(domainname,&buf[11]);
 137       domainname[strlen(domainname)-1] = '\0';
 138     }else if(strncmp(buf,"kernel_name=",12)==0){
 139       strcpy(kernel_name,&buf[12]);
 140       kernel_name[strlen(kernel_name)-1] = '\0';
 141     }else if(strncmp(buf,"kernel_release=",15)==0){
 142       strcpy(kernel_release,&buf[15]);
 143       kernel_release[strlen(kernel_release)-1] = '\0';
 144     }else if(strncmp(buf,"kernel_version=",15)==0){
 145       strcpy(kernel_version,&buf[15]);
 146       kernel_version[strlen(kernel_version)-1] = '\0';
 147     }else if(strncmp(buf,"machine=",8)==0){
 148       strcpy(machine,&buf[8]);
 149       machine[strlen(machine)-1] = '\0';
 150     }else if(strncmp(buf,"processor=",10)==0){
 151       strcpy(processor,&buf[10]);
 152       processor[strlen(processor)-1] = '\0';
 153     }else if(strncmp(buf,"hardware_platform=",18)==0){
 154       strcpy(hardware_platform,&buf[18]);
 155       hardware_platform[strlen(hardware_platform)-1] = '\0';
 156     }else if(strncmp(buf,"operating_system=",17)==0){
 157       strcpy(operating_system,&buf[17]);
 158       operating_system[strlen(operating_system)-1] = '\0';
 159     }
 160   }
 161   fclose(fp);
 162
 163   if(mkdir("foo", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo directory");
 164   if(mkdir("foo/info", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/info directory");
 165   if(mkdir("foo/cpu", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/cpu directory");
 166   if(mkdir("foo/control", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/control directory");
 167   if(mkdir("foo/eventdefs", S_IFDIR | S_IRWXU | S_IRGRP |  S_IROTH)) g_error("can not make foo/eventdefs directory");
 168
 169   fp = fopen("foo/info/system.xml","w");
 170   if(!fp){
 171     g_error("Unable to open file system.xml\n");
 172   }
 173
 174   fd = open(argv[1], O_RDONLY, 0);
 175   if(fd < 0){
 176     g_error("Unable to open input data file %s\n", argv[1]);
 177   }
 178
 179   fdFac = open("foo/control/facilities",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 180   if(fdFac < 0){
 181     g_error("Unable to open file facilities\n");
 182   }
 183   fdIntr = open("foo/control/interrupts",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 184   if(fdIntr<0){
 185     g_error("Unable to open file interrupts\n");
 186   }
 187   fdProc = open("foo/control/processes",O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH);
 188   if(fdIntr<0){
 189     g_error("Unable to open file process\n");
 190   }
 191
 192
 193
 194   if(fstat(fd, &lTDFStat) < 0){
 195     g_error("Unable to get the status of the input data file\n");
 196   }
 197   file_size = lTDFStat.st_size;
 198
 199   buffer = g_new(char, 4000);
 200   readFile(fd,(void*)buffer, 3500, "Unable to read block header");
 201
 202   cur_pos= buffer;
 203   evId = *(uint8_t *)cur_pos;
 204   cur_pos += sizeof(uint8_t);
 205   newId = evId;
 206   time_delta = *(uint32_t*)cur_pos;
 207   cur_pos += sizeof(uint32_t);
 208   tBufStart = (trace_buffer_start*)cur_pos;
 209   cur_pos += sizeof(trace_buffer_start);
 210   cur_pos += sizeof(uint16_t); //Skip event size
 211
 212   evId = *(uint8_t *)cur_pos;
 213   cur_pos += sizeof(uint8_t);
 214   cur_pos += sizeof(uint32_t);
 215   tStart = (trace_start*)cur_pos;
 216
 217   startId = newId;
 218   startTimeDelta = time_delta;
 219   start.seconds = tBufStart->Time.tv_sec;
 220   start.nanoseconds = tBufStart->Time.tv_usec;
 221   start.cycle_count = tBufStart->TSC;
 222   start.block_id = tBufStart->ID;
 223   end.block_id = start.block_id;
 224
 225   ltt_major_version = tStart->MajorVersion;
 226   ltt_minor_version = tStart->MinorVersion;
 227   ltt_block_size    = tStart->BufferSize;
 228   ltt_log_cpu       = tStart->LogCPUID;
 229
 230   block_size = ltt_block_size;
 231   block_number = file_size/block_size;
 232
 233   g_free(buffer);
 234   buffer         = g_new(char, block_size);
 235   buf_fac        = g_new(char, block_size);
 236   write_pos_fac  = buf_fac;
 237   buf_intr       = g_new(char, block_size);
 238   write_pos_intr = buf_intr;
 239   buf_proc       = g_new(char, block_size);
 240   write_pos_proc = buf_proc;
 241
 242   buf_out    = g_new(char*,cpu);
 243   write_pos  = g_new(void*, cpu);
 244   fdCpu      = g_new(int, cpu);
 245   has_event  = g_new(gboolean, cpu);
 246   for(i=0;i<cpu;i++){
 247     has_event[i] = FALSE;
 248     if(i==0)has_event[i] = TRUE;
 249     buf_out[i] = g_new(char, block_size);
 250     write_pos[i] = NULL;;
 251     sprintf(cpuStr,"foo/cpu/%d\0",i);
 252     fdCpu[i] = open(cpuStr, O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH); //for cpu i
 253     if(fdCpu[i] < 0)  g_error("Unable to open  cpu file %d\n", i);
 254   }
 255   lseek(fd,0,SEEK_SET);
 256
 257
 258   for(i=0;i<block_number;i++){
 259     int event_count = 0;
 260     beat_count = 0;
 261
 262     for(j=1;j<cpu;j++)has_event[j] = FALSE;
 263     for(j=0;j<cpu;j++) write_pos[j] = buf_out[j];
 264     write_pos_intr = buf_intr;
 265     write_pos_fac = buf_fac;
 266     write_pos_proc = buf_proc;
 267
 268     memset((void*)buffer,0,block_size);
 269     readFile(fd,(void*)buffer, block_size, "Unable to read block header");
 270
 271     cur_pos= buffer;
 272     evId = *(uint8_t *)cur_pos;
 273     cur_pos += sizeof(uint8_t);
 274     newId = evId;
 275     time_delta = *(uint32_t*)cur_pos;
 276     cur_pos += sizeof(uint32_t);
 277     tBufStart = (trace_buffer_start*)cur_pos;
 278     cur_pos += sizeof(trace_buffer_start);
 279     cur_pos += sizeof(uint16_t); //Skip event size
 280
 281     startId = newId;
 282     startTimeDelta = time_delta;
 283     start.seconds = tBufStart->Time.tv_sec;
 284     start.nanoseconds = tBufStart->Time.tv_usec;
 285     start.cycle_count = tBufStart->TSC;
 286     start.block_id = tBufStart->ID;
 287     end.block_id = start.block_id;
 288
 289     end_pos = buffer + block_size; //end of the buffer
 290     size_lost = *(uint32_t*)(end_pos - sizeof(uint32_t));
 291
 292     end_pos = buffer + block_size - size_lost ; //buffer_end event
 293     if(ltt_log_cpu){
 294       tBufEnd = (trace_buffer_end*)(end_pos + 2 * sizeof(uint8_t)+sizeof(uint32_t));
 295     }else{
 296       tBufEnd = (trace_buffer_end*)(end_pos+sizeof(uint8_t)+sizeof(uint32_t));
 297     }
 298     end.seconds = tBufEnd->Time.tv_sec;
 299     end.nanoseconds = tBufEnd->Time.tv_usec;
 300     end.cycle_count = tBufEnd->TSC;
 301
 302     //skip buffer start and trace start events
 303     if(i==0) //the first block
 304       cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(trace_start) + 2*(sizeof(uint8_t)+sizeof(uint16_t)+sizeof(uint32_t));
 305     else //other blocks
 306       cur_pos = buffer + sizeof(trace_buffer_start) + sizeof(uint8_t)+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));
 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));
 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 + ((void*)buf_out[i] - write_pos[i])+ sizeof(uint16_t) + sizeof(uint32_t);
 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 + ((void*)buf_out[0] - write_pos[0])+ sizeof(uint16_t) + sizeof(uint32_t);
 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);
 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         }
 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;
 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);
 407           break;
 408         case TRACE_IRQ_EXIT:
 409           event_size = 0;
 410           timeDelta = time_delta;
 411           write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
 412           write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint64_t));
 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;
 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);
 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){
 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);
 435           }
 436           break;
 437         case TRACE_FILE_SYSTEM:
 438           event_size = sizeof(trace_file_system)- sizeof(char*);
 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           write_to_buffer(write_pos[cpu_id], cur_pos, event_size);
 469         }else{
 470           write_to_buffer(write_pos[0], cur_pos, event_size);
 471         }
 472
 473         if(evId == TRACE_HEARTBEAT){
 474           if(ltt_log_cpu){
 475             write_to_buffer(write_pos[cpu_id],(void*)&beat , sizeof(heartbeat));
 476           }else{
 477             write_to_buffer(write_pos[0], (void*)&beat, sizeof(heartbeat));
 478           }
 479         }
 480
 481         cur_pos += event_size + sizeof(uint16_t); //skip data_size
 482       }else if(evId == TRACE_FILE_SYSTEM){
 483         size_t nbBytes;
 484         char  c = '\0';
 485         tFileSys = (trace_file_system*)cur_pos;
 486         subId = tFileSys->event_sub_id;
 487         if(subId == TRACE_FILE_SYSTEM_OPEN || subId == TRACE_FILE_SYSTEM_EXEC){
 488           nbBytes = tFileSys->event_data2 +1;
 489         }else nbBytes = 0;
 490
 491         if(ltt_log_cpu){
 492           write_to_buffer(write_pos[cpu_id], cur_pos, event_size);
 493           cur_pos += event_size + sizeof(char*);
 494           if(nbBytes){
 495             write_to_buffer(write_pos[cpu_id], cur_pos, nbBytes);
 496           }else{
 497             write_to_buffer(write_pos[cpu_id], (void*)&c, 1);
 498           }
 499         }else{
 500           write_to_buffer(write_pos[0], cur_pos, event_size);
 501           cur_pos += event_size + sizeof(char*);
 502           if(nbBytes){
 503             write_to_buffer(write_pos[0], cur_pos, nbBytes);
 504           }else{
 505             write_to_buffer(write_pos[0], (void*)&c, 1);
 506           }
 507         }
 508         cur_pos += nbBytes + sizeof(uint16_t); //skip data_size
 509       }else if(event_size == -1){
 510         printf("Unknown event: evId=%d, i=%d, event_count=%d\n", newId, i, event_count);
 511         exit(1);
 512       }
 513     } //end while(1)
 514
 515   }
 516
 517
 518
 519
 520
 521   //write to system.xml
 522   fprintf(fp,"<system\n");
 523   fprintf(fp,"node_name=\"%s\"\n", node_name);
 524   fprintf(fp,"domainname=\"%s\"\n", domainname);
 525   fprintf(fp,"cpu=%d\n", cpu);
 526   fprintf(fp,"arch_size=\"%s\"\n", arch_size);
 527   fprintf(fp,"endian=\"%s\"\n",endian);
 528   fprintf(fp,"kernel_name=\"%s\"\n",kernel_name);
 529   fprintf(fp,"kernel_release=\"%s\"\n",kernel_release);
 530   fprintf(fp,"kernel_version=\"%s\"\n",kernel_version);
 531   fprintf(fp,"machine=\"%s\"\n",machine);
 532   fprintf(fp,"processor=\"%s\"\n",processor);
 533   fprintf(fp,"hardware_platform=\"%s\"\n",hardware_platform);
 534   fprintf(fp,"operating_system=\"%s\"\n",operating_system);
 535   fprintf(fp,"ltt_major_version=%d\n",ltt_major_version);
 536   fprintf(fp,"ltt_minor_version=%d\n",ltt_minor_version);
 537   fprintf(fp,"ltt_block_size=%d\n",ltt_block_size);
 538   fprintf(fp,">\n");
 539   fprintf(fp,"This is just a test\n");
 540   fprintf(fp,"</system>\n");
 541   fflush(fp);
 542
 543   fclose(fp);
 544
 545   close(fdFac);
 546   close(fdIntr);
 547   close(fdProc);
 548   close(fd);
 549   for(i=0;i<cpu;i++) close(fdCpu[i]);
 550
 551 }
 552