6 #include <linux/errno.h>
8 #include <ltt/LTTTypes.h>
10 #include <ltt/trace.h>
12 #define DIR_NAME_SIZE 256
14 /* set the offset of the fields belonging to the event,
15 need the information of the archecture */
16 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
*t
);
18 /* get the size of the field type according to the archtecture's
19 size and endian type(info of the archecture) */
20 int getFieldtypeSize(LttTracefile
* tf
, LttEventType
* evT
, int offsetRoot
,
21 int offsetParent
, LttField
*fld
, void *evD
, LttTrace
* t
);
23 /* read a fixed size or a block information from the file (fd) */
24 int readFile(int fd
, void * buf
, size_t size
, char * mesg
);
25 int readBlock(LttTracefile
* tf
, int whichBlock
);
27 /* calculate cycles per nsec for current block */
28 void getCyclePerNsec(LttTracefile
* t
);
30 /* reinitialize the info of the block which is already in the buffer */
31 void updateTracefile(LttTracefile
* tf
);
33 /* go to the next event */
34 int skipEvent(LttTracefile
* t
);
36 /* compare two time (LttTime), 0:t1=t2, -1:t1<t2, 1:t1>t2 */
37 int timecmp(LttTime
* t1
, LttTime
* t2
);
41 /*****************************************************************************
43 * ltt_tracefile_open : open a trace file, construct a LttTracefile
45 * t : the trace containing the tracefile
46 * fileName : path name of the trace file
48 * : a pointer to a tracefile
49 ****************************************************************************/
51 LttTracefile
* ltt_tracefile_open(LttTrace
* t
, char * fileName
)
54 struct stat lTDFStat
; /* Trace data file status */
55 BlockStart a_block_start
;
57 tf
= g_new(LttTracefile
, 1);
60 tf
->name
= g_strdup(fileName
);
62 tf
->fd
= open(fileName
, O_RDONLY
, 0);
64 g_error("Unable to open input data file %s\n", fileName
);
67 // Get the file's status
68 if(fstat(tf
->fd
, &lTDFStat
) < 0){
69 g_error("Unable to get the status of the input data file %s\n", fileName
);
72 // Is the file large enough to contain a trace
73 if(lTDFStat
.st_size
< sizeof(BlockStart
) + EVENT_HEADER_SIZE
){
74 g_print("The input data file %s does not contain a trace\n", fileName
);
81 //store the size of the file
82 tf
->file_size
= lTDFStat
.st_size
;
83 tf
->block_size
= t
->system_description
->ltt_block_size
;
84 tf
->block_number
= tf
->file_size
/ tf
->block_size
;
87 //allocate memory to contain the info of a block
88 tf
->buffer
= (void *) g_new(char, t
->system_description
->ltt_block_size
);
90 //read the first block
91 if(readBlock(tf
,1)) exit(1);
97 /*****************************************************************************
98 *Open control and per cpu tracefiles
99 ****************************************************************************/
101 void ltt_tracefile_open_cpu(LttTrace
*t
, char * tracefile_name
)
104 tf
= ltt_tracefile_open(t
,tracefile_name
);
106 t
->per_cpu_tracefile_number
++;
107 g_ptr_array_add(t
->per_cpu_tracefiles
, tf
);
110 void ltt_tracefile_open_control(LttTrace
*t
, char * control_name
)
120 tf
= ltt_tracefile_open(t
,control_name
);
122 t
->control_tracefile_number
++;
123 g_ptr_array_add(t
->control_tracefiles
,tf
);
125 //parse facilities tracefile to get base_id
126 if(strcmp(&control_name
[strlen(control_name
)-10],"facilities") ==0){
128 ev
= ltt_tracefile_read(tf
);
129 if(!ev
)return; // end of file
131 if(ev
->event_id
== TRACE_FACILITY_LOAD
){
133 fLoad
.name
= (char*)pos
;
134 fLoad
.checksum
= *(LttChecksum
*)(pos
+ strlen(fLoad
.name
));
135 fLoad
.base_code
= *(uint32_t*)(pos
+ strlen(fLoad
.name
) + sizeof(LttChecksum
));
137 for(i
=0;i
<t
->facility_number
;i
++){
138 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
139 if(strcmp(f
->name
,fLoad
.name
)==0 && fLoad
.checksum
==f
->checksum
){
140 f
->base_id
= fLoad
.base_code
;
144 if(i
==t
->facility_number
)
145 g_error("Facility: %s, checksum: %d is not founded\n",
146 fLoad
.name
,fLoad
.checksum
);
147 }else if(ev
->event_id
== TRACE_BLOCK_START
){
149 }else if(ev
->event_id
== TRACE_BLOCK_END
){
151 }else g_error("Not valid facilities trace file\n");
156 /*****************************************************************************
158 * ltt_tracefile_close: close a trace file,
160 * t : tracefile which will be closed
161 ****************************************************************************/
163 void ltt_tracefile_close(LttTracefile
*t
)
172 /*****************************************************************************
173 *Get system information
174 ****************************************************************************/
175 void getSystemInfo(LttSystemDescription
* des
, char * pathname
)
179 int entry_number
= 15;
180 char buf
[DIR_NAME_SIZE
];
181 char description
[4*DIR_NAME_SIZE
];
184 fp
= fopen(pathname
,"r");
186 g_error("Can not open file : %s\n", pathname
);
189 while(fgets(buf
,DIR_NAME_SIZE
, fp
)!= NULL
){
191 while(isspace(*ptr
)) ptr
++;
192 if(strlen(ptr
) == 0) continue;
196 if(strlen(ptr
) == 0) g_error("Not a valid file: %s\n", pathname
);
197 if(strncmp("<system",ptr
,7) !=0)g_error("Not a valid file: %s\n", pathname
);
199 for(i
=0;i
<entry_number
;i
++){
200 if(fgets(buf
,DIR_NAME_SIZE
, fp
)== NULL
)
201 g_error("Not a valid file: %s\n", pathname
);
202 buf
[strlen(buf
)-1] = '\0';
204 while(isspace(*ptr
)) ptr
++;
207 if(strncmp("node_name=",ptr
,10)!=0)
208 g_error("Not a valid file: %s\n", pathname
);
209 des
->node_name
= g_strdup(ptr
+10);
212 if(strncmp("domainname=",ptr
,11)!=0)
213 g_error("Not a valid file: %s\n", pathname
);
214 des
->domain_name
= g_strdup(ptr
+11);
217 if(strncmp("cpu=",ptr
,4)!=0)
218 g_error("Not a valid file: %s\n", pathname
);
219 des
->nb_cpu
= (unsigned)atoi(ptr
+4);
222 if(strncmp("arch_size=",ptr
,10)!=0)
223 g_error("Not a valid file: %s\n", pathname
);
224 if(strcmp(ptr
+10,"\"LP32\"") == 0) des
->size
= LTT_LP32
;
225 else if(strcmp(ptr
+10,"\"ILP32\"") == 0) des
->size
= LTT_ILP32
;
226 else if(strcmp(ptr
+10,"\"LP64\"") == 0) des
->size
= LTT_LP64
;
227 else if(strcmp(ptr
+10,"\"ILP64\"") == 0) des
->size
= LTT_ILP64
;
228 else if(strcmp(ptr
+10,"\"UNKNOWN\"") == 0) des
->size
= LTT_UNKNOWN
;
231 if(strncmp("endian=",ptr
,7)!=0)
232 g_error("Not a valid file: %s\n", pathname
);
233 if(strcmp(ptr
+7,"\"LITTLE_ENDIAN\"") == 0)
234 des
->endian
= LTT_LITTLE_ENDIAN
;
235 else if(strcmp(ptr
+7,"\"BIG_ENDIAN\"") == 0)
236 des
->endian
= LTT_BIG_ENDIAN
;
239 if(strncmp("kernel_name=",ptr
,12)!=0)
240 g_error("Not a valid file: %s\n", pathname
);
241 des
->kernel_name
= g_strdup(ptr
+12);
244 if(strncmp("kernel_release=",ptr
,15)!=0)
245 g_error("Not a valid file: %s\n", pathname
);
246 des
->kernel_release
= g_strdup(ptr
+15);
249 if(strncmp("kernel_version=",ptr
,15)!=0)
250 g_error("Not a valid file: %s\n", pathname
);
251 des
->kernel_version
= g_strdup(ptr
+15);
254 if(strncmp("machine=",ptr
,8)!=0)
255 g_error("Not a valid file: %s\n", pathname
);
256 des
->machine
= g_strdup(ptr
+8);
259 if(strncmp("processor=",ptr
,10)!=0)
260 g_error("Not a valid file: %s\n", pathname
);
261 des
->processor
= g_strdup(ptr
+10);
264 if(strncmp("hardware_platform=",ptr
,18)!=0)
265 g_error("Not a valid file: %s\n", pathname
);
266 des
->hardware_platform
= g_strdup(ptr
+18);
269 if(strncmp("operating_system=",ptr
,17)!=0)
270 g_error("Not a valid file: %s\n", pathname
);
271 des
->operating_system
= g_strdup(ptr
+17);
274 if(strncmp("ltt_major_version=",ptr
,18)!=0)
275 g_error("Not a valid file: %s\n", pathname
);
277 // ptr++;//skip begining "
278 // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
279 des
->ltt_major_version
= (unsigned)atoi(ptr
);
282 if(strncmp("ltt_minor_version=",ptr
,18)!=0)
283 g_error("Not a valid file: %s\n", pathname
);
285 // ptr++;//skip begining "
286 // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
287 des
->ltt_minor_version
= (unsigned)atoi(ptr
);
290 if(strncmp("ltt_block_size=",ptr
,15)!=0)
291 g_error("Not a valid file: %s\n", pathname
);
293 // ptr++;//skip begining "
294 // ptr[strlen(ptr)-1] = '\0'; //get rid of the ending "
295 des
->ltt_block_size
= (unsigned)atoi(ptr
);
298 g_error("Not a valid file: %s\n", pathname
);
303 description
[0] = '\0';
304 if(fgets(buf
,DIR_NAME_SIZE
, fp
)== NULL
)
305 g_error("Not a valid file: %s\n", pathname
);
307 while(isspace(*ptr
)) ptr
++;
308 if(*ptr
!= '>') g_error("Not a valid file: %s\n", pathname
);
309 while((ptr
=fgets(buf
,DIR_NAME_SIZE
, fp
))!= NULL
){
311 while(isspace(*ptr
)) ptr
++;
312 if(strncmp("</system>",ptr
,9) == 0 )break;
313 strcat(description
, buf
);
315 if(!ptr
)g_error("Not a valid file: %s\n", pathname
);
316 if(description
[0] = '\0')des
->description
= NULL
;
317 des
->description
= g_strdup(description
);
322 /*****************************************************************************
323 *The following functions get facility/tracefile information
324 ****************************************************************************/
326 void getFacilityInfo(LttTrace
*t
, char* eventdefs
)
329 struct dirent
*entry
;
334 char name
[DIR_NAME_SIZE
];
336 dir
= opendir(eventdefs
);
337 if(!dir
) g_error("Can not open directory: %s\n", eventdefs
);
339 while((entry
= readdir(dir
)) != NULL
){
340 ptr
= &entry
->d_name
[strlen(entry
->d_name
)-4];
341 if(strcmp(ptr
,".xml") != 0) continue;
342 strcpy(name
,eventdefs
);
343 strcat(name
,entry
->d_name
);
344 ltt_facility_open(t
,name
);
348 for(j
=0;j
<t
->facility_number
;j
++){
349 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, j
);
350 for(i
=0; i
<f
->event_number
; i
++){
352 setFieldsOffset(NULL
, et
, NULL
, t
);
357 void getControlFileInfo(LttTrace
*t
, char* control
)
360 struct dirent
*entry
;
361 char name
[DIR_NAME_SIZE
];
363 dir
= opendir(control
);
364 if(!dir
) g_error("Can not open directory: %s\n", control
);
366 while((entry
= readdir(dir
)) != NULL
){
367 if(strcmp(entry
->d_name
,"facilities") != 0 &&
368 strcmp(entry
->d_name
,"interrupts") != 0 &&
369 strcmp(entry
->d_name
,"processes") != 0) continue;
371 strcpy(name
,control
);
372 strcat(name
,entry
->d_name
);
373 ltt_tracefile_open_control(t
,name
);
378 void getCpuFileInfo(LttTrace
*t
, char* cpu
)
381 struct dirent
*entry
;
382 char name
[DIR_NAME_SIZE
];
385 if(!dir
) g_error("Can not open directory: %s\n", cpu
);
387 while((entry
= readdir(dir
)) != NULL
){
388 if(strcmp(entry
->d_name
,".") != 0 &&
389 strcmp(entry
->d_name
,"..") != 0 ){
391 strcat(name
,entry
->d_name
);
392 ltt_tracefile_open_cpu(t
,name
);
398 /*****************************************************************************
399 *A trace is specified as a pathname to the directory containing all the
400 *associated data (control tracefiles, per cpu tracefiles, event
403 *When a trace is closed, all the associated facilities, types and fields
404 *are released as well.
405 ****************************************************************************/
407 LttTrace
*ltt_trace_open(char *pathname
)
410 LttSystemDescription
* sys_description
;
411 char eventdefs
[DIR_NAME_SIZE
];
412 char info
[DIR_NAME_SIZE
];
413 char control
[DIR_NAME_SIZE
];
414 char cpu
[DIR_NAME_SIZE
];
415 char tmp
[DIR_NAME_SIZE
];
416 gboolean has_slash
= FALSE
;
418 //establish the pathname to different directories
419 if(pathname
[strlen(pathname
)-1] == '/')has_slash
= TRUE
;
420 strcpy(eventdefs
,pathname
);
421 if(!has_slash
)strcat(eventdefs
,"/");
422 strcat(eventdefs
,"eventdefs/");
424 strcpy(info
,pathname
);
425 if(!has_slash
)strcat(info
,"/");
426 strcat(info
,"info/");
428 strcpy(control
,pathname
);
429 if(!has_slash
)strcat(control
,"/");
430 strcat(control
,"control/");
432 strcpy(cpu
,pathname
);
433 if(!has_slash
)strcat(cpu
,"/");
437 t
= g_new(LttTrace
, 1);
438 sys_description
= g_new(LttSystemDescription
, 1);
439 t
->pathname
= g_strdup(pathname
);
440 t
->facility_number
= 0;
441 t
->control_tracefile_number
= 0;
442 t
->per_cpu_tracefile_number
= 0;
443 t
->system_description
= sys_description
;
444 t
->control_tracefiles
= g_ptr_array_new();
445 t
->per_cpu_tracefiles
= g_ptr_array_new();
446 t
->facilities
= g_ptr_array_new();
447 getDataEndianType(&(t
->my_arch_size
), &(t
->my_arch_endian
));
449 //get system description
451 strcat(tmp
,"system.xml");
452 getSystemInfo(sys_description
, tmp
);
454 //get facilities info
455 getFacilityInfo(t
,eventdefs
);
457 //get control tracefile info
458 getControlFileInfo(t
,control
);
460 //get cpu tracefile info
461 getCpuFileInfo(t
,cpu
);
466 void ltt_trace_close(LttTrace
*t
)
474 //free system_description
475 g_free(t
->system_description
->description
);
476 g_free(t
->system_description
->node_name
);
477 g_free(t
->system_description
->domain_name
);
478 g_free(t
->system_description
->kernel_name
);
479 g_free(t
->system_description
->kernel_release
);
480 g_free(t
->system_description
->kernel_version
);
481 g_free(t
->system_description
->machine
);
482 g_free(t
->system_description
->processor
);
483 g_free(t
->system_description
->hardware_platform
);
484 g_free(t
->system_description
->operating_system
);
485 g_free(t
->system_description
);
487 //free control_tracefiles
488 for(i
=0;i
<t
->control_tracefile_number
;i
++){
489 tf
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
,i
);
490 ltt_tracefile_close(tf
);
492 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
494 //free per_cpu_tracefiles
495 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
496 tf
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
,i
);
497 ltt_tracefile_close(tf
);
499 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
502 for(i
=0;i
<t
->facility_number
;i
++){
503 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
504 ltt_facility_close(f
);
506 g_ptr_array_free(t
->facilities
, TRUE
);
514 /*****************************************************************************
515 *Get the system description of the trace
516 ****************************************************************************/
518 LttSystemDescription
*ltt_trace_system_description(LttTrace
*t
)
520 return t
->system_description
;
523 /*****************************************************************************
524 * The following functions discover the facilities of the trace
525 ****************************************************************************/
527 unsigned ltt_trace_facility_number(LttTrace
*t
)
529 return (unsigned)(t
->facility_number
);
532 LttFacility
*ltt_trace_facility_get(LttTrace
*t
, unsigned i
)
534 return (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
537 /*****************************************************************************
539 * ltt_trace_facility_find : find facilities in the trace
542 * name : facility name
544 * position : position of the facility in the trace
546 * : the number of facilities
547 ****************************************************************************/
549 unsigned ltt_trace_facility_find(LttTrace
*t
, char *name
, unsigned *position
)
553 for(i
=0;i
<t
->facility_number
;i
++){
554 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
555 if(strcmp(f
->name
,name
)==0){
557 if(count
==1) *position
= i
;
565 /*****************************************************************************
566 * Functions to discover all the event types in the trace
567 ****************************************************************************/
569 unsigned ltt_trace_eventtype_number(LttTrace
*t
)
574 for(i
=0;i
=t
->facility_number
;i
++){
575 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
576 count
+= f
->event_number
;
581 LttFacility
* ltt_trace_facility_by_id(LttTrace
* trace
, unsigned id
)
583 LttFacility
* facility
;
585 for(i
=0;i
<trace
->facility_number
;i
++){
586 facility
= (LttFacility
*) g_ptr_array_index(trace
->facilities
,i
);
587 if(id
>= facility
->base_id
&&
588 id
< facility
->base_id
+ facility
->event_number
)
591 if(i
==trace
->facility_number
) return NULL
;
592 else return facility
;
595 LttEventType
*ltt_trace_eventtype_get(LttTrace
*t
, unsigned evId
)
598 f
= ltt_trace_facility_by_id(t
,evId
);
600 return f
->events
[evId
- f
->base_id
];
603 /*****************************************************************************
604 *There is one "per cpu" tracefile for each CPU, numbered from 0 to
605 *the maximum number of CPU in the system. When the number of CPU installed
606 *is less than the maximum, some positions are unused. There are also a
607 *number of "control" tracefiles (facilities, interrupts...).
608 ****************************************************************************/
609 unsigned ltt_trace_control_tracefile_number(LttTrace
*t
)
611 return t
->control_tracefile_number
;
614 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace
*t
)
616 return t
->per_cpu_tracefile_number
;
619 /*****************************************************************************
620 *It is possible to search for the tracefiles by name or by CPU position.
621 *The index within the tracefiles of the same type is returned if found
622 *and a negative value otherwise.
623 ****************************************************************************/
625 int ltt_trace_control_tracefile_find(LttTrace
*t
, char *name
)
627 LttTracefile
* tracefile
;
629 for(i
=0;i
<t
->control_tracefile_number
;i
++){
630 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
631 if(strcmp(tracefile
->name
, name
)==0)break;
633 if(i
== t
->control_tracefile_number
) return -1;
637 int ltt_trace_per_cpu_tracefile_find(LttTrace
*t
, unsigned i
)
639 LttTracefile
* tracefile
;
641 for(j
=0;j
<t
->per_cpu_tracefile_number
;j
++){
642 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, j
);
643 name
= atoi(tracefile
->name
);
644 if(name
== (int)i
)break;
646 if(j
== t
->per_cpu_tracefile_number
) return -1;
650 /*****************************************************************************
651 *Get a specific tracefile
652 ****************************************************************************/
654 LttTracefile
*ltt_trace_control_tracefile_get(LttTrace
*t
, unsigned i
)
656 return (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
659 LttTracefile
*ltt_trace_per_cpu_tracefile_get(LttTrace
*t
, unsigned i
)
661 return (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
664 /*****************************************************************************
665 *Get the name of a tracefile
666 ****************************************************************************/
668 char *ltt_tracefile_name(LttTracefile
*tf
)
673 /*****************************************************************************
674 * Get the number of blocks in the tracefile
675 ****************************************************************************/
677 unsigned ltt_tracefile_block_number(LttTracefile
*tf
)
679 return tf
->block_number
;
682 /*****************************************************************************
684 * ltt_tracefile_seek_time: seek to the first event of the trace with time
685 * larger or equal to time
688 * time : criteria of the time
689 ****************************************************************************/
691 void ltt_tracefile_seek_time(LttTracefile
*t
, LttTime time
)
695 int headTime
= timecmp(&(t
->a_block_start
->time
), &time
);
696 int tailTime
= timecmp(&(t
->a_block_end
->time
), &time
);
699 if(headTime
< 0 && tailTime
> 0){
700 lttTime
= getEventTime(t
);
701 err
= timecmp(<tTime
, &time
);
703 if(t
->which_event
==2 || timecmp(&t
->prev_event_time
,&time
)<0){
707 return ltt_tracefile_seek_time(t
, time
);
711 ev
= ltt_tracefile_read(t
);
713 g_print("End of file\n");
716 lttTime
= getEventTime(t
);
717 err
= timecmp(<tTime
, &time
);
721 }else if(headTime
> 0){
722 if(t
->which_block
== 1){
725 if(timecmp(&(t
->prev_block_end_time
),&time
) >= 0 ){
726 err
=readBlock(t
,t
->which_block
-1);
727 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
728 return ltt_tracefile_seek_time(t
, time
) ;
733 }else if(tailTime
< 0){
734 if(t
->which_block
!= t
->block_number
){
735 err
=readBlock(t
,t
->which_block
+1);
736 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
738 g_print("End of file\n");
741 if(tailTime
< 0) return ltt_tracefile_seek_time(t
, time
);
742 }else if(headTime
== 0){
744 }else if(tailTime
== 0){
745 t
->cur_event_pos
= t
->a_block_end
- EVENT_HEADER_SIZE
;
746 t
->current_event_time
= time
;
747 t
->cur_heart_beat_number
= 0;
748 t
->prev_event_time
.tv_sec
= 0;
749 t
->prev_event_time
.tv_nsec
= 0;
754 /*****************************************************************************
755 * Seek to the first event with position equal or larger to ep
756 ****************************************************************************/
758 void ltt_tracefile_seek_position(LttTracefile
*t
, LttEventPosition
*ep
)
760 //if we are at the right place, just return
761 if(t
->which_block
== ep
->block_num
&& t
->which_event
== ep
->event_num
)
764 if(t
->which_block
== ep
->block_num
) updateTracefile(t
);
765 else readBlock(t
,ep
->block_num
);
767 //event offset is availiable
768 if(ep
->old_position
){
769 t
->cur_heart_beat_number
= ep
->heart_beat_number
;
770 t
->cur_event_pos
= t
->buffer
+ ep
->event_offset
;
774 //only block number and event index are availiable
775 while(t
->which_event
< ep
->event_num
) ltt_tracefile_read(t
);
780 /*****************************************************************************
782 * ltt_tracefile_read : read the current event, set the pointer to the next
786 * LttEvent * : an event to be processed
787 ****************************************************************************/
789 LttEvent
*ltt_tracefile_read(LttTracefile
*t
)
791 LttEvent
* lttEvent
= &t
->an_event
;
794 if(t
->cur_event_pos
== t
->buffer
+ t
->block_size
){
795 if(t
->which_block
== t
->block_number
){
799 err
= readBlock(t
, t
->which_block
+ 1);
800 if(err
)g_error("Can not read tracefile");
803 lttEvent
->event_id
= (int)(*(uint16_t *)(t
->cur_event_pos
));
804 if(lttEvent
->event_id
== TRACE_TIME_HEARTBEAT
)
805 t
->cur_heart_beat_number
++;
807 t
->prev_event_time
= t
->current_event_time
;
808 // t->current_event_time = getEventTime(t);
810 lttEvent
->time_delta
= *(uint32_t*)(t
->cur_event_pos
+ EVENT_ID_SIZE
);
811 lttEvent
->event_time
= t
->current_event_time
;
813 lttEvent
->event_cycle_count
= ((uint64_t)1)<<32 * t
->cur_heart_beat_number
814 + lttEvent
->time_delta
;
816 lttEvent
->tracefile
= t
;
817 lttEvent
->data
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
818 lttEvent
->which_block
= t
->which_block
;
819 lttEvent
->which_event
= t
->which_event
;
821 //update the fields of the current event and go to the next event
823 if(err
== ERANGE
) g_error("event id is out of range\n");
828 /****************************************************************************
830 * readFile : wrap function to read from a file
832 * fd : file descriptor
833 * buf : buf to contain the content
834 * size : number of bytes to be read
835 * mesg : message to be printed if some thing goes wrong
838 * EIO : can not read from the file
839 ****************************************************************************/
841 int readFile(int fd
, void * buf
, size_t size
, char * mesg
)
844 nbBytes
= read(fd
, buf
, size
);
852 /****************************************************************************
854 * readBlock : read a block from the file
856 * lttdes : ltt trace file
857 * whichBlock : the block which will be read
860 * EINVAL : lseek fail
861 * EIO : can not read from the file
862 ****************************************************************************/
864 int readBlock(LttTracefile
* tf
, int whichBlock
)
869 if(whichBlock
- tf
->which_block
== 1 && tf
->which_block
!= 0){
870 tf
->prev_block_end_time
= tf
->a_block_end
->time
;
871 tf
->prev_event_time
= tf
->a_block_end
->time
;
873 tf
->prev_block_end_time
.tv_sec
= 0;
874 tf
->prev_block_end_time
.tv_nsec
= 0;
875 tf
->prev_event_time
.tv_sec
= 0;
876 tf
->prev_event_time
.tv_nsec
= 0;
879 nbBytes
=lseek(tf
->fd
,(off_t
)((whichBlock
-1)*tf
->block_size
), SEEK_SET
);
880 if(nbBytes
== -1) return EINVAL
;
882 if(readFile(tf
->fd
,tf
->buffer
,tf
->block_size
,"Unable to read a block"))
885 tf
->a_block_start
=(BlockStart
*) (tf
->buffer
+ EVENT_HEADER_SIZE
);
886 lostSize
= *(uint32_t*)(tf
->buffer
+ tf
->block_size
- sizeof(uint32_t));
887 tf
->a_block_end
=(BlockEnd
*)(tf
->buffer
+ tf
->block_size
-
888 lostSize
+ EVENT_HEADER_SIZE
);
890 tf
->which_block
= whichBlock
;
892 tf
->cur_event_pos
= tf
->buffer
;//the beginning of the block, block start ev
893 tf
->cur_heart_beat_number
= 0;
897 tf
->current_event_time
= getEventTime(tf
);
902 /*****************************************************************************
904 * updateTracefile : reinitialize the info of the block which is already
908 ****************************************************************************/
910 void updateTracefile(LttTracefile
* tf
)
913 tf
->cur_event_pos
= tf
->buffer
;
914 tf
->current_event_time
= getEventTime(tf
);
915 tf
->cur_heart_beat_number
= 0;
917 tf
->prev_event_time
.tv_sec
= 0;
918 tf
->prev_event_time
.tv_nsec
= 0;
921 /*****************************************************************************
923 * skipEvent : go to the next event, update the fields of the current event
928 * ERANGE : event id is out of range
929 ****************************************************************************/
931 int skipEvent(LttTracefile
* t
)
938 evId
= (int)(*(uint16_t *)(t
->cur_event_pos
));
939 evData
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
941 evT
= ltt_trace_eventtype_get(t
->trace
,(unsigned)evId
);
943 if(evT
) rootFld
= evT
->root_field
;
947 //event has string/sequence or the last event is not the same event
948 if((evT
->latest_block
!=t
->which_block
|| evT
->latest_event
!=t
->which_event
)
949 && rootFld
->field_fixed
== 0){
950 setFieldsOffset(t
, evT
, evData
, t
->trace
);
952 t
->cur_event_pos
+= EVENT_HEADER_SIZE
+ rootFld
->field_size
;
953 }else t
->cur_event_pos
+= EVENT_HEADER_SIZE
;
955 evT
->latest_block
= t
->which_block
;
956 evT
->latest_event
= t
->which_event
;
958 //the next event is in the next block
959 if(evId
== TRACE_BLOCK_END
){
960 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
963 t
->current_event_time
= getEventTime(t
);
969 /*****************************************************************************
971 * getCyclePerNsec : calculate cycles per nsec for current block
974 ****************************************************************************/
976 void getCyclePerNsec(LttTracefile
* t
)
978 LttTime lBufTotalTime
; /* Total time for this buffer */
979 LttCycleCount lBufTotalNSec
; /* Total time for this buffer in nsecs */
980 LttCycleCount lBufTotalCycle
;/* Total cycles for this buffer */
982 /* Calculate the total time for this buffer */
983 TimeSub(lBufTotalTime
,t
->a_block_end
->time
, t
->a_block_start
->time
);
985 /* Calculate the total cycles for this bufffer */
986 lBufTotalCycle
= t
->a_block_end
->cycle_count
987 - t
->a_block_start
->cycle_count
;
989 /* Convert the total time to nsecs */
990 lBufTotalNSec
= lBufTotalTime
.tv_sec
* 1000000000 + lBufTotalTime
.tv_nsec
;
992 t
->cycle_per_nsec
= (double)lBufTotalCycle
/ (double)lBufTotalNSec
;
995 /****************************************************************************
997 * getEventTime : obtain the time of an event
1001 * LttTime : the time of the event
1002 ****************************************************************************/
1004 LttTime
getEventTime(LttTracefile
* tf
)
1007 LttCycleCount cycle_count
; // cycle count for the current event
1008 LttCycleCount lEventTotalCycle
; // Total cycles from start for event
1009 double lEventNSec
; // Total usecs from start for event
1010 LttTime lTimeOffset
; // Time offset in struct LttTime
1013 evId
= *(uint16_t*)tf
->cur_event_pos
;
1014 if(evId
== TRACE_BLOCK_START
)
1015 return tf
->a_block_start
->time
;
1016 else if(evId
== TRACE_BLOCK_END
)
1017 return tf
->a_block_end
->time
;
1020 // Calculate total time in cycles from start of buffer for this event
1021 cycle_count
= (LttCycleCount
)*(uint32_t*)(tf
->cur_event_pos
+ EVENT_ID_SIZE
);
1022 if(tf
->cur_heart_beat_number
)
1023 cycle_count
+= ((uint64_t)1)<<32 * tf
->cur_heart_beat_number
;
1024 lEventTotalCycle
= cycle_count
- tf
->a_block_start
->cycle_count
;
1026 // Convert it to nsecs
1027 lEventNSec
= lEventTotalCycle
/ tf
->cycle_per_nsec
;
1029 // Determine offset in struct LttTime
1030 lTimeOffset
.tv_nsec
= (long)lEventNSec
% 1000000000;
1031 lTimeOffset
.tv_sec
= (long)lEventNSec
/ 1000000000;
1033 TimeAdd(time
, tf
->a_block_start
->time
, lTimeOffset
);
1038 /*****************************************************************************
1040 * setFieldsOffset : set offset of the fields
1042 * tracefile : opened trace file
1043 * evT : the event type
1044 * evD : event data, it may be NULL
1045 ****************************************************************************/
1047 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
* t
)
1049 LttField
* rootFld
= evT
->root_field
;
1050 // rootFld->base_address = evD;
1053 rootFld
->field_size
= getFieldtypeSize(tf
, evT
, 0,0,rootFld
, evD
,t
);
1056 /*****************************************************************************
1058 * getFieldtypeSize: get the size of the field type (primitive type)
1060 * tracefile : opened trace file
1062 * offsetRoot : offset from the root
1063 * offsetParent : offset from the parrent
1065 * evD : event data, it may be NULL
1067 * int : size of the field
1068 ****************************************************************************/
1070 int getFieldtypeSize(LttTracefile
* t
, LttEventType
* evT
, int offsetRoot
,
1071 int offsetParent
, LttField
* fld
, void *evD
, LttTrace
*trace
)
1073 int size
, size1
, element_number
, i
, offset1
, offset2
;
1074 LttType
* type
= fld
->field_type
;
1077 if(evT
->latest_block
==t
->which_block
&& evT
->latest_event
==t
->which_event
){
1078 return fld
->field_size
;
1082 if(fld
->field_fixed
== 1){
1083 if(fld
== evT
->root_field
) return fld
->field_size
;
1086 if(type
->type_class
!= LTT_STRUCT
&& type
->type_class
!= LTT_ARRAY
&&
1087 type
->type_class
!= LTT_SEQUENCE
&& type
->type_class
!= LTT_STRING
){
1088 if(fld
->field_fixed
== -1){
1089 size
= (int) ltt_type_size(trace
, type
);
1090 fld
->field_fixed
= 1;
1091 }else size
= fld
->field_size
;
1093 }else if(type
->type_class
== LTT_ARRAY
){
1094 element_number
= (int) type
->element_number
;
1095 if(fld
->field_fixed
== -1){
1096 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1097 if(size
== 0){ //has string or sequence
1098 fld
->field_fixed
= 0;
1100 fld
->field_fixed
= 1;
1101 size
*= element_number
;
1103 }else if(fld
->field_fixed
== 0){// has string or sequence
1105 for(i
=0;i
<element_number
;i
++){
1106 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
,size
,
1107 fld
->child
[0], evD
+size
, trace
);
1109 }else size
= fld
->field_size
;
1111 }else if(type
->type_class
== LTT_SEQUENCE
){
1112 size1
= (int) ltt_type_size(trace
, type
);
1113 if(fld
->field_fixed
== -1){
1114 fld
->sequ_number_size
= size1
;
1115 fld
->field_fixed
= 0;
1116 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1117 fld
->element_size
= size
;
1119 element_number
= getIntNumber(size1
,evD
);
1120 type
->element_number
= element_number
;
1121 if(fld
->element_size
> 0){
1122 size
= element_number
* fld
->element_size
;
1123 }else{//sequence has string or sequence
1125 for(i
=0;i
<element_number
;i
++){
1126 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
+size1
,size
+size1
,
1127 fld
->child
[0], evD
+size
+size1
, trace
);
1133 }else if(type
->type_class
== LTT_STRING
){
1135 if(fld
->field_fixed
== -1){
1136 fld
->field_fixed
= 0;
1138 size
= strlen((char*)evD
) + 1; //include end : '\0'
1141 }else if(type
->type_class
== LTT_STRUCT
){
1142 element_number
= (int) type
->element_number
;
1144 if(fld
->field_fixed
== -1){
1145 offset1
= offsetRoot
;
1147 for(i
=0;i
<element_number
;i
++){
1148 size1
=getFieldtypeSize(t
, evT
,offset1
,offset2
, fld
->child
[i
], NULL
, trace
);
1149 if(size1
> 0 && size
>= 0){
1151 if(offset1
>= 0) offset1
+= size1
;
1160 fld
->field_fixed
= 0;
1162 }else fld
->field_fixed
= 1;
1163 }else if(fld
->field_fixed
== 0){
1164 offset1
= offsetRoot
;
1166 for(i
=0;i
<element_number
;i
++){
1167 size
=getFieldtypeSize(t
,evT
,offset1
,offset2
,fld
->child
[i
],evD
+offset2
, trace
);
1172 }else size
= fld
->field_size
;
1175 fld
->offset_root
= offsetRoot
;
1176 fld
->offset_parent
= offsetParent
;
1178 fld
->fixed_root
= (offsetRoot
==-1) ? 0 : 1;
1179 fld
->fixed_parent
= (offsetParent
==-1) ? 0 : 1;
1181 fld
->field_size
= size
;
1186 /*****************************************************************************
1188 * timecmp : compare two time
1193 * int : 0: t1 == t2; -1: t1 < t2; 1: t1 > t2
1194 ****************************************************************************/
1196 int timecmp(LttTime
* t1
, LttTime
* t2
)
1198 if(t1
->tv_sec
< t2
->tv_sec
) return -1;
1199 if(t1
->tv_sec
> t2
->tv_sec
) return 1;
1200 if(t1
->tv_nsec
< t2
->tv_nsec
) return -1;
1201 if(t1
->tv_nsec
> t2
->tv_nsec
) return 1;
1205 /*****************************************************************************
1207 * getIntNumber : get an integer number
1209 * size : the size of the integer
1210 * evD : the event data
1213 ****************************************************************************/
1215 int getIntNumber(int size
, void *evD
)
1218 if(size
== 1) i
= *(int8_t *)evD
;
1219 else if(size
== 2) i
= *(int16_t *)evD
;
1220 else if(size
== 4) i
= *(int32_t *)evD
;
1221 else if(size
== 8) i
= *(int64_t *)evD
;
1226 /*****************************************************************************
1228 * getDataEndianType : get the data type size and endian type of the local
1231 * size : size of data type
1232 * endian : endian type, little or big
1233 ****************************************************************************/
1235 void getDataEndianType(LttArchSize
* size
, LttArchEndian
* endian
)
1239 int sizeInt
=sizeof(int), sizeLong
=sizeof(long), sizePointer
=sizeof(void *);
1241 if(c
== 1) *endian
= LTT_LITTLE_ENDIAN
;
1242 else *endian
= LTT_BIG_ENDIAN
;
1244 if(sizeInt
== 2 && sizeLong
== 4 && sizePointer
== 4)
1246 else if(sizeInt
== 4 && sizeLong
== 4 && sizePointer
== 4)
1248 else if(sizeInt
== 4 && sizeLong
== 8 && sizePointer
== 8)
1250 else if(sizeInt
== 8 && sizeLong
== 8 && sizePointer
== 8)
1252 else *size
= LTT_UNKNOWN
;