1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Xiangxiu Yang
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22 #include <sys/types.h>
24 #include <linux/errno.h>
33 #include "ltt-private.h"
34 #include <ltt/trace.h>
35 #include <ltt/facility.h>
37 #define DIR_NAME_SIZE 256
39 /* set the offset of the fields belonging to the event,
40 need the information of the archecture */
41 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
*t
);
43 /* get the size of the field type according to the archtecture's
44 size and endian type(info of the archecture) */
45 int getFieldtypeSize(LttTracefile
* tf
, LttEventType
* evT
, int offsetRoot
,
46 int offsetParent
, LttField
*fld
, void *evD
, LttTrace
* t
);
48 /* read a fixed size or a block information from the file (fd) */
49 int readFile(int fd
, void * buf
, size_t size
, char * mesg
);
50 int readBlock(LttTracefile
* tf
, int whichBlock
);
52 /* calculate cycles per nsec for current block */
53 void getCyclePerNsec(LttTracefile
* t
);
55 /* reinitialize the info of the block which is already in the buffer */
56 void updateTracefile(LttTracefile
* tf
);
58 /* go to the next event */
59 int skipEvent(LttTracefile
* t
);
62 /* Functions to parse system.xml file (using glib xml parser) */
63 static void parser_start_element (GMarkupParseContext
*context
,
64 const gchar
*element_name
,
65 const gchar
**attribute_names
,
66 const gchar
**attribute_values
,
71 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
72 if(strcmp("system", element_name
)){
73 *error
= g_error_new(G_MARKUP_ERROR
,
75 "This is not system.xml file");
79 while(attribute_names
[i
]){
80 if(strcmp("node_name", attribute_names
[i
])==0){
81 des
->node_name
= g_strdup(attribute_values
[i
]);
82 }else if(strcmp("domainname", attribute_names
[i
])==0){
83 des
->domain_name
= g_strdup(attribute_values
[i
]);
84 }else if(strcmp("cpu", attribute_names
[i
])==0){
85 des
->nb_cpu
= atoi(attribute_values
[i
]);
86 }else if(strcmp("arch_size", attribute_names
[i
])==0){
87 if(strcmp(attribute_values
[i
],"LP32") == 0) des
->size
= LTT_LP32
;
88 else if(strcmp(attribute_values
[i
],"ILP32") == 0) des
->size
= LTT_ILP32
;
89 else if(strcmp(attribute_values
[i
],"LP64") == 0) des
->size
= LTT_LP64
;
90 else if(strcmp(attribute_values
[i
],"ILP64") == 0) des
->size
= LTT_ILP64
;
91 else if(strcmp(attribute_values
[i
],"UNKNOWN") == 0) des
->size
= LTT_UNKNOWN
;
92 }else if(strcmp("endian", attribute_names
[i
])==0){
93 if(strcmp(attribute_values
[i
],"LITTLE_ENDIAN") == 0)
94 des
->endian
= LTT_LITTLE_ENDIAN
;
95 else if(strcmp(attribute_values
[i
],"BIG_ENDIAN") == 0)
96 des
->endian
= LTT_BIG_ENDIAN
;
97 }else if(strcmp("kernel_name", attribute_names
[i
])==0){
98 des
->kernel_name
= g_strdup(attribute_values
[i
]);
99 }else if(strcmp("kernel_release", attribute_names
[i
])==0){
100 des
->kernel_release
= g_strdup(attribute_values
[i
]);
101 }else if(strcmp("kernel_version", attribute_names
[i
])==0){
102 des
->kernel_version
= g_strdup(attribute_values
[i
]);
103 }else if(strcmp("machine", attribute_names
[i
])==0){
104 des
->machine
= g_strdup(attribute_values
[i
]);
105 }else if(strcmp("processor", attribute_names
[i
])==0){
106 des
->processor
= g_strdup(attribute_values
[i
]);
107 }else if(strcmp("hardware_platform", attribute_names
[i
])==0){
108 des
->hardware_platform
= g_strdup(attribute_values
[i
]);
109 }else if(strcmp("operating_system", attribute_names
[i
])==0){
110 des
->operating_system
= g_strdup(attribute_values
[i
]);
111 }else if(strcmp("ltt_major_version", attribute_names
[i
])==0){
112 des
->ltt_major_version
= atoi(attribute_values
[i
]);
113 }else if(strcmp("ltt_minor_version", attribute_names
[i
])==0){
114 des
->ltt_minor_version
= atoi(attribute_values
[i
]);
115 }else if(strcmp("ltt_block_size", attribute_names
[i
])==0){
116 des
->ltt_block_size
= atoi(attribute_values
[i
]);
118 *error
= g_error_new(G_MARKUP_ERROR
,
120 "Not a valid attribute");
127 static void parser_end_element (GMarkupParseContext
*context
,
128 const gchar
*element_name
,
134 static void parser_characters (GMarkupParseContext
*context
,
140 LttSystemDescription
* des
= (LttSystemDescription
* )user_data
;
141 des
->description
= g_strdup(text
);
145 /*****************************************************************************
147 * ltt_tracefile_open : open a trace file, construct a LttTracefile
149 * t : the trace containing the tracefile
150 * fileName : path name of the trace file
152 * : a pointer to a tracefile
153 ****************************************************************************/
155 LttTracefile
* ltt_tracefile_open(LttTrace
* t
, char * fileName
)
158 struct stat lTDFStat
; /* Trace data file status */
159 BlockStart a_block_start
;
161 tf
= g_new(LttTracefile
, 1);
164 tf
->name
= g_strdup(fileName
);
166 tf
->fd
= open(fileName
, O_RDONLY
, 0);
168 g_warning("Unable to open input data file %s\n", fileName
);
174 // Get the file's status
175 if(fstat(tf
->fd
, &lTDFStat
) < 0){
176 g_warning("Unable to get the status of the input data file %s\n", fileName
);
183 // Is the file large enough to contain a trace
184 if(lTDFStat
.st_size
< sizeof(BlockStart
) + EVENT_HEADER_SIZE
){
185 g_print("The input data file %s does not contain a trace\n", fileName
);
192 //store the size of the file
193 tf
->file_size
= lTDFStat
.st_size
;
194 tf
->block_size
= t
->system_description
->ltt_block_size
;
195 tf
->block_number
= tf
->file_size
/ tf
->block_size
;
198 //allocate memory to contain the info of a block
199 tf
->buffer
= (void *) g_new(char, t
->system_description
->ltt_block_size
);
201 //read the first block
202 if(readBlock(tf
,1)) exit(1);
208 /*****************************************************************************
209 *Open control and per cpu tracefiles
210 ****************************************************************************/
212 void ltt_tracefile_open_cpu(LttTrace
*t
, char * tracefile_name
)
215 tf
= ltt_tracefile_open(t
,tracefile_name
);
217 t
->per_cpu_tracefile_number
++;
218 g_ptr_array_add(t
->per_cpu_tracefiles
, tf
);
221 gint
ltt_tracefile_open_control(LttTrace
*t
, char * control_name
)
231 tf
= ltt_tracefile_open(t
,control_name
);
233 g_warning("ltt_tracefile_open_control : bad file descriptor");
236 t
->control_tracefile_number
++;
237 g_ptr_array_add(t
->control_tracefiles
,tf
);
239 //parse facilities tracefile to get base_id
240 if(strcmp(&control_name
[strlen(control_name
)-10],"facilities") ==0){
242 ev
= ltt_tracefile_read(tf
);
243 if(!ev
)return 0; // end of file
245 if(ev
->event_id
== TRACE_FACILITY_LOAD
){
247 fLoad
.name
= (char*)pos
;
248 fLoad
.checksum
= *(LttChecksum
*)(pos
+ strlen(fLoad
.name
));
249 fLoad
.base_code
= *(guint32
*)(pos
+ strlen(fLoad
.name
) + sizeof(LttChecksum
));
251 for(i
=0;i
<t
->facility_number
;i
++){
252 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
253 if(strcmp(f
->name
,fLoad
.name
)==0 && fLoad
.checksum
==f
->checksum
){
254 f
->base_id
= fLoad
.base_code
;
258 if(i
==t
->facility_number
) {
259 g_warning("Facility: %s, checksum: %d is not found\n",
260 fLoad
.name
,fLoad
.checksum
);
263 }else if(ev
->event_id
== TRACE_BLOCK_START
){
265 }else if(ev
->event_id
== TRACE_BLOCK_END
){
268 g_warning("Not valid facilities trace file\n");
276 /*****************************************************************************
278 * ltt_tracefile_close: close a trace file,
280 * t : tracefile which will be closed
281 ****************************************************************************/
283 void ltt_tracefile_close(LttTracefile
*t
)
292 /*****************************************************************************
293 *Get system information
294 ****************************************************************************/
295 gint
getSystemInfo(LttSystemDescription
* des
, char * pathname
)
298 char buf
[DIR_NAME_SIZE
];
299 char description
[4*DIR_NAME_SIZE
];
301 GMarkupParseContext
* context
;
302 GError
* error
= NULL
;
303 GMarkupParser markup_parser
=
305 parser_start_element
,
308 NULL
, /* passthrough */
312 fp
= fopen(pathname
,"r");
314 g_warning("Can not open file : %s\n", pathname
);
318 context
= g_markup_parse_context_new(&markup_parser
, 0, des
,NULL
);
320 while(fgets(buf
,DIR_NAME_SIZE
, fp
) != NULL
){
321 if(!g_markup_parse_context_parse(context
, buf
, DIR_NAME_SIZE
, &error
)){
323 g_warning("Can not parse xml file: \n%s\n", error
->message
);
326 g_markup_parse_context_free(context
);
331 g_markup_parse_context_free(context
);
336 /*****************************************************************************
337 *The following functions get facility/tracefile information
338 ****************************************************************************/
340 gint
getFacilityInfo(LttTrace
*t
, char* eventdefs
)
343 struct dirent
*entry
;
348 char name
[DIR_NAME_SIZE
];
350 dir
= opendir(eventdefs
);
352 g_warning("Can not open directory: %s\n", eventdefs
);
356 while((entry
= readdir(dir
)) != NULL
){
357 ptr
= &entry
->d_name
[strlen(entry
->d_name
)-4];
358 if(strcmp(ptr
,".xml") != 0) continue;
359 strcpy(name
,eventdefs
);
360 strcat(name
,entry
->d_name
);
361 ltt_facility_open(t
,name
);
365 for(j
=0;j
<t
->facility_number
;j
++){
366 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, j
);
367 for(i
=0; i
<f
->event_number
; i
++){
369 setFieldsOffset(NULL
, et
, NULL
, t
);
375 gint
getControlFileInfo(LttTrace
*t
, char* control
)
378 struct dirent
*entry
;
379 char name
[DIR_NAME_SIZE
];
381 dir
= opendir(control
);
383 g_warning("Can not open directory: %s\n", control
);
387 while((entry
= readdir(dir
)) != NULL
){
388 if(strcmp(entry
->d_name
,"facilities") != 0 &&
389 strcmp(entry
->d_name
,"interrupts") != 0 &&
390 strcmp(entry
->d_name
,"processes") != 0) continue;
392 strcpy(name
,control
);
393 strcat(name
,entry
->d_name
);
394 if(ltt_tracefile_open_control(t
,name
))
401 gint
getCpuFileInfo(LttTrace
*t
, char* cpu
)
404 struct dirent
*entry
;
405 char name
[DIR_NAME_SIZE
];
409 g_warning("Can not open directory: %s\n", cpu
);
413 while((entry
= readdir(dir
)) != NULL
){
414 if(strcmp(entry
->d_name
,".") != 0 &&
415 strcmp(entry
->d_name
,"..") != 0 &&
416 strcmp(entry
->d_name
,".svn") != 0){
418 strcat(name
,entry
->d_name
);
419 ltt_tracefile_open_cpu(t
,name
);
426 /*****************************************************************************
427 *A trace is specified as a pathname to the directory containing all the
428 *associated data (control tracefiles, per cpu tracefiles, event
431 *When a trace is closed, all the associated facilities, types and fields
432 *are released as well.
434 * MD : Fixed this function so it uses realpath, dealing well with
435 * forgotten cases (.. were not used correctly before).
437 ****************************************************************************/
439 void get_absolute_pathname(const char *pathname
, char * abs_pathname
)
442 size_t size
= DIR_NAME_SIZE
;
443 abs_pathname
[0] = '\0';
445 if ( realpath (pathname
, abs_pathname
) != NULL
)
449 // FIXME : Path is wrong, is it ok to return the pathname unmodified ?
450 strcpy(abs_pathname
, pathname
);
458 LttTrace
*ltt_trace_open(const char *pathname
)
461 LttSystemDescription
* sys_description
;
462 char eventdefs
[DIR_NAME_SIZE
];
463 char info
[DIR_NAME_SIZE
];
464 char control
[DIR_NAME_SIZE
];
465 char cpu
[DIR_NAME_SIZE
];
466 char tmp
[DIR_NAME_SIZE
];
467 char abs_path
[DIR_NAME_SIZE
];
468 gboolean has_slash
= FALSE
;
470 get_absolute_pathname(pathname
, abs_path
);
471 //establish the pathname to different directories
472 if(abs_path
[strlen(abs_path
)-1] == '/')has_slash
= TRUE
;
473 strcpy(eventdefs
,abs_path
);
474 if(!has_slash
)strcat(eventdefs
,"/");
475 strcat(eventdefs
,"eventdefs/");
477 strcpy(info
,abs_path
);
478 if(!has_slash
)strcat(info
,"/");
479 strcat(info
,"info/");
481 strcpy(control
,abs_path
);
482 if(!has_slash
)strcat(control
,"/");
483 strcat(control
,"control/");
485 strcpy(cpu
,abs_path
);
486 if(!has_slash
)strcat(cpu
,"/");
490 sys_description
= g_new(LttSystemDescription
, 1);
491 t
= g_new(LttTrace
, 1);
492 t
->pathname
= g_strdup(abs_path
);
493 t
->facility_number
= 0;
494 t
->control_tracefile_number
= 0;
495 t
->per_cpu_tracefile_number
= 0;
496 t
->system_description
= sys_description
;
497 t
->control_tracefiles
= g_ptr_array_new();
498 t
->per_cpu_tracefiles
= g_ptr_array_new();
499 t
->facilities
= g_ptr_array_new();
500 getDataEndianType(&(t
->my_arch_size
), &(t
->my_arch_endian
));
502 //get system description
504 strcat(tmp
,"system.xml");
505 if(getSystemInfo(sys_description
, tmp
)) {
506 g_ptr_array_free(t
->facilities
, TRUE
);
507 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
508 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
509 g_free(sys_description
);
517 //get facilities info
518 if(getFacilityInfo(t
,eventdefs
)) {
519 g_ptr_array_free(t
->facilities
, TRUE
);
520 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
521 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
522 g_free(sys_description
);
528 //get control tracefile info
530 if(getControlFileInfo(t
,control
)) {
531 g_ptr_array_free(t
->facilities
, TRUE
);
532 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
533 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
534 g_free(sys_description
);
540 //get cpu tracefile info
541 if(getCpuFileInfo(t
,cpu
)) {
542 g_ptr_array_free(t
->facilities
, TRUE
);
543 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
544 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
545 g_free(sys_description
);
554 char * ltt_trace_name(LttTrace
*t
)
560 /******************************************************************************
561 * When we copy a trace, we want all the opening actions to happen again :
562 * the trace will be reopened and totally independant from the original.
563 * That's why we call ltt_trace_open.
564 *****************************************************************************/
565 LttTrace
*ltt_trace_copy(LttTrace
*self
)
567 return ltt_trace_open(self
->pathname
);
570 void ltt_trace_close(LttTrace
*t
)
578 //free system_description
579 g_free(t
->system_description
->description
);
580 g_free(t
->system_description
->node_name
);
581 g_free(t
->system_description
->domain_name
);
582 g_free(t
->system_description
->kernel_name
);
583 g_free(t
->system_description
->kernel_release
);
584 g_free(t
->system_description
->kernel_version
);
585 g_free(t
->system_description
->machine
);
586 g_free(t
->system_description
->processor
);
587 g_free(t
->system_description
->hardware_platform
);
588 g_free(t
->system_description
->operating_system
);
589 g_free(t
->system_description
);
591 //free control_tracefiles
592 for(i
=0;i
<t
->control_tracefile_number
;i
++){
593 tf
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
,i
);
594 ltt_tracefile_close(tf
);
596 g_ptr_array_free(t
->control_tracefiles
, TRUE
);
598 //free per_cpu_tracefiles
599 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
600 tf
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
,i
);
601 ltt_tracefile_close(tf
);
603 g_ptr_array_free(t
->per_cpu_tracefiles
, TRUE
);
606 for(i
=0;i
<t
->facility_number
;i
++){
607 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
,i
);
608 ltt_facility_close(f
);
610 g_ptr_array_free(t
->facilities
, TRUE
);
618 /*****************************************************************************
619 *Get the system description of the trace
620 ****************************************************************************/
622 LttSystemDescription
*ltt_trace_system_description(LttTrace
*t
)
624 return t
->system_description
;
627 /*****************************************************************************
628 * The following functions discover the facilities of the trace
629 ****************************************************************************/
631 unsigned ltt_trace_facility_number(LttTrace
*t
)
633 return (unsigned)(t
->facility_number
);
636 LttFacility
*ltt_trace_facility_get(LttTrace
*t
, unsigned i
)
638 return (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
641 /*****************************************************************************
643 * ltt_trace_facility_find : find facilities in the trace
646 * name : facility name
648 * position : position of the facility in the trace
650 * : the number of facilities
651 ****************************************************************************/
653 unsigned ltt_trace_facility_find(LttTrace
*t
, char *name
, unsigned *position
)
657 for(i
=0;i
<t
->facility_number
;i
++){
658 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
659 if(strcmp(f
->name
,name
)==0){
661 if(count
==1) *position
= i
;
669 /*****************************************************************************
670 * Functions to discover all the event types in the trace
671 ****************************************************************************/
673 unsigned ltt_trace_eventtype_number(LttTrace
*t
)
678 for(i
=0;i
<t
->facility_number
;i
++){
679 f
= (LttFacility
*)g_ptr_array_index(t
->facilities
, i
);
680 count
+= f
->event_number
;
685 LttFacility
* ltt_trace_facility_by_id(LttTrace
* trace
, unsigned id
)
687 LttFacility
* facility
;
689 for(i
=0;i
<trace
->facility_number
;i
++){
690 facility
= (LttFacility
*) g_ptr_array_index(trace
->facilities
,i
);
691 if(id
>= facility
->base_id
&&
692 id
< facility
->base_id
+ facility
->event_number
)
695 if(i
==trace
->facility_number
) return NULL
;
696 else return facility
;
699 LttEventType
*ltt_trace_eventtype_get(LttTrace
*t
, unsigned evId
)
702 f
= ltt_trace_facility_by_id(t
,evId
);
704 return f
->events
[evId
- f
->base_id
];
707 /*****************************************************************************
708 *There is one "per cpu" tracefile for each CPU, numbered from 0 to
709 *the maximum number of CPU in the system. When the number of CPU installed
710 *is less than the maximum, some positions are unused. There are also a
711 *number of "control" tracefiles (facilities, interrupts...).
712 ****************************************************************************/
713 unsigned ltt_trace_control_tracefile_number(LttTrace
*t
)
715 return t
->control_tracefile_number
;
718 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace
*t
)
720 return t
->per_cpu_tracefile_number
;
723 /*****************************************************************************
724 *It is possible to search for the tracefiles by name or by CPU position.
725 *The index within the tracefiles of the same type is returned if found
726 *and a negative value otherwise.
727 ****************************************************************************/
729 int ltt_trace_control_tracefile_find(LttTrace
*t
, char *name
)
731 LttTracefile
* tracefile
;
733 for(i
=0;i
<t
->control_tracefile_number
;i
++){
734 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
735 if(strcmp(tracefile
->name
, name
)==0)break;
737 if(i
== t
->control_tracefile_number
) return -1;
741 int ltt_trace_per_cpu_tracefile_find(LttTrace
*t
, unsigned i
)
743 LttTracefile
* tracefile
;
745 for(j
=0;j
<t
->per_cpu_tracefile_number
;j
++){
746 tracefile
= (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, j
);
747 name
= atoi(tracefile
->name
);
748 if(name
== (int)i
)break;
750 if(j
== t
->per_cpu_tracefile_number
) return -1;
754 /*****************************************************************************
755 *Get a specific tracefile
756 ****************************************************************************/
758 LttTracefile
*ltt_trace_control_tracefile_get(LttTrace
*t
, unsigned i
)
760 return (LttTracefile
*)g_ptr_array_index(t
->control_tracefiles
, i
);
763 LttTracefile
*ltt_trace_per_cpu_tracefile_get(LttTrace
*t
, unsigned i
)
765 return (LttTracefile
*)g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
768 /*****************************************************************************
769 * Get the start time and end time of the trace
770 ****************************************************************************/
772 void ltt_trace_time_span_get(LttTrace
*t
, LttTime
*start
, LttTime
*end
)
774 LttTime startSmall
, startTmp
, endBig
, endTmp
;
778 for(i
=0;i
<t
->control_tracefile_number
;i
++){
779 tf
= g_ptr_array_index(t
->control_tracefiles
, i
);
781 startTmp
= tf
->a_block_start
->time
;
782 readBlock(tf
,tf
->block_number
);
783 endTmp
= tf
->a_block_end
->time
;
785 startSmall
= startTmp
;
790 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
791 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
794 for(i
=0;i
<t
->per_cpu_tracefile_number
;i
++){
795 tf
= g_ptr_array_index(t
->per_cpu_tracefiles
, i
);
797 startTmp
= tf
->a_block_start
->time
;
798 readBlock(tf
,tf
->block_number
);
799 endTmp
= tf
->a_block_end
->time
;
801 startSmall
= startTmp
;
805 if(ltt_time_compare(startSmall
,startTmp
) > 0) startSmall
= startTmp
;
806 if(ltt_time_compare(endBig
,endTmp
) < 0) endBig
= endTmp
;
814 /*****************************************************************************
815 *Get the name of a tracefile
816 ****************************************************************************/
818 char *ltt_tracefile_name(LttTracefile
*tf
)
823 /*****************************************************************************
824 * Get the number of blocks in the tracefile
825 ****************************************************************************/
827 unsigned ltt_tracefile_block_number(LttTracefile
*tf
)
829 return tf
->block_number
;
832 /*****************************************************************************
834 * ltt_tracefile_seek_time: seek to the first event of the trace with time
835 * larger or equal to time
838 * time : criteria of the time
839 ****************************************************************************/
840 void ltt_tracefile_find_time_block(LttTracefile
*t
, LttTime time
,
841 int start_block
, int end_block
)
843 int err
, tmp_block
, s
, e
;
847 err
=readBlock(t
,start_block
);
848 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
849 if(start_block
== end_block
)return;
851 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
852 if(tailTime
>= 0) return;
854 err
=readBlock(t
,end_block
);
855 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
856 if(start_block
+1 == end_block
)return;
858 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
859 if(headTime
<= 0 ) return;
861 tmp_block
= (end_block
+ start_block
)/2;
862 err
=readBlock(t
,tmp_block
);
863 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
865 headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
866 tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
867 if(headTime
<= 0 && tailTime
>= 0) return;
873 ltt_tracefile_find_time_block(t
, time
, s
, e
);
881 ltt_tracefile_find_time_block(t
, time
, s
, e
);
886 void ltt_tracefile_backward_find_time_block(LttTracefile
*t
, LttTime time
)
888 int t_time
, h_time
, err
;
889 err
=readBlock(t
,t
->which_block
-1);
890 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
891 h_time
= ltt_time_compare(t
->a_block_start
->time
, time
);
892 t_time
= ltt_time_compare(t
->a_block_end
->time
, time
);
895 if(t
->which_block
== 1) return;
896 err
=readBlock(t
,t
->which_block
-1);
897 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
898 tmp
= ltt_time_compare(t
->a_block_end
->time
, time
);
899 if(tmp
== 0) return ltt_tracefile_seek_time(t
, time
);
900 err
=readBlock(t
,t
->which_block
+1);
901 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
902 }else if(h_time
> 0){
903 ltt_tracefile_find_time_block(t
, time
, 1, t
->which_block
);
904 return ltt_tracefile_seek_time(t
, time
) ;
906 if(t_time
>= 0) return ltt_tracefile_seek_time(t
, time
);
907 err
=readBlock(t
,t
->which_block
+1);
908 if(err
) g_error("Can not read tracefile: %s\n", t
->name
);
912 void ltt_tracefile_seek_time(LttTracefile
*t
, LttTime time
)
916 int headTime
= ltt_time_compare(t
->a_block_start
->time
, time
);
917 int tailTime
= ltt_time_compare(t
->a_block_end
->time
, time
);
920 if(headTime
< 0 && tailTime
> 0){
921 if(ltt_time_compare(t
->a_block_end
->time
, t
->current_event_time
) !=0) {
922 lttTime
= getEventTime(t
);
923 err
= ltt_time_compare(lttTime
, time
);
925 if(t
->which_event
==2 || (&t
->prev_event_time
,&time
)<0){
929 return ltt_tracefile_seek_time(t
, time
);
933 ev
= ltt_tracefile_read(t
);
935 g_print("End of file\n");
938 lttTime
= getEventTime(t
);
939 err
= ltt_time_compare(lttTime
, time
);
943 }else{//we are at the end of the block
945 return ltt_tracefile_seek_time(t
, time
);
947 }else if(headTime
>= 0){
948 if(t
->which_block
== 1){
951 if(ltt_time_compare(t
->prev_block_end_time
, time
) >= 0 ||
952 (t
->prev_block_end_time
.tv_sec
== 0 &&
953 t
->prev_block_end_time
.tv_nsec
== 0 )){
954 ltt_tracefile_backward_find_time_block(t
, time
);
959 }else if(tailTime
< 0){
960 if(t
->which_block
!= t
->block_number
){
961 ltt_tracefile_find_time_block(t
, time
, t
->which_block
+1, t
->block_number
);
962 return ltt_tracefile_seek_time(t
, time
);
964 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
965 g_print("End of file\n");
968 }else if(tailTime
== 0){
969 t
->cur_event_pos
= t
->last_event_pos
;
970 t
->current_event_time
= time
;
971 t
->cur_heart_beat_number
= 0;
972 t
->prev_event_time
.tv_sec
= 0;
973 t
->prev_event_time
.tv_nsec
= 0;
978 /*****************************************************************************
979 * Seek to the first event with position equal or larger to ep
980 ****************************************************************************/
982 void ltt_tracefile_seek_position(LttTracefile
*t
, const LttEventPosition
*ep
)
984 //if we are at the right place, just return
985 if(t
->which_block
== ep
->block_num
&& t
->which_event
== ep
->event_num
)
988 if(t
->which_block
== ep
->block_num
) updateTracefile(t
);
989 else readBlock(t
,ep
->block_num
);
991 //event offset is availiable
992 if(ep
->old_position
){
993 t
->cur_heart_beat_number
= ep
->heart_beat_number
;
994 t
->cur_event_pos
= t
->buffer
+ ep
->event_offset
;
998 //only block number and event index are availiable
999 while(t
->which_event
< ep
->event_num
) ltt_tracefile_read(t
);
1004 /*****************************************************************************
1006 * ltt_tracefile_read : read the current event, set the pointer to the next
1010 * LttEvent * : an event to be processed
1011 ****************************************************************************/
1013 LttEvent
*ltt_tracefile_read(LttTracefile
*t
)
1015 LttEvent
* lttEvent
= &t
->an_event
;
1018 if(t
->cur_event_pos
== t
->buffer
+ t
->block_size
){
1019 if(t
->which_block
== t
->block_number
){
1022 err
= readBlock(t
, t
->which_block
+ 1);
1023 if(err
)g_error("Can not read tracefile");
1026 lttEvent
->event_id
= (int)(*(guint16
*)(t
->cur_event_pos
));
1027 if(lttEvent
->event_id
== TRACE_TIME_HEARTBEAT
)
1028 t
->cur_heart_beat_number
++;
1030 t
->prev_event_time
= t
->current_event_time
;
1031 // t->current_event_time = getEventTime(t);
1033 lttEvent
->time_delta
= *(guint32
*)(t
->cur_event_pos
+ EVENT_ID_SIZE
);
1034 lttEvent
->event_time
= t
->current_event_time
;
1035 lttEvent
->event_cycle_count
= t
->cur_cycle_count
;
1037 lttEvent
->tracefile
= t
;
1038 lttEvent
->data
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
1039 lttEvent
->which_block
= t
->which_block
;
1040 lttEvent
->which_event
= t
->which_event
;
1042 //update the fields of the current event and go to the next event
1044 if(err
== ERANGE
) g_error("event id is out of range\n");
1049 /****************************************************************************
1051 * readFile : wrap function to read from a file
1053 * fd : file descriptor
1054 * buf : buf to contain the content
1055 * size : number of bytes to be read
1056 * mesg : message to be printed if some thing goes wrong
1059 * EIO : can not read from the file
1060 ****************************************************************************/
1062 int readFile(int fd
, void * buf
, size_t size
, char * mesg
)
1065 nbBytes
= read(fd
, buf
, size
);
1066 if(nbBytes
!= size
){
1067 printf("%s\n",mesg
);
1073 /****************************************************************************
1075 * readBlock : read a block from the file
1077 * lttdes : ltt trace file
1078 * whichBlock : the block which will be read
1081 * EINVAL : lseek fail
1082 * EIO : can not read from the file
1083 ****************************************************************************/
1085 int readBlock(LttTracefile
* tf
, int whichBlock
)
1090 if(whichBlock
- tf
->which_block
== 1 && tf
->which_block
!= 0){
1091 tf
->prev_block_end_time
= tf
->a_block_end
->time
;
1092 tf
->prev_event_time
= tf
->a_block_end
->time
;
1094 tf
->prev_block_end_time
.tv_sec
= 0;
1095 tf
->prev_block_end_time
.tv_nsec
= 0;
1096 tf
->prev_event_time
.tv_sec
= 0;
1097 tf
->prev_event_time
.tv_nsec
= 0;
1100 nbBytes
=lseek(tf
->fd
,(off_t
)((whichBlock
-1)*tf
->block_size
), SEEK_SET
);
1101 if(nbBytes
== -1) return EINVAL
;
1103 if(readFile(tf
->fd
,tf
->buffer
,tf
->block_size
,"Unable to read a block"))
1106 tf
->a_block_start
=(BlockStart
*) (tf
->buffer
+ EVENT_HEADER_SIZE
);
1107 lostSize
= *(guint32
*)(tf
->buffer
+ tf
->block_size
- sizeof(guint32
));
1108 tf
->a_block_end
=(BlockEnd
*)(tf
->buffer
+ tf
->block_size
-
1109 lostSize
+ EVENT_HEADER_SIZE
);
1110 tf
->last_event_pos
= tf
->buffer
+ tf
->block_size
- lostSize
;
1112 tf
->which_block
= whichBlock
;
1113 tf
->which_event
= 1;
1114 tf
->cur_event_pos
= tf
->buffer
;//the beginning of the block, block start ev
1115 tf
->cur_heart_beat_number
= 0;
1117 getCyclePerNsec(tf
);
1119 tf
->current_event_time
= getEventTime(tf
);
1124 /*****************************************************************************
1126 * updateTracefile : reinitialize the info of the block which is already
1130 ****************************************************************************/
1132 void updateTracefile(LttTracefile
* tf
)
1134 tf
->which_event
= 1;
1135 tf
->cur_event_pos
= tf
->buffer
;
1136 tf
->current_event_time
= getEventTime(tf
);
1137 tf
->cur_heart_beat_number
= 0;
1139 tf
->prev_event_time
.tv_sec
= 0;
1140 tf
->prev_event_time
.tv_nsec
= 0;
1143 /*****************************************************************************
1145 * skipEvent : go to the next event, update the fields of the current event
1150 * ERANGE : event id is out of range
1151 ****************************************************************************/
1153 int skipEvent(LttTracefile
* t
)
1160 evId
= (int)(*(guint16
*)(t
->cur_event_pos
));
1161 evData
= t
->cur_event_pos
+ EVENT_HEADER_SIZE
;
1163 evT
= ltt_trace_eventtype_get(t
->trace
,(unsigned)evId
);
1165 if(evT
) rootFld
= evT
->root_field
;
1169 //event has string/sequence or the last event is not the same event
1170 if((evT
->latest_block
!=t
->which_block
|| evT
->latest_event
!=t
->which_event
)
1171 && rootFld
->field_fixed
== 0){
1172 setFieldsOffset(t
, evT
, evData
, t
->trace
);
1174 t
->cur_event_pos
+= EVENT_HEADER_SIZE
+ rootFld
->field_size
;
1175 }else t
->cur_event_pos
+= EVENT_HEADER_SIZE
;
1177 evT
->latest_block
= t
->which_block
;
1178 evT
->latest_event
= t
->which_event
;
1180 //the next event is in the next block
1181 if(evId
== TRACE_BLOCK_END
){
1182 t
->cur_event_pos
= t
->buffer
+ t
->block_size
;
1185 t
->current_event_time
= getEventTime(t
);
1191 /*****************************************************************************
1193 * getCyclePerNsec : calculate cycles per nsec for current block
1196 ****************************************************************************/
1198 void getCyclePerNsec(LttTracefile
* t
)
1200 LttTime lBufTotalTime
; /* Total time for this buffer */
1201 LttCycleCount lBufTotalNSec
; /* Total time for this buffer in nsecs */
1202 LttCycleCount lBufTotalCycle
;/* Total cycles for this buffer */
1204 /* Calculate the total time for this buffer */
1205 lBufTotalTime
= ltt_time_sub(t
->a_block_end
->time
, t
->a_block_start
->time
);
1207 /* Calculate the total cycles for this bufffer */
1208 lBufTotalCycle
= t
->a_block_end
->cycle_count
;
1209 lBufTotalCycle
-= t
->a_block_start
->cycle_count
;
1211 /* Convert the total time to nsecs */
1212 lBufTotalNSec
= lBufTotalTime
.tv_sec
;
1213 lBufTotalNSec
*= NANOSECONDS_PER_SECOND
;
1214 lBufTotalNSec
+= lBufTotalTime
.tv_nsec
;
1216 t
->cycle_per_nsec
= (double)lBufTotalCycle
/ (double)lBufTotalNSec
;
1219 /****************************************************************************
1221 * getEventTime : obtain the time of an event
1225 * LttTime : the time of the event
1226 ****************************************************************************/
1228 LttTime
getEventTime(LttTracefile
* tf
)
1231 LttCycleCount cycle_count
; // cycle count for the current event
1232 LttCycleCount lEventTotalCycle
; // Total cycles from start for event
1233 LttCycleCount lEventNSec
; // Total usecs from start for event
1234 LttTime lTimeOffset
; // Time offset in struct LttTime
1236 LttCycleCount tmpCycleCount
= (((LttCycleCount
)1)<<32);
1238 evId
= *(guint16
*)tf
->cur_event_pos
;
1239 if(evId
== TRACE_BLOCK_START
){
1241 tf
->pre_cycle_count
= 0;
1242 tf
->cur_cycle_count
= tf
->a_block_start
->cycle_count
;
1243 return tf
->a_block_start
->time
;
1244 }else if(evId
== TRACE_BLOCK_END
){
1246 tf
->pre_cycle_count
= 0;
1247 tf
->cur_cycle_count
= tf
->a_block_end
->cycle_count
;
1248 return tf
->a_block_end
->time
;
1251 // Calculate total time in cycles from start of buffer for this event
1252 cycle_count
= (LttCycleCount
)*(guint32
*)(tf
->cur_event_pos
+ EVENT_ID_SIZE
);
1254 if(cycle_count
< tf
->pre_cycle_count
)tf
->count
++;
1255 tf
->pre_cycle_count
= cycle_count
;
1256 cycle_count
+= tmpCycleCount
* tf
->count
;
1258 // if(tf->cur_heart_beat_number > tf->count)
1259 // cycle_count += tmpCycleCount * (tf->cur_heart_beat_number - tf->count);
1261 tf
->cur_cycle_count
= cycle_count
;
1263 lEventTotalCycle
= cycle_count
;
1264 lEventTotalCycle
-= tf
->a_block_start
->cycle_count
;
1266 // Convert it to nsecs
1267 lEventNSec
= (double)lEventTotalCycle
/ (double)tf
->cycle_per_nsec
;
1269 // Determine offset in struct LttTime
1270 lTimeOffset
.tv_nsec
= lEventNSec
% NANOSECONDS_PER_SECOND
;
1271 lTimeOffset
.tv_sec
= lEventNSec
/ NANOSECONDS_PER_SECOND
;
1273 time
= ltt_time_add(tf
->a_block_start
->time
, lTimeOffset
);
1278 /*****************************************************************************
1280 * setFieldsOffset : set offset of the fields
1282 * tracefile : opened trace file
1283 * evT : the event type
1284 * evD : event data, it may be NULL
1285 ****************************************************************************/
1287 void setFieldsOffset(LttTracefile
*tf
,LttEventType
*evT
,void *evD
,LttTrace
* t
)
1289 LttField
* rootFld
= evT
->root_field
;
1290 // rootFld->base_address = evD;
1293 rootFld
->field_size
= getFieldtypeSize(tf
, evT
, 0,0,rootFld
, evD
,t
);
1296 /*****************************************************************************
1298 * getFieldtypeSize: get the size of the field type (primitive type)
1300 * tracefile : opened trace file
1302 * offsetRoot : offset from the root
1303 * offsetParent : offset from the parrent
1305 * evD : event data, it may be NULL
1307 * int : size of the field
1308 ****************************************************************************/
1310 int getFieldtypeSize(LttTracefile
* t
, LttEventType
* evT
, int offsetRoot
,
1311 int offsetParent
, LttField
* fld
, void *evD
, LttTrace
*trace
)
1313 int size
, size1
, element_number
, i
, offset1
, offset2
;
1314 LttType
* type
= fld
->field_type
;
1317 if(evT
->latest_block
==t
->which_block
&& evT
->latest_event
==t
->which_event
){
1318 return fld
->field_size
;
1322 if(fld
->field_fixed
== 1){
1323 if(fld
== evT
->root_field
) return fld
->field_size
;
1326 if(type
->type_class
!= LTT_STRUCT
&& type
->type_class
!= LTT_ARRAY
&&
1327 type
->type_class
!= LTT_SEQUENCE
&& type
->type_class
!= LTT_STRING
){
1328 if(fld
->field_fixed
== -1){
1329 size
= (int) ltt_type_size(trace
, type
);
1330 fld
->field_fixed
= 1;
1331 }else size
= fld
->field_size
;
1333 }else if(type
->type_class
== LTT_ARRAY
){
1334 element_number
= (int) type
->element_number
;
1335 if(fld
->field_fixed
== -1){
1336 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1337 if(size
== 0){ //has string or sequence
1338 fld
->field_fixed
= 0;
1340 fld
->field_fixed
= 1;
1341 size
*= element_number
;
1343 }else if(fld
->field_fixed
== 0){// has string or sequence
1345 for(i
=0;i
<element_number
;i
++){
1346 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
,size
,
1347 fld
->child
[0], evD
+size
, trace
);
1349 }else size
= fld
->field_size
;
1351 }else if(type
->type_class
== LTT_SEQUENCE
){
1352 size1
= (int) ltt_type_size(trace
, type
);
1353 if(fld
->field_fixed
== -1){
1354 fld
->sequ_number_size
= size1
;
1355 fld
->field_fixed
= 0;
1356 size
= getFieldtypeSize(t
, evT
, offsetRoot
,0,fld
->child
[0], NULL
, trace
);
1357 fld
->element_size
= size
;
1359 element_number
= getIntNumber(size1
,evD
);
1360 type
->element_number
= element_number
;
1361 if(fld
->element_size
> 0){
1362 size
= element_number
* fld
->element_size
;
1363 }else{//sequence has string or sequence
1365 for(i
=0;i
<element_number
;i
++){
1366 size
+= getFieldtypeSize(t
, evT
, offsetRoot
+size
+size1
,size
+size1
,
1367 fld
->child
[0], evD
+size
+size1
, trace
);
1373 }else if(type
->type_class
== LTT_STRING
){
1375 if(fld
->field_fixed
== -1){
1376 fld
->field_fixed
= 0;
1378 size
= strlen((char*)evD
) + 1; //include end : '\0'
1381 }else if(type
->type_class
== LTT_STRUCT
){
1382 element_number
= (int) type
->element_number
;
1384 if(fld
->field_fixed
== -1){
1385 offset1
= offsetRoot
;
1387 for(i
=0;i
<element_number
;i
++){
1388 size1
=getFieldtypeSize(t
, evT
,offset1
,offset2
, fld
->child
[i
], NULL
, trace
);
1389 if(size1
> 0 && size
>= 0){
1391 if(offset1
>= 0) offset1
+= size1
;
1400 fld
->field_fixed
= 0;
1402 }else fld
->field_fixed
= 1;
1403 }else if(fld
->field_fixed
== 0){
1404 offset1
= offsetRoot
;
1406 for(i
=0;i
<element_number
;i
++){
1407 size
=getFieldtypeSize(t
,evT
,offset1
,offset2
,fld
->child
[i
],evD
+offset2
, trace
);
1412 }else size
= fld
->field_size
;
1415 fld
->offset_root
= offsetRoot
;
1416 fld
->offset_parent
= offsetParent
;
1418 fld
->fixed_root
= (offsetRoot
==-1) ? 0 : 1;
1419 fld
->fixed_parent
= (offsetParent
==-1) ? 0 : 1;
1421 fld
->field_size
= size
;
1427 /*****************************************************************************
1429 * getIntNumber : get an integer number
1431 * size : the size of the integer
1432 * evD : the event data
1435 ****************************************************************************/
1437 int getIntNumber(int size
, void *evD
)
1440 if(size
== 1) i
= *(gint8
*)evD
;
1441 else if(size
== 2) i
= *(gint16
*)evD
;
1442 else if(size
== 4) i
= *(gint32
*)evD
;
1443 else if(size
== 8) i
= *(gint64
*)evD
;
1448 /*****************************************************************************
1450 * getDataEndianType : get the data type size and endian type of the local
1453 * size : size of data type
1454 * endian : endian type, little or big
1455 ****************************************************************************/
1457 void getDataEndianType(LttArchSize
* size
, LttArchEndian
* endian
)
1461 int sizeInt
=sizeof(int), sizeLong
=sizeof(long), sizePointer
=sizeof(void *);
1463 if(c
== 1) *endian
= LTT_LITTLE_ENDIAN
;
1464 else *endian
= LTT_BIG_ENDIAN
;
1466 if(sizeInt
== 2 && sizeLong
== 4 && sizePointer
== 4)
1468 else if(sizeInt
== 4 && sizeLong
== 4 && sizePointer
== 4)
1470 else if(sizeInt
== 4 && sizeLong
== 8 && sizePointer
== 8)
1472 else if(sizeInt
== 8 && sizeLong
== 8 && sizePointer
== 8)
1474 else *size
= LTT_UNKNOWN
;
1477 /* get the node name of the system */
1479 char * ltt_trace_system_description_node_name (LttSystemDescription
* s
)
1481 return s
->node_name
;
1485 /* get the domain name of the system */
1487 char * ltt_trace_system_description_domain_name (LttSystemDescription
* s
)
1489 return s
->domain_name
;
1493 /* get the description of the system */
1495 char * ltt_trace_system_description_description (LttSystemDescription
* s
)
1497 return s
->description
;
1501 /* get the start time of the trace */
1503 LttTime
ltt_trace_system_description_trace_start_time(LttSystemDescription
*s
)
1505 return s
->trace_start
;