projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
fix bug : forgot to save tracefile info with event position
[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 t->overflow_nsec = ep->overflow_nsec;
1024 /* end of workaround */
1025
1026 //update the fields of the current event and go to the next event
1027 err = skipEvent(t);
1028 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1029
1030 return;
1031 }
1032
1033 //only block number and event index are available
1034 //MD: warning : this is slow!
1035 g_warning("using slow O(n) tracefile seek position");
1036
1037 LttEvent event;
1038 while(likely(t->which_event < ep->event_num)) ltt_tracefile_read(t, &event);
1039
1040 return;
1041 }
1042
1043 /*****************************************************************************
1044 *Function name
1045 * ltt_tracefile_read : read the current event, set the pointer to the next
1046 *Input params
1047 * t : tracefile
1048 *Return value
1049 * LttEvent * : an event to be processed
1050 ****************************************************************************/
1051
1052 LttEvent *ltt_tracefile_read(LttTracefile *t, LttEvent *event)
1053 {
1054 int err;
1055
1056 if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){
1057 if(unlikely(t->which_block == t->block_number)){
1058 return NULL;
1059 }
1060 err = readBlock(t, t->which_block + 1);
1061 if(unlikely(err))g_error("Can not read tracefile");
1062 }
1063
1064 event->event_id = (int)(*(guint16 *)(t->cur_event_pos));
1065 if(unlikely(event->event_id == TRACE_TIME_HEARTBEAT))
1066 t->cur_heart_beat_number++;
1067
1068 t->prev_event_time = t->current_event_time;
1069 // t->current_event_time = getEventTime(t);
1070
1071 event->time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
1072 event->event_time = t->current_event_time;
1073 event->event_cycle_count = t->cur_cycle_count;
1074
1075 event->tracefile = t;
1076 event->data = t->cur_event_pos + EVENT_HEADER_SIZE;
1077 event->which_block = t->which_block;
1078 event->which_event = t->which_event;
1079
1080 /* This is a workaround for fast position seek */
1081 event->last_event_pos = t->last_event_pos;
1082 event->prev_block_end_time = t->prev_block_end_time;
1083 event->prev_event_time = t->prev_event_time;
1084 event->pre_cycle_count = t->pre_cycle_count;
1085 event->count = t->count;
1086 event->overflow_nsec = t->overflow_nsec;
1087
1088 /* end of workaround */
1089
1090
1091
1092 //update the fields of the current event and go to the next event
1093 err = skipEvent(t);
1094 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1095
1096 return event;
1097 }
1098
1099 /****************************************************************************
1100 *Function name
1101 * readFile : wrap function to read from a file
1102 *Input Params
1103 * fd : file descriptor
1104 * buf : buf to contain the content
1105 * size : number of bytes to be read
1106 * mesg : message to be printed if some thing goes wrong
1107 *return value
1108 * 0 : success
1109 * EIO : can not read from the file
1110 ****************************************************************************/
1111
1112 int readFile(int fd, void * buf, size_t size, char * mesg)
1113 {
1114 ssize_t nbBytes = read(fd, buf, size);
1115
1116 if((size_t)nbBytes != size) {
1117 if(nbBytes < 0) {
1118 perror("Error in readFile : ");
1119 } else {
1120 g_warning("%s",mesg);
1121 }
1122 return EIO;
1123 }
1124 return 0;
1125 }
1126
1127 /*****************************************************************************
1128 *Function name
1129 * skipEvent_pre_read_cycles : go to the next event,
1130 * update the necessary fields of the current event
1131 * increment the cycle counter, save it at the end.
1132 *Input params
1133 * t : tracefile
1134 *return value
1135 * 0 : success
1136 * ERANGE : event id is out of range
1137 ****************************************************************************/
1138
1139 int skipEvent_pre_read_cycles(LttTracefile * t)
1140 {
1141 int evId;
1142 void * evData;
1143 LttEventType * evT;
1144 LttField * rootFld;
1145
1146 evId = (int)(*(guint16 *)(t->cur_event_pos));
1147 evData = t->cur_event_pos + EVENT_HEADER_SIZE;
1148
1149 evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
1150
1151 if(likely(evT)) rootFld = evT->root_field;
1152 else return ERANGE;
1153
1154 if(likely(rootFld)){
1155 //event has string/sequence or the last event is not the same event
1156 if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event)
1157 && rootFld->field_fixed == 0)){
1158 setFieldsOffset(t, evT, evData, t->trace);
1159 }
1160 t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size;
1161 }else t->cur_event_pos += EVENT_HEADER_SIZE;
1162
1163 //evT->latest_block = t->which_block;
1164 //evT->latest_event = t->which_event;
1165
1166 //the next event is in the next block
1167 //if(unlikely(evId == TRACE_BLOCK_END)){
1168 // Specify end of buffer reached.
1169 // t->cur_event_pos = t->buffer + t->block_size;
1170 //}else{
1171 //g_critical("COUNT : %lu", t->cur_cycle_count);
1172 //t->which_event++;
1173 // t->current_event_time = getEventTime(t);
1174 //}
1175
1176 return 0;
1177 }
1178
1179
1180
1181
1182 /*****************************************************************************
1183 *Function name
1184 * ltt_tracefile_pre_read_cycles :
1185 * read the current event, increment the cycle counter
1186 *Input params
1187 * t : tracefile
1188 *Return value
1189 * False : end of bloc reached
1190 ****************************************************************************/
1191
1192 gboolean ltt_tracefile_pre_read_cycles(LttTracefile *tf)
1193 {
1194 int err;
1195 //LttEvent event;
1196
1197 // if(unlikely(t->cur_event_pos == t->buffer + t->block_size)){
1198 //if(unlikely(t->which_block == t->block_number)){
1199 // return FALSE;
1200 //}
1201 // return FALSE; // end of bloc reached
1202 //err = readBlock(t, t->which_block + 1);
1203 //if(unlikely(err))g_error("Can not read tracefile");
1204 //}
1205
1206 //event.event_id = (int)(*(guint16 *)(t->cur_event_pos));
1207 //if(unlikely(event.event_id == TRACE_TIME_HEARTBEAT))
1208 // t->cur_heart_beat_number++;
1209
1210 //t->prev_event_time = t->current_event_time;
1211 // t->current_event_time = getEventTime(t);
1212
1213 //event.time_delta = *(guint32 *)(t->cur_event_pos + EVENT_ID_SIZE);
1214 //event.event_time = t->current_event_time;
1215 //event.event_cycle_count = t->cur_cycle_count;
1216
1217 //event.tracefile = t;
1218 //event.data = t->cur_event_pos + EVENT_HEADER_SIZE;
1219 //event.which_block = t->which_block;
1220 //event.which_event = t->which_event;
1221
1222 /* This is a workaround for fast position seek */
1223 //event.last_event_pos = t->last_event_pos;
1224 //event.prev_block_end_time = t->prev_block_end_time;
1225 //event.prev_event_time = t->prev_event_time;
1226 //event.pre_cycle_count = t->pre_cycle_count;
1227 //event.count = t->count;
1228 /* end of workaround */
1229
1230
1231 /* Increment the cycle counter for the bloc */
1232 LttTime time;
1233 LttCycleCount cycle_count; // cycle count for the current event
1234 LttCycleCount lEventTotalCycle; // Total cycles from start for event
1235 LttCycleCount lEventNSec; // Total nsecs from start for event
1236 LttTime lTimeOffset; // Time offset in struct LttTime
1237 guint16 evId;
1238
1239 evId = *(guint16 *)tf->cur_event_pos;
1240
1241 // Calculate total time in cycles from start of buffer for this event
1242 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1243 //g_debug("event cycle count %llu", cycle_count);
1244 //
1245 //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
1246 //LttCycleCount res_delta_count;
1247 gboolean comp_count = cycle_count < tf->pre_cycle_count;
1248 tf->pre_cycle_count = cycle_count;
1249
1250 if(unlikely(comp_count)) {
1251 /* Wrapped */
1252 tf->count++; //increment wrap count
1253 }
1254
1255 //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1256 //if(unlikely(delta_count < 0)) {
1257 // tf->count++; //increment wrap count
1258 // keep in mind that delta_count is negative here.
1259 // res_delta_count = delta_count + 0x100000000ULL ;
1260 //} else
1261 // res_delta_count = (LttCycleCount)delta_count;
1262
1263 //cycle_count += (LttCycleCount)tf->count << 32;
1264
1265 //FIXME (MD)
1266 // if(tf->cur_heart_beat_number > tf->count)
1267 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1268
1269 //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
1270 tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
1271 //g_debug("cur cycle count %llu", tf->cur_cycle_count);
1272
1273
1274
1275
1276 if(unlikely(evId == TRACE_BLOCK_START)){
1277 //g_debug("BLOCK START");
1278 }else if(unlikely(evId == TRACE_BLOCK_END)){
1279 //g_debug("BLOCK END");
1280
1281 /* The goal of all this pre reading */
1282 tf->a_block_end->cycle_count = tf->cur_cycle_count;
1283 //g_debug("end of block cycle count : %llu", tf->cur_cycle_count);
1284
1285 return FALSE;
1286 }
1287
1288 //update the fields of the current event and go to the next event
1289 err = skipEvent_pre_read_cycles(tf);
1290 if(unlikely(err == ERANGE)) g_error("event id is out of range\n");
1291
1292
1293 return TRUE;
1294 }
1295
1296 /****************************************************************************
1297 *Function name
1298 * readBlock : read a block from the file
1299 *Input Params
1300 * lttdes : ltt trace file
1301 * whichBlock : the block which will be read
1302 *return value
1303 * 0 : success
1304 * EINVAL : lseek fail
1305 * EIO : can not read from the file
1306 ****************************************************************************/
1307
1308 int readBlock(LttTracefile * tf, int whichBlock)
1309 {
1310 off_t nbBytes;
1311 guint32 lostSize;
1312
1313 /* same block already opened requested */
1314 if((guint)whichBlock == tf->which_block) return 0;
1315
1316 if(likely(whichBlock - tf->which_block == 1 && tf->which_block != 0)){
1317 tf->prev_block_end_time = tf->a_block_end->time;
1318 tf->prev_event_time = tf->a_block_end->time;
1319 }else{
1320 tf->prev_block_end_time.tv_sec = 0;
1321 tf->prev_block_end_time.tv_nsec = 0;
1322 tf->prev_event_time.tv_sec = 0;
1323 tf->prev_event_time.tv_nsec = 0;
1324 }
1325
1326 nbBytes=lseek(tf->fd,(off_t)((whichBlock-1)*tf->block_size), SEEK_SET);
1327 if(unlikely(nbBytes == -1)) return EINVAL;
1328
1329 if(unlikely(readFile(tf->fd,tf->buffer,tf->block_size,"Unable to read a block")))
1330 return EIO;
1331
1332 tf->a_block_start=(BlockStart *) (tf->buffer + EVENT_HEADER_SIZE);
1333 lostSize = *(guint32 *)(tf->buffer + tf->block_size - sizeof(guint32));
1334 tf->a_block_end=(BlockEnd *)(tf->buffer + tf->block_size -
1335 lostSize + EVENT_HEADER_SIZE);
1336 tf->last_event_pos = tf->buffer + tf->block_size - lostSize;
1337
1338 tf->which_block = whichBlock;
1339 tf->which_event = 1;
1340 tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev
1341 tf->cur_heart_beat_number = 0;
1342
1343 /* read the whole block to precalculate total of cycles in it */
1344 tf->count = 0;
1345 tf->pre_cycle_count = 0;
1346 tf->cur_cycle_count = 0;
1347 //g_debug("precalculating cycles begin for block %i", whichBlock);
1348 while(likely(ltt_tracefile_pre_read_cycles(tf)));
1349 /* Rough approximation of cycles per usec to calculate
1350 * the real block start and end time.
1351 */
1352 getCyclePerNsec(tf);
1353 /* we are at end position, make end time more precise */
1354 /* Start overflow_nsec to a negative value : takes account of the
1355 * start of block cycle counter */
1356 tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
1357 * tf->nsec_per_cycle);
1358 /* put back the numbers corresponding to end time */
1359 tf->overflow_nsec += tf->one_overflow_nsec * tf->count;
1360
1361 tf->a_block_end->time = getEventTime(tf);
1362
1363 //g_debug("precalculating cycles end for block %i", whichBlock);
1364
1365 /* put back pointer at the beginning */
1366 tf->count = 0;
1367 tf->pre_cycle_count = 0;
1368 tf->cur_cycle_count = 0;
1369 tf->which_event = 1;
1370 tf->cur_event_pos = tf->buffer;//the beginning of the block, block start ev
1371 tf->cur_heart_beat_number = 0;
1372
1373 /* Make start time more precise */
1374 /* Start overflow_nsec to a negative value : takes account of the
1375 * start of block cycle counter */
1376 tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
1377 * tf->nsec_per_cycle);
1378
1379
1380 tf->a_block_start->time = getEventTime(tf);
1381
1382 /* recalculate the cycles per nsec, with now more precise start and end time
1383 */
1384 getCyclePerNsec(tf);
1385 tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
1386 * tf->nsec_per_cycle);
1387
1388
1389
1390 tf->current_event_time = getEventTime(tf);
1391
1392 return 0;
1393 }
1394
1395 /*****************************************************************************
1396 *Function name
1397 * updateTracefile : reinitialize the info of the block which is already
1398 * in the buffer
1399 *Input params
1400 * tf : tracefile
1401 ****************************************************************************/
1402
1403 void updateTracefile(LttTracefile * tf)
1404 {
1405 tf->which_event = 1;
1406 tf->cur_event_pos = tf->buffer;
1407 tf->current_event_time = getEventTime(tf);
1408 tf->cur_heart_beat_number = 0;
1409
1410 tf->prev_event_time.tv_sec = 0;
1411 tf->prev_event_time.tv_nsec = 0;
1412 tf->count = 0;
1413
1414 tf->overflow_nsec = (-((double)tf->a_block_start->cycle_count)
1415 * tf->nsec_per_cycle);
1416
1417 }
1418
1419 /*****************************************************************************
1420 *Function name
1421 * skipEvent : go to the next event, update the fields of the current event
1422 *Input params
1423 * t : tracefile
1424 *return value
1425 * 0 : success
1426 * ERANGE : event id is out of range
1427 ****************************************************************************/
1428
1429 int skipEvent(LttTracefile * t)
1430 {
1431 int evId;
1432 void * evData;
1433 LttEventType * evT;
1434 LttField * rootFld;
1435
1436 evId = (int)(*(guint16 *)(t->cur_event_pos));
1437 evData = t->cur_event_pos + EVENT_HEADER_SIZE;
1438
1439 evT = ltt_trace_eventtype_get(t->trace,(unsigned)evId);
1440
1441 if(likely(evT)) rootFld = evT->root_field;
1442 else return ERANGE;
1443
1444 if(likely(rootFld)){
1445 //event has string/sequence or the last event is not the same event
1446 if(likely((evT->latest_block!=t->which_block || evT->latest_event!=t->which_event)
1447 && rootFld->field_fixed == 0)){
1448 setFieldsOffset(t, evT, evData, t->trace);
1449 }
1450 t->cur_event_pos += EVENT_HEADER_SIZE + rootFld->field_size;
1451 }else t->cur_event_pos += EVENT_HEADER_SIZE;
1452
1453 evT->latest_block = t->which_block;
1454 evT->latest_event = t->which_event;
1455
1456 //the next event is in the next block
1457 if(unlikely(evId == TRACE_BLOCK_END)){
1458 t->cur_event_pos = t->buffer + t->block_size;
1459 }else{
1460 t->which_event++;
1461 t->current_event_time = getEventTime(t);
1462 }
1463
1464 return 0;
1465 }
1466
1467
1468 /*****************************************************************************
1469 *Function name
1470 * getCyclePerNsec : calculate cycles per nsec for current block
1471 * MD: should have tracefile_read the whole block, so we know the
1472 * total of cycles in it before being called.
1473 *Input Params
1474 * t : tracefile
1475 ****************************************************************************/
1476
1477 void getCyclePerNsec(LttTracefile * t)
1478 {
1479 LttTime lBufTotalTime; /* Total time for this buffer */
1480 double lBufTotalNSec; /* Total time for this buffer in nsecs */
1481 double lBufTotalCycle;/* Total cycles for this buffer */
1482
1483 /* Calculate the total time for this buffer */
1484 lBufTotalTime = ltt_time_sub(t->a_block_end->time, t->a_block_start->time);
1485
1486 /* Calculate the total cycles for this bufffer */
1487 lBufTotalCycle = t->a_block_end->cycle_count;
1488 lBufTotalCycle -= t->a_block_start->cycle_count;
1489
1490 /* Convert the total time to nsecs */
1491 lBufTotalNSec = ltt_time_to_double(lBufTotalTime);
1492
1493 t->nsec_per_cycle = (double)lBufTotalNSec / (double)lBufTotalCycle;
1494 /* Pre-multiply one overflow (2^32 cycles) by nsec_per_cycle */
1495 t->one_overflow_nsec = t->nsec_per_cycle * (double)0x100000000ULL;
1496
1497 /* See : http://www.azillionmonkeys.com/qed/adiv.html */
1498 // precalculate the reciprocal, so divisions will be really fast.
1499 // 2^32-1 == 0xFFFFFFFFULL
1500 //{
1501 // double int_res = lBufTotalCycle/lBufTotalNSec;
1502 // t->cycles_per_nsec_reciprocal =
1503 // ((0xFFFF+int_res)/int_res);
1504 //}
1505
1506 }
1507
1508 /****************************************************************************
1509 *Function name
1510 * getEventTime : obtain the time of an event
1511 * NOTE : this function _really_ is on critical path.
1512 *Input params
1513 * tf : tracefile
1514 *Return value
1515 * LttTime : the time of the event
1516 ****************************************************************************/
1517
1518 static inline LttTime getEventTime(LttTracefile * tf)
1519 {
1520 LttTime time;
1521 LttCycleCount cycle_count; // cycle count for the current event
1522 //LttCycleCount lEventTotalCycle; // Total cycles from start for event
1523 gint64 lEventNSec; // Total nsecs from start for event
1524 LttTime lTimeOffset; // Time offset in struct LttTime
1525 guint16 evId;
1526
1527 evId = *(guint16 *)tf->cur_event_pos;
1528 //if(unlikely(evId == TRACE_BLOCK_START)){
1529 // tf->count = 0;
1530 // tf->pre_cycle_count = 0;
1531 // tf->cur_cycle_count = tf->a_block_start->cycle_count;
1532 // return tf->a_block_start->time;
1533 //}//else if(unlikely(evId == TRACE_BLOCK_END)){
1534 //tf->count = 0;
1535 //tf->pre_cycle_count = 0;
1536 //tf->cur_cycle_count = tf->a_block_end->cycle_count;
1537 //return tf->a_block_end->time;
1538 //}
1539
1540 // Calculate total time in cycles from start of buffer for this event
1541 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1542 //g_debug("event cycle count %llu", cycle_count);
1543 //
1544 //gint64 delta_count = (gint64)(cycle_count - tf->pre_cycle_count);
1545 //LttCycleCount res_delta_count;
1546 gboolean comp_count = cycle_count < tf->pre_cycle_count;
1547 tf->pre_cycle_count = cycle_count;
1548
1549 if(unlikely(comp_count)) {
1550 /* Wrapped */
1551 tf->overflow_nsec += tf->one_overflow_nsec;
1552 tf->count++; //increment overflow count
1553 }
1554
1555 //if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1556 //if(unlikely(delta_count < 0)) {
1557 // tf->count++; //increment wrap count
1558 // keep in mind that delta_count is negative here.
1559 // res_delta_count = delta_count + 0x100000000ULL ;
1560 //} else
1561 // res_delta_count = (LttCycleCount)delta_count;
1562
1563 //cycle_count += (LttCycleCount)tf->count << 32;
1564
1565 //FIXME (MD)
1566 // if(tf->cur_heart_beat_number > tf->count)
1567 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1568
1569 //tf->cur_cycle_count = tf->cur_cycle_count + res_delta_count;
1570 //
1571 //
1572 // Total cycle counter of the event.
1573 //tf->cur_cycle_count = cycle_count | ((LttCycleCount)tf->count << 32);
1574
1575 //g_debug("cur cycle count %llu", tf->cur_cycle_count);
1576
1577 // Total number of cycles since the beginning of the block
1578 //lEventTotalCycle = tf->cur_cycle_count
1579 // - tf->a_block_start->cycle_count;
1580
1581
1582
1583 #if 0
1584 // Calculate total time in cycles from start of buffer for this event
1585 cycle_count = (LttCycleCount)*(guint32 *)(tf->cur_event_pos + EVENT_ID_SIZE);
1586
1587 if(unlikely(cycle_count < tf->pre_cycle_count)) tf->count++;
1588 tf->pre_cycle_count = cycle_count;
1589 cycle_count += (LttCycleCount)tf->count << 32;
1590
1591 //FIXME (MD)
1592 // if(tf->cur_heart_beat_number > tf->count)
1593 // cycle_count += (tf->cur_heart_beat_number - tf->count) << 32;
1594
1595 tf->cur_cycle_count = cycle_count;
1596
1597 lEventTotalCycle = cycle_count;
1598 lEventTotalCycle -= tf->a_block_start->cycle_count;
1599 #endif //0
1600 // Convert it to nsecs
1601 //lEventNSec = (double)lEventTotalCycle * (double)tf->nsec_per_cycle;
1602 //lEventNSec = (tf->cycles_per_nsec_reciprocal * lEventTotalCycle) >> 16;
1603
1604 // Determine offset in struct LttTime
1605 //lTimeOffset = ltt_time_from_double(lEventNSec);
1606 //
1607 // We do not substract block start cycle count here, it has already been done
1608 // on the overflow_nsec
1609 // The result should never be negative, because the cycle count of
1610 // the event following the block start should be >= the previous one.
1611 lEventNSec = (gint64)((double)cycle_count * tf->nsec_per_cycle)
1612 +tf->overflow_nsec;
1613 //g_assert(lEventNSec >= 0);
1614 lTimeOffset = ltt_time_from_uint64(lEventNSec);
1615
1616 time = ltt_time_add(tf->a_block_start->time, lTimeOffset);
1617
1618 return time;
1619 }
1620
1621 /*****************************************************************************
1622 *Function name
1623 * setFieldsOffset : set offset of the fields
1624 *Input params
1625 * tracefile : opened trace file
1626 * evT : the event type
1627 * evD : event data, it may be NULL
1628 ****************************************************************************/
1629
1630 void setFieldsOffset(LttTracefile *tf,LttEventType *evT,void *evD,LttTrace* t)
1631 {
1632 LttField * rootFld = evT->root_field;
1633 // rootFld->base_address = evD;
1634
1635 if(likely(rootFld))
1636 rootFld->field_size = getFieldtypeSize(tf, evT, 0,0,rootFld, evD,t);
1637 }
1638
1639 /*****************************************************************************
1640 *Function name
1641 * getFieldtypeSize: get the size of the field type (primitive type)
1642 *Input params
1643 * tracefile : opened trace file
1644 * evT : event type
1645 * offsetRoot : offset from the root
1646 * offsetParent : offset from the parrent
1647 * fld : field
1648 * evD : event data, it may be NULL
1649 *Return value
1650 * int : size of the field
1651 ****************************************************************************/
1652
1653 int getFieldtypeSize(LttTracefile * t, LttEventType * evT, int offsetRoot,
1654 int offsetParent, LttField * fld, void *evD, LttTrace *trace)
1655 {
1656 int size, size1, element_number, i, offset1, offset2;
1657 LttType * type = fld->field_type;
1658
1659 if(likely(t)){
1660 if(unlikely(evT->latest_block==t->which_block && evT->latest_event==t->which_event)){
1661 return fld->field_size;
1662 }
1663 }
1664
1665 if(likely(fld->field_fixed == 1)){
1666 if(fld == evT->root_field) return fld->field_size;
1667 }
1668
1669 switch(type->type_class) {
1670 case LTT_ARRAY:
1671 element_number = (int) type->element_number;
1672 if(fld->field_fixed == -1){
1673 size = getFieldtypeSize(t, evT, offsetRoot,
1674 0,fld->child[0], NULL, trace);
1675 if(size == 0){ //has string or sequence
1676 fld->field_fixed = 0;
1677 }else{
1678 fld->field_fixed = 1;
1679 size *= element_number;
1680 }
1681 }else if(fld->field_fixed == 0){// has string or sequence
1682 size = 0;
1683 for(i=0;i<element_number;i++){
1684 size += getFieldtypeSize(t, evT, offsetRoot+size,size,
1685 fld->child[0], evD+size, trace);
1686 }
1687 }else size = fld->field_size;
1688 break;
1689
1690 case LTT_SEQUENCE:
1691 size1 = (int) ltt_type_size(trace, type);
1692 if(fld->field_fixed == -1){
1693 fld->sequ_number_size = size1;
1694 fld->field_fixed = 0;
1695 size = getFieldtypeSize(t, evT, offsetRoot,
1696 0,fld->child[0], NULL, trace);
1697 fld->element_size = size;
1698 }else{//0: sequence
1699 element_number = getIntNumber(size1,evD);
1700 type->element_number = element_number;
1701 if(fld->element_size > 0){
1702 size = element_number * fld->element_size;
1703 }else{//sequence has string or sequence
1704 size = 0;
1705 for(i=0;i<element_number;i++){
1706 size += getFieldtypeSize(t, evT, offsetRoot+size+size1,size+size1,
1707 fld->child[0], evD+size+size1, trace);
1708 }
1709 }
1710 size += size1;
1711 }
1712 break;
1713
1714 case LTT_STRING:
1715 size = 0;
1716 if(fld->field_fixed == -1){
1717 fld->field_fixed = 0;
1718 }else{//0: string
1719 size = strlen((char*)evD) + 1; //include end : '\0'
1720 }
1721 break;
1722
1723 case LTT_STRUCT:
1724 element_number = (int) type->element_number;
1725 size = 0;
1726 if(fld->field_fixed == -1){
1727 offset1 = offsetRoot;
1728 offset2 = 0;
1729 for(i=0;i<element_number;i++){
1730 size1=getFieldtypeSize(t, evT,offset1,offset2,
1731 fld->child[i], NULL, trace);
1732 if(size1 > 0 && size >= 0){
1733 size += size1;
1734 if(offset1 >= 0) offset1 += size1;
1735 offset2 += size1;
1736 }else{
1737 size = -1;
1738 offset1 = -1;
1739 offset2 = -1;
1740 }
1741 }
1742 if(size == -1){
1743 fld->field_fixed = 0;
1744 size = 0;
1745 }else fld->field_fixed = 1;
1746 }else if(fld->field_fixed == 0){
1747 offset1 = offsetRoot;
1748 offset2 = 0;
1749 for(i=0;i<element_number;i++){
1750 size=getFieldtypeSize(t,evT,offset1,offset2,
1751 fld->child[i],evD+offset2, trace);
1752 offset1 += size;
1753 offset2 += size;
1754 }
1755 size = offset2;
1756 }else size = fld->field_size;
1757 break;
1758
1759 default:
1760 if(fld->field_fixed == -1){
1761 size = (int) ltt_type_size(trace, type);
1762 fld->field_fixed = 1;
1763 }else size = fld->field_size;
1764 break;
1765 }
1766
1767
1768
1769 #if 0
1770 if(type->type_class != LTT_STRUCT && type->type_class != LTT_ARRAY &&
1771 type->type_class != LTT_SEQUENCE && type->type_class != LTT_STRING){
1772 if(fld->field_fixed == -1){
1773 size = (int) ltt_type_size(trace, type);
1774 fld->field_fixed = 1;
1775 }else size = fld->field_size;
1776
1777 }else if(type->type_class == LTT_ARRAY){
1778 element_number = (int) type->element_number;
1779 if(fld->field_fixed == -1){
1780 size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL, trace);
1781 if(size == 0){ //has string or sequence
1782 fld->field_fixed = 0;
1783 }else{
1784 fld->field_fixed = 1;
1785 size *= element_number;
1786 }
1787 }else if(fld->field_fixed == 0){// has string or sequence
1788 size = 0;
1789 for(i=0;i<element_number;i++){
1790 size += getFieldtypeSize(t, evT, offsetRoot+size,size,
1791 fld->child[0], evD+size, trace);
1792 }
1793 }else size = fld->field_size;
1794
1795 }else if(type->type_class == LTT_SEQUENCE){
1796 size1 = (int) ltt_type_size(trace, type);
1797 if(fld->field_fixed == -1){
1798 fld->sequ_number_size = size1;
1799 fld->field_fixed = 0;
1800 size = getFieldtypeSize(t, evT, offsetRoot,0,fld->child[0], NULL, trace);
1801 fld->element_size = size;
1802 }else{//0: sequence
1803 element_number = getIntNumber(size1,evD);
1804 type->element_number = element_number;
1805 if(fld->element_size > 0){
1806 size = element_number * fld->element_size;
1807 }else{//sequence has string or sequence
1808 size = 0;
1809 for(i=0;i<element_number;i++){
1810 size += getFieldtypeSize(t, evT, offsetRoot+size+size1,size+size1,
1811 fld->child[0], evD+size+size1, trace);
1812 }
1813 }
1814 size += size1;
1815 }
1816
1817 }else if(type->type_class == LTT_STRING){
1818 size = 0;
1819 if(fld->field_fixed == -1){
1820 fld->field_fixed = 0;
1821 }else{//0: string
1822 size = strlen((char*)evD) + 1; //include end : '\0'
1823 }
1824
1825 }else if(type->type_class == LTT_STRUCT){
1826 element_number = (int) type->element_number;
1827 size = 0;
1828 if(fld->field_fixed == -1){
1829 offset1 = offsetRoot;
1830 offset2 = 0;
1831 for(i=0;i<element_number;i++){
1832 size1=getFieldtypeSize(t, evT,offset1,offset2, fld->child[i], NULL, trace);
1833 if(size1 > 0 && size >= 0){
1834 size += size1;
1835 if(offset1 >= 0) offset1 += size1;
1836 offset2 += size1;
1837 }else{
1838 size = -1;
1839 offset1 = -1;
1840 offset2 = -1;
1841 }
1842 }
1843 if(size == -1){
1844 fld->field_fixed = 0;
1845 size = 0;
1846 }else fld->field_fixed = 1;
1847 }else if(fld->field_fixed == 0){
1848 offset1 = offsetRoot;
1849 offset2 = 0;
1850 for(i=0;i<element_number;i++){
1851 size=getFieldtypeSize(t,evT,offset1,offset2,fld->child[i],evD+offset2, trace);
1852 offset1 += size;
1853 offset2 += size;
1854 }
1855 size = offset2;
1856 }else size = fld->field_size;
1857 }
1858 #endif //0
1859
1860 fld->offset_root = offsetRoot;
1861 fld->offset_parent = offsetParent;
1862 if(!evD){
1863 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
1864 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
1865 }
1866 fld->field_size = size;
1867
1868 return size;
1869 }
1870
1871
1872 /*****************************************************************************
1873 *Function name
1874 * getIntNumber : get an integer number
1875 *Input params
1876 * size : the size of the integer
1877 * evD : the event data
1878 *Return value
1879 * gint64 : a 64 bits integer
1880 ****************************************************************************/
1881
1882 gint64 getIntNumber(int size, void *evD)
1883 {
1884 gint64 i;
1885
1886 switch(size) {
1887 case 1: i = *(gint8 *)evD; break;
1888 case 2: i = *(gint16 *)evD; break;
1889 case 4: i = *(gint32 *)evD; break;
1890 case 8: i = *(gint64 *)evD; break;
1891 default: i = *(gint64 *)evD;
1892 g_critical("getIntNumber : integer size %d unknown", size);
1893 break;
1894 }
1895
1896 #if 0
1897 if(size == 1) i = *(gint8 *)evD;
1898 else if(size == 2) i = *(gint16 *)evD;
1899 else if(size == 4) i = *(gint32 *)evD;
1900 else if(size == 8) i = *(gint64 *)evD;
1901 #endif //0
1902
1903 return (gint64)i;
1904 }
1905
1906 /*****************************************************************************
1907 *Function name
1908 * getDataEndianType : get the data type size and endian type of the local
1909 * machine
1910 *Input params
1911 * size : size of data type
1912 * endian : endian type, little or big
1913 ****************************************************************************/
1914
1915 void getDataEndianType(LttArchSize * size, LttArchEndian * endian)
1916 {
1917 int i = 1;
1918 char c = (char) i;
1919 int sizeInt=sizeof(int), sizeLong=sizeof(long), sizePointer=sizeof(void *);
1920
1921 if(c == 1) *endian = LTT_LITTLE_ENDIAN;
1922 else *endian = LTT_BIG_ENDIAN;
1923
1924 if(sizeInt == 2 && sizeLong == 4 && sizePointer == 4)
1925 *size = LTT_LP32;
1926 else if(sizeInt == 4 && sizeLong == 4 && sizePointer == 4)
1927 *size = LTT_ILP32;
1928 else if(sizeInt == 4 && sizeLong == 8 && sizePointer == 8)
1929 *size = LTT_LP64;
1930 else if(sizeInt == 8 && sizeLong == 8 && sizePointer == 8)
1931 *size = LTT_ILP64;
1932 else *size = LTT_UNKNOWN;
1933 }
1934
1935 /* get the node name of the system */
1936
1937 char * ltt_trace_system_description_node_name (LttSystemDescription * s)
1938 {
1939 return s->node_name;
1940 }
1941
1942
1943 /* get the domain name of the system */
1944
1945 char * ltt_trace_system_description_domain_name (LttSystemDescription * s)
1946 {
1947 return s->domain_name;
1948 }
1949
1950
1951 /* get the description of the system */
1952
1953 char * ltt_trace_system_description_description (LttSystemDescription * s)
1954 {
1955 return s->description;
1956 }
1957
1958
1959 /* get the start time of the trace */
1960
1961 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
1962 {
1963 return s->trace_start;
1964 }
1965
1966
1967 LttTracefile *ltt_tracefile_new()
1968 {
1969 return g_new(LttTracefile, 1);
1970 }
1971
1972 void ltt_tracefile_destroy(LttTracefile *tf)
1973 {
1974 g_free(tf);
1975 }
1976
1977 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
1978 {
1979 *dest = *src;
1980 }
1981
LTTng 2.x Viewer (LTTV)
This page took 0.088746 seconds and 4 git commands to generate.