projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fixed substraction from start cycle counter : end and start times between blocs tested
[lttv.git] / ltt / branches / poly / ltt / tracefile.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Xiangxiu Yang
3 *
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;
7 *
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.
12 *
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,
16 * MA 02111-1307, USA.
17 */
18
19 #include <stdio.h>
20 #include <fcntl.h>
21 #include <string.h>
22 #include <dirent.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <errno.h>
26 #include <unistd.h>
27
28 // For realpath
29 #include <limits.h>
30 #include <stdlib.h>
31
32
33 #include "parser.h"
34 #include <ltt/ltt.h>
35 #include "ltt-private.h"
36 #include <ltt/trace.h>
37 #include <ltt/facility.h>
38 #include <ltt/event.h>
39 #include <ltt/type.h>
40
41 #define DIR_NAME_SIZE 256
42 #define __UNUSED__ __attribute__((__unused__))
43
44 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
45 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
46
47
48 /* obtain the time of an event */
49
50 static inline LttTime getEventTime(LttTracefile * tf);
51
52
53 /* set the offset of the fields belonging to the event,
54 need the information of the archecture */
55 void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace *t);
56
57 /* get the size of the field type according to the archtecture's
58 size and endian type(info of the archecture) */
59 int getFieldtypeSize(LttTracefile * tf, LttEventType * evT, int offsetRoot,
60 int offsetParent, LttField *fld, void *evD, LttTrace* t);
61
62 /* read a fixed size or a block information from the file (fd) */
63 int readFile(int fd, void * buf, size_t size, char * mesg);
64 int readBlock(LttTracefile * tf, int whichBlock);
65
66 /* calculate cycles per nsec for current block */
67 void getCyclePerNsec(LttTracefile * t);
68
69 /* reinitialize the info of the block which is already in the buffer */
70 void updateTracefile(LttTracefile * tf);
71
72 /* go to the next event */
73 int skipEvent(LttTracefile * t);
74
75
76 /* Functions to parse system.xml file (using glib xml parser) */
77 static void parser_start_element (GMarkupParseContext __UNUSED__ *context,
78 const gchar *element_name,
79 const gchar **attribute_names,
80 const gchar **attribute_values,
81 gpointer user_data,
82 GError **error)
83 {
84 int i=0;
85 LttSystemDescription* des = (LttSystemDescription* )user_data;
86 if(strcmp("system", element_name)){
87 *error = g_error_new(G_MARKUP_ERROR,
88 G_LOG_LEVEL_WARNING,
89 "This is not system.xml file");
90 return;
91 }
92
93 while(attribute_names[i]){
94 if(strcmp("node_name", attribute_names[i])==0){
95 des->node_name = g_strdup(attribute_values[i]);
96 }else if(strcmp("domainname", attribute_names[i])==0){
97 des->domain_name = g_strdup(attribute_values[i]);
98 }else if(strcmp("cpu", attribute_names[i])==0){
99 des->nb_cpu = atoi(attribute_values[i]);
100 }else if(strcmp("arch_size", attribute_names[i])==0){
101 if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32;
102 else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32;
103 else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64;
104 else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64;
105 else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN;
106 }else if(strcmp("endian", attribute_names[i])==0){
107 if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0)
108 des->endian = LTT_LITTLE_ENDIAN;
109 else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0)
110 des->endian = LTT_BIG_ENDIAN;
111 }else if(strcmp("kernel_name", attribute_names[i])==0){
112 des->kernel_name = g_strdup(attribute_values[i]);
113 }else if(strcmp("kernel_release", attribute_names[i])==0){
114 des->kernel_release = g_strdup(attribute_values[i]);
115 }else if(strcmp("kernel_version", attribute_names[i])==0){
116 des->kernel_version = g_strdup(attribute_values[i]);
117 }else if(strcmp("machine", attribute_names[i])==0){
118 des->machine = g_strdup(attribute_values[i]);
119 }else if(strcmp("processor", attribute_names[i])==0){
120 des->processor = g_strdup(attribute_values[i]);
121 }else if(strcmp("hardware_platform", attribute_names[i])==0){
122 des->hardware_platform = g_strdup(attribute_values[i]);
123 }else if(strcmp("operating_system", attribute_names[i])==0){
124 des->operating_system = g_strdup(attribute_values[i]);
125 }else if(strcmp("ltt_major_version", attribute_names[i])==0){
126 des->ltt_major_version = atoi(attribute_values[i]);
127 }else if(strcmp("ltt_minor_version", attribute_names[i])==0){
128 des->ltt_minor_version = atoi(attribute_values[i]);
129 }else if(strcmp("ltt_block_size", attribute_names[i])==0){
130 des->ltt_block_size = atoi(attribute_values[i]);
131 }else{
132 *error = g_error_new(G_MARKUP_ERROR,
133 G_LOG_LEVEL_WARNING,
134 "Not a valid attribute");
135 return;
136 }
137 i++;
138 }
139 }
140
141 static void parser_characters (GMarkupParseContext __UNUSED__ *context,
142 const gchar *text,
143 gsize __UNUSED__ text_len,
144 gpointer user_data,
145 GError __UNUSED__ **error)
146 {
147 LttSystemDescription* des = (LttSystemDescription* )user_data;
148 des->description = g_strdup(text);
149 }
150
151
152 /*****************************************************************************
153 *Function name
154 * ltt_tracefile_open : open a trace file, construct a LttTracefile
155 *Input params
156 * t : the trace containing the tracefile
157 * fileName : path name of the trace file
158 *Return value
159 * : a pointer to a tracefile
160 ****************************************************************************/
161
162 LttTracefile* ltt_tracefile_open(LttTrace * t, char * fileName)
163 {
164 LttTracefile * tf;
165 struct stat lTDFStat; /* Trace data file status */
166
167 tf = g_new(LttTracefile, 1);
168
169 //open the file
170 tf->name = g_strdup(fileName);
171 tf->trace = t;
172 tf->fd = open(fileName, O_RDONLY, 0);
173 if(tf->fd < 0){
174 g_warning("Unable to open input data file %s\n", fileName);
175 g_free(tf->name);
176 g_free(tf);
177 return NULL;
178 }
179
180 // Get the file's status
181 if(fstat(tf->fd, &lTDFStat) < 0){
182 g_warning("Unable to get the status of the input data file %s\n", fileName);
183 g_free(tf->name);
184 close(tf->fd);
185 g_free(tf);
186 return NULL;
187 }
188
189 // Is the file large enough to contain a trace
190 if(lTDFStat.st_size < (off_t)(sizeof(BlockStart) + EVENT_HEADER_SIZE)){
191 g_print("The input data file %s does not contain a trace\n", fileName);
192 g_free(tf->name);
193 close(tf->fd);
194 g_free(tf);
195 return NULL;
196 }
197
198 //store the size of the file
199 tf->file_size = lTDFStat.st_size;
200 tf->block_size = t->system_description->ltt_block_size;
201 tf->block_number = tf->file_size / tf->block_size;
202 tf->which_block = 0;
203
204 //allocate memory to contain the info of a block
205 tf->buffer = (void *) g_new(char, t->system_description->ltt_block_size);
206
207 //read the first block
208 if(readBlock(tf,1)) exit(1);
209
210 return tf;
211 }
212
213
214 /*****************************************************************************
215 *Open control and per cpu tracefiles
216 ****************************************************************************/
217
218 void ltt_tracefile_open_cpu(LttTrace *t, char * tracefile_name)
219 {
220 LttTracefile * tf;
221 tf = ltt_tracefile_open(t,tracefile_name);
222 if(!tf) return;
223 t->per_cpu_tracefile_number++;
224 g_ptr_array_add(t->per_cpu_tracefiles, tf);
225 }
226
227 gint ltt_tracefile_open_control(LttTrace *t, char * control_name)
228 {
229 LttTracefile * tf;
230 LttEvent ev;
231 LttFacility * f;
232 void * pos;
233 FacilityLoad fLoad;
234 unsigned int i;
235
236 tf = ltt_tracefile_open(t,control_name);
237 if(!tf) {
238 g_warning("ltt_tracefile_open_control : bad file descriptor");
239 return -1;
240 }
241 t->control_tracefile_number++;
242 g_ptr_array_add(t->control_tracefiles,tf);
243
244 //parse facilities tracefile to get base_id
245 if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){
246 while(1){
247 if(!ltt_tracefile_read(tf,&ev)) return 0; // end of file
248
249 if(ev.event_id == TRACE_FACILITY_LOAD){
250 pos = ev.data;
251 fLoad.name = (char*)pos;
252 fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
253 fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
254
255 for(i=0;i<t->facility_number;i++){
256 f = (LttFacility*)g_ptr_array_index(t->facilities,i);
257 if(strcmp(f->name,fLoad.name)==0 && fLoad.checksum==f->checksum){
258 f->base_id = fLoad.base_code;
259 break;
260 }
261 }
262 if(i==t->facility_number) {
263 g_warning("Facility: %s, checksum: %u is not found",
264 fLoad.name,(unsigned int)fLoad.checksum);
265 return -1;
266 }
267 }else if(ev.event_id == TRACE_BLOCK_START){
268 continue;
269 }else if(ev.event_id == TRACE_BLOCK_END){
270 break;
271 }else {
272 g_warning("Not valid facilities trace file");
273 return -1;
274 }
275 }
276 }
277 return 0;
278 }
279
280 /*****************************************************************************
281 *Function name
282 * ltt_tracefile_close: close a trace file,
283 *Input params
284 * t : tracefile which will be closed
285 ****************************************************************************/
286
287 void ltt_tracefile_close(LttTracefile *t)
288 {
289 g_free(t->name);
290 g_free(t->buffer);
291 close(t->fd);
292 g_free(t);
293 }
294
295
296 /*****************************************************************************
297 *Get system information
298 ****************************************************************************/
299 gint getSystemInfo(LttSystemDescription* des, char * pathname)
300 {
301 FILE * fp;
302 char buf[DIR_NAME_SIZE];
303
304 GMarkupParseContext * context;
305 GError * error = NULL;
306 GMarkupParser markup_parser =
307 {
308 parser_start_element,
309 NULL,
310 parser_characters,
311 NULL, /* passthrough */
312 NULL /* error */
313 };
314
315 fp = fopen(pathname,"r");
316 if(!fp){
317 g_warning("Can not open file : %s\n", pathname);
318 return -1;
319 }
320
321 context = g_markup_parse_context_new(&markup_parser, 0, des,NULL);
322
323 while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){
324 if(!g_markup_parse_context_parse(context, buf, DIR_NAME_SIZE, &error)){
325 if(error != NULL) {
326 g_warning("Can not parse xml file: \n%s\n", error->message);
327 g_error_free(error);
328 }
329 g_markup_parse_context_free(context);
330 fclose(fp);
331 return -1;
332 }
333 }
334 g_markup_parse_context_free(context);
335 fclose(fp);
336 return 0;
337 }
338
339 /*****************************************************************************
340 *The following functions get facility/tracefile information
341 ****************************************************************************/
342
343 gint getFacilityInfo(LttTrace *t, char* eventdefs)
344 {
345 DIR * dir;
346 struct dirent *entry;
347 char * ptr;
348 unsigned int i,j;
349 LttFacility * f;
350 LttEventType * et;
351 char name[DIR_NAME_SIZE];
352
353 dir = opendir(eventdefs);
354 if(!dir) {
355 g_warning("Can not open directory: %s\n", eventdefs);
356 return -1;
357 }
358
359 while((entry = readdir(dir)) != NULL){
360 ptr = &entry->d_name[strlen(entry->d_name)-4];
361 if(strcmp(ptr,".xml") != 0) continue;
362 strcpy(name,eventdefs);
363 strcat(name,entry->d_name);
364 ltt_facility_open(t,name);
365 }
366 closedir(dir);
367
368 for(j=0;j<t->facility_number;j++){
369 f = (LttFacility*)g_ptr_array_index(t->facilities, j);
370 for(i=0; i<f->event_number; i++){
371 et = f->events[i];
372 setFieldsOffset(NULL, et, NULL, t);
373 }
374 }
375 return 0;
376 }
377
378 gint getControlFileInfo(LttTrace *t, char* control)
379 {
380 DIR * dir;
381 struct dirent *entry;
382 char name[DIR_NAME_SIZE];
383
384 dir = opendir(control);
385 if(!dir) {
386 g_warning("Can not open directory: %s\n", control);
387 return -1;
388 }
389
390 while((entry = readdir(dir)) != NULL){
391 if(strcmp(entry->d_name,"facilities") != 0 &&
392 strcmp(entry->d_name,"interrupts") != 0 &&
393 strcmp(entry->d_name,"processes") != 0) continue;
394
395 strcpy(name,control);
396 strcat(name,entry->d_name);
397 if(ltt_tracefile_open_control(t,name))
398 return -1;
399 }
400 closedir(dir);
401 return 0;
402 }
403
404 gint getCpuFileInfo(LttTrace *t, char* cpu)
405 {
406 DIR * dir;
407 struct dirent *entry;
408 char name[DIR_NAME_SIZE];
409
410 dir = opendir(cpu);
411 if(!dir) {
412 g_warning("Can not open directory: %s\n", cpu);
413 return -1;
414 }
415
416 while((entry = readdir(dir)) != NULL){
417 if(strcmp(entry->d_name,".") != 0 &&
418 strcmp(entry->d_name,"..") != 0 &&
419 strcmp(entry->d_name,".svn") != 0){
420 strcpy(name,cpu);
421 strcat(name,entry->d_name);
422 ltt_tracefile_open_cpu(t,name);
423 }else continue;
424 }
425 closedir(dir);
426 return 0;
427 }
428
429 /*****************************************************************************
430 *A trace is specified as a pathname to the directory containing all the
431 *associated data (control tracefiles, per cpu tracefiles, event
432 *descriptions...).
433 *
434 *When a trace is closed, all the associated facilities, types and fields
435 *are released as well.
436 */
437
438
439 /****************************************************************************
440 * get_absolute_pathname
441 *
442 * return the unique pathname in the system
443 *
444 * MD : Fixed this function so it uses realpath, dealing well with
445 * forgotten cases (.. were not used correctly before).
446 *
447 ****************************************************************************/
448 void get_absolute_pathname(const char *pathname, char * abs_pathname)
449 {
450 abs_pathname[0] = '\0';
451
452 if ( realpath (pathname, abs_pathname) != NULL)
453 return;
454 else
455 {
456 /* error, return the original path unmodified */
457 strcpy(abs_pathname, pathname);
458 return;
459 }
460 return;
461 }
462
463 LttTrace *ltt_trace_open(const char *pathname)
464 {
465 LttTrace * t;
466 LttSystemDescription * sys_description;
467 char eventdefs[DIR_NAME_SIZE];
468 char info[DIR_NAME_SIZE];
469 char control[DIR_NAME_SIZE];
470 char cpu[DIR_NAME_SIZE];
471 char tmp[DIR_NAME_SIZE];
472 char abs_path[DIR_NAME_SIZE];
473 gboolean has_slash = FALSE;
474
475 get_absolute_pathname(pathname, abs_path);
476 //establish the pathname to different directories
477 if(abs_path[strlen(abs_path)-1] == '/')has_slash = TRUE;
478 strcpy(eventdefs,abs_path);
479 if(!has_slash)strcat(eventdefs,"/");
480 strcat(eventdefs,"eventdefs/");
481
482 strcpy(info,abs_path);
483 if(!has_slash)strcat(info,"/");
484 strcat(info,"info/");
485
486 strcpy(control,abs_path);
487 if(!has_slash)strcat(control,"/");
488 strcat(control,"control/");
489
490 strcpy(cpu,abs_path);
491 if(!has_slash)strcat(cpu,"/");
492 strcat(cpu,"cpu/");
493
494 //new trace
495 sys_description = g_new(LttSystemDescription, 1);
496 t = g_new(LttTrace, 1);
497 t->pathname = g_strdup(abs_path);
498 t->facility_number = 0;
499 t->control_tracefile_number = 0;
500 t->per_cpu_tracefile_number = 0;
501 t->system_description = sys_description;
502 t->control_tracefiles = g_ptr_array_new();
503 t->per_cpu_tracefiles = g_ptr_array_new();
504 t->facilities = g_ptr_array_new();
505 getDataEndianType(&(t->my_arch_size), &(t->my_arch_endian));
506
507 //get system description
508 strcpy(tmp,info);
509 strcat(tmp,"system.xml");
510 if(getSystemInfo(sys_description, tmp)) {
511 g_ptr_array_free(t->facilities, TRUE);
512 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
513 g_ptr_array_free(t->control_tracefiles, TRUE);
514 g_free(sys_description);
515 g_free(t->pathname);
516 g_free(t);
517 return NULL;
518 }
519
520
521
522 //get facilities info
523 if(getFacilityInfo(t,eventdefs)) {
524 g_ptr_array_free(t->facilities, TRUE);
525 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
526 g_ptr_array_free(t->control_tracefiles, TRUE);
527 g_free(sys_description);
528 g_free(t->pathname);
529 g_free(t);
530 return NULL;
531 }
532
533 //get control tracefile info
534 getControlFileInfo(t,control);
535 /*
536 if(getControlFileInfo(t,control)) {
537 g_ptr_array_free(t->facilities, TRUE);
538 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
539 g_ptr_array_free(t->control_tracefiles, TRUE);
540 g_free(sys_description);
541 g_free(t->pathname);
542 g_free(t);
543 return NULL;
544 }*/ // With fatal error
545
546 //get cpu tracefile info
547 if(getCpuFileInfo(t,cpu)) {
548 g_ptr_array_free(t->facilities, TRUE);
549 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
550 g_ptr_array_free(t->control_tracefiles, TRUE);
551 g_free(sys_description);
552 g_free(t->pathname);
553 g_free(t);
554 return NULL;
555 }
556
557 return t;
558 }
559
560 char * ltt_trace_name(LttTrace *t)
561 {
562 return t->pathname;
563 }
564
565
566 /******************************************************************************
567 * When we copy a trace, we want all the opening actions to happen again :
568 * the trace will be reopened and totally independant from the original.
569 * That's why we call ltt_trace_open.
570 *****************************************************************************/
571 LttTrace *ltt_trace_copy(LttTrace *self)
572 {
573 return ltt_trace_open(self->pathname);
574 }
575
576 void ltt_trace_close(LttTrace *t)
577 {
578 unsigned int i;
579 LttTracefile * tf;
580 LttFacility * f;
581
582 g_free(t->pathname);
583
584 //free system_description
585 g_free(t->system_description->description);
586 g_free(t->system_description->node_name);
587 g_free(t->system_description->domain_name);
588 g_free(t->system_description->kernel_name);
589 g_free(t->system_description->kernel_release);
590 g_free(t->system_description->kernel_version);
591 g_free(t->system_description->machine);
592 g_free(t->system_description->processor);
593 g_free(t->system_description->hardware_platform);
594 g_free(t->system_description->operating_system);
595 g_free(t->system_description);
596
597 //free control_tracefiles
598 for(i=0;i<t->control_tracefile_number;i++){
599 tf = (LttTracefile*)g_ptr_array_index(t->control_tracefiles,i);
600 ltt_tracefile_close(tf);
601 }
602 g_ptr_array_free(t->control_tracefiles, TRUE);
603
604 //free per_cpu_tracefiles
605 for(i=0;i<t->per_cpu_tracefile_number;i++){
606 tf = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles,i);
607 ltt_tracefile_close(tf);
608 }
609 g_ptr_array_free(t->per_cpu_tracefiles, TRUE);
610
611 //free facilities
612 for(i=0;i<t->facility_number;i++){
613 f = (LttFacility*)g_ptr_array_index(t->facilities,i);
614 ltt_facility_close(f);
615 }
616 g_ptr_array_free(t->facilities, TRUE);
617
618 g_free(t);
619
620 g_blow_chunks();
621 }
622
623
624 /*****************************************************************************
625 *Get the system description of the trace
626 ****************************************************************************/
627
628 LttSystemDescription *ltt_trace_system_description(LttTrace *t)
629 {
630 return t->system_description;
631 }
632
633 /*****************************************************************************
634 * The following functions discover the facilities of the trace
635 ****************************************************************************/
636
637 unsigned ltt_trace_facility_number(LttTrace *t)
638 {
639 return (unsigned)(t->facility_number);
640 }
641
642 LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i)
643 {
644 return (LttFacility*)g_ptr_array_index(t->facilities, i);
645 }
646
647 /*****************************************************************************
648 *Function name
649 * ltt_trace_facility_find : find facilities in the trace
650 *Input params
651 * t : the trace
652 * name : facility name
653 *Output params
654 * position : position of the facility in the trace
655 *Return value
656 * : the number of facilities
657 ****************************************************************************/
658
659 unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position)
660 {
661 unsigned int i, count=0;
662 LttFacility * f;
663 for(i=0;i<t->facility_number;i++){
664 f = (LttFacility*)g_ptr_array_index(t->facilities, i);
665 if(strcmp(f->name,name)==0){
666 count++;
667 if(count==1) *position = i;
668 }else{
669 if(count) break;
670 }
671 }
672 return count;
673 }
674
675 /*****************************************************************************
676 * Functions to discover all the event types in the trace
677 ****************************************************************************/
678
679 unsigned ltt_trace_eventtype_number(LttTrace *t)
680 {
681 unsigned int i;
682 unsigned count = 0;
683 LttFacility * f;
684 for(i=0;i<t->facility_number;i++){
685 f = (LttFacility*)g_ptr_array_index(t->facilities, i);
686 count += f->event_number;
687 }
688 return count;
689 }
690
691 /* FIXME : performances could be improved with a better design for this
692 * function */
693 LttFacility * ltt_trace_facility_by_id(LttTrace * trace, unsigned id)
694 {
695 LttFacility * facility = NULL;
696 unsigned int i;
697
698 for(i=0;i<trace->facility_number;i++){
699 LttFacility *iter_facility =
700 (LttFacility*) g_ptr_array_index(trace->facilities,i);
701 if(unlikely(id >= iter_facility->base_id &&
702 id < iter_facility->base_id + iter_facility->event_number)) {
703 facility = iter_facility;
704 break;
705 }
706 }
707
708 return facility;
709 }
710
711 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
712 {
713 LttFacility * f;
714 f = ltt_trace_facility_by_id(t,evId);
715 if(!f) return NULL;
716 return f->events[evId - f->base_id];
717 }
718
719 /*****************************************************************************
720 *There is one "per cpu" tracefile for each CPU, numbered from 0 to
721 *the maximum number of CPU in the system. When the number of CPU installed
722 *is less than the maximum, some positions are unused. There are also a
723 *number of "control" tracefiles (facilities, interrupts...).
724 ****************************************************************************/
725 unsigned ltt_trace_control_tracefile_number(LttTrace *t)
726 {
727 return t->control_tracefile_number;
728 }
729
730 unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t)
731 {
732 return t->per_cpu_tracefile_number;
733 }
734
735 /*****************************************************************************
736 *It is possible to search for the tracefiles by name or by CPU position.
737 *The index within the tracefiles of the same type is returned if found
738 *and a negative value otherwise.
739 ****************************************************************************/
740
741 int ltt_trace_control_tracefile_find(LttTrace *t, const gchar *name)
742 {
743 LttTracefile * tracefile;
744 unsigned int i;
745 for(i=0;i<t->control_tracefile_number;i++){
746 tracefile = (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);
747 if(strcmp(tracefile->name, name)==0)break;
748 }
749 if(i == t->control_tracefile_number) return -1;
750 return i;
751 }
752
753 /* not really useful. We just have to know that cpu tracefiles
754 * comes before control tracefiles.
755 */
756 int ltt_trace_per_cpu_tracefile_find(LttTrace *t, const gchar *name)
757 {
758 LttTracefile * tracefile;
759 unsigned int i;
760 for(i=0;i<t->per_cpu_tracefile_number;i++){
761 tracefile = (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
762 if(strcmp(tracefile->name, name)==0)break;
763 }
764 if(i == t->per_cpu_tracefile_number) return -1;
765 return i;
766 }
767
768 /*****************************************************************************
769 *Get a specific tracefile
770 ****************************************************************************/
771
772 LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i)
773 {
774 return (LttTracefile*)g_ptr_array_index(t->control_tracefiles, i);
775 }
776
777 LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i)
778 {
779 return (LttTracefile*)g_ptr_array_index(t->per_cpu_tracefiles, i);
780 }
781
782 /*****************************************************************************
783 * Get the start time and end time of the trace
784 ****************************************************************************/
785
786 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
787 {
788 LttTime startSmall, startTmp, endBig, endTmp;
789 unsigned int i, j=0;
790 LttTracefile * tf;
791
792 for(i=0;i<t->control_tracefile_number;i++){
793 tf = g_ptr_array_index(t->control_tracefiles, i);
794 readBlock(tf,1);
795 startTmp = tf->a_block_start->time;
796 readBlock(tf,tf->block_number);
797 endTmp = tf->a_block_end->time;
798 if(i==0){
799 startSmall = startTmp;
800 endBig = endTmp;
801 j = 1;
802 continue;
803 }
804 if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp;
805 if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp;
806 }
807
808 for(i=0;i<t->per_cpu_tracefile_number;i++){
809 tf = g_ptr_array_index(t->per_cpu_tracefiles, i);
810 readBlock(tf,1);
811 startTmp = tf->a_block_start->time;
812 readBlock(tf,tf->block_number);
813 endTmp = tf->a_block_end->time;
814 if(j == 0 && i==0){
815 startSmall = startTmp;
816 endBig = endTmp;
817 continue;
818 }
819 if(ltt_time_compare(startSmall,startTmp) > 0) startSmall = startTmp;
820 if(ltt_time_compare(endBig,endTmp) < 0) endBig = endTmp;
821 }
822
823 if(start != NULL) *start = startSmall;
824 if(end != NULL) *end = endBig;
825 }
826
827
828 /*****************************************************************************
829 *Get the name of a tracefile
830 ****************************************************************************/
831
832 char *ltt_tracefile_name(LttTracefile *tf)
833 {
834 return tf->name;
835 }
836
837 /*****************************************************************************
838 * Get the number of blocks in the tracefile
839 ****************************************************************************/
840
841 unsigned ltt_tracefile_block_number(LttTracefile *tf)
842 {
843 return tf->block_number;
844 }
845
846 /*****************************************************************************
847 *Function name
848 * ltt_tracefile_seek_time: seek to the first event of the trace with time
849 * larger or equal to time
850 *Input params
851 * t : tracefile
852 * time : criteria of the time
853 ****************************************************************************/
854 void ltt_tracefile_find_time_block(LttTracefile *t, LttTime time,
855 int start_block, int end_block)
856 {
857 int err, tmp_block, s, e;
858 int headTime;
859 int tailTime;
860
861 err=readBlock(t,start_block);
862 if(err) g_error("Can not read tracefile: %s\n", t->name);
863 if(start_block == end_block)return;
864
865 tailTime = ltt_time_compare(t->a_block_end->time, time);
866 if(tailTime >= 0) return;
867
868 err=readBlock(t,end_block);
869 if(err) g_error("Can not read tracefile: %s\n", t->name);
870 if(start_block+1 == end_block)return;
871
872 headTime = ltt_time_compare(t->a_block_start->time, time);
873 if(headTime <= 0 ) return;
874
875 tmp_block = (end_block + start_block)/2;
876 err=readBlock(t,tmp_block);
877 if(err) g_error("Can not read tracefile: %s\n", t->name);
878
879 headTime = ltt_time_compare(t->a_block_start->time, time);
880 tailTime = ltt_time_compare(t->a_block_end->time, time);
881 if(headTime <= 0 && tailTime >= 0) return;
882
883 if(headTime > 0){
884 s = start_block + 1;
885 e = tmp_block - 1;
886 if(s <= e)
887 ltt_tracefile_find_time_block(t, time, s, e);
888 else return;
889 }
890
891 if(tailTime < 0){
892 s = tmp_block + 1;
893 e = end_block - 1;
894 if(s <= e)
895 ltt_tracefile_find_time_block(t, time, s, e);
896 else return;
897 }
898 }
899
900 void ltt_tracefile_backward_find_time_block(LttTracefile *t, LttTime time)
901 {
902 int t_time, h_time, err;
903 err=readBlock(t,t->which_block-1);
904 if(err) g_error("Can not read tracefile: %s\n", t->name);
905 h_time = ltt_time_compare(t->a_block_start->time, time);
906 t_time = ltt_time_compare(t->a_block_end->time, time);
907 if(h_time == 0){
908 int tmp;
909 if(t->which_block == 1) return;
910 err=readBlock(t,t->which_block-1);
911 if(err) g_error("Can not read tracefile: %s\n", t->name);
912 tmp = ltt_time_compare(t->a_block_end->time, time);
913 if(tmp == 0) return ltt_tracefile_seek_time(t, time);
914 err=readBlock(t,t->which_block+1);
915 if(err) g_error("Can not read tracefile: %s\n", t->name);
916 }else if(h_time > 0){
917 ltt_tracefile_find_time_block(t, time, 1, t->which_block);
918 return ltt_tracefile_seek_time(t, time) ;
919 }else{
920 if(t_time >= 0) return ltt_tracefile_seek_time(t, time);
921 err=readBlock(t,t->which_block+1);
922 if(err) g_error("Can not read tracefile: %s\n", t->name);
923 }
924 }
925
926 void ltt_tracefile_seek_time(LttTracefile *t, LttTime time)
927 {
928 int err;
929 LttTime lttTime;
930 int headTime = ltt_time_compare(t->a_block_start->time, time);
931 int tailTime = ltt_time_compare(t->a_block_end->time, time);
932 LttEvent ev;
933
934 if(headTime < 0 && tailTime > 0){
935 if(ltt_time_compare(t->a_block_end->time, t->current_event_time) !=0) {
936 lttTime = getEventTime(t);
937 err = ltt_time_compare(lttTime, time);
938 if(err > 0){
939 if(t->which_event==2 || ltt_time_compare(t->prev_event_time,time)<0){
940 return;
941 }else{
942 updateTracefile(t);
943 return ltt_tracefile_seek_time(t, time);
944 }
945 }else if(err < 0){
946 while(1){
947 if(ltt_tracefile_read(t,&ev) == NULL) {
948 g_print("End of file\n");
949 return;
950 }
951 lttTime = getEventTime(t);
952 err = ltt_time_compare(lttTime, time);
953 if(err >= 0)return;
954 }
955 }else return;
956 }else{//we are at the end of the block
957 updateTracefile(t);
958 return ltt_tracefile_seek_time(t, time);
959 }
960 }else if(headTime >= 0){
961 if(t->which_block == 1){
962 updateTracefile(t);
963 }else{
964 if(ltt_time_compare(t->prev_block_end_time, time) >= 0 ||
965 (t->prev_block_end_time.tv_sec == 0 &&
966 t->prev_block_end_time.tv_nsec == 0 )){
967 ltt_tracefile_backward_find_time_block(t, time);
968 }else{
969 updateTracefile(t);
970 }
971 }
972 }else if(tailTime < 0){
973 if(t->which_block != t->block_number){
974 ltt_tracefile_find_time_block(t, time, t->which_block+1, t->block_number);
975 return ltt_tracefile_seek_time(t, time);
976 }else {
977 t->cur_event_pos = t->buffer + t->block_size;
978 g_print("End of file\n");
979 return;
980 }
981 }else if(tailTime == 0){
982 t->cur_event_pos = t->last_event_pos;
983 t->current_event_time = time;
984 t->cur_heart_beat_number = 0;
985 t->prev_event_time.tv_sec = 0;
986 t->prev_event_time.tv_nsec = 0;
987 return;
988 }
989 }
990
991 /*****************************************************************************
992 * Seek to the first event with position equal or larger to ep
993 *
994 * Modified by Mathieu Desnoyers to used faster offset position instead of
995 * re-reading the whole buffer.
996 ****************************************************************************/
997
998 void ltt_tracefile_seek_position(LttTracefile *t, const LttEventPosition *ep)
999 {
1000 //if we are at the right place, just return
1001 if(likely(t->which_block == ep->block_num && t->which_event == ep->event_num))
1002 return;
1003
1004 if(likely(t->which_block == ep->block_num)) updateTracefile(t);
1005 else readBlock(t,ep->block_num);
1006 //event offset is available
1007 if(likely(ep->old_position)){
1008 int err;
1009
1010 t->which_event = ep->event_num;
1011 t->cur_event_pos = t->buffer + ep->event_offset;
1012 t->prev_event_time = ep->event_time;
1013 t->current_event_time = ep->event_time;
1014 t->cur_heart_beat_number = ep->heart_beat_number;
1015 t->cur_cycle_count = ep->event_cycle_count;
1016
1017 /* This is a workaround for fast position seek */
1018 t->last_event_pos = ep->last_event_pos;
1019 t->prev_block_end_time = ep->prev_block_end_time;
1020 t->prev_event_time = ep->prev_event_time;
1021 t->pre_cycle_count = ep->pre_cycle_count;
1022 t->count = ep->count;
1023 /* end of workaround */
1024
1025 //update the fields of the current event and go to the next event
1026 err = skipEvent(t);
1027 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1028
1029 return;
1030 }
1031
1032 //only block number and event index are available
1033 //MD: warning : this is slow!
1034 g_warning("using slow O(n) tracefile seek position");
1035
1036 LttEvent event;
1037 while(likely(t->which_event < ep->event_num)) ltt_tracefile_read(t, &event);
1038
1039 return;
1040 }
1041
1042 /*****************************************************************************
1043 *Function name
1044 * ltt_tracefile_read : read the current event, set the pointer to the next
1045 *Input params
1046 * t : tracefile
1047 *Return value
1048 * LttEvent * : an event to be processed
1049 ****************************************************************************/
1050
1051 LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event)
1052 {
1053 int err;
1054
1055 if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){
1056 if(unlikely(t->which_block == t->block_number)){
1057 return NULL;
1058 }
1059 err = readBlock(t, t->which_block + 1);
1060 if(unlikely(err))g_error("Can not read tracefile");
1061 }
1062
1063 event->event_id = (int)(*(guint16 *)(t->cur_event_pos));
1064 if(unlikely(event->event_id == TRACE_TIME_HEARTBEAT))
1065 t->cur_heart_beat_number++;
1066
1067 t->prev_event_time = t->current_event_time;
1068 // t->current_event_time = getEventTime(t);
1069
1070 event->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
1071 event->event_time = t->current_event_time;
1072 event->event_cycle_count = t->cur_cycle_count;
1073
1074 event->tracefile = t;
1075 event->data = t->cur_event_pos + EVENT_HEADER_SIZE;
1076 event->which_block = t->which_block;
1077 event->which_event = t->which_event;
1078
1079 /* This is a workaround for fast position seek */
1080 event->last_event_pos = t->last_event_pos;
1081 event->prev_block_end_time = t->prev_block_end_time;
1082 event->prev_event_time = t->prev_event_time;
1083 event->pre_cycle_count = t->pre_cycle_count;
1084 event->count = t->count;
1085 /* end of workaround */
1086
1087
1088
1089 //update the fields of the current event and go to the next event
1090 err = skipEvent(t);
1091 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1092
1093 return event;
1094 }
1095
1096 /****************************************************************************
1097 *Function name
1098 * readFile : wrap function to read from a file
1099 *Input Params
1100 * fd : file descriptor
1101 * buf : buf to contain the content
1102 * size : number of bytes to be read
1103 * mesg : message to be printed if some thing goes wrong
1104 *return value
1105 * 0 : success
1106 * EIO : can not read from the file
1107 ****************************************************************************/
1108
1109 int readFile(int fd, void * buf, size_t size, char * mesg)
1110 {
1111 ssize_t nbBytes = read(fd, buf, size);
1112
1113 if((size_t)nbBytes != size) {
1114 if(nbBytes < 0) {
1115 perror("Error in readFile : ");
1116 } else {
1117 g_warning("%s",mesg);
1118 }
1119 return EIO;
1120 }
1121 return 0;
1122 }
1123
1124 /*****************************************************************************
1125 *Function name
1126 * skipEvent_pre_read_cycles : go to the next event,
1127 * update the necessary fields of the current event
1128 * increment the cycle counter, save it at the end.
1129 *Input params
1130 * t : tracefile
1131 *return value
1132 * 0 : success
1133 * ERANGE : event id is out of range
1134 ****************************************************************************/
1135
1136 int skipEvent_pre_read_cycles(LttTracefile * t)
1137 {
1138 int evId;
1139 void * evData;
1140 LttEventType * evT;
1141 LttField * rootFld;
1142
1143 evId = (int)(*(guint16 *)(t->cur_event_pos));
1144 evData = t->cur_event_pos + EVENT_HEADER_SIZE;
1145
1146 evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
1147
1148 if(likely(evT)) rootFld = evT->root_field;
1149 else return ERANGE;
1150
1151 if(likely(rootFld)){
1152 //event has string/sequence or the last event is not the same event
1153 if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event)
1154 && rootFld->field_fixed == 0)){
1155 setFieldsOffset(t, evT, evData, t->trace);
1156 }
1157 t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size;
1158 }else t->cur_event_pos += EVENT_HEADER_SIZE;
1159
1160 //evT->latest_block = t->which_block;
1161 //evT->latest_event = t->which_event;
1162
1163 //the next event is in the next block
1164 //if(unlikely(evId == TRACE_BLOCK_END)){
1165 // Specify end of buffer reached.
1166 // t->cur_event_pos = t->buffer + t->block_size;
1167 //}else{
1168 //g_critical("COUNT : %lu", t->cur_cycle_count);
1169 //t->which_event++;
1170 // t->current_event_time = getEventTime(t);
1171 //}
1172
1173 return 0;
1174 }
1175
1176
1177
1178
1179 /*****************************************************************************
1180 *Function name
1181 * ltt_tracefile_pre_read_cycles :
1182 * read the current event, increment the cycle counter
1183 *Input params
1184 * t : tracefile
1185 *Return value
1186 * False : end of bloc reached
1187 ****************************************************************************/
1188
1189 gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf)
1190 {
1191 int err;
1192 //LttEvent event;
1193
1194 // if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){
1195 //if(unlikely(t->which_block == t->block_number)){
1196 // return FALSE;
1197 //}
1198 // return FALSE; // end of bloc reached
1199 //err = readBlock(t, t->which_block + 1);
1200 //if(unlikely(err))g_error("Can not read tracefile");
1201 //}
1202
1203 //event.event_id = (int)(*(guint16 *)(t->cur_event_pos));
1204 //if(unlikely(event.event_id == TRACE_TIME_HEARTBEAT))
1205 // t->cur_heart_beat_number++;
1206
1207 //t->prev_event_time = t->current_event_time;
1208 // t->current_event_time = getEventTime(t);
1209
1210 //event.time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
1211 //event.event_time = t->current_event_time;
1212 //event.event_cycle_count = t->cur_cycle_count;
1213
1214 //event.tracefile = t;
1215 //event.data = t->cur_event_pos + EVENT_HEADER_SIZE;
1216 //event.which_block = t->which_block;
1217 //event.which_event = t->which_event;
1218
1219 /* This is a workaround for fast position seek */
1220 //event.last_event_pos = t->last_event_pos;
1221 //event.prev_block_end_time = t->prev_block_end_time;
1222 //event.prev_event_time = t->prev_event_time;
1223 //event.pre_cycle_count = t->pre_cycle_count;
1224 //event.count = t->count;
1225 /* end of workaround */
1226
1227
1228 /* Increment the cycle counter for the bloc */
1229 LttTime time;
1230 LttCycleCount cycle_count; // cycle count for the current event
1231 LttCycleCount lEventTotalCycle; // Total cycles from start for event
1232 LttCycleCount lEventNSec; // Total nsecs from start for event
1233 LttTime lTimeOffset; // Time offset in struct LttTime
1234 guint16 evId;
1235
1236 evId = *(guint16 *)tf->cur_event_pos;
1237
1238 // Calculate total time in cycles from start of buffer for this event
1239 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1240 //g_debug("event cycle count %llu", cycle_count);
1241 //
1242 //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
1243 //LttCycleCount res_delta_count;
1244 gboolean comp_count = cycle_count < tf->pre_cycle_count;
1245 tf->pre_cycle_count = cycle_count;
1246
1247 if(unlikely(comp_count)) {
1248 /* Wrapped */
1249 tf->count++; //increment wrap count
1250 }
1251
1252 //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1253 //if(unlikely(delta_count < 0)) {
1254 // tf->count++; //increment wrap count
1255 // keep in mind that delta_count is negative here.
1256 // res_delta_count = delta_count + 0x100000000ULL ;
1257 //} else
1258 // res_delta_count = (LttCycleCount)delta_count;
1259
1260 //cycle_count += (LttCycleCount)tf->count << 32;
1261
1262 //FIXME (MD)
1263 // if(tf->cur_heart_beat_number > tf->count)
1264 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1265
1266 //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
1267 tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
1268 //g_debug("cur cycle count %llu", tf->cur_cycle_count);
1269
1270
1271
1272
1273 if(unlikely(evId == TRACE_BLOCK_START)){
1274 //g_debug("BLOCK START");
1275 }else if(unlikely(evId == TRACE_BLOCK_END)){
1276 //g_debug("BLOCK END");
1277
1278 /* The goal of all this pre reading */
1279 tf->a_block_end->cycle_count = tf->cur_cycle_count;
1280 //g_debug("end of block cycle count : %llu", tf->cur_cycle_count);
1281
1282 return FALSE;
1283 }
1284
1285 //update the fields of the current event and go to the next event
1286 err = skipEvent_pre_read_cycles(tf);
1287 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1288
1289
1290 return TRUE;
1291 }
1292
1293 /****************************************************************************
1294 *Function name
1295 * readBlock : read a block from the file
1296 *Input Params
1297 * lttdes : ltt trace file
1298 * whichBlock : the block which will be read
1299 *return value
1300 * 0 : success
1301 * EINVAL : lseek fail
1302 * EIO : can not read from the file
1303 ****************************************************************************/
1304
1305 int readBlock(LttTracefile * tf, int whichBlock)
1306 {
1307 off_t nbBytes;
1308 guint32 lostSize;
1309
1310 /* same block already opened requested */
1311 if((guint)whichBlock == tf->which_block) return 0;
1312
1313 if(likely(whichBlock - tf->which_block == 1 && tf->which_block != 0)){
1314 tf->prev_block_end_time = tf->a_block_end->time;
1315 tf->prev_event_time = tf->a_block_end->time;
1316 }else{
1317 tf->prev_block_end_time.tv_sec = 0;
1318 tf->prev_block_end_time.tv_nsec = 0;
1319 tf->prev_event_time.tv_sec = 0;
1320 tf->prev_event_time.tv_nsec = 0;
1321 }
1322
1323 nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET);
1324 if(unlikely(nbBytes == -1)) return EINVAL;
1325
1326 if(unlikely(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block")))
1327 return EIO;
1328
1329 tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE);
1330 lostSize = *(guint32 *)(tf->buffer + tf->block_size - sizeof(guint32));
1331 tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size -
1332 lostSize + EVENT_HEADER_SIZE);
1333 tf->last_event_pos = tf->buffer + tf->block_size - lostSize;
1334
1335 tf->which_block = whichBlock;
1336 tf->which_event = 1;
1337 tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev
1338 tf->cur_heart_beat_number = 0;
1339
1340 /* read the whole block to precalculate total of cycles in it */
1341 tf->count = 0;
1342 tf->pre_cycle_count = 0;
1343 tf->cur_cycle_count = 0;
1344 //g_debug("precalculating cycles begin for block %i", whichBlock);
1345 while(likely(ltt_tracefile_pre_read_cycles(tf)));
1346 /* Rough approximation of cycles per usec to calculate
1347 * the real block start and end time.
1348 */
1349 getCyclePerNsec(tf);
1350 /* we are at end position, make end time more precise */
1351 tf->a_block_end->time = getEventTime(tf);
1352
1353 //g_debug("precalculating cycles end for block %i", whichBlock);
1354
1355 /* put back pointer at the beginning */
1356 tf->count = 0;
1357 tf->pre_cycle_count = 0;
1358 tf->cur_cycle_count = 0;
1359 tf->which_event = 1;
1360 tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev
1361 tf->cur_heart_beat_number = 0;
1362
1363 /* Make start time more precise */
1364 tf->a_block_start->time = getEventTime(tf);
1365
1366 /* recalculate the cycles per nsec, with now more precise start and end time
1367 */
1368 getCyclePerNsec(tf);
1369
1370 tf->current_event_time = getEventTime(tf);
1371
1372 return 0;
1373 }
1374
1375 /*****************************************************************************
1376 *Function name
1377 * updateTracefile : reinitialize the info of the block which is already
1378 * in the buffer
1379 *Input params
1380 * tf : tracefile
1381 ****************************************************************************/
1382
1383 void updateTracefile(LttTracefile * tf)
1384 {
1385 tf->which_event = 1;
1386 tf->cur_event_pos = tf->buffer;
1387 tf->current_event_time = getEventTime(tf);
1388 tf->cur_heart_beat_number = 0;
1389
1390 tf->prev_event_time.tv_sec = 0;
1391 tf->prev_event_time.tv_nsec = 0;
1392 }
1393
1394 /*****************************************************************************
1395 *Function name
1396 * skipEvent : go to the next event, update the fields of the current event
1397 *Input params
1398 * t : tracefile
1399 *return value
1400 * 0 : success
1401 * ERANGE : event id is out of range
1402 ****************************************************************************/
1403
1404 int skipEvent(LttTracefile * t)
1405 {
1406 int evId;
1407 void * evData;
1408 LttEventType * evT;
1409 LttField * rootFld;
1410
1411 evId = (int)(*(guint16 *)(t->cur_event_pos));
1412 evData = t->cur_event_pos + EVENT_HEADER_SIZE;
1413
1414 evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
1415
1416 if(likely(evT)) rootFld = evT->root_field;
1417 else return ERANGE;
1418
1419 if(likely(rootFld)){
1420 //event has string/sequence or the last event is not the same event
1421 if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event)
1422 && rootFld->field_fixed == 0)){
1423 setFieldsOffset(t, evT, evData, t->trace);
1424 }
1425 t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size;
1426 }else t->cur_event_pos += EVENT_HEADER_SIZE;
1427
1428 evT->latest_block = t->which_block;
1429 evT->latest_event = t->which_event;
1430
1431 //the next event is in the next block
1432 if(unlikely(evId == TRACE_BLOCK_END)){
1433 t->cur_event_pos = t->buffer + t->block_size;
1434 }else{
1435 t->which_event++;
1436 t->current_event_time = getEventTime(t);
1437 }
1438
1439 return 0;
1440 }
1441
1442
1443 /*****************************************************************************
1444 *Function name
1445 * getCyclePerNsec : calculate cycles per nsec for current block
1446 * MD: should have tracefile_read the whole block, so we know the
1447 * total of cycles in it before being called.
1448 *Input Params
1449 * t : tracefile
1450 ****************************************************************************/
1451
1452 void getCyclePerNsec(LttTracefile * t)
1453 {
1454 LttTime lBufTotalTime; /* Total time for this buffer */
1455 double lBufTotalNSec; /* Total time for this buffer in nsecs */
1456 double lBufTotalCycle;/* Total cycles for this buffer */
1457
1458 /* Calculate the total time for this buffer */
1459 lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time);
1460
1461 /* Calculate the total cycles for this bufffer */
1462 lBufTotalCycle = t->a_block_end->cycle_count;
1463 lBufTotalCycle -= t->a_block_start->cycle_count;
1464
1465 /* Convert the total time to nsecs */
1466 lBufTotalNSec = ltt_time_to_double(lBufTotalTime);
1467
1468 t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle;
1469 /* See : http://www.azillionmonkeys.com/qed/adiv.html */
1470 // precalculate the reciprocal, so divisions will be really fast.
1471 // 2^32-1 == 0xFFFFFFFFULL
1472 //{
1473 // double int_res = lBufTotalCycle/lBufTotalNSec;
1474 // t->cycles_per_nsec_reciprocal =
1475 // ((0xFFFF+int_res)/int_res);
1476 //}
1477
1478 }
1479
1480 /****************************************************************************
1481 *Function name
1482 * getEventTime : obtain the time of an event
1483 * NOTE : this function _really_ is on critical path.
1484 *Input params
1485 * tf : tracefile
1486 *Return value
1487 * LttTime : the time of the event
1488 ****************************************************************************/
1489
1490 static inline LttTime getEventTime(LttTracefile * tf)
1491 {
1492 LttTime time;
1493 LttCycleCount cycle_count; // cycle count for the current event
1494 LttCycleCount lEventTotalCycle; // Total cycles from start for event
1495 LttCycleCount lEventNSec; // Total nsecs from start for event
1496 LttTime lTimeOffset; // Time offset in struct LttTime
1497 guint16 evId;
1498
1499 evId = *(guint16 *)tf->cur_event_pos;
1500 //if(unlikely(evId == TRACE_BLOCK_START)){
1501 // tf->count = 0;
1502 // tf->pre_cycle_count = 0;
1503 // tf->cur_cycle_count = tf->a_block_start->cycle_count;
1504 // return tf->a_block_start->time;
1505 //}//else if(unlikely(evId == TRACE_BLOCK_END)){
1506 //tf->count = 0;
1507 //tf->pre_cycle_count = 0;
1508 //tf->cur_cycle_count = tf->a_block_end->cycle_count;
1509 //return tf->a_block_end->time;
1510 //}
1511
1512 // Calculate total time in cycles from start of buffer for this event
1513 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1514 //g_debug("event cycle count %llu", cycle_count);
1515 //
1516 //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
1517 //LttCycleCount res_delta_count;
1518 gboolean comp_count = cycle_count < tf->pre_cycle_count;
1519 tf->pre_cycle_count = cycle_count;
1520
1521 if(unlikely(comp_count)) {
1522 /* Wrapped */
1523 tf->count++; //increment wrap count
1524 }
1525
1526 //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1527 //if(unlikely(delta_count < 0)) {
1528 // tf->count++; //increment wrap count
1529 // keep in mind that delta_count is negative here.
1530 // res_delta_count = delta_count + 0x100000000ULL ;
1531 //} else
1532 // res_delta_count = (LttCycleCount)delta_count;
1533
1534 //cycle_count += (LttCycleCount)tf->count << 32;
1535
1536 //FIXME (MD)
1537 // if(tf->cur_heart_beat_number > tf->count)
1538 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1539
1540 //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
1541 // Total cycle counter of the event.
1542 tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
1543
1544 //g_debug("cur cycle count %llu", tf->cur_cycle_count);
1545
1546 // Total number of cycles since the beginning of the block
1547 lEventTotalCycle = tf->cur_cycle_count
1548 - tf->a_block_start->cycle_count;
1549
1550
1551
1552 #if 0
1553 // Calculate total time in cycles from start of buffer for this event
1554 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1555
1556 if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1557 tf->pre_cycle_count = cycle_count;
1558 cycle_count += (LttCycleCount)tf->count << 32;
1559
1560 //FIXME (MD)
1561 // if(tf->cur_heart_beat_number > tf->count)
1562 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1563
1564 tf->cur_cycle_count = cycle_count;
1565
1566 lEventTotalCycle = cycle_count;
1567 lEventTotalCycle -= tf->a_block_start->cycle_count;
1568 #endif //0
1569 // Convert it to nsecs
1570 lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle;
1571 //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16;
1572
1573 // Determine offset in struct LttTime
1574 lTimeOffset = ltt_time_from_double(lEventNSec);
1575
1576 time = ltt_time_add(tf->a_block_start->time, lTimeOffset);
1577
1578 return time;
1579 }
1580
1581 /*****************************************************************************
1582 *Function name
1583 * setFieldsOffset : set offset of the fields
1584 *Input params
1585 * tracefile : opened trace file
1586 * evT : the event type
1587 * evD : event data, it may be NULL
1588 ****************************************************************************/
1589
1590 void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t)
1591 {
1592 LttField * rootFld = evT->root_field;
1593 // rootFld->base_address = evD;
1594
1595 if(likely(rootFld))
1596 rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t);
1597 }
1598
1599 /*****************************************************************************
1600 *Function name
1601 * getFieldtypeSize: get the size of the field type (primitive type)
1602 *Input params
1603 * tracefile : opened trace file
1604 * evT : event type
1605 * offsetRoot : offset from the root
1606 * offsetParent : offset from the parrent
1607 * fld : field
1608 * evD : event data, it may be NULL
1609 *Return value
1610 * int : size of the field
1611 ****************************************************************************/
1612
1613 int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
1614 int offsetParent, LttField * fld, void *evD, LttTrace *trace)
1615 {
1616 int size, size1, element_number, i, offset1, offset2;
1617 LttType * type = fld->field_type;
1618
1619 if(likely(t)){
1620 if(unlikely(evT->latest_block==t->which_block && evT->latest_event==t->which_event)){
1621 return fld->field_size;
1622 }
1623 }
1624
1625 if(likely(fld->field_fixed == 1)){
1626 if(fld == evT->root_field) return fld->field_size;
1627 }
1628
1629 switch(type->type_class) {
1630 case LTT_ARRAY:
1631 element_number = (int) type->element_number;
1632 if(fld->field_fixed == -1){
1633 size = getFieldtypeSize(t, evT, offsetRoot,
1634 0,fld->child[0], NULL, trace);
1635 if(size == 0){ //has string or sequence
1636 fld->field_fixed = 0;
1637 }else{
1638 fld->field_fixed = 1;
1639 size *= element_number;
1640 }
1641 }else if(fld->field_fixed == 0){// has string or sequence
1642 size = 0;
1643 for(i=0;i<element_number;i++){
1644 size += getFieldtypeSize(t, evT, offsetRoot+size,size,
1645 fld->child[0], evD+size, trace);
1646 }
1647 }else size = fld->field_size;
1648 break;
1649
1650 case LTT_SEQUENCE:
1651 size1 = (int) ltt_type_size(trace, type);
1652 if(fld->field_fixed == -1){
1653 fld->sequ_number_size = size1;
1654 fld->field_fixed = 0;
1655 size = getFieldtypeSize(t, evT, offsetRoot,
1656 0,fld->child[0], NULL, trace);
1657 fld->element_size = size;
1658 }else{//0: sequence
1659 element_number = getIntNumber(size1,evD);
1660 type->element_number = element_number;
1661 if(fld->element_size > 0){
1662 size = element_number * fld->element_size;
1663 }else{//sequence has string or sequence
1664 size = 0;
1665 for(i=0;i<element_number;i++){
1666 size += getFieldtypeSize(t, evT, offsetRoot+size+size1,size+size1,
1667 fld->child[0], evD+size+size1, trace);
1668 }
1669 }
1670 size += size1;
1671 }
1672 break;
1673
1674 case LTT_STRING:
1675 size = 0;
1676 if(fld->field_fixed == -1){
1677 fld->field_fixed = 0;
1678 }else{//0: string
1679 size = strlen((char*)evD) + 1; //include end : '\0'
1680 }
1681 break;
1682
1683 case LTT_STRUCT:
1684 element_number = (int) type->element_number;
1685 size = 0;
1686 if(fld->field_fixed == -1){
1687 offset1 = offsetRoot;
1688 offset2 = 0;
1689 for(i=0;i<element_number;i++){
1690 size1=getFieldtypeSize(t, evT,offset1,offset2,
1691 fld->child[i], NULL, trace);
1692 if(size1 > 0 && size >= 0){
1693 size += size1;
1694 if(offset1 >= 0) offset1 += size1;
1695 offset2 += size1;
1696 }else{
1697 size = -1;
1698 offset1 = -1;
1699 offset2 = -1;
1700 }
1701 }
1702 if(size == -1){
1703 fld->field_fixed = 0;
1704 size = 0;
1705 }else fld->field_fixed = 1;
1706 }else if(fld->field_fixed == 0){
1707 offset1 = offsetRoot;
1708 offset2 = 0;
1709 for(i=0;i<element_number;i++){
1710 size=getFieldtypeSize(t,evT,offset1,offset2,
1711 fld->child[i],evD+offset2, trace);
1712 offset1 += size;
1713 offset2 += size;
1714 }
1715 size = offset2;
1716 }else size = fld->field_size;
1717 break;
1718
1719 default:
1720 if(fld->field_fixed == -1){
1721 size = (int) ltt_type_size(trace, type);
1722 fld->field_fixed = 1;
1723 }else size = fld->field_size;
1724 break;
1725 }
1726
1727
1728
1729 #if 0
1730 if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
1731 type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
1732 if(fld->field_fixed == -1){
1733 size = (int) ltt_type_size(trace, type);
1734 fld->field_fixed = 1;
1735 }else size = fld->field_size;
1736
1737 }else if(type->type_class == LTT_ARRAY){
1738 element_number = (int) type->element_number;
1739 if(fld->field_fixed == -1){
1740 size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL, trace);
1741 if(size == 0){ //has string or sequence
1742 fld->field_fixed = 0;
1743 }else{
1744 fld->field_fixed = 1;
1745 size *= element_number;
1746 }
1747 }else if(fld->field_fixed == 0){// has string or sequence
1748 size = 0;
1749 for(i=0;i<element_number;i++){
1750 size += getFieldtypeSize(t, evT, offsetRoot+size,size,
1751 fld->child[0], evD+size, trace);
1752 }
1753 }else size = fld->field_size;
1754
1755 }else if(type->type_class == LTT_SEQUENCE){
1756 size1 = (int) ltt_type_size(trace, type);
1757 if(fld->field_fixed == -1){
1758 fld->sequ_number_size = size1;
1759 fld->field_fixed = 0;
1760 size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL, trace);
1761 fld->element_size = size;
1762 }else{//0: sequence
1763 element_number = getIntNumber(size1,evD);
1764 type->element_number = element_number;
1765 if(fld->element_size > 0){
1766 size = element_number * fld->element_size;
1767 }else{//sequence has string or sequence
1768 size = 0;
1769 for(i=0;i<element_number;i++){
1770 size += getFieldtypeSize(t, evT, offsetRoot+size+size1,size+size1,
1771 fld->child[0], evD+size+size1, trace);
1772 }
1773 }
1774 size += size1;
1775 }
1776
1777 }else if(type->type_class == LTT_STRING){
1778 size = 0;
1779 if(fld->field_fixed == -1){
1780 fld->field_fixed = 0;
1781 }else{//0: string
1782 size = strlen((char*)evD) + 1; //include end : '\0'
1783 }
1784
1785 }else if(type->type_class == LTT_STRUCT){
1786 element_number = (int) type->element_number;
1787 size = 0;
1788 if(fld->field_fixed == -1){
1789 offset1 = offsetRoot;
1790 offset2 = 0;
1791 for(i=0;i<element_number;i++){
1792 size1=getFieldtypeSize(t, evT,offset1,offset2, fld->child[i], NULL, trace);
1793 if(size1 > 0 && size >= 0){
1794 size += size1;
1795 if(offset1 >= 0) offset1 += size1;
1796 offset2 += size1;
1797 }else{
1798 size = -1;
1799 offset1 = -1;
1800 offset2 = -1;
1801 }
1802 }
1803 if(size == -1){
1804 fld->field_fixed = 0;
1805 size = 0;
1806 }else fld->field_fixed = 1;
1807 }else if(fld->field_fixed == 0){
1808 offset1 = offsetRoot;
1809 offset2 = 0;
1810 for(i=0;i<element_number;i++){
1811 size=getFieldtypeSize(t,evT,offset1,offset2,fld->child[i],evD+offset2, trace);
1812 offset1 += size;
1813 offset2 += size;
1814 }
1815 size = offset2;
1816 }else size = fld->field_size;
1817 }
1818 #endif //0
1819
1820 fld->offset_root = offsetRoot;
1821 fld->offset_parent = offsetParent;
1822 if(!evD){
1823 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
1824 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
1825 }
1826 fld->field_size = size;
1827
1828 return size;
1829 }
1830
1831
1832 /*****************************************************************************
1833 *Function name
1834 * getIntNumber : get an integer number
1835 *Input params
1836 * size : the size of the integer
1837 * evD : the event data
1838 *Return value
1839 * gint64 : a 64 bits integer
1840 ****************************************************************************/
1841
1842 gint64 getIntNumber(int size, void *evD)
1843 {
1844 gint64 i;
1845
1846 switch(size) {
1847 case 1: i = *(gint8 *)evD; break;
1848 case 2: i = *(gint16 *)evD; break;
1849 case 4: i = *(gint32 *)evD; break;
1850 case 8: i = *(gint64 *)evD; break;
1851 default: i = *(gint64 *)evD;
1852 g_critical("getIntNumber : integer size %d unknown", size);
1853 break;
1854 }
1855
1856 #if 0
1857 if(size == 1) i = *(gint8 *)evD;
1858 else if(size == 2) i = *(gint16 *)evD;
1859 else if(size == 4) i = *(gint32 *)evD;
1860 else if(size == 8) i = *(gint64 *)evD;
1861 #endif //0
1862
1863 return (gint64)i;
1864 }
1865
1866 /*****************************************************************************
1867 *Function name
1868 * getDataEndianType : get the data type size and endian type of the local
1869 * machine
1870 *Input params
1871 * size : size of data type
1872 * endian : endian type, little or big
1873 ****************************************************************************/
1874
1875 void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
1876 {
1877 int i = 1;
1878 char c = (char) i;
1879 int sizeInt=sizeof(int), sizeLong=sizeof(long), sizePointer=sizeof(void *);
1880
1881 if(c == 1) *endian = LTT_LITTLE_ENDIAN;
1882 else *endian = LTT_BIG_ENDIAN;
1883
1884 if(sizeInt == 2 && sizeLong == 4 && sizePointer == 4)
1885 *size = LTT_LP32;
1886 else if(sizeInt == 4 && sizeLong == 4 && sizePointer == 4)
1887 *size = LTT_ILP32;
1888 else if(sizeInt == 4 && sizeLong == 8 && sizePointer == 8)
1889 *size = LTT_LP64;
1890 else if(sizeInt == 8 && sizeLong == 8 && sizePointer == 8)
1891 *size = LTT_ILP64;
1892 else *size = LTT_UNKNOWN;
1893 }
1894
1895 /* get the node name of the system */
1896
1897 char * ltt_trace_system_description_node_name (LttSystemDescription * s)
1898 {
1899 return s->node_name;
1900 }
1901
1902
1903 /* get the domain name of the system */
1904
1905 char * ltt_trace_system_description_domain_name (LttSystemDescription * s)
1906 {
1907 return s->domain_name;
1908 }
1909
1910
1911 /* get the description of the system */
1912
1913 char * ltt_trace_system_description_description (LttSystemDescription * s)
1914 {
1915 return s->description;
1916 }
1917
1918
1919 /* get the start time of the trace */
1920
1921 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
1922 {
1923 return s->trace_start;
1924 }
1925
1926
1927 LttTracefile *ltt_tracefile_new()
1928 {
1929 return g_new(LttTracefile, 1);
1930 }
1931
1932 void ltt_tracefile_destroy(LttTracefile *tf)
1933 {
1934 g_free(tf);
1935 }
1936
1937 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
1938 {
1939 *dest = *src;
1940 }
1941
LTTng 2.x Viewer (LTTV)
This page took 0.073719 seconds and 5 git commands to generate.