projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add eventdefs exclusion in open_tracefiles
[lttv.git] / ltt / branches / poly / ltt / tracefile.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2005 Mathieu Desnoyers
3 *
4 * Complete rewrite from the original version made by XangXiu Yang.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License Version 2 as
8 * published by the Free Software Foundation;
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
18 * MA 02111-1307, USA.
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdio.h>
26 #include <fcntl.h>
27 #include <string.h>
28 #include <dirent.h>
29 #include <sys/stat.h>
30 #include <sys/types.h>
31 #include <errno.h>
32 #include <unistd.h>
33 #include <math.h>
34 #include <glib.h>
35 #include <malloc.h>
36 #include <sys/mman.h>
37
38 // For realpath
39 #include <limits.h>
40 #include <stdlib.h>
41
42
43 #include "parser.h"
44 #include <ltt/ltt.h>
45 #include "ltt-private.h"
46 #include <ltt/trace.h>
47 #include <ltt/facility.h>
48 #include <ltt/event.h>
49 #include <ltt/type.h>
50 #include <ltt/ltt-types.h>
51
52
53 /* Facility names used in this file */
54
55 GQuark LTT_FACILITY_NAME_HEARTBEAT,
56 LTT_EVENT_NAME_HEARTBEAT;
57 GQuark LTT_TRACEFILE_NAME_FACILITIES;
58
59 #ifndef g_open
60 #define g_open open
61 #endif
62
63
64 #define __UNUSED__ __attribute__((__unused__))
65
66 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
67
68 #ifndef g_debug
69 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
70 #endif
71
72 #define g_close close
73
74 /* Those macros must be called from within a function where page_size is a known
75 * variable */
76 #define PAGE_MASK (~(page_size-1))
77 #define PAGE_ALIGN(addr) (((addr)+page_size-1)&PAGE_MASK)
78
79 /* set the offset of the fields belonging to the event,
80 need the information of the archecture */
81 void set_fields_offsets(LttTracefile *tf, LttEventType *event_type);
82 //size_t get_fields_offsets(LttTracefile *tf, LttEventType *event_type, void *data);
83
84 /* get the size of the field type according to
85 * The facility size information. */
86 static inline void preset_field_type_size(LttTracefile *tf,
87 LttEventType *event_type,
88 off_t offset_root, off_t offset_parent,
89 enum field_status *fixed_root, enum field_status *fixed_parent,
90 LttField *field);
91
92 /* map a fixed size or a block information from the file (fd) */
93 static gint map_block(LttTracefile * tf, guint block_num);
94
95 /* calculate nsec per cycles for current block */
96 static double calc_nsecs_per_cycle(LttTracefile * t);
97
98 /* go to the next event */
99 static int ltt_seek_next_event(LttTracefile *tf);
100
101 void ltt_update_event_size(LttTracefile *tf);
102
103 #if 0
104 /* Functions to parse system.xml file (using glib xml parser) */
105 static void parser_start_element (GMarkupParseContext __UNUSED__ *context,
106 const gchar *element_name,
107 const gchar **attribute_names,
108 const gchar **attribute_values,
109 gpointer user_data,
110 GError **error)
111 {
112 int i=0;
113 LttSystemDescription* des = (LttSystemDescription* )user_data;
114 if(strcmp("system", element_name)){
115 *error = g_error_new(G_MARKUP_ERROR,
116 G_LOG_LEVEL_WARNING,
117 "This is not system.xml file");
118 return;
119 }
120
121 while(attribute_names[i]){
122 if(strcmp("node_name", attribute_names[i])==0){
123 des->node_name = g_strdup(attribute_values[i]);
124 }else if(strcmp("domainname", attribute_names[i])==0){
125 des->domain_name = g_strdup(attribute_values[i]);
126 }else if(strcmp("cpu", attribute_names[i])==0){
127 des->nb_cpu = atoi(attribute_values[i]);
128 }else if(strcmp("arch_size", attribute_names[i])==0){
129 if(strcmp(attribute_values[i],"LP32") == 0) des->size = LTT_LP32;
130 else if(strcmp(attribute_values[i],"ILP32") == 0) des->size = LTT_ILP32;
131 else if(strcmp(attribute_values[i],"LP64") == 0) des->size = LTT_LP64;
132 else if(strcmp(attribute_values[i],"ILP64") == 0) des->size = LTT_ILP64;
133 else if(strcmp(attribute_values[i],"UNKNOWN") == 0) des->size = LTT_UNKNOWN;
134 }else if(strcmp("endian", attribute_names[i])==0){
135 if(strcmp(attribute_values[i],"LITTLE_ENDIAN") == 0)
136 des->endian = LTT_LITTLE_ENDIAN;
137 else if(strcmp(attribute_values[i],"BIG_ENDIAN") == 0)
138 des->endian = LTT_BIG_ENDIAN;
139 }else if(strcmp("kernel_name", attribute_names[i])==0){
140 des->kernel_name = g_strdup(attribute_values[i]);
141 }else if(strcmp("kernel_release", attribute_names[i])==0){
142 des->kernel_release = g_strdup(attribute_values[i]);
143 }else if(strcmp("kernel_version", attribute_names[i])==0){
144 des->kernel_version = g_strdup(attribute_values[i]);
145 }else if(strcmp("machine", attribute_names[i])==0){
146 des->machine = g_strdup(attribute_values[i]);
147 }else if(strcmp("processor", attribute_names[i])==0){
148 des->processor = g_strdup(attribute_values[i]);
149 }else if(strcmp("hardware_platform", attribute_names[i])==0){
150 des->hardware_platform = g_strdup(attribute_values[i]);
151 }else if(strcmp("operating_system", attribute_names[i])==0){
152 des->operating_system = g_strdup(attribute_values[i]);
153 }else if(strcmp("ltt_major_version", attribute_names[i])==0){
154 des->ltt_major_version = atoi(attribute_values[i]);
155 }else if(strcmp("ltt_minor_version", attribute_names[i])==0){
156 des->ltt_minor_version = atoi(attribute_values[i]);
157 }else if(strcmp("ltt_block_size", attribute_names[i])==0){
158 des->ltt_block_size = atoi(attribute_values[i]);
159 }else{
160 *error = g_error_new(G_MARKUP_ERROR,
161 G_LOG_LEVEL_WARNING,
162 "Not a valid attribute");
163 return;
164 }
165 i++;
166 }
167 }
168
169 static void parser_characters (GMarkupParseContext __UNUSED__ *context,
170 const gchar *text,
171 gsize __UNUSED__ text_len,
172 gpointer user_data,
173 GError __UNUSED__ **error)
174 {
175 LttSystemDescription* des = (LttSystemDescription* )user_data;
176 des->description = g_strdup(text);
177 }
178 #endif //0
179 LttFacility *ltt_trace_get_facility_by_num(LttTrace *t,
180 guint num)
181 {
182 g_assert(num < t->facilities_by_num->len);
183
184 return &g_array_index(t->facilities_by_num, LttFacility, num);
185
186 }
187
188 guint ltt_trace_get_num_cpu(LttTrace *t)
189 {
190 return t->num_cpu;
191 }
192
193
194 /*****************************************************************************
195 *Function name
196 * ltt_tracefile_open : open a trace file, construct a LttTracefile
197 *Input params
198 * t : the trace containing the tracefile
199 * fileName : path name of the trace file
200 * tf : the tracefile structure
201 *Return value
202 * : 0 for success, -1 otherwise.
203 ****************************************************************************/
204
205 gint ltt_tracefile_open(LttTrace *t, gchar * fileName, LttTracefile *tf)
206 {
207 struct stat lTDFStat; /* Trace data file status */
208 struct ltt_block_start_header *header;
209 int page_size = getpagesize();
210
211 //open the file
212 tf->long_name = g_quark_from_string(fileName);
213 tf->trace = t;
214 tf->fd = open(fileName, O_RDONLY);
215 if(tf->fd < 0){
216 g_warning("Unable to open input data file %s\n", fileName);
217 goto end;
218 }
219
220 // Get the file's status
221 if(fstat(tf->fd, &lTDFStat) < 0){
222 g_warning("Unable to get the status of the input data file %s\n", fileName);
223 goto close_file;
224 }
225
226 // Is the file large enough to contain a trace
227 if(lTDFStat.st_size < (off_t)(sizeof(struct ltt_block_start_header))){
228 g_print("The input data file %s does not contain a trace\n", fileName);
229 goto close_file;
230 }
231
232 /* Temporarily map the buffer start header to get trace information */
233 /* Multiple of pages aligned head */
234 tf->buffer.head = mmap(0,
235 PAGE_ALIGN(sizeof(struct ltt_block_start_header)), PROT_READ,
236 MAP_PRIVATE, tf->fd, 0);
237 if(tf->buffer.head == MAP_FAILED) {
238 perror("Error in allocating memory for buffer of tracefile");
239 goto close_file;
240 }
241 g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
242
243 header = (struct ltt_block_start_header*)tf->buffer.head;
244
245 if(header->trace.magic_number == LTT_MAGIC_NUMBER)
246 tf->reverse_bo = 0;
247 else if(header->trace.magic_number == LTT_REV_MAGIC_NUMBER)
248 tf->reverse_bo = 1;
249 else /* invalid magic number, bad tracefile ! */
250 goto unmap_file;
251
252 //store the size of the file
253 tf->file_size = lTDFStat.st_size;
254 tf->buf_size = ltt_get_uint32(LTT_GET_BO(tf), &header->buf_size);
255 tf->num_blocks = tf->file_size / tf->buf_size;
256
257 if(munmap(tf->buffer.head,
258 PAGE_ALIGN(sizeof(struct ltt_block_start_header)))) {
259 g_warning("unmap size : %u\n",
260 PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
261 perror("munmap error");
262 g_assert(0);
263 }
264 tf->buffer.head = NULL;
265
266 //read the first block
267 if(map_block(tf,0)) {
268 perror("Cannot map block for tracefile");
269 goto close_file;
270 }
271
272 return 0;
273
274 /* Error */
275 unmap_file:
276 if(munmap(tf->buffer.head,
277 PAGE_ALIGN(sizeof(struct ltt_block_start_header)))) {
278 g_warning("unmap size : %u\n",
279 PAGE_ALIGN(sizeof(struct ltt_block_start_header)));
280 perror("munmap error");
281 g_assert(0);
282 }
283 close_file:
284 close(tf->fd);
285 end:
286 return -1;
287 }
288
289 LttTrace *ltt_tracefile_get_trace(LttTracefile *tf)
290 {
291 return tf->trace;
292 }
293
294 #if 0
295 /*****************************************************************************
296 *Open control and per cpu tracefiles
297 ****************************************************************************/
298
299 void ltt_tracefile_open_cpu(LttTrace *t, gchar * tracefile_name)
300 {
301 LttTracefile * tf;
302 tf = ltt_tracefile_open(t,tracefile_name);
303 if(!tf) return;
304 t->per_cpu_tracefile_number++;
305 g_ptr_array_add(t->per_cpu_tracefiles, tf);
306 }
307
308 gint ltt_tracefile_open_control(LttTrace *t, gchar * control_name)
309 {
310 LttTracefile * tf;
311 LttEvent ev;
312 LttFacility * f;
313 void * pos;
314 FacilityLoad fLoad;
315 unsigned int i;
316
317 tf = ltt_tracefile_open(t,control_name);
318 if(!tf) {
319 g_warning("ltt_tracefile_open_control : bad file descriptor");
320 return -1;
321 }
322 t->control_tracefile_number++;
323 g_ptr_array_add(t->control_tracefiles,tf);
324
325 //parse facilities tracefile to get base_id
326 if(strcmp(&control_name[strlen(control_name)-10],"facilities") ==0){
327 while(1){
328 if(!ltt_tracefile_read(tf,&ev)) return 0; // end of file
329
330 if(ev.event_id == TRACE_FACILITY_LOAD){
331 pos = ev.data;
332 fLoad.name = (gchar*)pos;
333 fLoad.checksum = *(LttChecksum*)(pos + strlen(fLoad.name));
334 fLoad.base_code = *(guint32 *)(pos + strlen(fLoad.name) + sizeof(LttChecksum));
335
336 for(i=0;i<t->facility_number;i++){
337 f = (LttFacility*)g_ptr_array_index(t->facilities,i);
338 if(strcmp(f->name,fLoad.name)==0 && fLoad.checksum==f->checksum){
339 f->base_id = fLoad.base_code;
340 break;
341 }
342 }
343 if(i==t->facility_number) {
344 g_warning("Facility: %s, checksum: %u is not found",
345 fLoad.name,(unsigned int)fLoad.checksum);
346 return -1;
347 }
348 }else if(ev.event_id == TRACE_BLOCK_START){
349 continue;
350 }else if(ev.event_id == TRACE_BLOCK_END){
351 break;
352 }else {
353 g_warning("Not valid facilities trace file");
354 return -1;
355 }
356 }
357 }
358 return 0;
359 }
360 #endif //0
361
362 /*****************************************************************************
363 *Function name
364 * ltt_tracefile_close: close a trace file,
365 *Input params
366 * t : tracefile which will be closed
367 ****************************************************************************/
368
369 void ltt_tracefile_close(LttTracefile *t)
370 {
371 int page_size = getpagesize();
372
373 if(t->buffer.head != NULL)
374 if(munmap(t->buffer.head, PAGE_ALIGN(t->buf_size))) {
375 g_warning("unmap size : %u\n",
376 PAGE_ALIGN(t->buf_size));
377 perror("munmap error");
378 g_assert(0);
379 }
380
381 close(t->fd);
382 }
383
384
385 /*****************************************************************************
386 *Get system information
387 ****************************************************************************/
388 #if 0
389 gint getSystemInfo(LttSystemDescription* des, gchar * pathname)
390 {
391 int fd;
392 GIOChannel *iochan;
393 gchar *buf = NULL;
394 gsize length;
395
396 GMarkupParseContext * context;
397 GError * error = NULL;
398 GMarkupParser markup_parser =
399 {
400 parser_start_element,
401 NULL,
402 parser_characters,
403 NULL, /* passthrough */
404 NULL /* error */
405 };
406
407 fd = g_open(pathname, O_RDONLY, 0);
408 if(fd == -1){
409 g_warning("Can not open file : %s\n", pathname);
410 return -1;
411 }
412
413 iochan = g_io_channel_unix_new(fd);
414
415 context = g_markup_parse_context_new(&markup_parser, 0, des,NULL);
416
417 //while(fgets(buf,DIR_NAME_SIZE, fp) != NULL){
418 while(g_io_channel_read_line(iochan, &buf, &length, NULL, &error)
419 != G_IO_STATUS_EOF) {
420
421 if(error != NULL) {
422 g_warning("Can not read xml file: \n%s\n", error->message);
423 g_error_free(error);
424 }
425 if(!g_markup_parse_context_parse(context, buf, length, &error)){
426 if(error != NULL) {
427 g_warning("Can not parse xml file: \n%s\n", error->message);
428 g_error_free(error);
429 }
430 g_markup_parse_context_free(context);
431
432 g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
433 if(error != NULL) {
434 g_warning("Can not close file: \n%s\n", error->message);
435 g_error_free(error);
436 }
437
438 close(fd);
439 return -1;
440 }
441 }
442 g_markup_parse_context_free(context);
443
444 g_io_channel_shutdown(iochan, FALSE, &error); /* No flush */
445 if(error != NULL) {
446 g_warning("Can not close file: \n%s\n", error->message);
447 g_error_free(error);
448 }
449
450 g_close(fd);
451
452 g_free(buf);
453 return 0;
454 }
455 #endif //0
456
457 /*****************************************************************************
458 *The following functions get facility/tracefile information
459 ****************************************************************************/
460 #if 0
461 gint getFacilityInfo(LttTrace *t, gchar* eventdefs)
462 {
463 GDir * dir;
464 const gchar * name;
465 unsigned int i,j;
466 LttFacility * f;
467 LttEventType * et;
468 gchar fullname[DIR_NAME_SIZE];
469 GError * error = NULL;
470
471 dir = g_dir_open(eventdefs, 0, &error);
472
473 if(error != NULL) {
474 g_warning("Can not open directory: %s, %s\n", eventdefs, error->message);
475 g_error_free(error);
476 return -1;
477 }
478
479 while((name = g_dir_read_name(dir)) != NULL){
480 if(!g_pattern_match_simple("*.xml", name)) continue;
481 strcpy(fullname,eventdefs);
482 strcat(fullname,name);
483 ltt_facility_open(t,fullname);
484 }
485 g_dir_close(dir);
486
487 for(j=0;j<t->facility_number;j++){
488 f = (LttFacility*)g_ptr_array_index(t->facilities, j);
489 for(i=0; i<f->event_number; i++){
490 et = f->events[i];
491 setFieldsOffset(NULL, et, NULL, t);
492 }
493 }
494 return 0;
495 }
496 #endif //0
497
498 /*****************************************************************************
499 *A trace is specified as a pathname to the directory containing all the
500 *associated data (control tracefiles, per cpu tracefiles, event
501 *descriptions...).
502 *
503 *When a trace is closed, all the associated facilities, types and fields
504 *are released as well.
505 */
506
507
508 /****************************************************************************
509 * get_absolute_pathname
510 *
511 * return the unique pathname in the system
512 *
513 * MD : Fixed this function so it uses realpath, dealing well with
514 * forgotten cases (.. were not used correctly before).
515 *
516 ****************************************************************************/
517 void get_absolute_pathname(const gchar *pathname, gchar * abs_pathname)
518 {
519 abs_pathname[0] = '\0';
520
521 if ( realpath (pathname, abs_pathname) != NULL)
522 return;
523 else
524 {
525 /* error, return the original path unmodified */
526 strcpy(abs_pathname, pathname);
527 return;
528 }
529 return;
530 }
531
532 /* Search for something like : .*_.*
533 *
534 * The left side is the name, the right side is the number.
535 */
536
537 int get_tracefile_name_number(const gchar *raw_name,
538 GQuark *name,
539 guint *num)
540 {
541 guint raw_name_len = strlen(raw_name);
542 gchar char_name[PATH_MAX];
543 int i;
544 int underscore_pos;
545 long int cpu_num;
546 gchar *endptr;
547
548 for(i=raw_name_len-1;i>=0;i--) {
549 if(raw_name[i] == '_') break;
550 }
551 if(i==0) /* Either not found or name length is 0 */
552 return -1;
553 underscore_pos = i;
554
555 cpu_num = strtol(raw_name+underscore_pos+1, &endptr, 10);
556
557 if(endptr == raw_name+underscore_pos+1)
558 return -1; /* No digit */
559 if(cpu_num == LONG_MIN || cpu_num == LONG_MAX)
560 return -1; /* underflow / overflow */
561
562 strncpy(char_name, raw_name, underscore_pos);
563
564 char_name[underscore_pos] = '\0';
565
566 *name = g_quark_from_string(char_name);
567 *num = cpu_num;
568
569 return 0;
570 }
571
572
573 GData **ltt_trace_get_tracefiles_groups(LttTrace *trace)
574 {
575 return &trace->tracefiles;
576 }
577
578
579 void compute_tracefile_group(GQuark key_id,
580 GArray *group,
581 struct compute_tracefile_group_args *args)
582 {
583 int i;
584 LttTracefile *tf;
585
586 for(i=0; i<group->len; i++) {
587 tf = &g_array_index (group, LttTracefile, i);
588 if(tf->cpu_online)
589 args->func(tf, args->func_args);
590 }
591 }
592
593
594 void ltt_tracefile_group_destroy(gpointer data)
595 {
596 GArray *group = (GArray *)data;
597 int i;
598 LttTracefile *tf;
599
600 for(i=0; i<group->len; i++) {
601 tf = &g_array_index (group, LttTracefile, i);
602 if(tf->cpu_online)
603 ltt_tracefile_close(tf);
604 }
605 g_array_free(group, TRUE);
606 }
607
608 gboolean ltt_tracefile_group_has_cpu_online(gpointer data)
609 {
610 GArray *group = (GArray *)data;
611 int i;
612 LttTracefile *tf;
613
614 for(i=0; i<group->len; i++) {
615 tf = &g_array_index (group, LttTracefile, i);
616 if(tf->cpu_online) return 1;
617 }
618 return 0;
619 }
620
621
622 /* Open each tracefile under a specific directory. Put them in a
623 * GData : permits to access them using their tracefile group pathname.
624 * i.e. access control/modules tracefile group by index :
625 * "control/module".
626 *
627 * relative path is the path relative to the trace root
628 * root path is the full path
629 *
630 * A tracefile group is simply an array where all the per cpu tracefiles sits.
631 */
632
633 static int open_tracefiles(LttTrace *trace, gchar *root_path,
634 gchar *relative_path)
635 {
636 DIR *dir = opendir(root_path);
637 struct dirent *entry;
638 struct stat stat_buf;
639 int ret;
640
641 gchar path[PATH_MAX];
642 int path_len;
643 gchar *path_ptr;
644
645 int rel_path_len;
646 gchar rel_path[PATH_MAX];
647 gchar *rel_path_ptr;
648 LttTracefile tmp_tf;
649
650 if(dir == NULL) {
651 perror(root_path);
652 return ENOENT;
653 }
654
655 strncpy(path, root_path, PATH_MAX-1);
656 path_len = strlen(path);
657 path[path_len] = '/';
658 path_len++;
659 path_ptr = path + path_len;
660
661 strncpy(rel_path, relative_path, PATH_MAX-1);
662 rel_path_len = strlen(rel_path);
663 rel_path[rel_path_len] = '/';
664 rel_path_len++;
665 rel_path_ptr = rel_path + rel_path_len;
666
667 while((entry = readdir(dir)) != NULL) {
668
669 if(entry->d_name[0] == '.') continue;
670
671 strncpy(path_ptr, entry->d_name, PATH_MAX - path_len);
672 strncpy(rel_path_ptr, entry->d_name, PATH_MAX - rel_path_len);
673
674 ret = stat(path, &stat_buf);
675 if(ret == -1) {
676 perror(path);
677 continue;
678 }
679
680 g_debug("Tracefile file or directory : %s\n", path);
681
682 if(strcmp(rel_path, "/eventdefs") == 0) continue;
683
684 if(S_ISDIR(stat_buf.st_mode)) {
685
686 g_debug("Entering subdirectory...\n");
687 ret = open_tracefiles(trace, path, rel_path);
688 if(ret < 0) continue;
689 } else if(S_ISREG(stat_buf.st_mode)) {
690 GQuark name;
691 guint num;
692 GArray *group;
693
694 if(get_tracefile_name_number(rel_path, &name, &num))
695 continue; /* invalid name */
696
697 g_debug("Opening file.\n");
698 if(ltt_tracefile_open(trace, path, &tmp_tf)) {
699 g_info("Error opening tracefile %s", path);
700
701 continue; /* error opening the tracefile : bad magic number ? */
702 }
703
704 g_debug("Tracefile name is %s and number is %u",
705 g_quark_to_string(name), num);
706
707 tmp_tf.cpu_online = 1;
708 tmp_tf.cpu_num = num;
709 tmp_tf.name = name;
710
711 group = g_datalist_id_get_data(&trace->tracefiles, name);
712 if(group == NULL) {
713 /* Elements are automatically cleared when the array is allocated.
714 * It makes the cpu_online variable set to 0 : cpu offline, by default.
715 */
716 group = g_array_sized_new (FALSE, TRUE, sizeof(LttTracefile), 10);
717 g_datalist_id_set_data_full(&trace->tracefiles, name,
718 group, ltt_tracefile_group_destroy);
719 }
720
721 /* Add the per cpu tracefile to the named group */
722 unsigned int old_len = group->len;
723 if(num+1 > old_len)
724 group = g_array_set_size(group, num+1);
725 g_array_index (group, LttTracefile, num) = tmp_tf;
726
727 }
728 }
729
730 closedir(dir);
731
732 return 0;
733 }
734
735 /* ltt_get_facility_description
736 *
737 * Opens the trace corresponding to the requested facility (identified by fac_id
738 * and checksum).
739 *
740 * The name searched is : %trace root%/eventdefs/facname_checksum.xml
741 *
742 * Returns 0 on success, or 1 on failure.
743 */
744
745 static int ltt_get_facility_description(LttFacility *f,
746 LttTrace *t,
747 LttTracefile *fac_tf)
748 {
749 char desc_file_name[PATH_MAX];
750 const gchar *text;
751 guint textlen;
752 gint err;
753
754 text = g_quark_to_string(t->pathname);
755 textlen = strlen(text);
756
757 if(textlen >= PATH_MAX) goto name_error;
758 strcpy(desc_file_name, text);
759
760 text = "/eventdefs/";
761 textlen+=strlen(text);
762 if(textlen >= PATH_MAX) goto name_error;
763 strcat(desc_file_name, text);
764
765 text = g_quark_to_string(f->name);
766 textlen+=strlen(text);
767 if(textlen >= PATH_MAX) goto name_error;
768 strcat(desc_file_name, text);
769
770 text = "_";
771 textlen+=strlen(text);
772 if(textlen >= PATH_MAX) goto name_error;
773 strcat(desc_file_name, text);
774
775 err = snprintf(desc_file_name+textlen, PATH_MAX-textlen-1,
776 "%u", f->checksum);
777 if(err < 0) goto name_error;
778
779 textlen=strlen(desc_file_name);
780
781 text = ".xml";
782 textlen+=strlen(text);
783 if(textlen >= PATH_MAX) goto name_error;
784 strcat(desc_file_name, text);
785
786 err = ltt_facility_open(f, t, desc_file_name);
787 if(err) goto facility_error;
788
789 return 0;
790
791 facility_error:
792 name_error:
793 return 1;
794 }
795
796 static void ltt_fac_ids_destroy(gpointer data)
797 {
798 GArray *fac_ids = (GArray *)data;
799
800 g_array_free(fac_ids, TRUE);
801 }
802
803
804 /* Presumes the tracefile is already seeked at the beginning. It makes sense,
805 * because it must be done just after the opening */
806 static int ltt_process_facility_tracefile(LttTracefile *tf)
807 {
808 int err;
809 LttFacility *fac;
810 GArray *fac_ids;
811 guint i;
812 LttEventType *et;
813
814 while(1) {
815 err = ltt_tracefile_read_seek(tf);
816 if(err == EPERM) goto seek_error;
817 else if(err == ERANGE) break; /* End of tracefile */
818
819 err = ltt_tracefile_read_update_event(tf);
820 if(err) goto update_error;
821
822 /* We are on a facility load/or facility unload/ or heartbeat event */
823 /* The rules are :
824 * * facility 0 is hardcoded : this is the core facility. It will be shown
825 * in the facility array though, and is shown as "loaded builtin" in the
826 * trace.
827 * It contains event :
828 * 0 : facility load
829 * 1 : facility unload
830 * 2 : state dump facility load
831 * 3 : heartbeat
832 */
833 if(tf->event.facility_id != LTT_FACILITY_CORE) {
834 /* Should only contain core facility */
835 g_warning("Error in processing facility file %s, "
836 "should not contain facility id %u.", g_quark_to_string(tf->name),
837 tf->event.facility_id);
838 err = EPERM;
839 goto fac_id_error;
840 } else {
841
842 struct LttFacilityLoad *fac_load_data;
843 struct LttStateDumpFacilityLoad *fac_state_dump_load_data;
844 char *fac_name;
845
846 // FIXME align
847 switch((enum ltt_core_events)tf->event.event_id) {
848 case LTT_EVENT_FACILITY_LOAD:
849 fac_name = (char*)(tf->event.data);
850 g_debug("Doing LTT_EVENT_FACILITY_LOAD of facility %s",
851 fac_name);
852 fac_load_data =
853 (struct LttFacilityLoad *)
854 (tf->event.data + strlen(fac_name) + 1);
855 fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
856 ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id));
857 g_assert(fac->exists == 0);
858 fac->name = g_quark_from_string(fac_name);
859 fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
860 &fac_load_data->checksum);
861 fac->id = ltt_get_uint32(LTT_GET_BO(tf), &fac_load_data->id);
862 fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
863 &fac_load_data->pointer_size);
864 fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
865 &fac_load_data->long_size);
866 fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
867 &fac_load_data->size_t_size);
868 fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
869 &fac_load_data->alignment);
870
871 if(ltt_get_facility_description(fac, tf->trace, tf))
872 continue; /* error opening description */
873
874 fac->trace = tf->trace;
875
876 /* Preset the field offsets */
877 for(i=0; i<fac->events->len; i++){
878 et = &g_array_index(fac->events, LttEventType, i);
879 set_fields_offsets(tf, et);
880 }
881
882 fac->exists = 1;
883
884 fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
885 fac->name);
886 if(fac_ids == NULL) {
887 fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
888 g_datalist_id_set_data_full(&tf->trace->facilities_by_name,
889 fac->name,
890 fac_ids, ltt_fac_ids_destroy);
891 }
892 g_array_append_val(fac_ids, fac->id);
893
894 break;
895 case LTT_EVENT_FACILITY_UNLOAD:
896 g_debug("Doing LTT_EVENT_FACILITY_UNLOAD");
897 /* We don't care about unload : facilities ID are valid for the whole
898 * trace. They simply won't be used after the unload. */
899 break;
900 case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
901 fac_name = (char*)(tf->event.data);
902 g_debug("Doing LTT_EVENT_STATE_DUMP_FACILITY_LOAD of facility %s",
903 fac_name);
904 fac_state_dump_load_data =
905 (struct LttStateDumpFacilityLoad *)
906 (tf->event.data + strlen(fac_name) + 1);
907 fac = &g_array_index (tf->trace->facilities_by_num, LttFacility,
908 ltt_get_uint32(LTT_GET_BO(tf), &fac_state_dump_load_data->id));
909 g_assert(fac->exists == 0);
910 fac->name = g_quark_from_string(fac_name);
911 fac->checksum = ltt_get_uint32(LTT_GET_BO(tf),
912 &fac_state_dump_load_data->checksum);
913 fac->id = fac_state_dump_load_data->id;
914 fac->pointer_size = ltt_get_uint32(LTT_GET_BO(tf),
915 &fac_state_dump_load_data->pointer_size);
916 fac->long_size = ltt_get_uint32(LTT_GET_BO(tf),
917 &fac_state_dump_load_data->long_size);
918 fac->size_t_size = ltt_get_uint32(LTT_GET_BO(tf),
919 &fac_state_dump_load_data->size_t_size);
920 fac->alignment = ltt_get_uint32(LTT_GET_BO(tf),
921 &fac_state_dump_load_data->alignment);
922 if(ltt_get_facility_description(fac, tf->trace, tf))
923 continue; /* error opening description */
924
925 fac->trace = tf->trace;
926
927 /* Preset the field offsets */
928 for(i=0; i<fac->events->len; i++){
929 et = &g_array_index(fac->events, LttEventType, i);
930 set_fields_offsets(tf, et);
931 }
932
933 fac->exists = 1;
934
935 fac_ids = g_datalist_id_get_data(&tf->trace->facilities_by_name,
936 fac->name);
937 if(fac_ids == NULL) {
938 fac_ids = g_array_sized_new (FALSE, TRUE, sizeof(guint), 1);
939 g_datalist_id_set_data_full(&tf->trace->facilities_by_name,
940 fac->name,
941 fac_ids, ltt_fac_ids_destroy);
942 }
943 g_array_append_val(fac_ids, fac->id);
944
945 break;
946 case LTT_EVENT_HEARTBEAT:
947 break;
948 default:
949 g_warning("Error in processing facility file %s, "
950 "unknown event id %hhu in core facility.",
951 g_quark_to_string(tf->name),
952 tf->event.event_id);
953 err = EPERM;
954 goto event_id_error;
955 }
956 }
957 }
958 return 0;
959
960 /* Error handling */
961 event_id_error:
962 fac_id_error:
963 update_error:
964 seek_error:
965 g_warning("An error occured in facility tracefile parsing");
966 return err;
967 }
968
969
970 LttTrace *ltt_trace_open(const gchar *pathname)
971 {
972 gchar abs_path[PATH_MAX];
973 LttTrace * t;
974 LttTracefile *tf;
975 GArray *group;
976 int i, ret;
977 struct ltt_block_start_header *header;
978 DIR *dir;
979 struct dirent *entry;
980 guint control_found = 0;
981 guint eventdefs_found = 0;
982 struct stat stat_buf;
983 gchar path[PATH_MAX];
984
985 t = g_new(LttTrace, 1);
986 if(!t) goto alloc_error;
987
988 get_absolute_pathname(pathname, abs_path);
989 t->pathname = g_quark_from_string(abs_path);
990
991 g_datalist_init(&t->tracefiles);
992
993 /* Test to see if it looks like a trace */
994 dir = opendir(abs_path);
995 if(dir == NULL) {
996 perror(abs_path);
997 goto open_error;
998 }
999 while((entry = readdir(dir)) != NULL) {
1000 strcpy(path, abs_path);
1001 strcat(path, "/");
1002 strcat(path, entry->d_name);
1003 ret = stat(path, &stat_buf);
1004 if(ret == -1) {
1005 perror(path);
1006 continue;
1007 }
1008 if(S_ISDIR(stat_buf.st_mode)) {
1009 if(strcmp(entry->d_name, "control") == 0) {
1010 control_found = 1;
1011 }
1012 if(strcmp(entry->d_name, "eventdefs") == 0) {
1013 eventdefs_found = 1;
1014 }
1015 }
1016 }
1017 closedir(dir);
1018
1019 if(!control_found || !eventdefs_found) goto find_error;
1020
1021 /* Open all the tracefiles */
1022 if(open_tracefiles(t, abs_path, "")) {
1023 g_warning("Error opening tracefile %s", abs_path);
1024 goto find_error;
1025 }
1026
1027 /* Prepare the facilities containers : array and mapping */
1028 /* Array is zeroed : the "exists" field is set to false by default */
1029 t->facilities_by_num = g_array_sized_new (FALSE,
1030 TRUE, sizeof(LttFacility),
1031 NUM_FACILITIES);
1032 t->facilities_by_num = g_array_set_size(t->facilities_by_num, NUM_FACILITIES);
1033
1034 g_datalist_init(&t->facilities_by_name);
1035
1036 /* Parse each trace control/facilitiesN files : get runtime fac. info */
1037 group = g_datalist_id_get_data(&t->tracefiles, LTT_TRACEFILE_NAME_FACILITIES);
1038 if(group == NULL) {
1039 g_error("Trace %s has no facility tracefile", abs_path);
1040 g_assert(0);
1041 goto facilities_error;
1042 }
1043
1044 /* Get the trace information for the control/facility 0 tracefile */
1045 g_assert(group->len > 0);
1046 tf = &g_array_index (group, LttTracefile, 0);
1047 header = (struct ltt_block_start_header*)tf->buffer.head;
1048 t->arch_type = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_type);
1049 t->arch_variant = ltt_get_uint32(LTT_GET_BO(tf), &header->trace.arch_variant);
1050 t->arch_size = header->trace.arch_size;
1051 t->ltt_major_version = header->trace.major_version;
1052 t->ltt_minor_version = header->trace.minor_version;
1053 t->flight_recorder = header->trace.flight_recorder;
1054 t->has_heartbeat = header->trace.has_heartbeat;
1055 t->has_alignment = header->trace.has_alignment;
1056 t->has_tsc = header->trace.has_tsc;
1057
1058 t->num_cpu = group->len;
1059
1060 for(i=0; i<group->len; i++) {
1061 tf = &g_array_index (group, LttTracefile, i);
1062 if(ltt_process_facility_tracefile(tf))
1063 goto facilities_error;
1064 }
1065
1066 return t;
1067
1068 /* Error handling */
1069 facilities_error:
1070 g_datalist_clear(&t->facilities_by_name);
1071 g_array_free(t->facilities_by_num, TRUE);
1072 find_error:
1073 g_datalist_clear(&t->tracefiles);
1074 open_error:
1075 g_free(t);
1076 alloc_error:
1077 return NULL;
1078
1079 }
1080
1081 GQuark ltt_trace_name(const LttTrace *t)
1082 {
1083 return t->pathname;
1084 }
1085
1086
1087 /******************************************************************************
1088 * When we copy a trace, we want all the opening actions to happen again :
1089 * the trace will be reopened and totally independant from the original.
1090 * That's why we call ltt_trace_open.
1091 *****************************************************************************/
1092 LttTrace *ltt_trace_copy(LttTrace *self)
1093 {
1094 return ltt_trace_open(g_quark_to_string(self->pathname));
1095 }
1096
1097 void ltt_trace_close(LttTrace *t)
1098 {
1099 guint i;
1100 LttFacility *fac;
1101
1102 for(i=0; i<t->facilities_by_num->len; i++) {
1103 fac = &g_array_index (t->facilities_by_num, LttFacility, i);
1104 if(fac->exists)
1105 ltt_facility_close(fac);
1106 }
1107
1108 g_datalist_clear(&t->facilities_by_name);
1109 g_array_free(t->facilities_by_num, TRUE);
1110 g_datalist_clear(&t->tracefiles);
1111 g_free(t);
1112 }
1113
1114
1115 /*****************************************************************************
1116 *Get the system description of the trace
1117 ****************************************************************************/
1118
1119 LttFacility *ltt_trace_facility_by_id(LttTrace *t, guint8 id)
1120 {
1121 g_assert(id < t->facilities_by_num->len);
1122 return &g_array_index(t->facilities_by_num, LttFacility, id);
1123 }
1124
1125 /* ltt_trace_facility_get_by_name
1126 *
1127 * Returns the GArray of facility indexes. All the fac_ids that matches the
1128 * requested facility name.
1129 *
1130 * If name is not found, returns NULL.
1131 */
1132 GArray *ltt_trace_facility_get_by_name(LttTrace *t, GQuark name)
1133 {
1134 return g_datalist_id_get_data(&t->facilities_by_name, name);
1135 }
1136
1137 /*****************************************************************************
1138 * Functions to discover all the event types in the trace
1139 ****************************************************************************/
1140
1141 #if 0
1142 unsigned ltt_trace_eventtype_number(LttTrace *t)
1143 {
1144 unsigned int i;
1145 unsigned count = 0;
1146 unsigned int num = t->facility_number;
1147 LttFacility * f;
1148
1149 for(i=0;i<num;i++){
1150 f = (LttFacility*)g_ptr_array_index(t->facilities, i);
1151 count += f->event_number;
1152 }
1153 return count;
1154 }
1155 #endif //0
1156
1157 #if 0
1158 //use an iteration on all the trace facilities, and inside iteration on all the
1159 //event types in each facilities instead.
1160 LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned evId)
1161 {
1162 LttEventType *event_type;
1163
1164 LttFacility * f;
1165 f = ltt_trace_facility_by_id(t,evId);
1166
1167 if(unlikely(!f)) event_type = NULL;
1168 else event_type = f->events[evId - f->base_id];
1169
1170 return event_type;
1171 }
1172 #endif //0
1173
1174 #if 0
1175 /*****************************************************************************
1176 * ltt_trace_find_tracefile
1177 *
1178 * Find a tracefile by name and index in the group.
1179 *
1180 * Returns a pointer to the tracefiles, else NULL.
1181 ****************************************************************************/
1182
1183 LttTracefile *ltt_trace_find_tracefile(LttTrace *t, const gchar *name)
1184 {
1185 }
1186 #endif //0
1187
1188 /*****************************************************************************
1189 * Get the start time and end time of the trace
1190 ****************************************************************************/
1191
1192 static void ltt_tracefile_time_span_get(LttTracefile *tf,
1193 LttTime *start, LttTime *end)
1194 {
1195 int err;
1196
1197 err = map_block(tf, 0);
1198 if(unlikely(err)) {
1199 g_error("Can not map block");
1200 *start = ltt_time_infinite;
1201 } else
1202 *start = tf->buffer.begin.timestamp;
1203
1204 err = map_block(tf, tf->num_blocks - 1); /* Last block */
1205 if(unlikely(err)) {
1206 g_error("Can not map block");
1207 *end = ltt_time_zero;
1208 } else
1209 *end = tf->buffer.end.timestamp;
1210 }
1211
1212 struct tracefile_time_span_get_args {
1213 LttTrace *t;
1214 LttTime *start;
1215 LttTime *end;
1216 };
1217
1218 static void group_time_span_get(GQuark name, gpointer data, gpointer user_data)
1219 {
1220 struct tracefile_time_span_get_args *args =
1221 (struct tracefile_time_span_get_args*)user_data;
1222
1223 GArray *group = (GArray *)data;
1224 int i;
1225 LttTracefile *tf;
1226 LttTime tmp_start;
1227 LttTime tmp_end;
1228
1229 for(i=0; i<group->len; i++) {
1230 tf = &g_array_index (group, LttTracefile, i);
1231 if(tf->cpu_online) {
1232 ltt_tracefile_time_span_get(tf, &tmp_start, &tmp_end);
1233 if(ltt_time_compare(*args->start, tmp_start)>0) *args->start = tmp_start;
1234 if(ltt_time_compare(*args->end, tmp_end)<0) *args->end = tmp_end;
1235 }
1236 }
1237 }
1238
1239 void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end)
1240 {
1241 LttTime min_start = ltt_time_infinite;
1242 LttTime max_end = ltt_time_zero;
1243 struct tracefile_time_span_get_args args = { t, &min_start, &max_end };
1244
1245 g_datalist_foreach(&t->tracefiles, &group_time_span_get, &args);
1246
1247 if(start != NULL) *start = min_start;
1248 if(end != NULL) *end = max_end;
1249
1250 }
1251
1252
1253 /*****************************************************************************
1254 *Get the name of a tracefile
1255 ****************************************************************************/
1256
1257 GQuark ltt_tracefile_name(LttTracefile *tf)
1258 {
1259 return tf->name;
1260 }
1261
1262
1263 guint ltt_tracefile_num(LttTracefile *tf)
1264 {
1265 return tf->cpu_num;
1266 }
1267
1268 /*****************************************************************************
1269 * Get the number of blocks in the tracefile
1270 ****************************************************************************/
1271
1272 guint ltt_tracefile_block_number(LttTracefile *tf)
1273 {
1274 return tf->num_blocks;
1275 }
1276
1277
1278 /* Seek to the first event in a tracefile that has a time equal or greater than
1279 * the time passed in parameter.
1280 *
1281 * If the time parameter is outside the tracefile time span, seek to the first
1282 * event or if after, return ERANGE.
1283 *
1284 * If the time parameter is before the first event, we have to seek specially to
1285 * there.
1286 *
1287 * If the time is after the end of the trace, return ERANGE.
1288 *
1289 * Do a binary search to find the right block, then a sequential search in the
1290 * block to find the event.
1291 *
1292 * In the special case where the time requested fits inside a block that has no
1293 * event corresponding to the requested time, the first event of the next block
1294 * will be seeked.
1295 *
1296 * IMPORTANT NOTE : // FIXME everywhere...
1297 *
1298 * You MUST NOT do a ltt_tracefile_read right after a ltt_tracefile_seek_time :
1299 * you will jump over an event if you do.
1300 *
1301 * Return value : 0 : no error, the tf->event can be used
1302 * ERANGE : time if after the last event of the trace
1303 * otherwise : this is an error.
1304 *
1305 * */
1306
1307 int ltt_tracefile_seek_time(LttTracefile *tf, LttTime time)
1308 {
1309 int ret = 0;
1310 int err;
1311 unsigned int block_num, high, low;
1312
1313 /* seek at the beginning of trace */
1314 err = map_block(tf, 0); /* First block */
1315 if(unlikely(err)) {
1316 g_error("Can not map block");
1317 goto fail;
1318 }
1319
1320 /* If the time is lower or equal the beginning of the trace,
1321 * go to the first event. */
1322 if(ltt_time_compare(time, tf->buffer.begin.timestamp) <= 0) {
1323 ret = ltt_tracefile_read(tf);
1324 if(ret == ERANGE) goto range;
1325 else if (ret) goto fail;
1326 goto found; /* There is either no event in the trace or the event points
1327 to the first event in the trace */
1328 }
1329
1330 err = map_block(tf, tf->num_blocks - 1); /* Last block */
1331 if(unlikely(err)) {
1332 g_error("Can not map block");
1333 goto fail;
1334 }
1335
1336 /* If the time is after the end of the trace, return ERANGE. */
1337 if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
1338 goto range;
1339 }
1340
1341 /* Binary search the block */
1342 high = tf->num_blocks - 1;
1343 low = 0;
1344
1345 while(1) {
1346 block_num = ((high-low) / 2) + low;
1347
1348 err = map_block(tf, block_num);
1349 if(unlikely(err)) {
1350 g_error("Can not map block");
1351 goto fail;
1352 }
1353 if(high == low) {
1354 /* We cannot divide anymore : this is what would happen if the time
1355 * requested was exactly between two consecutive buffers'end and start
1356 * timestamps. This is also what would happend if we didn't deal with out
1357 * of span cases prior in this function. */
1358 /* The event is right in the buffer!
1359 * (or in the next buffer first event) */
1360 while(1) {
1361 ret = ltt_tracefile_read(tf);
1362 if(ret == ERANGE) goto range; /* ERANGE or EPERM */
1363 else if(ret) goto fail;
1364
1365 if(ltt_time_compare(time, tf->event.event_time) >= 0)
1366 goto found;
1367 }
1368
1369 } else if(ltt_time_compare(time, tf->buffer.begin.timestamp) < 0) {
1370 /* go to lower part */
1371 high = block_num;
1372 } else if(ltt_time_compare(time, tf->buffer.end.timestamp) > 0) {
1373 /* go to higher part */
1374 low = block_num;
1375 } else {/* The event is right in the buffer!
1376 (or in the next buffer first event) */
1377 while(1) {
1378 ret = ltt_tracefile_read(tf);
1379 if(ret == ERANGE) goto range; /* ERANGE or EPERM */
1380 else if(ret) goto fail;
1381
1382 if(ltt_time_compare(time, tf->event.event_time) >= 0)
1383 break;
1384 }
1385 goto found;
1386 }
1387 }
1388
1389 found:
1390 return 0;
1391 range:
1392 return ERANGE;
1393
1394 /* Error handling */
1395 fail:
1396 g_error("ltt_tracefile_seek_time failed on tracefile %s",
1397 g_quark_to_string(tf->name));
1398 return EPERM;
1399 }
1400
1401
1402 int ltt_tracefile_seek_position(LttTracefile *tf, const LttEventPosition *ep) {
1403
1404 int err;
1405
1406 if(ep->tracefile != tf) {
1407 goto fail;
1408 }
1409
1410 err = map_block(tf, ep->block);
1411 if(unlikely(err)) {
1412 g_error("Can not map block");
1413 goto fail;
1414 }
1415
1416 tf->event.offset = ep->offset;
1417
1418 err = ltt_tracefile_read_update_event(tf);
1419 if(err) goto fail;
1420 err = ltt_tracefile_read_op(tf);
1421 if(err) goto fail;
1422
1423 return 0;
1424
1425 fail:
1426 g_error("ltt_tracefile_seek_time failed on tracefile %s",
1427 g_quark_to_string(tf->name));
1428 return 1;
1429 }
1430
1431 /* Calculate the real event time based on the buffer boundaries */
1432 LttTime ltt_interpolate_time(LttTracefile *tf, LttEvent *event)
1433 {
1434 LttTime time;
1435
1436 g_assert(tf->trace->has_tsc);
1437
1438 time = ltt_time_from_uint64(
1439 (guint64)(tf->buffer.tsc - tf->buffer.begin.cycle_count) *
1440 tf->buffer.nsecs_per_cycle);
1441 time = ltt_time_add(tf->buffer.begin.timestamp, time);
1442
1443 return time;
1444 }
1445
1446
1447 /* Get the current event of the tracefile : valid until the next read */
1448 LttEvent *ltt_tracefile_get_event(LttTracefile *tf)
1449 {
1450 return &tf->event;
1451 }
1452
1453
1454
1455 /*****************************************************************************
1456 *Function name
1457 * ltt_tracefile_read : Read the next event in the tracefile
1458 *Input params
1459 * t : tracefile
1460 *Return value
1461 *
1462 * Returns 0 if an event can be used in tf->event.
1463 * Returns ERANGE on end of trace. The event in tf->event still can be used
1464 * (if the last block was not empty).
1465 * Returns EPERM on error.
1466 *
1467 * This function does make the tracefile event structure point to the event
1468 * currently pointed to by the tf->event.
1469 *
1470 * Note : you must call a ltt_tracefile_seek to the beginning of the trace to
1471 * reinitialize it after an error if you want results to be coherent.
1472 * It would be the case if a end of trace last buffer has no event : the end
1473 * of trace wouldn't be returned, but an error.
1474 * We make the assumption there is at least one event per buffer.
1475 ****************************************************************************/
1476
1477 int ltt_tracefile_read(LttTracefile *tf)
1478 {
1479 int err;
1480
1481 err = ltt_tracefile_read_seek(tf);
1482 if(err) return err;
1483 err = ltt_tracefile_read_update_event(tf);
1484 if(err) return err;
1485 err = ltt_tracefile_read_op(tf);
1486 if(err) return err;
1487
1488 return 0;
1489 }
1490
1491 int ltt_tracefile_read_seek(LttTracefile *tf)
1492 {
1493 int err;
1494
1495 /* Get next buffer until we finally have an event, or end of trace */
1496 while(1) {
1497 err = ltt_seek_next_event(tf);
1498 if(unlikely(err == ENOPROTOOPT)) {
1499 return EPERM;
1500 }
1501
1502 /* Are we at the end of the buffer ? */
1503 if(err == ERANGE) {
1504 if(unlikely(tf->buffer.index == tf->num_blocks-1)){ /* end of trace ? */
1505 return ERANGE;
1506 } else {
1507 /* get next block */
1508 err = map_block(tf, tf->buffer.index + 1);
1509 if(unlikely(err)) {
1510 g_error("Can not map block");
1511 return EPERM;
1512 }
1513 }
1514 } else break; /* We found an event ! */
1515 }
1516
1517 return 0;
1518 }
1519
1520
1521 /* do specific operation on events */
1522 int ltt_tracefile_read_op(LttTracefile *tf)
1523 {
1524 LttEvent *event;
1525
1526 event = &tf->event;
1527
1528 /* do event specific operation */
1529
1530 /* do something if its an heartbeat event : increment the heartbeat count */
1531 //if(event->facility_id == LTT_FACILITY_CORE)
1532 // if(event->event_id == LTT_EVENT_HEARTBEAT)
1533 // tf->cur_heart_beat_number++;
1534
1535 return 0;
1536 }
1537
1538
1539 /* same as ltt_tracefile_read, but does not seek to the next event nor call
1540 * event specific operation. */
1541 int ltt_tracefile_read_update_event(LttTracefile *tf)
1542 {
1543 void * pos;
1544 LttEvent *event;
1545
1546 event = &tf->event;
1547 pos = tf->buffer.head + event->offset;
1548
1549 /* Read event header */
1550
1551 //TODO align
1552
1553 if(tf->trace->has_tsc) {
1554 if(tf->trace->has_heartbeat) {
1555 event->time.timestamp = ltt_get_uint32(LTT_GET_BO(tf),
1556 pos);
1557 /* 32 bits -> 64 bits tsc */
1558 /* note : still works for seek and non seek cases. */
1559 if(event->time.timestamp < (0xFFFFFFFFULL&tf->buffer.tsc)) {
1560 tf->buffer.tsc = ((tf->buffer.tsc&0xFFFFFFFF00000000ULL)
1561 + 0x100000000ULL)
1562 | (guint64)event->time.timestamp;
1563 event->tsc = tf->buffer.tsc;
1564 } else {
1565 /* no overflow */
1566 tf->buffer.tsc = (tf->buffer.tsc&0xFFFFFFFF00000000ULL)
1567 | (guint64)event->time.timestamp;
1568 event->tsc = tf->buffer.tsc;
1569 }
1570 pos += sizeof(guint32);
1571 } else {
1572 event->tsc = ltt_get_uint64(LTT_GET_BO(tf), pos);
1573 tf->buffer.tsc = event->tsc;
1574 pos += sizeof(guint64);
1575 }
1576
1577 event->event_time = ltt_interpolate_time(tf, event);
1578 } else {
1579 event->time.delta.tv_sec = 0;
1580 event->time.delta.tv_nsec = ltt_get_uint32(LTT_GET_BO(tf),
1581 pos) * NSEC_PER_USEC;
1582 tf->buffer.tsc = 0;
1583 event->tsc = tf->buffer.tsc;
1584
1585 event->event_time = ltt_time_add(tf->buffer.begin.timestamp,
1586 event->time.delta);
1587 pos += sizeof(guint32);
1588 }
1589
1590 event->facility_id = *(guint8*)pos;
1591 pos += sizeof(guint8);
1592
1593 event->event_id = *(guint8*)pos;
1594 pos += sizeof(guint8);
1595
1596 event->event_size = ltt_get_uint16(LTT_GET_BO(tf), pos);
1597 pos += sizeof(guint16);
1598
1599 event->data = pos;
1600
1601 /* get the data size and update the event fields with the current
1602 * information */
1603 ltt_update_event_size(tf);
1604
1605 return 0;
1606 }
1607
1608
1609 /****************************************************************************
1610 *Function name
1611 * map_block : map a block from the file
1612 *Input Params
1613 * lttdes : ltt trace file
1614 * whichBlock : the block which will be read
1615 *return value
1616 * 0 : success
1617 * EINVAL : lseek fail
1618 * EIO : can not read from the file
1619 ****************************************************************************/
1620
1621 static gint map_block(LttTracefile * tf, guint block_num)
1622 {
1623 int page_size = getpagesize();
1624 struct ltt_block_start_header *header;
1625
1626 g_assert(block_num < tf->num_blocks);
1627
1628 if(tf->buffer.head != NULL) {
1629 if(munmap(tf->buffer.head, PAGE_ALIGN(tf->buf_size))) {
1630 g_warning("unmap size : %u\n",
1631 PAGE_ALIGN(tf->buf_size));
1632 perror("munmap error");
1633 g_assert(0);
1634 }
1635 }
1636
1637
1638 /* Multiple of pages aligned head */
1639 tf->buffer.head = mmap(0,
1640 PAGE_ALIGN(tf->buf_size),
1641 PROT_READ, MAP_PRIVATE, tf->fd,
1642 PAGE_ALIGN((off_t)tf->buf_size * (off_t)block_num));
1643
1644 if(tf->buffer.head == MAP_FAILED) {
1645 perror("Error in allocating memory for buffer of tracefile");
1646 g_assert(0);
1647 goto map_error;
1648 }
1649 g_assert( ( (guint)tf->buffer.head&(8-1) ) == 0); // make sure it's aligned.
1650
1651
1652 tf->buffer.index = block_num;
1653
1654 header = (struct ltt_block_start_header*)tf->buffer.head;
1655
1656 tf->buffer.begin.timestamp = ltt_get_time(LTT_GET_BO(tf),
1657 &header->begin.timestamp);
1658 tf->buffer.begin.timestamp.tv_nsec *= NSEC_PER_USEC;
1659 g_debug("block %u begin : %lu.%lu", block_num,
1660 tf->buffer.begin.timestamp.tv_sec, tf->buffer.begin.timestamp.tv_nsec);
1661 tf->buffer.begin.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
1662 &header->begin.cycle_count);
1663 tf->buffer.end.timestamp = ltt_get_time(LTT_GET_BO(tf),
1664 &header->end.timestamp);
1665 tf->buffer.end.timestamp.tv_nsec *= NSEC_PER_USEC;
1666 g_debug("block %u end : %lu.%lu", block_num,
1667 tf->buffer.end.timestamp.tv_sec, tf->buffer.end.timestamp.tv_nsec);
1668 tf->buffer.end.cycle_count = ltt_get_uint64(LTT_GET_BO(tf),
1669 &header->end.cycle_count);
1670 tf->buffer.lost_size = ltt_get_uint32(LTT_GET_BO(tf),
1671 &header->lost_size);
1672
1673 tf->buffer.tsc = tf->buffer.begin.cycle_count;
1674 tf->event.tsc = tf->buffer.tsc;
1675
1676 /* FIXME
1677 * eventually support variable buffer size : will need a partial pre-read of
1678 * the headers to create an index when we open the trace... eventually. */
1679 g_assert(tf->buf_size == ltt_get_uint32(LTT_GET_BO(tf),
1680 &header->buf_size));
1681
1682 /* Now that the buffer is mapped, calculate the time interpolation for the
1683 * block. */
1684
1685 tf->buffer.nsecs_per_cycle = calc_nsecs_per_cycle(tf);
1686
1687 /* Make the current event point to the beginning of the buffer :
1688 * it means that the event read must get the first event. */
1689 tf->event.tracefile = tf;
1690 tf->event.block = block_num;
1691 tf->event.offset = 0;
1692
1693 return 0;
1694
1695 map_error:
1696 return -errno;
1697
1698 }
1699
1700 /* It will update the fields offsets too */
1701 void ltt_update_event_size(LttTracefile *tf)
1702 {
1703 ssize_t size = 0;
1704
1705 /* Specific handling of core events : necessary to read the facility control
1706 * tracefile. */
1707 LttFacility *f = ltt_trace_get_facility_by_num(tf->trace,
1708 tf->event.facility_id);
1709
1710 if(likely(tf->event.facility_id == LTT_FACILITY_CORE)) {
1711 switch((enum ltt_core_events)tf->event.event_id) {
1712 case LTT_EVENT_FACILITY_LOAD:
1713 size = strlen((char*)tf->event.data) + 1;
1714 g_debug("Update Event facility load of facility %s", (char*)tf->event.data);
1715 size += sizeof(struct LttFacilityLoad);
1716 break;
1717 case LTT_EVENT_FACILITY_UNLOAD:
1718 g_debug("Update Event facility unload");
1719 size = sizeof(struct LttFacilityUnload);
1720 break;
1721 case LTT_EVENT_STATE_DUMP_FACILITY_LOAD:
1722 size = strlen((char*)tf->event.data) + 1;
1723 g_debug("Update Event facility load state dump of facility %s",
1724 (char*)tf->event.data);
1725 size += sizeof(struct LttStateDumpFacilityLoad);
1726 break;
1727 case LTT_EVENT_HEARTBEAT:
1728 g_debug("Update Event heartbeat");
1729 size = sizeof(TimeHeartbeat);
1730 break;
1731 default:
1732 g_warning("Error in getting event size : tracefile %s, "
1733 "unknown event id %hhu in core facility.",
1734 g_quark_to_string(tf->name),
1735 tf->event.event_id);
1736 goto event_id_error;
1737
1738 }
1739 } else {
1740 if(!f->exists) {
1741 g_error("Unknown facility %hhu (0x%hhx) in tracefile %s",
1742 tf->event.facility_id,
1743 tf->event.facility_id,
1744 g_quark_to_string(tf->name));
1745 goto facility_error;
1746 }
1747
1748 LttEventType *event_type =
1749 ltt_facility_eventtype_get(f, tf->event.event_id);
1750
1751 if(!event_type) {
1752 g_error("Unknown event id %hhu in facility %s in tracefile %s",
1753 tf->event.event_id,
1754 g_quark_to_string(f->name),
1755 g_quark_to_string(tf->name));
1756 goto event_type_error;
1757 }
1758
1759 if(event_type->root_field)
1760 size = get_field_type_size(tf, event_type,
1761 0, 0, event_type->root_field, tf->event.data);
1762 else
1763 size = 0;
1764
1765 g_debug("Event root field : f.e %hhu.%hhu size %zd",
1766 tf->event.facility_id,
1767 tf->event.event_id, size);
1768 }
1769
1770 tf->event.data_size = size;
1771
1772 /* Check consistency between kernel and LTTV structure sizes */
1773 g_assert(tf->event.data_size == tf->event.event_size);
1774
1775 return;
1776
1777 facility_error:
1778 event_type_error:
1779 event_id_error:
1780 tf->event.data_size = 0;
1781 }
1782
1783
1784 /* Take the tf current event offset and use the event facility id and event id
1785 * to figure out where is the next event offset.
1786 *
1787 * This is an internal function not aiming at being used elsewhere : it will
1788 * not jump over the current block limits. Please consider using
1789 * ltt_tracefile_read to do this.
1790 *
1791 * Returns 0 on success
1792 * ERANGE if we are at the end of the buffer.
1793 * ENOPROTOOPT if an error occured when getting the current event size.
1794 */
1795 static int ltt_seek_next_event(LttTracefile *tf)
1796 {
1797 int ret = 0;
1798 void *pos;
1799
1800 /* seek over the buffer header if we are at the buffer start */
1801 if(tf->event.offset == 0) {
1802 tf->event.offset += sizeof(struct ltt_block_start_header);
1803
1804 if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
1805 ret = ERANGE;
1806 }
1807 goto found;
1808 }
1809
1810
1811 pos = tf->event.data;
1812
1813 if(tf->event.data_size < 0) goto error;
1814
1815 pos += (size_t)tf->event.data_size;
1816
1817 tf->event.offset = pos - tf->buffer.head;
1818
1819 if(tf->event.offset == tf->buf_size - tf->buffer.lost_size) {
1820 ret = ERANGE;
1821 goto found;
1822 }
1823
1824 found:
1825 return ret;
1826
1827 error:
1828 g_error("Error in ltt_seek_next_event for tracefile %s",
1829 g_quark_to_string(tf->name));
1830 return ENOPROTOOPT;
1831 }
1832
1833
1834 /*****************************************************************************
1835 *Function name
1836 * calc_nsecs_per_cycle : calculate nsecs per cycle for current block
1837 *Input Params
1838 * t : tracefile
1839 ****************************************************************************/
1840
1841 static double calc_nsecs_per_cycle(LttTracefile * tf)
1842 {
1843 LttTime lBufTotalTime; /* Total time for this buffer */
1844 double lBufTotalNSec; /* Total time for this buffer in nsecs */
1845 LttCycleCount lBufTotalCycle;/* Total cycles for this buffer */
1846
1847 /* Calculate the total time for this buffer */
1848 lBufTotalTime = ltt_time_sub(tf->buffer.end.timestamp,
1849 tf->buffer.begin.timestamp);
1850
1851 /* Calculate the total cycles for this bufffer */
1852 lBufTotalCycle = tf->buffer.end.cycle_count;
1853 lBufTotalCycle -= tf->buffer.begin.cycle_count;
1854
1855 /* Convert the total time to double */
1856 lBufTotalNSec = ltt_time_to_double(lBufTotalTime);
1857
1858 return lBufTotalNSec / (double)lBufTotalCycle;
1859
1860 }
1861 #if 0
1862 void setFieldsOffset(LttTracefile *tf, LttEventType *evT,void *evD)
1863 {
1864 LttField * rootFld = evT->root_field;
1865 // rootFld->base_address = evD;
1866
1867 if(likely(rootFld))
1868 rootFld->field_size = getFieldtypeSize(tf, evT->facility,
1869 evT, 0,0,rootFld, evD);
1870 }
1871 #endif //0
1872
1873 /*****************************************************************************
1874 *Function name
1875 * set_fields_offsets : set the precomputable offset of the fields
1876 *Input params
1877 * tracefile : opened trace file
1878 * event_type : the event type
1879 ****************************************************************************/
1880
1881 void set_fields_offsets(LttTracefile *tf, LttEventType *event_type)
1882 {
1883 LttField *field = event_type->root_field;
1884 enum field_status fixed_root = FIELD_FIXED, fixed_parent = FIELD_FIXED;
1885
1886 if(likely(field))
1887 preset_field_type_size(tf, event_type, 0, 0,
1888 &fixed_root, &fixed_parent,
1889 field);
1890
1891 }
1892
1893
1894 /*****************************************************************************
1895 *Function name
1896 * preset_field_type_size : set the fixed sizes of the field type
1897 *Input params
1898 * tf : tracefile
1899 * event_type : event type
1900 * offset_root : offset from the root
1901 * offset_parent : offset from the parent
1902 * fixed_root : Do we know a fixed offset to the root ?
1903 * fixed_parent : Do we know a fixed offset to the parent ?
1904 * field : field
1905 ****************************************************************************/
1906 void preset_field_type_size(LttTracefile *tf, LttEventType *event_type,
1907 off_t offset_root, off_t offset_parent,
1908 enum field_status *fixed_root, enum field_status *fixed_parent,
1909 LttField *field)
1910 {
1911 enum field_status local_fixed_root, local_fixed_parent;
1912 guint i;
1913 LttType *type;
1914
1915 g_assert(field->fixed_root == FIELD_UNKNOWN);
1916 g_assert(field->fixed_parent == FIELD_UNKNOWN);
1917 g_assert(field->fixed_size == FIELD_UNKNOWN);
1918
1919 type = field->field_type;
1920
1921 field->fixed_root = *fixed_root;
1922 if(field->fixed_root == FIELD_FIXED)
1923 field->offset_root = offset_root;
1924 else
1925 field->offset_root = 0;
1926
1927 field->fixed_parent = *fixed_parent;
1928 if(field->fixed_parent == FIELD_FIXED)
1929 field->offset_parent = offset_parent;
1930 else
1931 field->offset_parent = 0;
1932
1933 size_t current_root_offset;
1934 size_t current_offset;
1935 enum field_status current_child_status, final_child_status;
1936 size_t max_size;
1937
1938 switch(type->type_class) {
1939 case LTT_INT:
1940 case LTT_UINT:
1941 case LTT_FLOAT:
1942 case LTT_ENUM:
1943 field->field_size = ltt_type_size(tf->trace, type);
1944 field->fixed_size = FIELD_FIXED;
1945 break;
1946 case LTT_POINTER:
1947 field->field_size = (off_t)event_type->facility->pointer_size;
1948 field->fixed_size = FIELD_FIXED;
1949 break;
1950 case LTT_LONG:
1951 case LTT_ULONG:
1952 field->field_size = (off_t)event_type->facility->long_size;
1953 field->fixed_size = FIELD_FIXED;
1954 break;
1955 case LTT_SIZE_T:
1956 case LTT_SSIZE_T:
1957 case LTT_OFF_T:
1958 field->field_size = (off_t)event_type->facility->size_t_size;
1959 field->fixed_size = FIELD_FIXED;
1960 break;
1961 case LTT_SEQUENCE:
1962 local_fixed_root = FIELD_VARIABLE;
1963 local_fixed_parent = FIELD_VARIABLE;
1964 preset_field_type_size(tf, event_type,
1965 0, 0,
1966 &local_fixed_root, &local_fixed_parent,
1967 field->child[0]);
1968 field->fixed_size = FIELD_VARIABLE;
1969 field->field_size = 0;
1970 *fixed_root = FIELD_VARIABLE;
1971 *fixed_parent = FIELD_VARIABLE;
1972 break;
1973 case LTT_STRING:
1974 field->fixed_size = FIELD_VARIABLE;
1975 field->field_size = 0;
1976 *fixed_root = FIELD_VARIABLE;
1977 *fixed_parent = FIELD_VARIABLE;
1978 break;
1979 case LTT_ARRAY:
1980 local_fixed_root = FIELD_VARIABLE;
1981 local_fixed_parent = FIELD_VARIABLE;
1982 preset_field_type_size(tf, event_type,
1983 0, 0,
1984 &local_fixed_root, &local_fixed_parent,
1985 field->child[0]);
1986 field->fixed_size = field->child[0]->fixed_size;
1987 if(field->fixed_size == FIELD_FIXED) {
1988 field->field_size = type->element_number * field->child[0]->field_size;
1989 } else {
1990 field->field_size = 0;
1991 *fixed_root = FIELD_VARIABLE;
1992 *fixed_parent = FIELD_VARIABLE;
1993 }
1994 break;
1995 case LTT_STRUCT:
1996 current_root_offset = field->offset_root;
1997 current_offset = 0;
1998 current_child_status = FIELD_FIXED;
1999 for(i=0;i<type->element_number;i++) {
2000 preset_field_type_size(tf, event_type,
2001 current_root_offset, current_offset,
2002 fixed_root, &current_child_status,
2003 field->child[i]);
2004 if(current_child_status == FIELD_FIXED) {
2005 current_root_offset += field->child[i]->field_size;
2006 current_offset += field->child[i]->field_size;
2007 } else {
2008 current_root_offset = 0;
2009 current_offset = 0;
2010 }
2011 }
2012 if(current_child_status != FIELD_FIXED) {
2013 *fixed_parent = current_child_status;
2014 field->field_size = 0;
2015 field->fixed_size = current_child_status;
2016 } else {
2017 field->field_size = current_offset;
2018 field->fixed_size = FIELD_FIXED;
2019 }
2020 break;
2021 case LTT_UNION:
2022 current_root_offset = field->offset_root;
2023 current_offset = 0;
2024 max_size = 0;
2025 final_child_status = FIELD_FIXED;
2026 for(i=0;i<type->element_number;i++) {
2027 enum field_status current_root_child_status = FIELD_FIXED;
2028 enum field_status current_child_status = FIELD_FIXED;
2029 preset_field_type_size(tf, event_type,
2030 current_root_offset, current_offset,
2031 &current_root_child_status, &current_child_status,
2032 field->child[i]);
2033 if(current_child_status != FIELD_FIXED)
2034 final_child_status = current_child_status;
2035 else
2036 max_size = max(max_size, field->child[i]->field_size);
2037 }
2038 if(final_child_status != FIELD_FIXED) {
2039 *fixed_root = final_child_status;
2040 *fixed_parent = final_child_status;
2041 field->field_size = 0;
2042 field->fixed_size = current_child_status;
2043 } else {
2044 field->field_size = max_size;
2045 field->fixed_size = FIELD_FIXED;
2046 }
2047 break;
2048 }
2049
2050 }
2051
2052
2053 /*****************************************************************************
2054 *Function name
2055 * check_fields_compatibility : Check for compatibility between two fields :
2056 * do they use the same inner structure ?
2057 *Input params
2058 * event_type1 : event type
2059 * event_type2 : event type
2060 * field1 : field
2061 * field2 : field
2062 *Returns : 0 if identical
2063 * 1 if not.
2064 ****************************************************************************/
2065 gint check_fields_compatibility(LttEventType *event_type1,
2066 LttEventType *event_type2,
2067 LttField *field1, LttField *field2)
2068 {
2069 guint different = 0;
2070 guint i;
2071 LttType *type1;
2072 LttType *type2;
2073
2074 if(field1 == NULL) {
2075 if(field2 == NULL) goto end;
2076 else {
2077 different = 1;
2078 goto end;
2079 }
2080 } else if(field2 == NULL) {
2081 different = 1;
2082 goto end;
2083 }
2084
2085 g_assert(field1->fixed_root != FIELD_UNKNOWN);
2086 g_assert(field2->fixed_root != FIELD_UNKNOWN);
2087 g_assert(field1->fixed_parent != FIELD_UNKNOWN);
2088 g_assert(field2->fixed_parent != FIELD_UNKNOWN);
2089 g_assert(field1->fixed_size != FIELD_UNKNOWN);
2090 g_assert(field2->fixed_size != FIELD_UNKNOWN);
2091
2092 type1 = field1->field_type;
2093 type2 = field2->field_type;
2094
2095 if(type1->type_class != type2->type_class) {
2096 different = 1;
2097 goto end;
2098 }
2099 if(type1->element_name != type2->element_name) {
2100 different = 1;
2101 goto end;
2102 }
2103
2104 switch(type1->type_class) {
2105 case LTT_INT:
2106 case LTT_UINT:
2107 case LTT_FLOAT:
2108 case LTT_POINTER:
2109 case LTT_LONG:
2110 case LTT_ULONG:
2111 case LTT_SIZE_T:
2112 case LTT_SSIZE_T:
2113 case LTT_OFF_T:
2114 if(field1->field_size != field2->field_size) {
2115 different = 1;
2116 goto end;
2117 }
2118 break;
2119 case LTT_ENUM:
2120 if(type1->element_number != type2->element_number) {
2121 different = 1;
2122 goto end;
2123 }
2124 for(i=0;i<type1->element_number;i++) {
2125 if(type1->enum_strings[i] != type2->enum_strings[i]) {
2126 different = 1;
2127 goto end;
2128 }
2129 }
2130 break;
2131 case LTT_SEQUENCE:
2132 /* Two elements : size and child */
2133 g_assert(type1->element_number != type2->element_number);
2134 for(i=0;i<type1->element_number;i++) {
2135 if(check_fields_compatibility(event_type1, event_type2,
2136 field1->child[0], field2->child[0])) {
2137 different = 1;
2138 goto end;
2139 }
2140 }
2141 break;
2142 case LTT_STRING:
2143 break;
2144 case LTT_ARRAY:
2145 if(field1->field_size != field2->field_size) {
2146 different = 1;
2147 goto end;
2148 }
2149 /* Two elements : size and child */
2150 g_assert(type1->element_number != type2->element_number);
2151 for(i=0;i<type1->element_number;i++) {
2152 if(check_fields_compatibility(event_type1, event_type2,
2153 field1->child[0], field2->child[0])) {
2154 different = 1;
2155 goto end;
2156 }
2157 }
2158 break;
2159 case LTT_STRUCT:
2160 case LTT_UNION:
2161 if(type1->element_number != type2->element_number) {
2162 different = 1;
2163 break;
2164 }
2165 for(i=0;i<type1->element_number;i++) {
2166 if(check_fields_compatibility(event_type1, event_type2,
2167 field1->child[0], field2->child[0])) {
2168 different = 1;
2169 goto end;
2170 }
2171 }
2172 break;
2173 }
2174 end:
2175 return different;
2176 }
2177
2178
2179
2180
2181 #if 0
2182 /*****************************************************************************
2183 *Function name
2184 * getFieldtypeSize: get the size of the field type (primitive type)
2185 *Input params
2186 * evT : event type
2187 * offsetRoot : offset from the root
2188 * offsetParent : offset from the parrent
2189 * fld : field
2190 * evD : event data, it may be NULL
2191 *Return value
2192 * int : size of the field
2193 ****************************************************************************/
2194
2195 static inline gint getFieldtypeSize(LttTracefile *tf,
2196 LttEventType * evT, gint offsetRoot,
2197 gint offsetParent, LttField * fld, void *evD)
2198 {
2199 gint size, size1, element_number, i, offset1, offset2;
2200 LttType * type = fld->field_type;
2201
2202 /* This likely has been tested with gcov : half of them.. */
2203 if(unlikely(fld->field_fixed == 1)){
2204 /* tested : none */
2205 if(unlikely(fld == evT->root_field)) {
2206 size = fld->field_size;
2207 goto end_getFieldtypeSize;
2208 }
2209 }
2210
2211 /* From gcov profiling : half string, half struct, can we gain something
2212 * from that ? (Mathieu) */
2213 switch(type->type_class) {
2214 case LTT_ARRAY:
2215 element_number = (int) type->element_number;
2216 if(fld->field_fixed == -1){
2217 size = getFieldtypeSize(tf, evT, offsetRoot,
2218 0,fld->child[0], NULL);
2219 if(size == 0){ //has string or sequence
2220 fld->field_fixed = 0;
2221 }else{
2222 fld->field_fixed = 1;
2223 size *= element_number;
2224 }
2225 }else if(fld->field_fixed == 0){// has string or sequence
2226 size = 0;
2227 for(i=0;i<element_number;i++){
2228 size += getFieldtypeSize(tf, evT, offsetRoot+size,size,
2229 fld->child[0], evD+size);
2230 }
2231 }else size = fld->field_size;
2232 if(unlikely(!evD)){
2233 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
2234 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
2235 }
2236
2237 break;
2238
2239 case LTT_SEQUENCE:
2240 size1 = (int) ltt_type_size(fac, type);
2241 if(fld->field_fixed == -1){
2242 fld->sequ_number_size = size1;
2243 fld->field_fixed = 0;
2244 size = getFieldtypeSize(evT, offsetRoot,
2245 0,fld->child[0], NULL);
2246 fld->element_size = size;
2247 }else{//0: sequence
2248 element_number = getIntNumber(tf,size1,evD);
2249 type->element_number = element_number;
2250 if(fld->element_size > 0){
2251 size = element_number * fld->element_size;
2252 }else{//sequence has string or sequence
2253 size = 0;
2254 for(i=0;i<element_number;i++){
2255 size += getFieldtypeSize(tf, evT,
2256 offsetRoot+size+size1,size+size1,
2257 fld->child[0], evD+size+size1);
2258 }
2259 }
2260 size += size1;
2261 }
2262 if(unlikely(!evD)){
2263 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
2264 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
2265 }
2266
2267 break;
2268
2269 case LTT_STRING:
2270 size = 0;
2271 if(fld->field_fixed == -1){
2272 fld->field_fixed = 0;
2273 }else{//0: string
2274 /* Hope my implementation is faster than strlen (Mathieu) */
2275 char *ptr=(char*)evD;
2276 size = 1;
2277 /* from gcov : many many strings are empty, make it the common case.*/
2278 while(unlikely(*ptr != '\0')) { size++; ptr++; }
2279 //size = ptr - (char*)evD + 1; //include end : '\0'
2280 }
2281 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
2282 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
2283
2284 break;
2285
2286 case LTT_STRUCT:
2287 element_number = (int) type->element_number;
2288 size = 0;
2289 /* tested with gcov */
2290 if(unlikely(fld->field_fixed == -1)){
2291 offset1 = offsetRoot;
2292 offset2 = 0;
2293 for(i=0;i<element_number;i++){
2294 size1=getFieldtypeSize(tf, evT,offset1,offset2,
2295 fld->child[i], NULL);
2296 if(likely(size1 > 0 && size >= 0)){
2297 size += size1;
2298 if(likely(offset1 >= 0)) offset1 += size1;
2299 offset2 += size1;
2300 }else{
2301 size = -1;
2302 offset1 = -1;
2303 offset2 = -1;
2304 }
2305 }
2306 if(unlikely(size == -1)){
2307 fld->field_fixed = 0;
2308 size = 0;
2309 }else fld->field_fixed = 1;
2310 }else if(likely(fld->field_fixed == 0)){
2311 offset1 = offsetRoot;
2312 offset2 = 0;
2313 for(i=0;unlikely(i<element_number);i++){
2314 size=getFieldtypeSize(tf, evT, offset1, offset2,
2315 fld->child[i], evD+offset2);
2316 offset1 += size;
2317 offset2 += size;
2318 }
2319 size = offset2;
2320 }else size = fld->field_size;
2321 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
2322 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
2323 break;
2324
2325 default:
2326 if(unlikely(fld->field_fixed == -1)){
2327 size = (int) ltt_type_size(LTT_GET_BO(tf), type);
2328 fld->field_fixed = 1;
2329 }else size = fld->field_size;
2330 if(unlikely(!evD)){
2331 fld->fixed_root = (offsetRoot==-1) ? 0 : 1;
2332 fld->fixed_parent = (offsetParent==-1) ? 0 : 1;
2333 }
2334 break;
2335 }
2336
2337 fld->offset_root = offsetRoot;
2338 fld->offset_parent = offsetParent;
2339 fld->field_size = size;
2340
2341 end_getFieldtypeSize:
2342
2343 return size;
2344 }
2345 #endif //0
2346
2347 /*****************************************************************************
2348 *Function name
2349 * ltt_get_int : get an integer number
2350 *Input params
2351 * reverse_byte_order: must we reverse the byte order ?
2352 * size : the size of the integer
2353 * ptr : the data pointer
2354 *Return value
2355 * gint64 : a 64 bits integer
2356 ****************************************************************************/
2357
2358 gint64 ltt_get_int(gboolean reverse_byte_order, gint size, void *data)
2359 {
2360 gint64 val;
2361
2362 switch(size) {
2363 case 1: val = *((gint8*)data); break;
2364 case 2: val = ltt_get_int16(reverse_byte_order, data); break;
2365 case 4: val = ltt_get_int32(reverse_byte_order, data); break;
2366 case 8: val = ltt_get_int64(reverse_byte_order, data); break;
2367 default: val = ltt_get_int64(reverse_byte_order, data);
2368 g_critical("get_int : integer size %d unknown", size);
2369 break;
2370 }
2371
2372 return val;
2373 }
2374
2375 /*****************************************************************************
2376 *Function name
2377 * ltt_get_uint : get an unsigned integer number
2378 *Input params
2379 * reverse_byte_order: must we reverse the byte order ?
2380 * size : the size of the integer
2381 * ptr : the data pointer
2382 *Return value
2383 * guint64 : a 64 bits unsigned integer
2384 ****************************************************************************/
2385
2386 guint64 ltt_get_uint(gboolean reverse_byte_order, gint size, void *data)
2387 {
2388 guint64 val;
2389
2390 switch(size) {
2391 case 1: val = *((gint8*)data); break;
2392 case 2: val = ltt_get_uint16(reverse_byte_order, data); break;
2393 case 4: val = ltt_get_uint32(reverse_byte_order, data); break;
2394 case 8: val = ltt_get_uint64(reverse_byte_order, data); break;
2395 default: val = ltt_get_uint64(reverse_byte_order, data);
2396 g_critical("get_uint : unsigned integer size %d unknown",
2397 size);
2398 break;
2399 }
2400
2401 return val;
2402 }
2403
2404
2405 /* get the node name of the system */
2406
2407 char * ltt_trace_system_description_node_name (LttSystemDescription * s)
2408 {
2409 return s->node_name;
2410 }
2411
2412
2413 /* get the domain name of the system */
2414
2415 char * ltt_trace_system_description_domain_name (LttSystemDescription * s)
2416 {
2417 return s->domain_name;
2418 }
2419
2420
2421 /* get the description of the system */
2422
2423 char * ltt_trace_system_description_description (LttSystemDescription * s)
2424 {
2425 return s->description;
2426 }
2427
2428
2429 /* get the start time of the trace */
2430
2431 LttTime ltt_trace_system_description_trace_start_time(LttSystemDescription *s)
2432 {
2433 return s->trace_start;
2434 }
2435
2436
2437 LttTracefile *ltt_tracefile_new()
2438 {
2439 return g_new(LttTracefile, 1);
2440 }
2441
2442 void ltt_tracefile_destroy(LttTracefile *tf)
2443 {
2444 g_free(tf);
2445 }
2446
2447 void ltt_tracefile_copy(LttTracefile *dest, const LttTracefile *src)
2448 {
2449 *dest = *src;
2450 }
2451
2452 /* Before library loading... */
2453
2454 static void __attribute__((constructor)) init(void)
2455 {
2456 LTT_FACILITY_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
2457 LTT_EVENT_NAME_HEARTBEAT = g_quark_from_string("heartbeat");
2458
2459 LTT_TRACEFILE_NAME_FACILITIES = g_quark_from_string("/control/facilities");
2460 }
2461
LTTng 2.x Viewer (LTTV)
This page took 0.080035 seconds and 5 git commands to generate.