1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 Michel Dagenais
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
23 #include <lttv/traceset.h>
24 #include <lttv/iattribute.h>
25 #include <lttv/state.h>
26 #include <lttv/event.h>
27 #include <lttv/hook.h>
29 #include <babeltrace/babeltrace.h>
30 #include <babeltrace/context.h>
31 #include <babeltrace/ctf/iterator.h>
32 #include <babeltrace/ctf/events.h>
34 /* To traverse a tree recursively */
37 /* For the use of realpath*/
43 /* A trace is a sequence of events gathered in the same tracing session. The
44 events may be stored in several tracefiles in the same directory.
45 A trace set is defined when several traces are to be analyzed together,
46 possibly to study the interactions between events in the different traces.
50 LttvTraceset
*lttv_traceset_new(void)
53 struct bt_iter_pos begin_pos
;
55 ts
= g_new(LttvTraceset
, 1);
57 ts
->traces
= g_ptr_array_new();
58 ts
->context
= bt_context_create();
59 ts
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
60 //TODO remove this when we have really mecanism
61 //s->tmpState = g_new(LttvTraceState *, 1);
62 //lttv_trace_state_init(s->tmpState,0);
64 /*Initialize iterator to the beginning of the traces*/
65 begin_pos
.type
= BT_SEEK_BEGIN
;
66 ts
->iter
= bt_ctf_iter_create(ts
->context
, &begin_pos
, NULL
);
68 ts
->event_hooks
= lttv_hooks_new();
70 ts
->state_trace_handle_index
= g_ptr_array_new();
75 char * lttv_traceset_name(LttvTraceset
* s
)
81 LttvTrace
*lttv_trace_new(LttTrace
*t
)
85 new_trace
= g_new(LttvTrace
, 1);
86 new_trace
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
88 new_trace
->ref_count
= 0;
93 * get_absolute_pathname : Return the unique pathname in the system
95 * pathname is the relative path.
97 * abs_pathname is being set to the absolute path.
100 void get_absolute_pathname(const gchar
*pathname
, gchar
* abs_pathname
)
102 abs_pathname
[0] = '\0';
104 if (realpath(pathname
, abs_pathname
) != NULL
)
108 /* error, return the original path unmodified */
109 strcpy(abs_pathname
, pathname
);
118 * lttv_trace_create : Create a trace from a path
120 * ts is the traceset in which will be contained the trace
122 * path is the path where to find a trace. It is not recursive.
124 * This function is static since a trace should always be contained in a
127 * return the created trace or NULL on failure
129 static LttvTrace
*lttv_trace_create(LttvTraceset
*ts
, const char *path
)
131 int id
= bt_context_add_trace(lttv_traceset_get_context(ts
),
140 // Create the trace and save the trace handle id returned by babeltrace
141 LttvTrace
*new_trace
;
143 new_trace
= g_new(LttvTrace
, 1);
144 new_trace
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
146 new_trace
->ref_count
= 0;
147 new_trace
->traceset
= ts
;
148 new_trace
->state
= g_new(LttvTraceState
,1);
149 lttv_trace_state_init(new_trace
->state
,new_trace
);
151 /* Add the state to the trace_handle to state index */
152 g_ptr_array_set_size(ts
->state_trace_handle_index
,id
+1);
153 g_ptr_array_index(ts
->state_trace_handle_index
,id
) = new_trace
->state
;
159 * lttv_trace_create : Create and add a single trace to a traceset
161 * ts is the traceset in which will be contained the trace
163 * path is the path where to find a trace. It is not recursive.
165 * return a positive integer (>=0)on success or -1 on failure
167 static int lttv_traceset_create_trace(LttvTraceset
*ts
, const char *path
)
169 LttvTrace
*trace
= lttv_trace_create(ts
, path
);
173 lttv_traceset_add(ts
, trace
);
177 LttvTraceset
*lttv_traceset_copy(LttvTraceset
*s_orig
)
183 s
= g_new(LttvTraceset
, 1);
185 s
->traces
= g_ptr_array_new();
186 s
->state_trace_handle_index
= g_ptr_array_new();
187 for(i
=0;i
<s_orig
->traces
->len
;i
++)
189 trace
= g_ptr_array_index(s_orig
->traces
, i
);
192 /* WARNING: this is an alias, not a copy. */
193 g_ptr_array_add(s
->traces
, trace
);
195 g_ptr_array_set_size(s
->state_trace_handle_index
,trace
->id
+1);
196 g_ptr_array_index(s
->state_trace_handle_index
,trace
->id
) = trace
->state
;
199 s
->context
= s_orig
->context
;
200 bt_context_get(s
->context
);
201 s
->a
= LTTV_ATTRIBUTE(lttv_iattribute_deep_copy(LTTV_IATTRIBUTE(s_orig
->a
)));
206 LttvTraceset
*lttv_traceset_load(const gchar
*filename
)
208 LttvTraceset
*s
= g_new(LttvTraceset
,1);
211 s
->filename
= g_strdup(filename
);
212 tf
= fopen(filename
,"r");
214 g_critical("NOT IMPLEMENTED : load traceset data from a XML file");
220 gint
lttv_traceset_save(LttvTraceset
*s
)
224 tf
= fopen(s
->filename
, "w");
226 g_critical("NOT IMPLEMENTED : save traceset data in a XML file");
232 void lttv_traceset_destroy(LttvTraceset
*s
)
236 for(i
=0;i
<s
->traces
->len
;i
++) {
237 LttvTrace
*trace
= g_ptr_array_index(s
->traces
, i
);
238 lttv_trace_unref(trace
);
239 // todo mdenis 2012-03-27: uncomment when babeltrace gets fixed
240 //bt_context_remove_trace(lttv_traceset_get_context(s), trace->id);
241 if(lttv_trace_get_ref_number(trace
) == 0)
242 lttv_trace_destroy(trace
);
244 g_ptr_array_free(s
->traces
, TRUE
);
245 bt_context_put(s
->context
);
246 g_object_unref(s
->a
);
250 struct bt_context
*lttv_traceset_get_context(LttvTraceset
*s
)
255 LttvTraceset
*lttv_trace_get_traceset(LttvTrace
*trace
)
257 return trace
->traceset
;
260 LttvHooks
*lttv_traceset_get_hooks(LttvTraceset
*s
)
262 return s
->event_hooks
;
265 void lttv_trace_destroy(LttvTrace
*t
)
267 g_object_unref(t
->a
);
271 void lttv_traceset_add(LttvTraceset
*s
, LttvTrace
*t
)
274 g_ptr_array_add(s
->traces
, t
);
277 int lttv_traceset_add_path(LttvTraceset
*ts
, char *trace_path
)
281 char * const paths
[2] = { trace_path
, NULL
};
284 gboolean metaFileFound
= FALSE
;
286 tree
= fts_open(paths
, FTS_NOCHDIR
| FTS_LOGICAL
, 0);
288 g_warning("Cannot traverse \"%s\" for reading.\n",
294 while ((node
= fts_read(tree
))) {
296 if (!(node
->fts_info
& FTS_D
))
299 dirfd
= open(node
->fts_accpath
, 0);
301 g_warning("Unable to open trace "
302 "directory file descriptor : %s.", node
->fts_accpath
);
307 // Check if a metadata file exists in the current directory
308 metafd
= openat(dirfd
, "metadata", O_RDONLY
);
312 g_warning("Unable to open metadata "
313 "file descriptor : %s.", node
->fts_accpath
);
319 g_warning("Unable to close metadata "
320 "file descriptor : %s.", node
->fts_accpath
);
325 g_warning("Unable to close trace "
326 "directory file descriptor : %s.", node
->fts_accpath
);
330 ret
= lttv_traceset_create_trace(ts
, node
->fts_accpath
);
332 g_warning("Opening trace \"%s\" from %s "
333 "for reading.", node
->fts_accpath
, trace_path
);
336 metaFileFound
= TRUE
;
341 ret
= fts_close(tree
);
343 g_warning("Unable to close tree "
344 "file descriptor : %s.", trace_path
);
353 unsigned lttv_traceset_number(LttvTraceset
*s
)
355 return s
->traces
->len
;
359 LttvTrace
*lttv_traceset_get(LttvTraceset
*s
, unsigned i
)
361 g_assert(s
->traces
->len
> i
);
362 return ((LttvTrace
*)s
->traces
->pdata
[i
]);
366 void lttv_traceset_remove(LttvTraceset
*s
, unsigned i
)
369 g_assert(s
->traces
->len
> i
);
370 t
= (LttvTrace
*)s
->traces
->pdata
[i
];
372 bt_context_remove_trace(lttv_traceset_get_context(s
), t
->id
);
373 g_ptr_array_remove_index(s
->traces
, i
);
377 /* A set of attributes is attached to each trace set, trace and tracefile
378 to store user defined data as needed. */
380 LttvAttribute
*lttv_traceset_attribute(LttvTraceset
*s
)
386 LttvAttribute
*lttv_trace_attribute(LttvTrace
*t
)
392 gint
lttv_trace_get_id(LttvTrace
*t
)
397 guint
lttv_trace_get_ref_number(LttvTrace
* t
)
399 // todo mdenis: adapt to babeltrace
403 guint
lttv_trace_ref(LttvTrace
* t
)
410 guint
lttv_trace_unref(LttvTrace
* t
)
412 if(likely(t
->ref_count
> 0))
418 guint
lttv_trace_get_num_cpu(LttvTrace
*t
)
420 #warning "TODO - Set the right number of CPU"
424 LttvTracesetPosition
*lttv_traceset_create_current_position(LttvTraceset
*traceset
)
426 LttvTracesetPosition
*traceset_pos
;
428 traceset_pos
= g_new(LttvTracesetPosition
, 1);
430 /* Check if the new passed */
431 if(traceset_pos
== NULL
) {
435 traceset_pos
->iter
= traceset
->iter
;
436 traceset_pos
->bt_pos
= bt_iter_get_pos(bt_ctf_get_iter(traceset
->iter
));
441 LttvTracesetPosition
*lttv_traceset_create_time_position(LttvTraceset
*traceset
,
444 LttvTracesetPosition
*traceset_pos
;
446 traceset_pos
= g_new(LttvTracesetPosition
, 1);
448 /* Check if the new passed */
449 if(traceset_pos
== NULL
) {
453 traceset_pos
->iter
= traceset
->iter
;
454 traceset_pos
->bt_pos
= bt_iter_create_time_pos(
455 bt_ctf_get_iter(traceset_pos
->iter
),
456 ltt_time_to_uint64(timestamp
));
461 void lttv_traceset_destroy_position(LttvTracesetPosition
*traceset_pos
)
463 bt_iter_free_pos(traceset_pos
->bt_pos
);
464 g_free(traceset_pos
);
467 void lttv_traceset_seek_to_position(const LttvTracesetPosition
*traceset_pos
)
469 bt_iter_set_pos(bt_ctf_get_iter(traceset_pos
->iter
), traceset_pos
->bt_pos
);
472 guint
lttv_traceset_get_cpuid_from_event(LttvEvent
*event
)
474 unsigned long timestamp
;
477 struct bt_ctf_event
*ctf_event
= event
->bt_event
;
478 timestamp
= bt_ctf_get_timestamp(ctf_event
);
479 if (timestamp
== -1ULL) {
482 const struct definition
*scope
= bt_ctf_get_top_level_scope(ctf_event
, BT_STREAM_PACKET_CONTEXT
);
483 if (bt_ctf_field_get_error()) {
486 cpu_id
= bt_ctf_get_uint64(bt_ctf_get_field(ctf_event
, scope
, "cpu_id"));
487 if (bt_ctf_field_get_error()) {
494 guint64
lttv_traceset_get_timestamp_first_event(LttvTraceset
*ts
)
496 LttvTracesetPosition begin_position
;
497 struct bt_iter_pos pos
;
498 begin_position
.bt_pos
= &pos
;
500 /* Assign iterator to the beginning of the traces */
501 begin_position
.bt_pos
->type
= BT_SEEK_BEGIN
;
502 begin_position
.iter
= ts
->iter
;
504 return lttv_traceset_position_get_timestamp(&begin_position
);
508 * lttv_traceset_get_timestamp_begin : returns the minimum timestamp of
509 * all the traces in the traceset.
512 guint64
lttv_traceset_get_timestamp_begin(LttvTraceset
*traceset
)
514 struct bt_context
*bt_ctx
;
515 bt_ctx
= lttv_traceset_get_context(traceset
);
516 guint64 timestamp_min
, timestamp_cur
= 0;
519 LttvTrace
*currentTrace
;
520 trace_count
= traceset
->traces
->len
;
524 timestamp_min
= G_MAXUINT64
;
525 for(i
= 0; i
< trace_count
;i
++)
527 currentTrace
= g_ptr_array_index(traceset
->traces
,i
);
528 timestamp_cur
= bt_trace_handle_get_timestamp_begin(bt_ctx
,
530 if(timestamp_cur
< timestamp_min
)
531 timestamp_min
= timestamp_cur
;
534 return timestamp_min
;
538 * lttv_traceset_get_timestamp_end: returns the maximum timestamp of
539 * all the traces in the traceset.
542 guint64
lttv_traceset_get_timestamp_end(LttvTraceset
*traceset
)
544 struct bt_context
*bt_ctx
;
545 bt_ctx
= lttv_traceset_get_context(traceset
);
546 guint64 timestamp_max
, timestamp_cur
= 0;
549 LttvTrace
*currentTrace
;
550 trace_count
= traceset
->traces
->len
;
552 if(trace_count
== 0){
557 for(i
=0; i
< trace_count
;i
++)
559 currentTrace
= g_ptr_array_index(traceset
->traces
,i
);
560 timestamp_cur
= bt_trace_handle_get_timestamp_end(bt_ctx
,
562 if(timestamp_cur
> timestamp_max
){
563 timestamp_max
= timestamp_cur
;
567 return timestamp_max
;
570 * lttv_traceset_get_time_span_real : return a TimeInterval representing the
571 * minimum timestamp dans le maximum timestamp of the traceset.
574 TimeInterval
lttv_traceset_get_time_span_real(LttvTraceset
*ts
)
576 TimeInterval time_span
;
577 time_span
.start_time
=ltt_time_from_uint64(lttv_traceset_get_timestamp_first_event(ts
));
578 time_span
.end_time
= ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts
));
583 * lttv_traceset_get_time_span : return a TimeInterval representing the
584 * minimum timestamp dans le maximum timestamp of the traceset.
587 TimeInterval
lttv_traceset_get_time_span(LttvTraceset
*ts
)
589 TimeInterval time_span
;
590 time_span
.start_time
=ltt_time_from_uint64(lttv_traceset_get_timestamp_begin(ts
));
591 time_span
.end_time
= ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts
));
595 const char *lttv_traceset_get_name_from_event(LttvEvent
*event
)
597 return bt_ctf_event_name(event
->bt_event
);
600 guint64
lttv_traceset_position_get_timestamp(const LttvTracesetPosition
*pos
)
602 guint64 timestamp
= 0;
603 /*We save the current iterator,so we can reassign it after the seek*/
604 LttvTracesetPosition previous_pos
;
605 previous_pos
.iter
= pos
->iter
;
606 previous_pos
.bt_pos
= bt_iter_get_pos(bt_ctf_get_iter(pos
->iter
));
607 /* Seek to the new desired position */
608 lttv_traceset_seek_to_position(pos
);
610 struct bt_ctf_event
*event
= bt_ctf_iter_read_event(pos
->iter
);
613 timestamp
= bt_ctf_get_timestamp_raw(event
);
615 /* Reassign the previously saved position */
616 lttv_traceset_seek_to_position(&previous_pos
);
620 LttTime
lttv_traceset_position_get_time(const LttvTracesetPosition
*pos
)
622 return ltt_time_from_uint64(lttv_traceset_position_get_timestamp(pos
));
627 int lttv_traceset_position_compare(const LttvTracesetPosition
*pos1
, const LttvTracesetPosition
*pos2
)
629 #warning " TODO :Rename for lttv_traceset_position_equals && Must return COMPARAISON OF THE 2 POSITION && verify if it is the best way to compare position"
630 if(pos1
== NULL
|| pos2
== NULL
){
634 guint64 timeStampPos1
,timeStampPos2
;
635 guint cpuId1
, cpuId2
;
636 LttvEvent event1
, event2
;
639 timeStampPos1
= lttv_traceset_position_get_timestamp(pos1
);
640 timeStampPos2
= lttv_traceset_position_get_timestamp(pos2
);
642 event1
.bt_event
= bt_ctf_iter_read_event(pos1
->iter
);
643 event2
.bt_event
= bt_ctf_iter_read_event(pos2
->iter
);
645 if(event1
.bt_event
== NULL
|| event2
.bt_event
== NULL
){
649 cpuId1
= lttv_traceset_get_cpuid_from_event(&event1
);
650 cpuId2
= lttv_traceset_get_cpuid_from_event(&event2
);
652 if(timeStampPos1
== timeStampPos2
&& cpuId1
== cpuId2
){
660 int lttv_traceset_position_time_compare(const LttvTracesetPosition
*pos1
,
661 const LttvTracesetPosition
*pos2
)
663 guint64 timeStampPos1
,timeStampPos2
;
665 timeStampPos1
= lttv_traceset_position_get_timestamp(pos1
);
666 timeStampPos2
= lttv_traceset_position_get_timestamp(pos2
);
668 return timeStampPos1
- timeStampPos2
;
670 int lttv_traceset_position_compare_current(const LttvTraceset
*ts
,
671 const LttvTracesetPosition
*pos
)
674 LttvTracesetPosition
*curPos
= lttv_traceset_create_current_position(ts
);
676 result
= lttv_traceset_position_compare(curPos
,pos
);
678 lttv_traceset_destroy_position(curPos
);
683 LttTime
lttv_traceset_get_current_time(const LttvTraceset
*ts
)
685 LttvTracesetPosition
*curPos
= lttv_traceset_create_current_position(ts
);
686 guint64 currentTimestamp
= lttv_traceset_position_get_timestamp(curPos
);
687 lttv_traceset_destroy_position(curPos
);
689 return ltt_time_from_uint64(currentTimestamp
);