fix for smp cfv, fix convert bug for 2.2 format, add task release event handling
[lttv.git] / ltt / branches / poly / ltt / convert / convert.c
index 4f03804346374ec4860db1b4c069a3b7d1efbb1f..7b4403ea5b0df11c5b2571116a646cb654605a9c 100644 (file)
@@ -1,8 +1,11 @@
 #include <stdio.h>
+#include <unistd.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <linux/errno.h>  
+#include <errno.h>  
+#include <stdlib.h>
+#include <string.h>
 
 #include <glib.h>
 #include "LTTTypes.h"
@@ -13,7 +16,7 @@
 #define PROCESS_EXIT_ID     21
 
 #define INFO_ENTRY          9
-#define OVERFLOW_FIGURE     4294967295
+#define OVERFLOW_FIGURE     0x100000000ULL
 
 typedef struct _new_process
 {
@@ -30,10 +33,14 @@ do\
 
 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);
+   ssize_t nbBytes = read(fd, buf, size);
+   
+   if((size_t)nbBytes != size) {
+     if(nbBytes < 0) {
+       perror("Error in readFile : ");
+     } else {
+       printf("%s\n",mesg);
+     }
      exit(1);
    }
    return 0;
@@ -68,6 +75,14 @@ typedef struct _buffer_start{
   uint32_t block_id;  
 } __attribute__ ((packed)) buffer_start;
 
