6 #include <linux/errno.h>
10 #include "ltt-private.h"
11 #include <ltt/trace.h>
12 #include <ltt/facility.h>
14 #define DIR_NAME_SIZE 256
16 /* set the offset of the fields belonging to the event,
17 need the information of the archecture */
18 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
*t
);
20 /* get the size of the field type according to the archtecture's
21 size and endian type(info of the archecture) */
22 int getFieldtypeSize(LttTracefile
* tf
, LttEventType
* evT
, int offsetRoot
,
23 int offsetParent
, LttField
*fld
, void *evD
, LttTrace
* t
);
25 /* read a fixed size or a block information from the file (fd) */
26 int readFile(int fd
, void * buf
, size_t size
, char * mesg
);
27 int readBlock(LttTracefile
* tf
, int whichBlock
);
29 /* calculate cycles per nsec for current block */
30 void getCyclePerNsec(LttTracefile
* t
);
32 /* reinitialize the info of the block which is already in the buffer */
33 void updateTracefile(LttTracefile
* tf
);
35 /* go to the next event */
36 int skipEvent(LttTracefile
* t
);
39 /* Functions to parse system.xml file (using glib xml parser) */
40 static void parser_start_element (GMarkupParseContext
*context
,
41 const gchar
*element_name
,
42 const gchar
**attribute_names
,
43 const gchar
**attribute_values
,
48 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
49 if(strcmp("system", element_name
)){
50 g_warning("This is not system.xml file\n");
54 while(attribute_names
[i
]){
55 if(strcmp("node_name", attribute_names
[i
])==0){
56 des
->node_name
= g_strdup(attribute_values
[i
]);
57 }else if(strcmp("domainname", attribute_names
[i
])==0){
58 des
->domain_name
= g_strdup(attribute_values
[i
]);
59 }else if(strcmp("cpu", attribute_names
[i
])==0){
60 des
->nb_cpu
= atoi(attribute_values
[i
]);
61 }else if(strcmp("arch_size", attribute_names
[i
])==0){
62 if(strcmp(attribute_values
[i
],"LP32") == 0) des
->size
= LTT_LP32
;
63 else if(strcmp(attribute_values
[i
],"ILP32") == 0) des
->size
= LTT_ILP32
;
64 else if(strcmp(attribute_values
[i
],"LP64") == 0) des
->size
= LTT_LP64
;
65 else if(strcmp(attribute_values
[i
],"ILP64") == 0) des
->size
= LTT_ILP64
;
66 else if(strcmp(attribute_values
[i
],"UNKNOWN") == 0) des
->size
= LTT_UNKNOWN
;
67 }else if(strcmp("endian", attribute_names
[i
])==0){
68 if(strcmp(attribute_values
[i
],"LITTLE_ENDIAN") == 0)
69 des
->endian
= LTT_LITTLE_ENDIAN
;
70 else if(strcmp(attribute_values
[i
],"BIG_ENDIAN") == 0)
71 des
->endian
= LTT_BIG_ENDIAN
;
72 }else if(strcmp("kernel_name", attribute_names
[i
])==0){
73 des
->kernel_name
= g_strdup(attribute_values
[i
]);
74 }else if(strcmp("kernel_release", attribute_names
[i
])==0){
75 des
->kernel_release
= g_strdup(attribute_values
[i
]);
76 }else if(strcmp("kernel_version", attribute_names
[i
])==0){
77 des
->kernel_version
= g_strdup(attribute_values
[i
]);
78 }else if(strcmp("machine", attribute_names
[i
])==0){
79 des
->machine
= g_strdup(attribute_values
[i
]);
80 }else if(strcmp("processor", attribute_names
[i
])==0){
81 des
->processor
= g_strdup(attribute_values
[i
]);
82 }else if(strcmp("hardware_platform", attribute_names
[i
])==0){
83 des
->hardware_platform
= g_strdup(attribute_values
[i
]);
84 }else if(strcmp("operating_system", attribute_names
[i
])==0){
85 des
->operating_system
= g_strdup(attribute_values
[i
]);
86 }else if(strcmp("ltt_major_version", attribute_names
[i
])==0){
87 des
->ltt_major_version
= atoi(attribute_values
[i
]);
88 }else if(strcmp("ltt_minor_version", attribute_names
[i
])==0){
89 des
->ltt_minor_version
= atoi(attribute_values
[i
]);
90 }else if(strcmp("ltt_block_size", attribute_names
[i
])==0){
91 des
->ltt_block_size
= atoi(attribute_values
[i
]);
93 g_warning("Not a valid attribute\n");
100 static void parser_end_element (GMarkupParseContext
*context
,
101 const gchar
*element_name
,
107 static void parser_characters (GMarkupParseContext
*context
,
113 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
114 des
->description
= g_strdup(text
);
118 /*****************************************************************************
120 * ltt_tracefile_open : open a trace file, construct a LttTracefile
122 * t : the trace containing the tracefile
123 * fileName : path name of the trace file
125 * : a pointer to a tracefile
126 ****************************************************************************/
128 LttTracefile
* ltt_tracefile_open(LttTrace
* t
, char * fileName
)
131 struct stat lTDFStat
; /* Trace data file status */
132 BlockStart a_block_start
;
134 tf
= g_new(LttTracefile
, 1);
137 tf
->name
= g_strdup(fileName
);
139 tf
->fd
= open(fileName
, O_RDONLY
, 0);
141 g_error("Unable to open input data file %s\n", fileName
);
144 // Get the file's status
145 if(fstat(tf
->fd
, &lTDFStat
) < 0){
146 g_error("Unable to get the status of the input data file %s\n", fileName
);
149 // Is the file large enough to contain a trace
150 if(lTDFStat
.st_size
< sizeof(BlockStart
) + EVENT_HEADER_SIZE
){
151 g_print("The input data file %s does not contain a trace\n", fileName
);
158 //store the size of the file
159 tf
->file_size
= lTDFStat
.st_size
;
160 tf
->block_size
= t
->system_description
->ltt_block_size
;
161 tf
->block_number
= tf
->file_size
/ tf
->block_size
;
164 //allocate memory to contain the info of a block
165 tf
->buffer
= (void *) g_new(char, t
->system_description
->ltt_block_size
);
167 //read the first block
168 if(readBlock(tf
,1)) exit(1);
174 /*****************************************************************************
175 *Open control and per cpu tracefiles
176 ****************************************************************************/
178 void ltt_tracefile_open_cpu(LttTrace
*t
, char * tracefile_name
)
181 tf
= ltt_tracefile_open(t
,tracefile_name
);
183 t
->per_cpu_tracefile_number
++;
184 g_ptr_array_add(t
->per_cpu_tracefiles
, tf
);
187 void ltt_tracefile_open_control(LttTrace
*t
, char * control_name
)
197 tf
= ltt_tracefile_open(t
,control_name
);
199 t
->control_tracefile_number
++;
200 g_ptr_array_add(t
->control_tracefiles
,tf
);
202 //parse facilities tracefile to get base_id
203 if(strcmp(&control_name
[strlen(control_name
)-10],"facilities") ==0){
205 ev
= ltt_tracefile_read(tf
);
206 if(!ev
)return; // end of file
208 if(ev
->event_id
== TRACE_FACILITY_LOAD
){
210 fLoad
.name
= (char*)pos
;
211 fLoad
.checksum
= *(LttChecksum
*)(pos
+ strlen(fLoad
.name
));
212 fLoad
.base_code
= *(guint32
*)(pos
+ strlen(fLoad
.name
) + sizeof(LttChecksum
));
214 for(i
=0;i
<t
->facility_number
;i
++){
215 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
216 if(strcmp(f
->name
,fLoad
.name
)==0 && fLoad
.checksum
==f
->checksum
){
217 f
->base_id
= fLoad
.base_code
;
221 if(i
==t
->facility_number
)
222 g_error("Facility: %s, checksum: %d is not founded\n",
223 fLoad
.name
,fLoad
.checksum
);
224 }else if(ev
->event_id
== TRACE_BLOCK_START
){
226 }else if(ev
->event_id
== TRACE_BLOCK_END
){
228 }else g_error("Not valid facilities trace file\n");
233 /*****************************************************************************
235 * ltt_tracefile_close: close a trace file,
237 * t : tracefile which will be closed
238 ****************************************************************************/
240 void ltt_tracefile_close(LttTracefile
*t
)
249 /*****************************************************************************
250 *Get system information
251 ****************************************************************************/
252 void getSystemInfo(LttSystemDescription
* des
, char * pathname
)
255 char buf
[DIR_NAME_SIZE
];
256 char description
[4*DIR_NAME_SIZE
];
258 GMarkupParseContext
* context
;
260 GMarkupParser markup_parser
=
262 parser_start_element
,
265 NULL
, /* passthrough */
269 fp
= fopen(pathname
,"r");
271 g_error("Can not open file : %s\n", pathname
);
274 context
= g_markup_parse_context_new(&markup_parser
, 0, des
,NULL
);
276 while(fgets(buf
,DIR_NAME_SIZE
, fp
) != NULL
){
277 if(!g_markup_parse_context_parse(context
, buf
, DIR_NAME_SIZE
, &error
)){
278 g_warning("Can not parse xml file: \n%s\n", error
->message
);
285 /*****************************************************************************
286 *The following functions get facility/tracefile information
287 ****************************************************************************/
289 void getFacilityInfo(LttTrace
*t
, char* eventdefs
)
292 struct dirent
*entry
;
297 char name
[DIR_NAME_SIZE
];
299 dir
= opendir(eventdefs
);
300 if(!dir
) g_error("Can not open directory: %s\n", eventdefs
);
302 while((entry
= readdir(dir
)) != NULL
){
303 ptr
= &entry
->d_name
[strlen(entry
->d_name
)-4];
304 if(strcmp(ptr
,".xml") != 0) continue;
305 strcpy(name
,eventdefs
);
306 strcat(name
,entry
->d_name
);
307 ltt_facility_open(t
,name
);
311 for(j
=0;j
<t
->facility_number
;j
++){
312 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, j
);
313 for(i
=0; i
<f
->event_number
; i
++){
315 setFieldsOffset(NULL
, et
, NULL
, t
);
320 void getControlFileInfo(LttTrace
*t
, char* control
)
323 struct dirent
*entry
;
324 char name
[DIR_NAME_SIZE
];
326 dir
= opendir(control
);
327 if(!dir
) g_error("Can not open directory: %s\n", control
);
329 while((entry
= readdir(dir
)) != NULL
){
330 if(strcmp(entry
->d_name
,"facilities") != 0 &&
331 strcmp(entry
->d_name
,"interrupts") != 0 &&
332 strcmp(entry
->d_name
,"processes") != 0) continue;
334 strcpy(name
,control
);
335 strcat(name
,entry
->d_name
);
336 ltt_tracefile_open_control(t
,name
);
341 void getCpuFileInfo(LttTrace
*t
, char* cpu
)
344 struct dirent
*entry
;
345 char name
[DIR_NAME_SIZE
];
348 if(!dir
) g_error("Can not open directory: %s\n", cpu
);
350 while((entry
= readdir(dir
)) != NULL
){
351 if(strcmp(entry
->d_name
,".") != 0 &&
352 strcmp(entry
->d_name
,"..") != 0 ){
354 strcat(name
,entry
->d_name
);
355 ltt_tracefile_open_cpu(t
,name
);
361 /*****************************************************************************
362 *A trace is specified as a pathname to the directory containing all the
363 *associated data (control tracefiles, per cpu tracefiles, event
366 *When a trace is closed, all the associated facilities, types and fields
367 *are released as well.
368 ****************************************************************************/
370 LttTrace
*ltt_trace_open(const char *pathname
)
373 LttSystemDescription
* sys_description
;
374 char eventdefs
[DIR_NAME_SIZE
];
375 char info
[DIR_NAME_SIZE
];
376 char control
[DIR_NAME_SIZE
];
377 char cpu
[DIR_NAME_SIZE
];
378 char tmp
[DIR_NAME_SIZE
];
379 gboolean has_slash
= FALSE
;
381 //establish the pathname to different directories
382 if(pathname
[strlen(pathname
)-1] == '/')has_slash
= TRUE
;
383 strcpy(eventdefs
,pathname
);
384 if(!has_slash
)strcat(eventdefs
,"/");
385 strcat(eventdefs
,"eventdefs/");
387 strcpy(info
,pathname
);
388 if(!has_slash
)strcat(info
,"/");
389 strcat(info
,"info/");
391 strcpy(control
,pathname
);
392 if(!has_slash
)strcat(control
,"/");
393 strcat(control
,"control/");
395 strcpy(cpu
,pathname
);
396 if(!has_slash
)strcat(cpu
,"/");
400 t
= g_new(LttTrace
, 1);
401 sys_description
= g_new(LttSystemDescription
, 1);
402 t
->pathname
= g_strdup(pathname
);
403 t
->facility_number
= 0;
404 t
->control_tracefile_number
= 0;
405 t
->per_cpu_tracefile_number
= 0;
406 t
->system_description
= sys_description
;
407 t
->control_tracefiles
= g_ptr_array_new();
408 t
->per_cpu_tracefiles
= g_ptr_array_new();
409 t
->facilities
= g_ptr_array_new();
410 getDataEndianType(&(t
->my_arch_size
), &(t
->my_arch_endian
));
412 //get system description
414 strcat(tmp
,"system.xml");
415 getSystemInfo(sys_description
, tmp
);
417 //get facilities info
418 getFacilityInfo(t
,eventdefs
);
420 //get control tracefile info
421 getControlFileInfo(t
,control
);
423 //get cpu tracefile info
424 getCpuFileInfo(t
,cpu
);
429 char * ltt_trace_name(LttTrace
*t
)
435 /******************************************************************************
436 * When we copy a trace, we want all the opening actions to happen again :
437 * the trace will be reopened and totally independant from the original.
438 * That's why we call ltt_trace_open.
439 *****************************************************************************/
440 LttTrace
*ltt_trace_copy(LttTrace
*self
)
442 return ltt_trace_open(self
->pathname
);
445 void ltt_trace_close(LttTrace
*t
)
453 //free system_description
454 g_free(t
->system_description
->description
);
455 g_free(t
->system_description
->node_name
);
456 g_free(t
->system_description
->domain_name
);
457 g_free(t
->system_description
->kernel_name
);
458 g_free(t
->system_description
->kernel_release
);
459 g_free(t
->system_description
->kernel_version
);
460 g_free(t
->system_description
->machine
);
461 g_free(t
->system_description
->processor
);
462 g_free(t
->system_description
->hardware_platform
);
463 g_free(t
->system_description
->operating_system
);
464 g_free(t
->system_description
);
466 //free control_tracefiles
467 for(i
=0;i
<t
->control_tracefile_number
;i
++){
468 tf
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
,i
);
469 ltt_tracefile_close(tf
);
471 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
473 //free per_cpu_tracefiles
474 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
475 tf
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
,i
);
476 ltt_tracefile_close(tf
);
478 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
481 for(i
=0;i
<t
->facility_number
;i
++){
482 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
483 ltt_facility_close(f
);
485 g_ptr_array_free(t
->facilities
, TRUE
);
493 /*****************************************************************************
494 *Get the system description of the trace
495 ****************************************************************************/
497 LttSystemDescription
*ltt_trace_system_description(LttTrace
*t
)
499 return t
->system_description
;
502 /*****************************************************************************
503 * The following functions discover the facilities of the trace
504 ****************************************************************************/
506 unsigned ltt_trace_facility_number(LttTrace
*t
)
508 return (unsigned)(t
->facility_number
);
511 LttFacility
*ltt_trace_facility_get(LttTrace
*t
, unsigned i
)
513 return (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
516 /*****************************************************************************
518 * ltt_trace_facility_find : find facilities in the trace
521 * name : facility name
523 * position : position of the facility in the trace
525 * : the number of facilities
526 ****************************************************************************/
528 unsigned ltt_trace_facility_find(LttTrace
*t
, char *name
, unsigned *position
)
532 for(i
=0;i
<t
->facility_number
;i
++){
533 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
534 if(strcmp(f
->name
,name
)==0){
536 if(count
==1) *position
= i
;
544 /*****************************************************************************
545 * Functions to discover all the event types in the trace
546 ****************************************************************************/
548 unsigned ltt_trace_eventtype_number(LttTrace
*t
)
553 for(i
=0;i
<t
->facility_number
;i
++){
554 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
555 count
+= f
->event_number
;
560 LttFacility
* ltt_trace_facility_by_id(LttTrace
* trace
, unsigned id
)
562 LttFacility
* facility
;
564 for(i
=0;i
<trace
->facility_number
;i
++){
565 facility
= (LttFacility
*) g_ptr_array_index(trace
->facilities
,i
);
566 if(id
>= facility
->base_id
&&
567 id
< facility
->base_id
+ facility
->event_number
)
570 if(i
==trace
->facility_number
) return NULL
;
571 else return facility
;
574 LttEventType
*ltt_trace_eventtype_get(LttTrace
*t
, unsigned evId
)
577 f
= ltt_trace_facility_by_id(t
,evId
);
579 return f
->events
[evId
- f
->base_id
];
582 /*****************************************************************************
583 *There is one "per cpu" tracefile for each CPU, numbered from 0 to
584 *the maximum number of CPU in the system. When the number of CPU installed
585 *is less than the maximum, some positions are unused. There are also a
586 *number of "control" tracefiles (facilities, interrupts...).
587 ****************************************************************************/
588 unsigned ltt_trace_control_tracefile_number(LttTrace
*t
)
590 return t
->control_tracefile_number
;
593 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace
*t
)
595 return t
->per_cpu_tracefile_number
;
598 /*****************************************************************************
599 *It is possible to search for the tracefiles by name or by CPU position.
600 *The index within the tracefiles of the same type is returned if found
601 *and a negative value otherwise.
602 ****************************************************************************/
604 int ltt_trace_control_tracefile_find(LttTrace
*t
, char *name
)
606 LttTracefile
* tracefile
;
608 for(i
=0;i
<t
->control_tracefile_number
;i
++){
609 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
610 if(strcmp(tracefile
->name
, name
)==0)break;
612 if(i
== t
->control_tracefile_number
) return -1;
616 int ltt_trace_per_cpu_tracefile_find(LttTrace
*t
, unsigned i
)
618 LttTracefile
* tracefile
;
620 for(j
=0;j
<t
->per_cpu_tracefile_number
;j
++){
621 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, j
);
622 name
= atoi(tracefile
->name
);
623 if(name
== (int)i
)break;
625 if(j
== t
->per_cpu_tracefile_number
) return -1;
629 /*****************************************************************************
630 *Get a specific tracefile
631 ****************************************************************************/
633 LttTracefile
*ltt_trace_control_tracefile_get(LttTrace
*t
, unsigned i
)
635 return (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
638 LttTracefile
*ltt_trace_per_cpu_tracefile_get(LttTrace
*t
, unsigned i
)
640 return (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
643 /*****************************************************************************
644 * Get the start time and end time of the trace
645 ****************************************************************************/
647 void ltt_trace_time_span_get(LttTrace
*t
, LttTime
*start
, LttTime
*end
)
649 LttTime startSmall
, startTmp
, endBig
, endTmp
;
653 for(i
=0;i
<t
->control_tracefile_number
;i
++){
654 tf
= g_ptr_array_index(t
->control_tracefiles
, i
);
656 startTmp
= tf
->a_block_start
->time
;
657 readBlock(tf
,tf
->block_number
);
658 endTmp
= tf
->a_block_end
->time
;
660 startSmall
= startTmp
;
665 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
666 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
669 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
670 tf
= g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
672 startTmp
= tf
->a_block_start
->time
;
673 readBlock(tf
,tf
->block_number
);
674 endTmp
= tf
->a_block_end
->time
;
676 startSmall
= startTmp
;
680 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
681 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
689 /*****************************************************************************
690 *Get the name of a tracefile
691 ****************************************************************************/
693 char *ltt_tracefile_name(LttTracefile
*tf
)
698 /*****************************************************************************
699 * Get the number of blocks in the tracefile
700 ****************************************************************************/
702 unsigned ltt_tracefile_block_number(LttTracefile
*tf
)
704 return tf
->block_number
;
707 /*****************************************************************************
709 * ltt_tracefile_seek_time: seek to the first event of the trace with time
710 * larger or equal to time
713 * time : criteria of the time
714 ****************************************************************************/
715 void ltt_tracefile_find_time_block(LttTracefile
*t
, LttTime time
,
716 int start_block
, int end_block
)
718 int err
, tmp_block
, s
, e
;
722 err
=readBlock(t
,start_block
);
723 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
724 if(start_block
== end_block
)return;
726 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
727 if(tailTime
>= 0) return;
729 err
=readBlock(t
,end_block
);
730 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
731 if(start_block
+1 == end_block
)return;
733 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
734 if(headTime
<= 0 ) return;
736 tmp_block
= (end_block
+ start_block
)/2;
737 err
=readBlock(t
,tmp_block
);
738 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
740 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
741 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
742 if(headTime
<= 0 && tailTime
>= 0) return;
748 ltt_tracefile_find_time_block(t
, time
, s
, e
);
756 ltt_tracefile_find_time_block(t
, time
, s
, e
);
761 void ltt_tracefile_backward_find_time_block(LttTracefile
*t
, LttTime time
)
763 int t_time
, h_time
, err
;
764 err
=readBlock(t
,t
->which_block
-1);
765 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
766 h_time
= ltt_time_compare(t
->a_block_start
->time
, time
);
767 t_time
= ltt_time_compare(t
->a_block_end
->time
, time
);
770 if(t
->which_block
== 1) return;
771 err
=readBlock(t
,t
->which_block
-1);
772 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
773 tmp
= ltt_time_compare(t
->a_block_end
->time
, time
);
774 if(tmp
== 0) return ltt_tracefile_seek_time(t
, time
);
775 err
=readBlock(t
,t
->which_block
+1);
776 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
777 }else if(h_time
> 0){
778 ltt_tracefile_find_time_block(t
, time
, 1, t
->which_block
);
779 return ltt_tracefile_seek_time(t
, time
) ;
781 if(t_time
>= 0) return ltt_tracefile_seek_time(t
, time
);
782 err
=readBlock(t
,t
->which_block
+1);
783 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
787 void ltt_tracefile_seek_time(LttTracefile
*t
, LttTime time
)
791 int headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
792 int tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
795 if(headTime
< 0 && tailTime
> 0){
796 if(ltt_time_compare(t
->a_block_end
->time
, t
->current_event_time
) !=0) {
797 lttTime
= getEventTime(t
);
798 err
= ltt_time_compare(lttTime
, time
);
800 if(t
->which_event
==2 || (&t
->prev_event_time
,&time
)<0){
804 return ltt_tracefile_seek_time(t
, time
);
808 ev
= ltt_tracefile_read(t
);
810 g_print("End of file\n");
813 lttTime
= getEventTime(t
);
814 err
= ltt_time_compare(lttTime
, time
);
818 }else{//we are at the end of the block
820 return ltt_tracefile_seek_time(t
, time
);
822 }else if(headTime
>= 0){
823 if(t
->which_block
== 1){
826 if(ltt_time_compare(t
->prev_block_end_time
, time
) >= 0 ||
827 (t
->prev_block_end_time
.tv_sec
== 0 &&
828 t
->prev_block_end_time
.tv_nsec
== 0 )){
829 ltt_tracefile_backward_find_time_block(t
, time
);
834 }else if(tailTime
< 0){
835 if(t
->which_block
!= t
->block_number
){
836 ltt_tracefile_find_time_block(t
, time
, t
->which_block
+1, t
->block_number
);
837 return ltt_tracefile_seek_time(t
, time
);
839 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
840 g_print("End of file\n");
843 }else if(tailTime
== 0){
844 t
->cur_event_pos
= t
->last_event_pos
;
845 t
->current_event_time
= time
;
846 t
->cur_heart_beat_number
= 0;
847 t
->prev_event_time
.tv_sec
= 0;
848 t
->prev_event_time
.tv_nsec
= 0;
853 /*****************************************************************************
854 * Seek to the first event with position equal or larger to ep
855 ****************************************************************************/
857 void ltt_tracefile_seek_position(LttTracefile
*t
, LttEventPosition
*ep
)
859 //if we are at the right place, just return
860 if(t
->which_block
== ep
->block_num
&& t
->which_event
== ep
->event_num
)
863 if(t
->which_block
== ep
->block_num
) updateTracefile(t
);
864 else readBlock(t
,ep
->block_num
);
866 //event offset is availiable
867 if(ep
->old_position
){
868 t
->cur_heart_beat_number
= ep
->heart_beat_number
;
869 t
->cur_event_pos
= t
->buffer
+ ep
->event_offset
;
873 //only block number and event index are availiable
874 while(t
->which_event
< ep
->event_num
) ltt_tracefile_read(t
);
879 /*****************************************************************************
881 * ltt_tracefile_read : read the current event, set the pointer to the next
885 * LttEvent * : an event to be processed
886 ****************************************************************************/
888 LttEvent
*ltt_tracefile_read(LttTracefile
*t
)
890 LttEvent
* lttEvent
= &t
->an_event
;
893 if(t
->cur_event_pos
== t
->buffer
+ t
->block_size
){
894 if(t
->which_block
== t
->block_number
){
897 err
= readBlock(t
, t
->which_block
+ 1);
898 if(err
)g_error("Can not read tracefile");
901 lttEvent
->event_id
= (int)(*(guint16
*)(t
->cur_event_pos
));
902 if(lttEvent
->event_id
== TRACE_TIME_HEARTBEAT
)
903 t
->cur_heart_beat_number
++;
905 t
->prev_event_time
= t
->current_event_time
;
906 // t->current_event_time = getEventTime(t);
908 lttEvent
->time_delta
= *(guint32
*)(t
->cur_event_pos
+ EVENT_ID_SIZE
);
909 lttEvent
->event_time
= t
->current_event_time
;
911 lttEvent
->tracefile
= t
;
912 lttEvent
->data
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
913 lttEvent
->which_block
= t
->which_block
;
914 lttEvent
->which_event
= t
->which_event
;
916 //update the fields of the current event and go to the next event
918 if(err
== ERANGE
) g_error("event id is out of range\n");
920 lttEvent
->event_cycle_count
= t
->cur_cycle_count
;
925 /****************************************************************************
927 * readFile : wrap function to read from a file
929 * fd : file descriptor
930 * buf : buf to contain the content
931 * size : number of bytes to be read
932 * mesg : message to be printed if some thing goes wrong
935 * EIO : can not read from the file
936 ****************************************************************************/
938 int readFile(int fd
, void * buf
, size_t size
, char * mesg
)
941 nbBytes
= read(fd
, buf
, size
);
949 /****************************************************************************
951 * readBlock : read a block from the file
953 * lttdes : ltt trace file
954 * whichBlock : the block which will be read
957 * EINVAL : lseek fail
958 * EIO : can not read from the file
959 ****************************************************************************/
961 int readBlock(LttTracefile
* tf
, int whichBlock
)
966 if(whichBlock
- tf
->which_block
== 1 && tf
->which_block
!= 0){
967 tf
->prev_block_end_time
= tf
->a_block_end
->time
;
968 tf
->prev_event_time
= tf
->a_block_end
->time
;
970 tf
->prev_block_end_time
.tv_sec
= 0;
971 tf
->prev_block_end_time
.tv_nsec
= 0;
972 tf
->prev_event_time
.tv_sec
= 0;
973 tf
->prev_event_time
.tv_nsec
= 0;
976 nbBytes
=lseek(tf
->fd
,(off_t
)((whichBlock
-1)*tf
->block_size
), SEEK_SET
);
977 if(nbBytes
== -1) return EINVAL
;
979 if(readFile(tf
->fd
,tf
->buffer
,tf
->block_size
,"Unable to read a block"))
982 tf
->a_block_start
=(BlockStart
*) (tf
->buffer
+ EVENT_HEADER_SIZE
);
983 lostSize
= *(guint32
*)(tf
->buffer
+ tf
->block_size
- sizeof(guint32
));
984 tf
->a_block_end
=(BlockEnd
*)(tf
->buffer
+ tf
->block_size
-
985 lostSize
+ EVENT_HEADER_SIZE
);
986 tf
->last_event_pos
= tf
->buffer
+ tf
->block_size
- lostSize
;
988 tf
->which_block
= whichBlock
;
990 tf
->cur_event_pos
= tf
->buffer
;//the beginning of the block, block start ev
991 tf
->cur_heart_beat_number
= 0;
995 tf
->current_event_time
= getEventTime(tf
);
1000 /*****************************************************************************
1002 * updateTracefile : reinitialize the info of the block which is already
1006 ****************************************************************************/
1008 void updateTracefile(LttTracefile
* tf
)
1010 tf
->which_event
= 1;
1011 tf
->cur_event_pos
= tf
->buffer
;
1012 tf
->current_event_time
= getEventTime(tf
);
1013 tf
->cur_heart_beat_number
= 0;
1015 tf
->prev_event_time
.tv_sec
= 0;
1016 tf
->prev_event_time
.tv_nsec
= 0;
1019 /*****************************************************************************
1021 * skipEvent : go to the next event, update the fields of the current event
1026 * ERANGE : event id is out of range
1027 ****************************************************************************/
1029 int skipEvent(LttTracefile
* t
)
1036 evId
= (int)(*(guint16
*)(t
->cur_event_pos
));
1037 evData
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
1039 evT
= ltt_trace_eventtype_get(t
->trace
,(unsigned)evId
);
1041 if(evT
) rootFld
= evT
->root_field
;
1045 //event has string/sequence or the last event is not the same event
1046 if((evT
->latest_block
!=t
->which_block
|| evT
->latest_event
!=t
->which_event
)
1047 && rootFld
->field_fixed
== 0){
1048 setFieldsOffset(t
, evT
, evData
, t
->trace
);
1050 t
->cur_event_pos
+= EVENT_HEADER_SIZE
+ rootFld
->field_size
;
1051 }else t
->cur_event_pos
+= EVENT_HEADER_SIZE
;
1053 evT
->latest_block
= t
->which_block
;
1054 evT
->latest_event
= t
->which_event
;
1056 //the next event is in the next block
1057 if(evId
== TRACE_BLOCK_END
){
1058 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
1061 t
->current_event_time
= getEventTime(t
);
1067 /*****************************************************************************
1069 * getCyclePerNsec : calculate cycles per nsec for current block
1072 ****************************************************************************/
1074 void getCyclePerNsec(LttTracefile
* t
)
1076 LttTime lBufTotalTime
; /* Total time for this buffer */
1077 LttCycleCount lBufTotalNSec
; /* Total time for this buffer in nsecs */
1078 LttCycleCount lBufTotalCycle
;/* Total cycles for this buffer */
1080 /* Calculate the total time for this buffer */
1081 lBufTotalTime
= ltt_time_sub(t
->a_block_end
->time
, t
->a_block_start
->time
);
1083 /* Calculate the total cycles for this bufffer */
1084 lBufTotalCycle
= t
->a_block_end
->cycle_count
;
1085 lBufTotalCycle
-= t
->a_block_start
->cycle_count
;
1087 /* Convert the total time to nsecs */
1088 lBufTotalNSec
= lBufTotalTime
.tv_sec
;
1089 lBufTotalNSec
*= NANOSECONDS_PER_SECOND
;
1090 lBufTotalNSec
+= lBufTotalTime
.tv_nsec
;
1092 t
->cycle_per_nsec
= (double)lBufTotalCycle
/ (double)lBufTotalNSec
;
1095 /****************************************************************************
1097 * getEventTime : obtain the time of an event
1101 * LttTime : the time of the event
1102 ****************************************************************************/
1104 LttTime
getEventTime(LttTracefile
* tf
)
1107 LttCycleCount cycle_count
; // cycle count for the current event
1108 LttCycleCount lEventTotalCycle
; // Total cycles from start for event
1109 double lEventNSec
; // Total usecs from start for event
1110 LttTime lTimeOffset
; // Time offset in struct LttTime
1112 gint64 nanoSec
, tmpCycleCount
= (((guint64
)1)<<32);
1114 evId
= *(guint16
*)tf
->cur_event_pos
;
1115 if(evId
== TRACE_BLOCK_START
){
1117 tf
->pre_cycle_count
= 0;
1118 tf
->cur_cycle_count
= tf
->a_block_start
->cycle_count
;
1119 return tf
->a_block_start
->time
;
1120 }else if(evId
== TRACE_BLOCK_END
){
1122 tf
->pre_cycle_count
= 0;
1123 tf
->cur_cycle_count
= tf
->a_block_end
->cycle_count
;
1124 return tf
->a_block_end
->time
;
1127 // Calculate total time in cycles from start of buffer for this event
1128 cycle_count
= (LttCycleCount
)*(guint32
*)(tf
->cur_event_pos
+ EVENT_ID_SIZE
);
1130 if(cycle_count
< tf
->pre_cycle_count
)tf
->count
++;
1131 tf
->pre_cycle_count
= cycle_count
;
1132 cycle_count
+= tmpCycleCount
* tf
->count
;
1134 if(tf
->cur_heart_beat_number
> tf
->count
)
1135 cycle_count
+= tmpCycleCount
* (tf
->cur_heart_beat_number
- tf
->count
);
1137 tf
->cur_cycle_count
= cycle_count
;
1139 lEventTotalCycle
= cycle_count
;
1140 lEventTotalCycle
-= tf
->a_block_start
->cycle_count
;
1142 // Convert it to nsecs
1143 lEventNSec
= lEventTotalCycle
/ tf
->cycle_per_nsec
;
1144 nanoSec
= lEventNSec
;
1146 // Determine offset in struct LttTime
1147 lTimeOffset
.tv_nsec
= nanoSec
% NANOSECONDS_PER_SECOND
;
1148 lTimeOffset
.tv_sec
= nanoSec
/ NANOSECONDS_PER_SECOND
;
1150 time
= ltt_time_add(tf
->a_block_start
->time
, lTimeOffset
);
1155 /*****************************************************************************
1157 * setFieldsOffset : set offset of the fields
1159 * tracefile : opened trace file
1160 * evT : the event type
1161 * evD : event data, it may be NULL
1162 ****************************************************************************/
1164 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
* t
)
1166 LttField
* rootFld
= evT
->root_field
;
1167 // rootFld->base_address = evD;
1170 rootFld
->field_size
= getFieldtypeSize(tf
, evT
, 0,0,rootFld
, evD
,t
);
1173 /*****************************************************************************
1175 * getFieldtypeSize: get the size of the field type (primitive type)
1177 * tracefile : opened trace file
1179 * offsetRoot : offset from the root
1180 * offsetParent : offset from the parrent
1182 * evD : event data, it may be NULL
1184 * int : size of the field
1185 ****************************************************************************/
1187 int getFieldtypeSize(LttTracefile
* t
, LttEventType
* evT
, int offsetRoot
,
1188 int offsetParent
, LttField
* fld
, void *evD
, LttTrace
*trace
)
1190 int size
, size1
, element_number
, i
, offset1
, offset2
;
1191 LttType
* type
= fld
->field_type
;
1194 if(evT
->latest_block
==t
->which_block
&& evT
->latest_event
==t
->which_event
){
1195 return fld
->field_size
;
1199 if(fld
->field_fixed
== 1){
1200 if(fld
== evT
->root_field
) return fld
->field_size
;
1203 if(type
->type_class
!= LTT_STRUCT
&& type
->type_class
!= LTT_ARRAY
&&
1204 type
->type_class
!= LTT_SEQUENCE
&& type
->type_class
!= LTT_STRING
){
1205 if(fld
->field_fixed
== -1){
1206 size
= (int) ltt_type_size(trace
, type
);
1207 fld
->field_fixed
= 1;
1208 }else size
= fld
->field_size
;
1210 }else if(type
->type_class
== LTT_ARRAY
){
1211 element_number
= (int) type
->element_number
;
1212 if(fld
->field_fixed
== -1){
1213 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1214 if(size
== 0){ //has string or sequence
1215 fld
->field_fixed
= 0;
1217 fld
->field_fixed
= 1;
1218 size
*= element_number
;
1220 }else if(fld
->field_fixed
== 0){// has string or sequence
1222 for(i
=0;i
<element_number
;i
++){
1223 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
,size
,
1224 fld
->child
[0], evD
+size
, trace
);
1226 }else size
= fld
->field_size
;
1228 }else if(type
->type_class
== LTT_SEQUENCE
){
1229 size1
= (int) ltt_type_size(trace
, type
);
1230 if(fld
->field_fixed
== -1){
1231 fld
->sequ_number_size
= size1
;
1232 fld
->field_fixed
= 0;
1233 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1234 fld
->element_size
= size
;
1236 element_number
= getIntNumber(size1
,evD
);
1237 type
->element_number
= element_number
;
1238 if(fld
->element_size
> 0){
1239 size
= element_number
* fld
->element_size
;
1240 }else{//sequence has string or sequence
1242 for(i
=0;i
<element_number
;i
++){
1243 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
+size1
,size
+size1
,
1244 fld
->child
[0], evD
+size
+size1
, trace
);
1250 }else if(type
->type_class
== LTT_STRING
){
1252 if(fld
->field_fixed
== -1){
1253 fld
->field_fixed
= 0;
1255 size
= strlen((char*)evD
) + 1; //include end : '\0'
1258 }else if(type
->type_class
== LTT_STRUCT
){
1259 element_number
= (int) type
->element_number
;
1261 if(fld
->field_fixed
== -1){
1262 offset1
= offsetRoot
;
1264 for(i
=0;i
<element_number
;i
++){
1265 size1
=getFieldtypeSize(t
, evT
,offset1
,offset2
, fld
->child
[i
], NULL
, trace
);
1266 if(size1
> 0 && size
>= 0){
1268 if(offset1
>= 0) offset1
+= size1
;
1277 fld
->field_fixed
= 0;
1279 }else fld
->field_fixed
= 1;
1280 }else if(fld
->field_fixed
== 0){
1281 offset1
= offsetRoot
;
1283 for(i
=0;i
<element_number
;i
++){
1284 size
=getFieldtypeSize(t
,evT
,offset1
,offset2
,fld
->child
[i
],evD
+offset2
, trace
);
1289 }else size
= fld
->field_size
;
1292 fld
->offset_root
= offsetRoot
;
1293 fld
->offset_parent
= offsetParent
;
1295 fld
->fixed_root
= (offsetRoot
==-1) ? 0 : 1;
1296 fld
->fixed_parent
= (offsetParent
==-1) ? 0 : 1;
1298 fld
->field_size
= size
;
1304 /*****************************************************************************
1306 * getIntNumber : get an integer number
1308 * size : the size of the integer
1309 * evD : the event data
1312 ****************************************************************************/
1314 int getIntNumber(int size
, void *evD
)
1317 if(size
== 1) i
= *(gint8
*)evD
;
1318 else if(size
== 2) i
= *(gint16
*)evD
;
1319 else if(size
== 4) i
= *(gint32
*)evD
;
1320 else if(size
== 8) i
= *(gint64
*)evD
;
1325 /*****************************************************************************
1327 * getDataEndianType : get the data type size and endian type of the local
1330 * size : size of data type
1331 * endian : endian type, little or big
1332 ****************************************************************************/
1334 void getDataEndianType(LttArchSize
* size
, LttArchEndian
* endian
)
1338 int sizeInt
=sizeof(int), sizeLong
=sizeof(long), sizePointer
=sizeof(void *);
1340 if(c
== 1) *endian
= LTT_LITTLE_ENDIAN
;
1341 else *endian
= LTT_BIG_ENDIAN
;
1343 if(sizeInt
== 2 && sizeLong
== 4 && sizePointer
== 4)
1345 else if(sizeInt
== 4 && sizeLong
== 4 && sizePointer
== 4)
1347 else if(sizeInt
== 4 && sizeLong
== 8 && sizePointer
== 8)
1349 else if(sizeInt
== 8 && sizeLong
== 8 && sizePointer
== 8)
1351 else *size
= LTT_UNKNOWN
;
1354 /* get the node name of the system */
1356 char * ltt_trace_system_description_node_name (LttSystemDescription
* s
)
1358 return s
->node_name
;
1362 /* get the domain name of the system */
1364 char * ltt_trace_system_description_domain_name (LttSystemDescription
* s
)
1366 return s
->domain_name
;
1370 /* get the description of the system */
1372 char * ltt_trace_system_description_description (LttSystemDescription
* s
)
1374 return s
->description
;
1378 /* get the start time of the trace */
1380 LttTime
ltt_trace_system_description_trace_start_time(LttSystemDescription
*s
)
1382 return s
->trace_start
;