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 */
36 /* 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();
71 ts
->has_precomputed_states
= FALSE
;
73 ts
->time_span
.start_time
= ltt_time_zero
;
74 ts
->time_span
.end_time
= ltt_time_zero
;
75 lttv_traceset_get_time_span_real(ts
);
79 char * lttv_traceset_name(LttvTraceset
* s
)
85 LttvTrace
*lttv_trace_new(LttTrace
*t
)
89 new_trace
= g_new(LttvTrace
, 1);
90 new_trace
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
92 new_trace
->ref_count
= 0;
97 * get_absolute_pathname : Return the unique pathname in the system
99 * pathname is the relative path.
101 * abs_pathname is being set to the absolute path.
104 void get_absolute_pathname(const gchar
*pathname
, gchar
* abs_pathname
)
106 abs_pathname
[0] = '\0';
108 if (realpath(pathname
, abs_pathname
) != NULL
)
112 /* error, return the original path unmodified */
113 strcpy(abs_pathname
, pathname
);
122 * lttv_trace_create : Create a trace from a path
124 * ts is the traceset in which will be contained the trace
126 * path is the path where to find a trace. It is not recursive.
128 * This function is static since a trace should always be contained in a
131 * return the created trace or NULL on failure
133 static LttvTrace
*lttv_trace_create(LttvTraceset
*ts
, const char *path
)
135 int id
= bt_context_add_trace(lttv_traceset_get_context(ts
),
144 // Create the trace and save the trace handle id returned by babeltrace
145 LttvTrace
*new_trace
;
147 new_trace
= g_new(LttvTrace
, 1);
148 new_trace
->a
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
150 new_trace
->ref_count
= 0;
151 new_trace
->traceset
= ts
;
152 new_trace
->state
= g_new(LttvTraceState
,1);
153 lttv_trace_state_init(new_trace
->state
,new_trace
);
155 /* Add the state to the trace_handle to state index */
156 g_ptr_array_set_size(ts
->state_trace_handle_index
,id
+1);
157 g_ptr_array_index(ts
->state_trace_handle_index
,id
) = new_trace
->state
;
163 * lttv_trace_create : Create and add a single trace to a traceset
165 * ts is the traceset in which will be contained the trace
167 * path is the path where to find a trace. It is not recursive.
169 * return a positive integer (>=0)on success or -1 on failure
171 static int lttv_traceset_create_trace(LttvTraceset
*ts
, const char *path
)
173 LttvTrace
*trace
= lttv_trace_create(ts
, path
);
177 lttv_traceset_add(ts
, trace
);
181 LttvTraceset
*lttv_traceset_copy(LttvTraceset
*s_orig
)
187 s
= g_new(LttvTraceset
, 1);
189 s
->traces
= g_ptr_array_new();
190 s
->state_trace_handle_index
= g_ptr_array_new();
191 for(i
=0;i
<s_orig
->traces
->len
;i
++)
193 trace
= g_ptr_array_index(s_orig
->traces
, i
);
196 /* WARNING: this is an alias, not a copy. */
197 g_ptr_array_add(s
->traces
, trace
);
199 g_ptr_array_set_size(s
->state_trace_handle_index
,trace
->id
+1);
200 g_ptr_array_index(s
->state_trace_handle_index
,trace
->id
) = trace
->state
;
203 s
->context
= s_orig
->context
;
204 bt_context_get(s
->context
);
205 s
->a
= LTTV_ATTRIBUTE(lttv_iattribute_deep_copy(LTTV_IATTRIBUTE(s_orig
->a
)));
210 LttvTraceset
*lttv_traceset_load(const gchar
*filename
)
212 LttvTraceset
*s
= g_new(LttvTraceset
,1);
215 s
->filename
= g_strdup(filename
);
216 tf
= fopen(filename
,"r");
218 g_critical("NOT IMPLEMENTED : load traceset data from a XML file");
224 gint
lttv_traceset_save(LttvTraceset
*s
)
228 tf
= fopen(s
->filename
, "w");
230 g_critical("NOT IMPLEMENTED : save traceset data in a XML file");
236 void lttv_traceset_destroy(LttvTraceset
*s
)
240 for(i
=0;i
<s
->traces
->len
;i
++) {
241 LttvTrace
*trace
= g_ptr_array_index(s
->traces
, i
);
242 lttv_trace_unref(trace
);
243 // todo mdenis 2012-03-27: uncomment when babeltrace gets fixed
244 //bt_context_remove_trace(lttv_traceset_get_context(s), trace->id);
245 if(lttv_trace_get_ref_number(trace
) == 0)
246 lttv_trace_destroy(trace
);
248 g_ptr_array_free(s
->traces
, TRUE
);
249 bt_context_put(s
->context
);
250 g_object_unref(s
->a
);
254 struct bt_context
*lttv_traceset_get_context(LttvTraceset
*s
)
259 LttvTraceset
*lttv_trace_get_traceset(LttvTrace
*trace
)
261 return trace
->traceset
;
264 LttvHooks
*lttv_traceset_get_hooks(LttvTraceset
*s
)
266 return s
->event_hooks
;
269 void lttv_trace_destroy(LttvTrace
*t
)
271 g_object_unref(t
->a
);
275 void lttv_traceset_add(LttvTraceset
*s
, LttvTrace
*t
)
278 g_ptr_array_add(s
->traces
, t
);
281 int lttv_traceset_add_path(LttvTraceset
*ts
, char *trace_path
)
285 gboolean metaFileFound
= FALSE
;
287 /* Open top level directory */
288 curdir
= opendir(trace_path
);
289 if (curdir
== NULL
) {
290 g_warning("Cannot open directory %s (%s)", trace_path
, strerror(errno
));
294 // Check if a metadata file exists in the current directory
295 int metafd
= openat(dirfd(curdir
), "metadata", O_RDONLY
);
301 g_warning("Unable to close metadata "
302 "file descriptor : %s.", trace_path
);
306 ret
= lttv_traceset_create_trace(ts
, trace_path
);
308 g_warning("Opening trace \"%s\" "
309 "for reading.", trace_path
);
312 metaFileFound
= TRUE
;
315 struct dirent curentry
;
316 struct dirent
*resultentry
;
317 while ((ret
= readdir_r(curdir
, &curentry
, &resultentry
)) == 0) {
318 if (resultentry
== NULL
) {
322 if (curentry
.d_name
[0] != '.') {
323 if (curentry
.d_type
== DT_DIR
) {
325 char curpath
[PATH_MAX
];
326 snprintf(curpath
, PATH_MAX
, "%s/%s", trace_path
, curentry
.d_name
);
327 ret
= lttv_traceset_add_path(ts
, curpath
);
329 metaFileFound
= TRUE
;
336 g_warning("Invalid readdir");
346 unsigned lttv_traceset_number(LttvTraceset
*s
)
348 return s
->traces
->len
;
352 LttvTrace
*lttv_traceset_get(LttvTraceset
*s
, unsigned i
)
354 g_assert(s
->traces
->len
> i
);
355 return ((LttvTrace
*)s
->traces
->pdata
[i
]);
359 void lttv_traceset_remove(LttvTraceset
*s
, unsigned i
)
362 g_assert(s
->traces
->len
> i
);
363 t
= (LttvTrace
*)s
->traces
->pdata
[i
];
365 bt_context_remove_trace(lttv_traceset_get_context(s
), t
->id
);
366 g_ptr_array_remove_index(s
->traces
, i
);
370 /* A set of attributes is attached to each trace set, trace and tracefile
371 to store user defined data as needed. */
373 LttvAttribute
*lttv_traceset_attribute(LttvTraceset
*s
)
379 LttvAttribute
*lttv_trace_attribute(LttvTrace
*t
)
385 gint
lttv_trace_get_id(LttvTrace
*t
)
390 guint
lttv_trace_get_ref_number(LttvTrace
* t
)
392 // todo mdenis: adapt to babeltrace
396 guint
lttv_trace_ref(LttvTrace
* t
)
403 guint
lttv_trace_unref(LttvTrace
* t
)
405 if(likely(t
->ref_count
> 0))
411 guint
lttv_trace_get_num_cpu(LttvTrace
*t
)
413 #warning "TODO - Set the right number of CPU"
417 LttvTracesetPosition
*lttv_traceset_create_current_position(LttvTraceset
*traceset
)
419 LttvTracesetPosition
*traceset_pos
;
421 traceset_pos
= g_new(LttvTracesetPosition
, 1);
423 /* Check if the new passed */
424 if(traceset_pos
== NULL
) {
428 traceset_pos
->iter
= traceset
->iter
;
429 traceset_pos
->bt_pos
= bt_iter_get_pos(bt_ctf_get_iter(traceset
->iter
));
430 traceset_pos
->timestamp
= G_MAXUINT64
;
431 traceset_pos
->cpu_id
= INT_MAX
;
436 LttvTracesetPosition
*lttv_traceset_create_time_position(LttvTraceset
*traceset
,
439 LttvTracesetPosition
*traceset_pos
;
441 traceset_pos
= g_new(LttvTracesetPosition
, 1);
443 /* Check if the new passed */
444 if(traceset_pos
== NULL
) {
448 traceset_pos
->iter
= traceset
->iter
;
449 traceset_pos
->bt_pos
= bt_iter_create_time_pos(
450 bt_ctf_get_iter(traceset_pos
->iter
),
451 ltt_time_to_uint64(timestamp
));
452 traceset_pos
->timestamp
= G_MAXUINT64
;
453 traceset_pos
->cpu_id
= INT_MAX
;
457 void lttv_traceset_destroy_position(LttvTracesetPosition
*traceset_pos
)
459 bt_iter_free_pos(traceset_pos
->bt_pos
);
460 g_free(traceset_pos
);
463 void lttv_traceset_seek_to_position(const LttvTracesetPosition
*traceset_pos
)
465 bt_iter_set_pos(bt_ctf_get_iter(traceset_pos
->iter
), traceset_pos
->bt_pos
);
468 guint
lttv_traceset_get_cpuid_from_event(LttvEvent
*event
)
470 unsigned long timestamp
;
473 struct bt_ctf_event
*ctf_event
= event
->bt_event
;
474 timestamp
= bt_ctf_get_timestamp(ctf_event
);
475 if (timestamp
== -1ULL) {
478 const struct bt_definition
*scope
= bt_ctf_get_top_level_scope(ctf_event
, BT_STREAM_PACKET_CONTEXT
);
479 if (bt_ctf_field_get_error()) {
482 cpu_id
= bt_ctf_get_uint64(bt_ctf_get_field(ctf_event
, scope
, "cpu_id"));
483 if (bt_ctf_field_get_error()) {
490 guint64
lttv_traceset_get_timestamp_first_event(LttvTraceset
*ts
)
492 LttvTracesetPosition begin_position
;
493 struct bt_iter_pos pos
;
494 begin_position
.bt_pos
= &pos
;
495 begin_position
.timestamp
= G_MAXUINT64
;
496 begin_position
.cpu_id
= INT_MAX
;
498 /* Assign iterator to the beginning of the traces */
499 begin_position
.bt_pos
->type
= BT_SEEK_BEGIN
;
500 begin_position
.iter
= ts
->iter
;
502 return lttv_traceset_position_get_timestamp(&begin_position
);
505 guint64
lttv_traceset_get_timestamp_last_event(LttvTraceset
*ts
)
507 LttvTracesetPosition last_position
;
508 struct bt_iter_pos pos
;
509 last_position
.bt_pos
= &pos
;
510 last_position
.timestamp
= G_MAXUINT64
;
511 last_position
.cpu_id
= INT_MAX
;
513 /* Assign iterator to the last event of the traces */
514 last_position
.bt_pos
->type
= BT_SEEK_LAST
;
515 last_position
.iter
= ts
->iter
;
517 return lttv_traceset_position_get_timestamp(&last_position
);
521 * lttv_traceset_get_timestamp_begin : returns the minimum timestamp of
522 * all the traces in the traceset.
525 guint64
lttv_traceset_get_timestamp_begin(LttvTraceset
*traceset
)
527 struct bt_context
*bt_ctx
;
528 bt_ctx
= lttv_traceset_get_context(traceset
);
529 guint64 timestamp_min
, timestamp_cur
= 0;
532 LttvTrace
*currentTrace
;
533 trace_count
= traceset
->traces
->len
;
537 timestamp_min
= G_MAXUINT64
;
538 for(i
= 0; i
< trace_count
;i
++)
540 currentTrace
= g_ptr_array_index(traceset
->traces
,i
);
541 timestamp_cur
= bt_trace_handle_get_timestamp_begin(bt_ctx
,
544 if(timestamp_cur
< timestamp_min
)
545 timestamp_min
= timestamp_cur
;
548 return timestamp_min
;
552 * lttv_traceset_get_timestamp_end: returns the maximum timestamp of
553 * all the traces in the traceset.
556 guint64
lttv_traceset_get_timestamp_end(LttvTraceset
*traceset
)
558 struct bt_context
*bt_ctx
;
559 bt_ctx
= lttv_traceset_get_context(traceset
);
560 guint64 timestamp_max
, timestamp_cur
= 0;
563 LttvTrace
*currentTrace
;
564 trace_count
= traceset
->traces
->len
;
566 if(trace_count
== 0){
571 for(i
=0; i
< trace_count
;i
++)
573 currentTrace
= g_ptr_array_index(traceset
->traces
,i
);
574 timestamp_cur
= bt_trace_handle_get_timestamp_end(bt_ctx
,
577 if(timestamp_cur
> timestamp_max
){
578 timestamp_max
= timestamp_cur
;
582 return timestamp_max
;
585 * lttv_traceset_get_time_span_real : return a TimeInterval representing the
586 * minimum timestamp and the maximum timestamp of the traceset.
589 TimeInterval
lttv_traceset_get_time_span_real(LttvTraceset
*ts
)
593 if(ltt_time_compare(ts
->time_span
.start_time
,
594 ltt_time_zero
) == 0 && ts
->traces
->len
> 0){
595 ts
->time_span
.start_time
= ltt_time_from_uint64(
596 lttv_traceset_get_timestamp_first_event(ts
));
597 ts
->time_span
.end_time
= ltt_time_from_uint64(
598 lttv_traceset_get_timestamp_last_event(ts
));
600 return ts
->time_span
;
604 * lttv_traceset_get_time_span : return a TimeInterval representing the
605 * minimum timestamp and the maximum timestamp of the traceset.
608 TimeInterval
lttv_traceset_get_time_span(LttvTraceset
*ts
)
610 if(ltt_time_compare(ts
->time_span
.start_time
, ltt_time_zero
) == 0){
611 ts
->time_span
.start_time
=ltt_time_from_uint64(
612 lttv_traceset_get_timestamp_begin(ts
));
613 ts
->time_span
.end_time
= ltt_time_from_uint64(
614 lttv_traceset_get_timestamp_end(ts
));
616 return ts
->time_span
;
619 const char *lttv_traceset_get_name_from_event(LttvEvent
*event
)
621 return bt_ctf_event_name(event
->bt_event
);
624 int set_values_position(const LttvTracesetPosition
*pos
)
626 LttvTracesetPosition previous_pos
;
627 previous_pos
.iter
= pos
->iter
;
628 previous_pos
.bt_pos
= bt_iter_get_pos(bt_ctf_get_iter(pos
->iter
));
629 /* Seek to the new desired position */
630 lttv_traceset_seek_to_position(pos
);
632 struct bt_ctf_event
*event
= bt_ctf_iter_read_event(pos
->iter
);
635 ((LttvTracesetPosition
*)pos
)->timestamp
= bt_ctf_get_timestamp(event
);
637 LttvEvent lttv_event
;
638 lttv_event
.bt_event
= event
;
639 ((LttvTracesetPosition
*)pos
)->cpu_id
= lttv_traceset_get_cpuid_from_event(<tv_event
);
642 /* The event is null */
646 /* Reassign the previously saved position */
647 lttv_traceset_seek_to_position(&previous_pos
);
648 /*We must desallocate because the function bt_iter_get_pos() does a g_new */
649 bt_iter_free_pos(previous_pos
.bt_pos
);
650 if (pos
->timestamp
== G_MAXUINT64
) {
656 guint64
lttv_traceset_position_get_timestamp(const LttvTracesetPosition
*pos
)
658 if(pos
->timestamp
== G_MAXUINT64
){
659 if(set_values_position(pos
) == 0){
664 return pos
->timestamp
;
667 int lttv_traceset_position_get_cpuid(const LttvTracesetPosition
*pos
){
668 if(pos
->cpu_id
== INT_MAX
){
669 if(set_values_position(pos
) == 0){
676 LttTime
lttv_traceset_position_get_time(const LttvTracesetPosition
*pos
)
678 return ltt_time_from_uint64(lttv_traceset_position_get_timestamp(pos
));
682 /* 0 if equals, other is different */
683 int lttv_traceset_position_compare(const LttvTracesetPosition
*pos1
, const LttvTracesetPosition
*pos2
)
685 #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"
686 if(pos1
== NULL
|| pos2
== NULL
){
691 #ifdef HAVE_BT_ITER_EQUALS_POS
692 if(pos1
->timestamp
== G_MAXUINT64
|| pos2
->timestamp
== G_MAXUINT64
) {
693 res
= bt_iter_equals_pos(pos1
->bt_pos
, pos2
->bt_pos
);
698 guint64 timeStampPos1
,timeStampPos2
;
699 guint cpuId1
, cpuId2
;
701 timeStampPos1
= lttv_traceset_position_get_timestamp(pos1
);
702 timeStampPos2
= lttv_traceset_position_get_timestamp(pos2
);
704 if (timeStampPos1
== timeStampPos2
) {
706 cpuId1
= lttv_traceset_position_get_cpuid(pos1
);
707 cpuId2
= lttv_traceset_position_get_cpuid(pos2
);
709 if(cpuId1
== cpuId2
){
720 int lttv_traceset_position_time_compare(const LttvTracesetPosition
*pos1
,
721 const LttvTracesetPosition
*pos2
)
723 guint64 timeStampPos1
,timeStampPos2
;
725 timeStampPos1
= lttv_traceset_position_get_timestamp(pos1
);
726 timeStampPos2
= lttv_traceset_position_get_timestamp(pos2
);
728 return timeStampPos1
- timeStampPos2
;
730 int lttv_traceset_position_compare_current(const LttvTraceset
*ts
,
731 const LttvTracesetPosition
*pos
)
734 LttvTracesetPosition
*curPos
= lttv_traceset_create_current_position(ts
);
736 result
= lttv_traceset_position_compare(curPos
,pos
);
738 lttv_traceset_destroy_position(curPos
);
743 LttTime
lttv_traceset_get_current_time(const LttvTraceset
*ts
)
745 LttvTracesetPosition
*curPos
= lttv_traceset_create_current_position(ts
);
746 guint64 currentTimestamp
= lttv_traceset_position_get_timestamp(curPos
);
747 lttv_traceset_destroy_position(curPos
);
749 return ltt_time_from_uint64(currentTimestamp
);