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