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