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