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