+typedef struct _buffer_end{
+  uint32_t seconds;
+  uint32_t nanoseconds;
+  uint64_t cycle_count;
+  uint32_t block_id;  
+} __attribute__ ((packed)) buffer_end;
+
+
 typedef struct _heartbeat{
   uint32_t seconds;
   uint32_t nanoseconds;
@@ -92,12 +107,13 @@ int main(int argc, char ** argv){
   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_block_size=0;
+  int  ltt_major_version=0;
+  int  ltt_minor_version=0;
   int  ltt_log_cpu;
+  guint ltt_trace_start_size = 0;
   char buf[BUFFER_SIZE];
-  int i,j, k;
+  int i, k;
 
   uint8_t cpu_id;
 
@@ -118,20 +134,22 @@ int main(int argc, char ** argv){
   char * buffer, *buf_out, cpuStr[4*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_start_any *tStart;
   trace_buffer_start *tBufStart;
   trace_buffer_end *tBufEnd;
   trace_file_system * tFileSys;
   uint16_t newId, startId, tmpId;
   uint8_t  evId;
-  uint32_t time_delta, startTimeDelta, previous_time_delta;
+  uint32_t time_delta, startTimeDelta;
   void * cur_pos, *end_pos;
   buffer_start start, start_proc, start_intr;
-  buffer_start end, end_proc, end_intr;
+  buffer_end end, end_proc, end_intr;
   heartbeat beat;
-  int beat_count = 0;
+  uint64_t adaptation_tsc;    // (Mathieu)
   uint32_t size_lost;
-  int reserve_size = sizeof(buffer_start) + sizeof(uint16_t) + 2*sizeof(uint32_t);//lost_size and buffer_end event
+  int reserve_size = sizeof(buffer_start) + 
+                     sizeof(buffer_end) + //buffer_end event
+                     sizeof(uint32_t);  //lost size
   int nb_para;
 
   new_process process;
@@ -275,28 +293,70 @@ int main(int argc, char ** argv){
     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;
+    g_assert(evId == TRACE_START);
+    cur_pos += sizeof(uint8_t); //skip EvId
+    cur_pos += sizeof(uint32_t); //skip time delta
+    tStart = (trace_start_any*)cur_pos;
+    if(tStart->MagicNumber != TRACER_MAGIC_NUMBER)
+      g_error("Trace magic number does not match : %lx, should be %lx",
+               tStart->MagicNumber, TRACER_MAGIC_NUMBER);
+    if(tStart->MajorVersion != TRACER_SUP_VERSION_MAJOR)
+      g_error("Trace Major number does match : %hu, should be %u",
+               tStart->MajorVersion, TRACER_SUP_VERSION_MAJOR);
 
     startId = newId;
     startTimeDelta = time_delta;
     start.seconds = tBufStart->Time.tv_sec;
-    start.nanoseconds = tBufStart->Time.tv_usec;
+    /* Fix (Mathieu) */
+    start.nanoseconds = tBufStart->Time.tv_usec * 1000;
     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_printf("Trace version %hu.%hu detected\n",
+             tStart->MajorVersion,
+             tStart->MinorVersion);
+    if(tStart->MinorVersion == 2) {
+      trace_start_2_2* tStart_2_2 = (trace_start_2_2*)tStart;
+      ltt_major_version = tStart_2_2->MajorVersion;
+      ltt_minor_version = tStart_2_2->MinorVersion;
+      ltt_block_size    = tStart_2_2->BufferSize;
+      ltt_log_cpu       = tStart_2_2->LogCPUID;
+      ltt_trace_start_size = sizeof(trace_start_2_2);
+      /* Verify if it's a broken 2.2 format */
+      if(*(uint8_t*)(cur_pos + sizeof(trace_start_2_2)) == 0) {
+        /* Cannot have two trace start events. We cannot detect the problem
+         * if the flight recording flag is set to 1, as it conflicts
+         * with TRACE_SYSCALL_ENTRY.
+         */
+        g_warning("This is a 2.3 trace format that has a 2.2 tag. Please upgrade your kernel");
+        g_printf("Processing the trace as a 2.3 format\n");
+
+        tStart->MinorVersion = 3;
+      }
+    }
+    
+    if(tStart->MinorVersion == 3) {
+      trace_start_2_3* tStart_2_3 = (trace_start_2_3*)tStart;
+      ltt_major_version = tStart_2_3->MajorVersion;
+      ltt_minor_version = tStart_2_3->MinorVersion;
+      ltt_block_size    = tStart_2_3->BufferSize;
+      ltt_log_cpu       = tStart_2_3->LogCPUID;
+      ltt_trace_start_size = sizeof(trace_start_2_3);
+    /* We do not use the flight recorder information for now, because we
+     * never use the .proc file anyway */
+    }
+    
+    if(ltt_trace_start_size == 0) 
+      g_error("Minor version unknown : %hu. Supported minors : 2, 3",
+               tStart->MinorVersion);
+
+    block_size = ltt_block_size;//FIXME
+    block_number = file_size/ltt_block_size;
 
     g_free(buffer);
-    buffer         = g_new(char, block_size);
+    buffer         = g_new(char, ltt_block_size);
     buf_fac        = g_new(char, block_size);
     write_pos_fac  = buf_fac;
     buf_intr       = g_new(char, block_size);
@@ -306,14 +366,13 @@ int main(int argc, char ** argv){
 
     buf_out = g_new(char, block_size);
     write_pos = buf_out;
-    sprintf(cpuStr,"%s/%d\0",foo_cpu,k);
+    sprintf(cpuStr,"%s/%d",foo_cpu,k);
     fdCpu = open(cpuStr, O_CREAT | O_RDWR | O_TRUNC,S_IRUSR |S_IWUSR | S_IRGRP | S_IROTH); //for cpu k
     if(fdCpu < 0)  g_error("Unable to open  cpu file %d\n", k);    
     lseek(fd,0,SEEK_SET);
     
     for(i=0;i<block_number;i++){
       int event_count = 0;
-      beat_count = 0;
 
       memset((void*)buf_out, 0, block_size);
       write_pos = buf_out;
@@ -324,8 +383,8 @@ int main(int argc, char ** argv){
       write_pos_fac = buf_fac;
       write_pos_proc = buf_proc;
       
-      memset((void*)buffer,0,block_size); 
-      readFile(fd,(void*)buffer, block_size, "Unable to read block header");
+      memset((void*)buffer,0,ltt_block_size); 
+      readFile(fd,(void*)buffer, ltt_block_size, "Unable to read block header");
       
       cur_pos= buffer;
       evId = *(uint8_t *)cur_pos;
@@ -339,32 +398,55 @@ int main(int argc, char ** argv){
 
       startId = newId;
       startTimeDelta = time_delta;
-      previous_time_delta = time_delta;
       start.seconds = tBufStart->Time.tv_sec;
-      start.nanoseconds = tBufStart->Time.tv_usec;
-      start.cycle_count = tBufStart->TSC;
+      /* usec -> nsec (Mathieu) */
+      start.nanoseconds = tBufStart->Time.tv_usec * 1000;
       start.block_id = tBufStart->ID;
       end.block_id = start.block_id;
       
-      end_pos = buffer + block_size; //end of the buffer
+      end_pos = buffer + ltt_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
+      end_pos = buffer + ltt_block_size - size_lost ; //buffer_end event
       if(ltt_log_cpu){
        tBufEnd = (trace_buffer_end*)(end_pos + 2 * sizeof(uint8_t)+sizeof(uint32_t));
       }else{
        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;
+      /* usec -> nsec (Mathieu) */
+      end.nanoseconds = tBufEnd->Time.tv_usec * 1000;
+      // only 32 bits :( 
+      //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);
-      
+      if(i==0) {
+        //the first block
+        adaptation_tsc = (uint64_t)tBufStart->TSC;
+             cur_pos = buffer + sizeof(trace_buffer_start) 
+                         + ltt_trace_start_size 
+                         + 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);
+
+        /* Fix (Mathieu) */
+        if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
+          /* Overflow */
+          adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) 
+                                       + 0x100000000ULL 
+                                       + (uint64_t)time_delta;
+        } else {
+          /* No overflow */
+          adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
+        }
+
+      }
+      start.cycle_count = adaptation_tsc;
+
       //write start block event
       write_to_buffer(write_pos,(void*)&startId, sizeof(uint16_t));    
       write_to_buffer(write_pos,(void*)&startTimeDelta, sizeof(uint32_t));
@@ -437,27 +519,56 @@ int main(int argc, char ** argv){
        cur_pos += sizeof(uint8_t);
        time_delta = *(uint32_t*)cur_pos;
        cur_pos += sizeof(uint32_t); 
-       
-       if(time_delta < previous_time_delta){
-         end.cycle_count += OVERFLOW_FIGURE;
-       }
-       previous_time_delta = time_delta;
+
 
        //write event_id and time_delta
        write_to_buffer(write_pos,(void*)&newId,sizeof(uint16_t));
        write_to_buffer(write_pos,(void*)&time_delta, sizeof(uint32_t));     
-       
+
+  /* Fix (Mathieu) */
+  if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
+    /* Overflow */
+    adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + 0x100000000ULL 
+                                 + (uint64_t)time_delta;
+  } else {
+    /* No overflow */
+    adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
+  }
+
+
        if(evId == TRACE_BUFFER_END){
-         int size = block_size + ((void*)buf_out - write_pos)+ sizeof(uint16_t) + sizeof(uint32_t);
-         write_to_buffer(write_pos,(void*)&end,sizeof(buffer_start));   
+#if 0
+    /* Fix (Mathieu) */
+    if(time_delta < (0xFFFFFFFFULL&adaptation_tsc)) {
+      /* Overflow */
+     adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + 0x100000000ULL 
+                                   + (uint64_t)time_delta;
+    } else {
+      /* No overflow */
+      adaptation_tsc = (adaptation_tsc&0xFFFFFFFF00000000ULL) + time_delta;
+    }
+#endif //0
+    end.cycle_count = adaptation_tsc;
+         int size = (void*)buf_out + block_size - write_pos 
+                   - sizeof(buffer_end) - sizeof(uint32_t);
+
+    /* size _lost_ ? */
+    //int size = (void*)buf_out + block_size - write_pos 
+    //            + sizeof(uint16_t) + sizeof(uint32_t);
+    g_assert((void*)write_pos < (void*)buf_out + block_size);
+         write_to_buffer(write_pos,(void*)&end,sizeof(buffer_end));
          write_pos = buf_out + block_size - sizeof(uint32_t);
          write_to_buffer(write_pos,(void*)&size, sizeof(uint32_t));
          write(fdCpu,(void*)buf_out, block_size);
          
          //write out processes and intrrupts files
          {
-           int size_intr = block_size - (write_pos_intr - (void*)buf_intr);
-           int size_proc = block_size - (write_pos_proc - (void*)buf_proc);
+           int size_intr = block_size + (void*)buf_intr - write_pos_intr
+                         - sizeof(buffer_end) - sizeof(uint32_t);
+           int size_proc = block_size + (void*)buf_proc - write_pos_proc
+                         - sizeof(buffer_end) - sizeof(uint32_t);
+      //int size_intr = block_size - (write_pos_intr - (void*)buf_intr);
+      //int size_proc = block_size - (write_pos_proc - (void*)buf_proc);
            write_to_buffer(write_pos_intr,(void*)&newId,sizeof(uint16_t));
            write_to_buffer(write_pos_intr,(void*)&time_delta, sizeof(uint32_t));     
            end_intr = end;
@@ -554,19 +665,16 @@ int main(int argc, char ** argv){
            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 * OVERFLOW_FIGURE;
+           beat.cycle_count = adaptation_tsc;
            event_size = 0;
-
-           //    end.cycle_count += OVERFLOW_FIGURE;
            
            write_to_buffer(write_pos_intr,(void*)&newId, sizeof(uint16_t));
-           write_to_buffer(write_pos_intr,(void*)&timeDelta, sizeof(uint32_t));
+           write_to_buffer(write_pos_intr,(void*)&time_delta, sizeof(uint32_t));
            write_to_buffer(write_pos_intr,(void*)&beat, sizeof(heartbeat));              
            write_to_buffer(write_pos_proc,(void*)&newId, sizeof(uint16_t));
-           write_to_buffer(write_pos_proc,(void*)&timeDelta, sizeof(uint32_t));
+           write_to_buffer(write_pos_proc,(void*)&time_delta, sizeof(uint32_t));
            write_to_buffer(write_pos_proc,(void*)&beat, sizeof(heartbeat));              
            break;
           default:
@@ -645,5 +753,8 @@ int main(int argc, char ** argv){
   close(fdProc); 
   fclose(fp);
 
+  g_printf("Conversion completed. Don't forget to copy core.xml to eventdefs directory\n");
+  
+  return 0;
 }
 
This page took 0.026645 seconds and 4 git commands to generate.